ya

.gitignore

@@ -97,6 +97,8 @@ celerybeat.pid
 
 # Environments
 .env
+.env.local
+.env.production
 .venv
 env/
 venv/

README.md

@@ -31,7 +31,7 @@ Professional SEO analysis and reporting tool that creates comprehensive SEO audi
 
 ### 🚧 Planned for Future Versions
 - Keyword Rankings (Google Search Console integration)
-- Backlink Profile Analysis (Ahrefs/SEMrush APIs)
+- Backlink Profile Analysis (RapidAPI)
 - Advanced Competitor Analysis
 - GA4/Conversion Tracking Integration
 

app.py

@@ -8,8 +8,11 @@ import uuid
 # Import SEO modules
 from modules.technical_seo import TechnicalSEOModule
 from modules.content_audit import ContentAuditModule
+from modules.keywords import KeywordsModule
+from modules.backlinks import BacklinksModule
 from report_generator import ReportGenerator
 from simple_pdf_generator import SimplePDFGenerator
+from llm_recommendations import LLMRecommendations
 
 app = Flask(__name__, static_folder='static')
 app.secret_key = 'seo_report_generator_2024'
@@ -17,8 +20,11 @@ app.secret_key = 'seo_report_generator_2024'
 # Initialize modules
 technical_module = TechnicalSEOModule()
 content_module = ContentAuditModule()
+keywords_module = KeywordsModule()
+backlinks_module = BacklinksModule()
 report_gen = ReportGenerator()
 pdf_gen = SimplePDFGenerator()
+llm_recommendations = LLMRecommendations()
 
 # Store for generated reports (in production, use database)
 reports_store = {}
@@ -56,15 +62,59 @@ def generate_report():
         # Content Audit
         content_data = content_module.analyze(url)
         
+        # Keywords Analysis
+        keywords_data = keywords_module.analyze(url).data
+        
+        # Backlinks Analysis - COMMENTED OUT TO SAVE API CREDITS
+        # print(f"DEBUG: Starting backlinks analysis for {url}")
+        # backlinks_result = backlinks_module.analyze(url)
+        # backlinks_data = backlinks_result.data
+        # print(f"DEBUG: Backlinks analysis result - Success: {backlinks_result.success}")
+        # print(f"DEBUG: Backlinks data keys: {list(backlinks_data.keys())}")
+        # if backlinks_data.get('total_backlinks'):
+        #     print(f"DEBUG: Total backlinks found: {backlinks_data.get('total_backlinks')}")
+        # if backlinks_data.get('placeholder'):
+        #     print(f"DEBUG: Using placeholder data: {backlinks_data.get('message')}")
+        
+        # Use placeholder backlinks data to save API credits
+        backlinks_data = {
+            'total_backlinks': 0,
+            'total_ref_domains': 0,
+            'domain_rating': 0,
+            'authority_scores': {'ahrefs_dr': 0, 'moz_da': 0, 'moz_pa': 0, 'majestic_tf': 0, 'majestic_cf': 0},
+            'referring_domains': [],
+            'anchor_distribution': [],
+            'monthly_changes': {'new_backlinks': 0, 'lost_backlinks': 0, 'net_change': 0},
+            'top_backlinks': [],
+            'quality_metrics': {'follow_ratio': 0, 'avg_authority': 0, 'quality_score': 0},
+            'edu_links': 0,
+            'gov_links': 0,
+            'estimated_organic_traffic': 0,
+            'organic_keywords': 0,
+            'data_sources': ['API disabled to save credits'],
+            'placeholder': True,
+            'message': 'Backlinks analysis temporarily disabled to conserve API credits.'
+        }
+        
+        # Generate LLM Recommendations
+        llm_rec_data = llm_recommendations.generate_recommendations(
+            url, technical_data, content_data, keywords_data, backlinks_data
+        )
+        
         # Competitor Analysis
         competitor_data = []
         for comp_url in competitor_list:
             comp_technical = technical_module.analyze(comp_url)
             comp_content = content_module.analyze(comp_url, quick_scan=True)
+            comp_keywords = keywords_module.analyze(comp_url, quick_scan=True).data
+            # comp_backlinks = backlinks_module.analyze(comp_url, quick_scan=True).data  # SAVE API CREDITS
+            comp_backlinks = {'placeholder': True, 'message': 'Disabled to save credits'}
             competitor_data.append({
                 'url': comp_url,
                 'technical': comp_technical,
-                'content': comp_content
+                'content': comp_content,
+                'keywords': comp_keywords,
+                'backlinks': comp_backlinks
             })
         
         # Generate HTML report
@@ -73,6 +123,9 @@ def generate_report():
             technical_data=technical_data,
             content_data=content_data,
             competitor_data=competitor_data,
+            keywords_data=keywords_data,
+            backlinks_data=backlinks_data,
+            llm_recommendations=llm_rec_data,
             include_charts=True
         )
         
@@ -82,6 +135,9 @@ def generate_report():
             'html': report_html,
             'technical_data': technical_data,
             'content_data': content_data,
+            'keywords_data': keywords_data,
+            'backlinks_data': backlinks_data,
+            'llm_recommendations': llm_rec_data,
             'competitor_data': competitor_data
         }
         

llm_recommendations.py

@@ -0,0 +1,344 @@
+"""
+Groq LLM Integration for Smart SEO Recommendations
+Analyzes all 4 modules (Technical SEO, Content Audit, Keywords, Backlinks) to generate intelligent recommendations
+"""
+
+import os
+import json
+from typing import Dict, Any, List
+from groq import Groq
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+
+class LLMRecommendations:
+    def __init__(self):
+        try:
+            self.client = Groq(api_key=os.getenv('GROQ_API_KEY'))
+            self.available = True
+        except Exception:
+            self.client = None
+            self.available = False
+    
+    def generate_recommendations(self, url: str, technical_data: Dict[str, Any], 
+                               content_data: Dict[str, Any], keywords_data: Dict[str, Any], 
+                               backlinks_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Generate comprehensive SEO recommendations based on all module data
+        
+        Args:
+            url: Target website URL
+            technical_data: Technical SEO analysis results
+            content_data: Content audit results
+            keywords_data: Keywords analysis results
+            backlinks_data: Backlinks analysis results
+            
+        Returns:
+            Dictionary with recommendations and insights
+        """
+        if not self.available:
+            return self._generate_fallback_recommendations(technical_data, content_data, keywords_data, backlinks_data)
+        
+        try:
+            # Prepare context data for LLM
+            context = self._prepare_context(url, technical_data, content_data, keywords_data, backlinks_data)
+            
+            # Generate recommendations using Groq
+            recommendations = self._query_llm(context)
+            
+            return {
+                'recommendations': recommendations,
+                'executive_insights': self._generate_executive_insights(context),
+                'priority_actions': self._extract_priority_actions(recommendations),
+                'data_source': 'Groq LLM Analysis',
+                'generated_at': context['analysis_date']
+            }
+            
+        except Exception as e:
+            return self._generate_fallback_recommendations(technical_data, content_data, keywords_data, backlinks_data, error=str(e))
+    
+    def _prepare_context(self, url: str, technical_data: Dict, content_data: Dict, 
+                        keywords_data: Dict, backlinks_data: Dict) -> Dict[str, Any]:
+        """Prepare structured context for LLM analysis"""
+        
+        # Extract key metrics from each module
+        context = {
+            'website': url,
+            'analysis_date': technical_data.get('last_updated', ''),
+            'technical_seo': {
+                'mobile_score': technical_data.get('mobile_score', 0),
+                'desktop_score': technical_data.get('desktop_score', 0),
+                'core_web_vitals': technical_data.get('core_web_vitals', {}),
+                'issues_count': len(technical_data.get('issues', [])),
+                'top_issues': technical_data.get('issues', [])[:3]
+            },
+            'content_audit': {
+                'pages_analyzed': content_data.get('pages_analyzed', 0),
+                'metadata_completeness': content_data.get('metadata_completeness', {}),
+                'avg_word_count': content_data.get('avg_word_count', 0),
+                'cta_presence': content_data.get('cta_presence', 0),
+                'content_freshness': content_data.get('content_freshness', {})
+            },
+            'keywords': {
+                'total_keywords': keywords_data.get('total_keywords', 0),
+                'position_distribution': keywords_data.get('position_distribution', {}),
+                'data_available': not keywords_data.get('placeholder', False),
+                'opportunity_keywords': len(keywords_data.get('opportunity_keywords', [])),
+                'data_source': keywords_data.get('data_source', 'Unknown')
+            },
+            'backlinks': {
+                'total_backlinks': backlinks_data.get('total_backlinks', 0),
+                'total_ref_domains': backlinks_data.get('total_ref_domains', 0),
+                'domain_rating': backlinks_data.get('domain_rating', 0),
+                'monthly_changes': backlinks_data.get('monthly_changes', {}),
+                'data_available': not backlinks_data.get('placeholder', False),
+                'data_source': backlinks_data.get('data_source', 'Unknown')
+            }
+        }
+        
+        return context
+    
+    def _query_llm(self, context: Dict[str, Any]) -> List[str]:
+        """Query Groq LLM for SEO recommendations"""
+        
+        prompt = f"""
+You are an expert SEO consultant analyzing a comprehensive SEO audit for {context['website']}. Based on the data below, provide specific, actionable SEO recommendations.
+
+TECHNICAL SEO DATA:
+- Mobile Performance Score: {context['technical_seo']['mobile_score']}/100
+- Desktop Performance Score: {context['technical_seo']['desktop_score']}/100
+- Core Web Vitals: {json.dumps(context['technical_seo']['core_web_vitals'])}
+- Critical Issues Found: {context['technical_seo']['issues_count']}
+- Top Issues: {context['technical_seo']['top_issues']}
+
+CONTENT AUDIT DATA:
+- Pages Analyzed: {context['content_audit']['pages_analyzed']}
+- Metadata Completeness: {json.dumps(context['content_audit']['metadata_completeness'])}
+- Average Word Count: {context['content_audit']['avg_word_count']}
+- CTA Presence: {context['content_audit']['cta_presence']}%
+- Content Freshness: {json.dumps(context['content_audit']['content_freshness'])}
+
+KEYWORDS DATA:
+- Total Keywords Tracked: {context['keywords']['total_keywords']}
+- Position Distribution: {json.dumps(context['keywords']['position_distribution'])}
+- Data Available: {context['keywords']['data_available']}
+- Opportunity Keywords: {context['keywords']['opportunity_keywords']}
+- Source: {context['keywords']['data_source']}
+
+BACKLINKS DATA:
+- Total Backlinks: {context['backlinks']['total_backlinks']}
+- Referring Domains: {context['backlinks']['total_ref_domains']}
+- Domain Rating: {context['backlinks']['domain_rating']}
+- Monthly Changes: {json.dumps(context['backlinks']['monthly_changes'])}
+- Data Available: {context['backlinks']['data_available']}
+- Source: {context['backlinks']['data_source']}
+
+CRITICAL INSTRUCTIONS:
+1. Analyze the data holistically across all 4 modules
+2. Identify the TOP 3 most critical issues that need immediate attention
+3. Provide specific, actionable recommendations with clear steps
+4. If API data is missing (placeholder: true), acknowledge this and focus on available data
+5. Prioritize recommendations by potential impact and ease of implementation
+6. Include technical optimizations, content improvements, keyword opportunities, and link building strategies
+7. Provide estimated timelines and resources needed for each recommendation
+
+Generate exactly 8-12 specific recommendations in this format:
+- **[Priority Level]** [Specific Action]: [Detailed explanation with steps and expected impact]
+
+Priority Levels: HIGH, MEDIUM, LOW
+Focus on actionable items that can be implemented within 30-90 days.
+
+Response:
+"""
+
+        try:
+            chat_completion = self.client.chat.completions.create(
+                messages=[
+                    {'role': 'user', 'content': prompt}
+                ],
+                model="mixtral-8x7b-32768",  # Using Mixtral for better reasoning
+                stream=False,
+                temperature=0.1,  # Low temperature for consistent, focused recommendations
+                max_tokens=1500
+            )
+            
+            response = chat_completion.choices[0].message.content.strip()
+            
+            # Parse recommendations from response
+            recommendations = []
+            lines = response.split('\n')
+            for line in lines:
+                line = line.strip()
+                if line.startswith('- **') or line.startswith('•'):
+                    # Clean up the recommendation
+                    recommendation = line.replace('- **', '').replace('• **', '').strip()
+                    if recommendation:
+                        recommendations.append(recommendation)
+            
+            return recommendations if recommendations else [response]
+            
+        except Exception as e:
+            return [f"LLM Error: {str(e)}"]
+    
+    def _generate_executive_insights(self, context: Dict[str, Any]) -> List[str]:
+        """Generate high-level executive insights"""
+        insights = []
+        
+        # Technical Performance Insight
+        mobile_score = context['technical_seo']['mobile_score']
+        desktop_score = context['technical_seo']['desktop_score']
+        avg_score = (mobile_score + desktop_score) / 2
+        
+        if avg_score < 50:
+            insights.append(f"🔴 Critical: Website performance is severely impacting user experience (avg: {avg_score:.0f}/100)")
+        elif avg_score < 75:
+            insights.append(f"🟡 Warning: Website performance needs improvement (avg: {avg_score:.0f}/100)")
+        else:
+            insights.append(f"🟢 Good: Website performance is solid (avg: {avg_score:.0f}/100)")
+        
+        # Content Insight
+        pages = context['content_audit']['pages_analyzed']
+        if pages > 0:
+            metadata = context['content_audit']['metadata_completeness']
+            title_pct = (metadata.get('with_title', 0) / pages * 100) if pages > 0 else 0
+            
+            if title_pct < 80:
+                insights.append(f"🔴 Content Issue: {100-title_pct:.0f}% of pages missing critical metadata")
+            else:
+                insights.append(f"🟢 Content Quality: Metadata completeness is good ({title_pct:.0f}%)")
+        
+        # Keywords Insight
+        if context['keywords']['data_available']:
+            total_keywords = context['keywords']['total_keywords']
+            pos_dist = context['keywords']['position_distribution']
+            top_10_pct = (pos_dist.get('top_10', 0) / total_keywords * 100) if total_keywords > 0 else 0
+            
+            if top_10_pct < 15:
+                insights.append(f"🔴 SEO Visibility: Only {top_10_pct:.0f}% of keywords rank in top 10")
+            elif top_10_pct < 30:
+                insights.append(f"🟡 SEO Opportunity: {top_10_pct:.0f}% of keywords in top 10 - room for growth")
+            else:
+                insights.append(f"🟢 Strong SEO: {top_10_pct:.0f}% of keywords ranking in top 10")
+        else:
+            insights.append("📊 Connect keyword tracking tools for visibility insights")
+        
+        # Backlinks Insight
+        if context['backlinks']['data_available']:
+            ref_domains = context['backlinks']['total_ref_domains']
+            domain_rating = context['backlinks']['domain_rating']
+            
+            if ref_domains < 50:
+                insights.append(f"🔴 Link Building: Low referring domains ({ref_domains}) - aggressive outreach needed")
+            elif ref_domains < 200:
+                insights.append(f"🟡 Authority Building: Moderate link profile ({ref_domains} domains)")
+            else:
+                insights.append(f"🟢 Strong Authority: Healthy backlink profile ({ref_domains} referring domains)")
+        else:
+            insights.append("🔗 Connect backlink analysis tools for authority insights")
+        
+        return insights
+    
+    def _extract_priority_actions(self, recommendations: List[str]) -> List[Dict[str, str]]:
+        """Extract priority actions from recommendations"""
+        priority_actions = []
+        
+        for rec in recommendations:
+            if '**HIGH**' in rec or '**CRITICAL**' in rec:
+                # Extract action title and description
+                parts = rec.replace('**HIGH**', '').replace('**CRITICAL**', '').strip()
+                if ':' in parts:
+                    title, description = parts.split(':', 1)
+                    priority_actions.append({
+                        'title': title.strip(),
+                        'description': description.strip(),
+                        'priority': 'HIGH'
+                    })
+        
+        # If no high priority actions found, take first 3
+        if not priority_actions and recommendations:
+            for i, rec in enumerate(recommendations[:3]):
+                if ':' in rec:
+                    title, description = rec.split(':', 1)
+                    priority_actions.append({
+                        'title': title.replace('*', '').strip(),
+                        'description': description.strip(),
+                        'priority': 'HIGH'
+                    })
+        
+        return priority_actions[:5]  # Top 5 priority actions
+    
+    def _generate_fallback_recommendations(self, technical_data: Dict, content_data: Dict, 
+                                         keywords_data: Dict, backlinks_data: Dict, error: str = None) -> Dict[str, Any]:
+        """Generate basic recommendations when LLM is not available"""
+        
+        recommendations = []
+        
+        # Technical recommendations
+        mobile_score = technical_data.get('mobile_score', 0)
+        desktop_score = technical_data.get('desktop_score', 0)
+        
+        if mobile_score < 50:
+            recommendations.append("**HIGH** Improve Mobile Performance: Optimize images, reduce JavaScript, enable compression")
+        if desktop_score < 50:
+            recommendations.append("**HIGH** Improve Desktop Performance: Optimize server response time, minimize CSS and JavaScript")
+        
+        # Content recommendations
+        pages = content_data.get('pages_analyzed', 0)
+        if pages > 0:
+            metadata = content_data.get('metadata_completeness', {})
+            if metadata.get('with_title', 0) < pages * 0.8:
+                recommendations.append("**HIGH** Fix Metadata: Add missing title tags and meta descriptions")
+            
+            if content_data.get('avg_word_count', 0) < 300:
+                recommendations.append("**MEDIUM** Enhance Content: Increase average page content length")
+        
+        # Keywords recommendations
+        if not keywords_data.get('placeholder', False):
+            total_keywords = keywords_data.get('total_keywords', 0)
+            pos_dist = keywords_data.get('position_distribution', {})
+            
+            if total_keywords > 0 and pos_dist.get('top_10', 0) < total_keywords * 0.2:
+                recommendations.append("**HIGH** Improve Keyword Rankings: Focus on on-page SEO for underperforming keywords")
+        else:
+            recommendations.append("**MEDIUM** Set Up Keyword Tracking: Connect Google Search Console for keyword insights")
+        
+        # Backlinks recommendations
+        if not backlinks_data.get('placeholder', False):
+            ref_domains = backlinks_data.get('total_ref_domains', 0)
+            if ref_domains < 50:
+                recommendations.append("**HIGH** Build Authority: Implement aggressive link building and outreach strategy")
+        else:
+            recommendations.append("**MEDIUM** Set Up Backlink Monitoring: Add RapidAPI key for comprehensive link analysis")
+        
+        # Default recommendations if none generated
+        if not recommendations:
+            recommendations = [
+                "**HIGH** Audit Technical Issues: Review site speed and mobile performance",
+                "**MEDIUM** Optimize Content Strategy: Ensure all pages have unique, valuable content",
+                "**LOW** Monitor SEO Performance: Set up tracking for keywords and backlinks"
+            ]
+        
+        insights = [
+            "🔄 Basic SEO analysis completed - connect APIs for deeper insights",
+            f"📊 Analyzed {pages} pages for content quality",
+            "⚠️ Enhanced recommendations require API integrations"
+        ]
+        
+        if error:
+            insights.append(f"❌ LLM Error: {error}")
+        
+        return {
+            'recommendations': recommendations,
+            'executive_insights': insights,
+            'priority_actions': [
+                {
+                    'title': 'Connect SEO APIs',
+                    'description': 'Set up Google Search Console and RapidAPI for comprehensive analysis',
+                    'priority': 'HIGH'
+                }
+            ],
+            'data_source': 'Fallback Analysis',
+            'generated_at': technical_data.get('last_updated', '')
+        }

modules/backlinks.py

@@ -0,0 +1,451 @@
+"""
+Backlinks Profile Module using RapidAPI endpoints
+Combines 3 RapidAPI endpoints: Best Backlink Checker, Majestic, and Domain Metrics Check
+"""
+
+import os
+import requests
+import time
+from typing import Dict, Any, List, Optional
+from urllib.parse import urlparse
+from datetime import datetime, timedelta
+
+
+class ModuleResult:
+    """Standard result object for SEO modules"""
+    def __init__(self, success: bool, data: Dict[str, Any], error: str = None):
+        self.success = success
+        self.data = data
+        self.error = error
+
+
+class BacklinksModule:
+    def __init__(self):
+        self.rapidapi_key = os.getenv('RAPIDAPI_KEY')
+        self.timeout = int(os.getenv('RAPIDAPI_TIMEOUT', '30'))
+        self.max_retries = int(os.getenv('BACKLINKS_MAX_RETRIES', '3'))
+        
+        # RapidAPI endpoints
+        self.backlink_checker_url = "https://best-backlink-checker-api.p.rapidapi.com/excatbacklinks_noneng.php"
+        self.majestic_url = "https://majestic1.p.rapidapi.com/url_metrics"
+        self.domain_metrics_url = "https://domain-metrics-check.p.rapidapi.com/domain-metrics"
+        
+        # Common headers
+        self.headers = {
+            'x-rapidapi-key': self.rapidapi_key,
+            'Accept': 'application/json'
+        }
+        
+    def analyze(self, url: str, quick_scan: bool = False) -> ModuleResult:
+        """
+        Analyze backlink profile using multiple RapidAPI endpoints
+        
+        Args:
+            url: Target website URL
+            quick_scan: If True, use cached data or limited analysis
+            
+        Returns:
+            ModuleResult with comprehensive backlinks data
+        """
+        try:
+            if not self.rapidapi_key:
+                return self._generate_no_api_data(url)
+            
+            domain = self._extract_domain(url)
+            
+            # Call all 3 APIs with retry logic
+            individual_backlinks = self._get_individual_backlinks(domain, quick_scan)
+            majestic_metrics = self._get_majestic_metrics(domain)
+            domain_metrics = self._get_domain_metrics(domain)
+            
+            # Combine and process all data
+            combined_data = self._combine_backlink_data(
+                domain, individual_backlinks, majestic_metrics, domain_metrics, quick_scan
+            )
+            
+            return ModuleResult(success=True, data=combined_data)
+            
+        except Exception as e:
+            return ModuleResult(
+                success=False,
+                data={},
+                error=f"Backlinks analysis failed: {str(e)}"
+            )
+    
+    def _extract_domain(self, url: str) -> str:
+        """Extract clean domain from URL"""
+        if not url.startswith(('http://', 'https://')):
+            url = 'https://' + url
+        domain = urlparse(url).netloc.replace('www.', '')
+        return domain
+    
+    def _api_request_with_retry(self, url: str, params: Dict = None, headers: Dict = None) -> Optional[Dict]:
+        """Make API request with retry logic"""
+        if headers is None:
+            headers = self.headers.copy()
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = requests.get(url, params=params, headers=headers, timeout=self.timeout)
+                
+                if response.status_code == 200:
+                    return response.json()
+                elif response.status_code == 429:  # Rate limit
+                    wait_time = (attempt + 1) * 2  # Exponential backoff
+                    print(f"Rate limited, waiting {wait_time}s...")
+                    time.sleep(wait_time)
+                    continue
+                else:
+                    print(f"API error {response.status_code}: {response.text}")
+                    
+            except requests.exceptions.Timeout:
+                print(f"Timeout on attempt {attempt + 1}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(2)
+                    
+            except Exception as e:
+                print(f"Request error: {str(e)}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(2)
+        
+        return None
+    
+    def _get_individual_backlinks(self, domain: str, quick_scan: bool = False) -> List[Dict]:
+        """Get individual backlinks data"""
+        try:
+            headers = self.headers.copy()
+            headers['x-rapidapi-host'] = 'best-backlink-checker-api.p.rapidapi.com'
+            
+            params = {'domain': f'https://{domain}'}
+            
+            data = self._api_request_with_retry(self.backlink_checker_url, params, headers)
+            
+            if data and isinstance(data, list):
+                # Limit results for quick scan
+                if quick_scan:
+                    return data[:50]
+                return data[:500]  # Reasonable limit to avoid memory issues
+                
+        except Exception as e:
+            print(f"Individual backlinks API error: {str(e)}")
+        
+        return []
+    
+    def _get_majestic_metrics(self, domain: str) -> Dict[str, Any]:
+        """Get Majestic domain metrics via RapidAPI"""
+        try:
+            headers = self.headers.copy()
+            headers['x-rapidapi-host'] = 'majestic1.p.rapidapi.com'
+            
+            params = {'url': domain}
+            
+            data = self._api_request_with_retry(self.majestic_url, params, headers)
+            
+            if data and data.get('status') == 'success':
+                return data
+                
+        except Exception as e:
+            print(f"Majestic RapidAPI error: {str(e)}")
+        
+        return {}
+    
+    def _get_domain_metrics(self, domain: str) -> Dict[str, Any]:
+        """Get comprehensive domain metrics"""
+        try:
+            headers = self.headers.copy()
+            headers['x-rapidapi-host'] = 'domain-metrics-check.p.rapidapi.com'
+            
+            # API expects domain with trailing slash
+            url = f"{self.domain_metrics_url}/{domain}/"
+            
+            data = self._api_request_with_retry(url, headers=headers)
+            
+            if data and data.get('domain'):
+                return data
+                
+        except Exception as e:
+            print(f"Domain metrics API error: {str(e)}")
+        
+        return {}
+    
+    def _combine_backlink_data(self, domain: str, individual_backlinks: List[Dict], 
+                              majestic_metrics: Dict, domain_metrics: Dict, quick_scan: bool) -> Dict[str, Any]:
+        """Combine data from all 3 APIs into comprehensive backlinks profile"""
+        
+        # Primary metrics (prefer Domain Metrics Check, fallback to Majestic)
+        total_backlinks = (
+            int(domain_metrics.get('ahrefsBacklinks', 0)) or
+            int(domain_metrics.get('majesticLinks', 0)) or
+            int(majestic_metrics.get('majesticLinks', 0)) or
+            len(individual_backlinks)
+        )
+        
+        total_ref_domains = (
+            int(domain_metrics.get('ahrefsRefDomains', 0)) or
+            int(domain_metrics.get('majesticRefDomains', 0)) or
+            int(majestic_metrics.get('majesticRefDomains', 0)) or
+            len(set(link.get('url_from', '').split('/')[2] for link in individual_backlinks if link.get('url_from')))
+        )
+        
+        # Authority scores (multiple sources for validation)
+        domain_rating = (
+            int(domain_metrics.get('ahrefsDR', 0)) or
+            int(domain_metrics.get('majesticTF', 0)) or
+            int(majestic_metrics.get('majesticTF', 0))
+        )
+        
+        # Process individual backlinks for detailed analysis
+        referring_domains = self._extract_referring_domains(individual_backlinks)
+        anchor_distribution = self._extract_anchor_distribution(individual_backlinks)
+        monthly_changes = self._calculate_monthly_changes(individual_backlinks)
+        top_backlinks = self._get_top_backlinks(individual_backlinks)
+        
+        # Link quality analysis
+        quality_metrics = self._analyze_link_quality(individual_backlinks, domain_metrics)
+        
+        # Comprehensive backlinks data
+        backlinks_data = {
+            'total_backlinks': total_backlinks,
+            'total_ref_domains': total_ref_domains,
+            'domain_rating': domain_rating,
+            
+            # Authority scores from multiple sources
+            'authority_scores': {
+                'ahrefs_dr': int(domain_metrics.get('ahrefsDR', 0)),
+                'moz_da': int(domain_metrics.get('mozDA', 0)),
+                'moz_pa': int(domain_metrics.get('mozPA', 0)),
+                'majestic_tf': int(domain_metrics.get('majesticTF', 0) or majestic_metrics.get('majesticTF', 0)),
+                'majestic_cf': int(domain_metrics.get('majesticCF', 0) or majestic_metrics.get('majesticCF', 0))
+            },
+            
+            # Detailed analysis
+            'referring_domains': referring_domains,
+            'anchor_distribution': anchor_distribution,
+            'monthly_changes': monthly_changes,
+            'top_backlinks': top_backlinks,
+            'quality_metrics': quality_metrics,
+            
+            # Educational and government links (high-quality indicators)
+            'edu_links': int(domain_metrics.get('majesticRefEDU', 0) or majestic_metrics.get('majesticRefEDU', 0)),
+            'gov_links': int(domain_metrics.get('majesticRefGov', 0) or majestic_metrics.get('majesticRefGov', 0)),
+            
+            # Traffic estimates (if available)
+            'estimated_organic_traffic': float(domain_metrics.get('ahrefsTraffic', 0)),
+            'organic_keywords': int(domain_metrics.get('ahrefsOrganicKeywords', 0)),
+            
+            # Data sources and metadata
+            'data_sources': self._get_data_sources(individual_backlinks, majestic_metrics, domain_metrics),
+            'last_updated': datetime.now().isoformat(),
+            'quick_scan': quick_scan,
+            'analysis_depth': 'comprehensive' if not quick_scan else 'basic'
+        }
+        
+        return backlinks_data
+    
+    def _extract_referring_domains(self, backlinks: List[Dict]) -> List[Dict[str, Any]]:
+        """Extract and analyze referring domains"""
+        domain_stats = {}
+        
+        for link in backlinks:
+            if not link.get('url_from'):
+                continue
+                
+            try:
+                source_domain = urlparse(link['url_from']).netloc
+                if source_domain not in domain_stats:
+                    domain_stats[source_domain] = {
+                        'domain': source_domain,
+                        'backlinks': 0,
+                        'first_seen': link.get('first_seen', ''),
+                        'domain_authority': link.get('domain_inlink_rank', 0),
+                        'follow_links': 0,
+                        'nofollow_links': 0
+                    }
+                
+                domain_stats[source_domain]['backlinks'] += 1
+                
+                if link.get('nofollow'):
+                    domain_stats[source_domain]['nofollow_links'] += 1
+                else:
+                    domain_stats[source_domain]['follow_links'] += 1
+                    
+            except Exception:
+                continue
+        
+        # Sort by backlinks count and return top domains
+        top_domains = sorted(domain_stats.values(), key=lambda x: x['backlinks'], reverse=True)
+        return top_domains[:20]  # Top 20 referring domains
+    
+    def _extract_anchor_distribution(self, backlinks: List[Dict]) -> List[Dict[str, Any]]:
+        """Analyze anchor text distribution"""
+        anchor_stats = {}
+        
+        for link in backlinks:
+            anchor = link.get('anchor', '').strip()
+            if not anchor or len(anchor) > 100:  # Skip very long anchors
+                continue
+                
+            if anchor not in anchor_stats:
+                anchor_stats[anchor] = {
+                    'anchor_text': anchor,
+                    'backlinks': 0,
+                    'follow_links': 0,
+                    'nofollow_links': 0,
+                    'unique_domains': set()
+                }
+            
+            anchor_stats[anchor]['backlinks'] += 1
+            
+            if link.get('nofollow'):
+                anchor_stats[anchor]['nofollow_links'] += 1
+            else:
+                anchor_stats[anchor]['follow_links'] += 1
+            
+            # Track unique domains for this anchor
+            try:
+                domain = urlparse(link.get('url_from', '')).netloc
+                anchor_stats[anchor]['unique_domains'].add(domain)
+            except Exception:
+                pass
+        
+        # Convert sets to counts and sort
+        anchor_distribution = []
+        for anchor_data in anchor_stats.values():
+            anchor_data['unique_domains'] = len(anchor_data['unique_domains'])
+            anchor_distribution.append(anchor_data)
+        
+        # Sort by backlinks count
+        anchor_distribution.sort(key=lambda x: x['backlinks'], reverse=True)
+        return anchor_distribution[:15]  # Top 15 anchor texts
+    
+    def _calculate_monthly_changes(self, backlinks: List[Dict]) -> Dict[str, int]:
+        """Calculate monthly backlinks changes"""
+        now = datetime.now()
+        last_month = now - timedelta(days=30)
+        
+        new_links = 0
+        recent_links = 0
+        
+        for link in backlinks:
+            first_seen = link.get('first_seen', '')
+            if not first_seen:
+                continue
+                
+            try:
+                link_date = datetime.strptime(first_seen, '%Y-%m-%d')
+                if link_date >= last_month:
+                    new_links += 1
+                if link_date >= now - timedelta(days=90):  # 3 months
+                    recent_links += 1
+            except Exception:
+                continue
+        
+        return {
+            'new_backlinks': new_links,
+            'lost_backlinks': 0,  # Can't calculate without historical data
+            'net_change': new_links,
+            'recent_backlinks_3m': recent_links
+        }
+    
+    def _get_top_backlinks(self, backlinks: List[Dict]) -> List[Dict[str, Any]]:
+        """Get top-quality backlinks"""
+        # Sort by inlink_rank (higher is better)
+        sorted_links = sorted(
+            backlinks, 
+            key=lambda x: x.get('inlink_rank', 0), 
+            reverse=True
+        )
+        
+        top_links = []
+        for link in sorted_links[:10]:
+            top_links.append({
+                'source_url': link.get('url_from', ''),
+                'source_title': link.get('title', ''),
+                'anchor_text': link.get('anchor', ''),
+                'is_follow': not link.get('nofollow', True),
+                'authority_score': link.get('inlink_rank', 0),
+                'first_seen': link.get('first_seen', '')
+            })
+        
+        return top_links
+    
+    def _analyze_link_quality(self, backlinks: List[Dict], domain_metrics: Dict) -> Dict[str, Any]:
+        """Analyze overall link quality metrics"""
+        if not backlinks:
+            return {'follow_ratio': 0, 'avg_authority': 0, 'quality_score': 0}
+        
+        follow_count = sum(1 for link in backlinks if not link.get('nofollow', True))
+        total_links = len(backlinks)
+        follow_ratio = (follow_count / total_links * 100) if total_links > 0 else 0
+        
+        # Average authority score
+        authority_scores = [link.get('inlink_rank', 0) for link in backlinks if link.get('inlink_rank')]
+        avg_authority = sum(authority_scores) / len(authority_scores) if authority_scores else 0
+        
+        # Quality score (0-100)
+        quality_score = min(100, (
+            (follow_ratio * 0.4) +  # 40% weight on follow ratio
+            (avg_authority * 2) +   # 40% weight on authority (scaled)
+            (min(20, len(set(link.get('url_from', '').split('/')[2] for link in backlinks))) * 1)  # 20% on domain diversity
+        ))
+        
+        return {
+            'follow_ratio': round(follow_ratio, 1),
+            'avg_authority': round(avg_authority, 1),
+            'quality_score': round(quality_score, 1),
+            'total_analyzed': total_links,
+            'edu_gov_count': int(domain_metrics.get('majesticRefEDU', 0)) + int(domain_metrics.get('majesticRefGov', 0))
+        }
+    
+    def _get_data_sources(self, individual_backlinks: List, majestic_metrics: Dict, domain_metrics: Dict) -> List[str]:
+        """Track which data sources provided information"""
+        sources = []
+        
+        if individual_backlinks:
+            sources.append('Best Backlink Checker API')
+        if majestic_metrics:
+            sources.append('Majestic RapidAPI')
+        if domain_metrics:
+            sources.append('Domain Metrics Check API')
+            
+        return sources or ['No data sources available']
+    
+    def _generate_no_api_data(self, url: str) -> ModuleResult:
+        """Generate response when no API key is available"""
+        domain = self._extract_domain(url)
+        
+        no_api_data = {
+            'total_backlinks': 0,
+            'total_ref_domains': 0,
+            'domain_rating': 0,
+            'authority_scores': {
+                'ahrefs_dr': 0,
+                'moz_da': 0,
+                'moz_pa': 0,
+                'majestic_tf': 0,
+                'majestic_cf': 0
+            },
+            'referring_domains': [],
+            'anchor_distribution': [],
+            'monthly_changes': {
+                'new_backlinks': 0,
+                'lost_backlinks': 0,
+                'net_change': 0
+            },
+            'top_backlinks': [],
+            'quality_metrics': {
+                'follow_ratio': 0,
+                'avg_authority': 0,
+                'quality_score': 0
+            },
+            'edu_links': 0,
+            'gov_links': 0,
+            'estimated_organic_traffic': 0,
+            'organic_keywords': 0,
+            'data_sources': ['No API credentials available'],
+            'last_updated': datetime.now().isoformat(),
+            'placeholder': True,
+            'message': 'Add RAPIDAPI_KEY to your .env file to unlock comprehensive backlinks analysis using Best Backlink Checker, Majestic, and Domain Metrics Check RapidAPIs.'
+        }
+        
+        return ModuleResult(success=True, data=no_api_data)

modules/keywords.py

@@ -0,0 +1,315 @@
+"""
+Keywords Rankings Module for SEO Report Generator
+Supports Google Search Console API (primary) and SERP API (fallback)
+"""
+
+import os
+import requests
+import json
+from typing import Dict, Any, List, Optional
+from urllib.parse import urlparse
+from datetime import datetime, timedelta
+
+
+class ModuleResult:
+    """Standard result object for SEO modules"""
+    def __init__(self, success: bool, data: Dict[str, Any], error: str = None):
+        self.success = success
+        self.data = data
+        self.error = error
+
+
+class KeywordsModule:
+    def __init__(self):
+        self.gsc_api_key = os.getenv('GOOGLE_SEARCH_CONSOLE_API_KEY')
+        self.serp_api_key = os.getenv('SERP_API_KEY')  # SerpAPI or similar
+        self.data_for_seo_key = os.getenv('DATAFORSEO_API_KEY')
+        
+    def analyze(self, url: str, quick_scan: bool = False) -> ModuleResult:
+        """
+        Analyze keyword rankings for the given URL
+        
+        Args:
+            url: Target website URL
+            quick_scan: If True, use limited data for competitor analysis
+            
+        Returns:
+            ModuleResult with keywords data
+        """
+        try:
+            domain = self._extract_domain(url)
+            
+            # Try Google Search Console first (if credentials available)
+            if self.gsc_api_key:
+                result = self._analyze_with_gsc(domain, quick_scan)
+                if result.success:
+                    return result
+            
+            # Fallback to SERP API
+            if self.serp_api_key:
+                result = self._analyze_with_serp_api(domain, quick_scan)
+                if result.success:
+                    return result
+            
+            # Fallback to DataForSEO
+            if self.data_for_seo_key:
+                result = self._analyze_with_dataforseo(domain, quick_scan)
+                if result.success:
+                    return result
+            
+            # No API keys available - return placeholder data
+            return self._generate_placeholder_data(domain)
+            
+        except Exception as e:
+            return ModuleResult(
+                success=False,
+                data={},
+                error=f"Keywords analysis failed: {str(e)}"
+            )
+    
+    def _extract_domain(self, url: str) -> str:
+        """Extract domain from URL"""
+        if not url.startswith(('http://', 'https://')):
+            url = 'https://' + url
+        return urlparse(url).netloc.replace('www.', '')
+    
+    def _analyze_with_gsc(self, domain: str, quick_scan: bool) -> ModuleResult:
+        """Analyze with Google Search Console API"""
+        try:
+            # Note: GSC API requires site verification and proper setup
+            # This is a simplified implementation - real GSC API needs OAuth2
+            
+            # GSC API endpoint (simplified)
+            base_url = "https://searchconsole.googleapis.com/webmasters/v3/sites"
+            site_url = f"https://{domain}/"
+            
+            # Get search analytics data
+            analytics_url = f"{base_url}/{site_url}/searchAnalytics/query"
+            
+            # Date range (last 90 days)
+            end_date = datetime.now().date()
+            start_date = end_date - timedelta(days=90)
+            
+            payload = {
+                "startDate": start_date.isoformat(),
+                "endDate": end_date.isoformat(),
+                "dimensions": ["query", "page"],
+                "rowLimit": 1000 if not quick_scan else 100
+            }
+            
+            headers = {
+                "Authorization": f"Bearer {self.gsc_api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            response = requests.post(analytics_url, json=payload, headers=headers, timeout=30)
+            
+            if response.status_code != 200:
+                raise Exception(f"GSC API error: {response.status_code}")
+            
+            data = response.json()
+            return self._process_gsc_data(data, domain)
+            
+        except Exception as e:
+            return ModuleResult(success=False, data={}, error=str(e))
+    
+    def _analyze_with_serp_api(self, domain: str, quick_scan: bool) -> ModuleResult:
+        """Analyze with SERP API (SerpAPI, etc.)"""
+        try:
+            # Using SerpAPI as example
+            url = "https://serpapi.com/search"
+            
+            params = {
+                "engine": "google",
+                "q": f"site:{domain}",
+                "api_key": self.serp_api_key,
+                "num": 100 if not quick_scan else 20
+            }
+            
+            response = requests.get(url, params=params, timeout=30)
+            
+            if response.status_code != 200:
+                raise Exception(f"SERP API error: {response.status_code}")
+            
+            data = response.json()
+            return self._process_serp_data(data, domain)
+            
+        except Exception as e:
+            return ModuleResult(success=False, data={}, error=str(e))
+    
+    def _analyze_with_dataforseo(self, domain: str, quick_scan: bool) -> ModuleResult:
+        """Analyze with DataForSEO API"""
+        try:
+            # DataForSEO implementation
+            auth = (self.data_for_seo_key, os.getenv('DATAFORSEO_API_PASSWORD', ''))
+            
+            # Get domain keywords
+            url = "https://api.dataforseo.com/v3/dataforseo_labs/google/ranked_keywords/live"
+            
+            payload = {
+                "target": domain,
+                "limit": 1000 if not quick_scan else 100,
+                "offset": 0,
+                "filters": [
+                    ["metrics.organic.pos", "<=", 100]
+                ]
+            }
+            
+            response = requests.post(url, json=[payload], auth=auth, timeout=60)
+            
+            if response.status_code != 200:
+                raise Exception(f"DataForSEO API error: {response.status_code}")
+            
+            data = response.json()
+            return self._process_dataforseo_data(data, domain)
+            
+        except Exception as e:
+            return ModuleResult(success=False, data={}, error=str(e))
+    
+    def _process_gsc_data(self, data: Dict, domain: str) -> ModuleResult:
+        """Process Google Search Console data"""
+        if 'rows' not in data:
+            return ModuleResult(success=False, data={}, error="No GSC data available")
+        
+        rows = data['rows']
+        total_keywords = len(rows)
+        
+        # Position distribution
+        top_3 = sum(1 for row in rows if row.get('position', 100) <= 3)
+        top_10 = sum(1 for row in rows if row.get('position', 100) <= 10)
+        top_50 = sum(1 for row in rows if row.get('position', 100) <= 50)
+        
+        # Best and worst performing
+        sorted_by_position = sorted(rows, key=lambda x: x.get('position', 100))
+        best_keywords = sorted_by_position[:10]
+        worst_keywords = sorted_by_position[-10:]
+        
+        # High opportunity keywords (high impressions, low clicks)
+        opportunity_keywords = []
+        for row in rows:
+            impressions = row.get('impressions', 0)
+            clicks = row.get('clicks', 0)
+            ctr = (clicks / impressions * 100) if impressions > 0 else 0
+            
+            if impressions > 100 and ctr < 2 and row.get('position', 100) > 10:
+                opportunity_keywords.append({
+                    'keyword': row.get('keys', [''])[0],
+                    'position': row.get('position', 0),
+                    'impressions': impressions,
+                    'clicks': clicks,
+                    'ctr': round(ctr, 2)
+                })
+        
+        opportunity_keywords = sorted(opportunity_keywords, key=lambda x: x['impressions'], reverse=True)[:10]
+        
+        keywords_data = {
+            'total_keywords': total_keywords,
+            'position_distribution': {
+                'top_3': top_3,
+                'top_10': top_10,
+                'top_50': top_50,
+                'beyond_50': total_keywords - top_50
+            },
+            'best_keywords': [
+                {
+                    'keyword': row.get('keys', [''])[0],
+                    'position': row.get('position', 0),
+                    'clicks': row.get('clicks', 0),
+                    'impressions': row.get('impressions', 0)
+                } for row in best_keywords
+            ],
+            'worst_keywords': [
+                {
+                    'keyword': row.get('keys', [''])[0],
+                    'position': row.get('position', 0),
+                    'clicks': row.get('clicks', 0),
+                    'impressions': row.get('impressions', 0)
+                } for row in worst_keywords
+            ],
+            'opportunity_keywords': opportunity_keywords,
+            'data_source': 'Google Search Console',
+            'last_updated': datetime.now().isoformat()
+        }
+        
+        return ModuleResult(success=True, data=keywords_data)
+    
+    def _process_serp_data(self, data: Dict, domain: str) -> ModuleResult:
+        """Process SERP API data"""
+        # Simplified SERP data processing
+        organic_results = data.get('organic_results', [])
+        
+        keywords_data = {
+            'total_keywords': len(organic_results),
+            'position_distribution': {
+                'top_3': len([r for r in organic_results if r.get('position', 100) <= 3]),
+                'top_10': len([r for r in organic_results if r.get('position', 100) <= 10]),
+                'top_50': len([r for r in organic_results if r.get('position', 100) <= 50]),
+                'beyond_50': len([r for r in organic_results if r.get('position', 100) > 50])
+            },
+            'best_keywords': [
+                {
+                    'keyword': r.get('title', ''),
+                    'position': r.get('position', 0),
+                    'url': r.get('link', '')
+                } for r in organic_results[:10]
+            ],
+            'data_source': 'SERP API',
+            'last_updated': datetime.now().isoformat()
+        }
+        
+        return ModuleResult(success=True, data=keywords_data)
+    
+    def _process_dataforseo_data(self, data: Dict, domain: str) -> ModuleResult:
+        """Process DataForSEO data"""
+        if not data.get('tasks') or not data['tasks'][0].get('result'):
+            return ModuleResult(success=False, data={}, error="No DataForSEO data available")
+        
+        results = data['tasks'][0]['result']
+        total_keywords = len(results)
+        
+        # Position distribution
+        top_3 = sum(1 for r in results if r.get('metrics', {}).get('organic', {}).get('pos', 100) <= 3)
+        top_10 = sum(1 for r in results if r.get('metrics', {}).get('organic', {}).get('pos', 100) <= 10)
+        top_50 = sum(1 for r in results if r.get('metrics', {}).get('organic', {}).get('pos', 100) <= 50)
+        
+        keywords_data = {
+            'total_keywords': total_keywords,
+            'position_distribution': {
+                'top_3': top_3,
+                'top_10': top_10,
+                'top_50': top_50,
+                'beyond_50': total_keywords - top_50
+            },
+            'best_keywords': [
+                {
+                    'keyword': r.get('keyword', ''),
+                    'position': r.get('metrics', {}).get('organic', {}).get('pos', 0),
+                    'search_volume': r.get('keyword_info', {}).get('search_volume', 0)
+                } for r in sorted(results, key=lambda x: x.get('metrics', {}).get('organic', {}).get('pos', 100))[:10]
+            ],
+            'data_source': 'DataForSEO',
+            'last_updated': datetime.now().isoformat()
+        }
+        
+        return ModuleResult(success=True, data=keywords_data)
+    
+    def _generate_placeholder_data(self, domain: str) -> ModuleResult:
+        """Generate placeholder data when no API keys are available"""
+        keywords_data = {
+            'total_keywords': 0,
+            'position_distribution': {
+                'top_3': 0,
+                'top_10': 0,
+                'top_50': 0,
+                'beyond_50': 0
+            },
+            'best_keywords': [],
+            'worst_keywords': [],
+            'opportunity_keywords': [],
+            'data_source': 'No API credentials',
+            'last_updated': datetime.now().isoformat(),
+            'placeholder': True,
+            'message': 'Connect Google Search Console or SERP API to unlock keyword data'
+        }
+        
+        return ModuleResult(success=True, data=keywords_data)

report_generator.py

@@ -12,16 +12,17 @@ class ReportGenerator:
     
     def generate_html_report(self, url: str, technical_data: Dict[str, Any], 
                            content_data: Dict[str, Any], competitor_data: List[Dict] = None,
-                           include_charts: bool = True) -> str:
+                           keywords_data: Dict[str, Any] = None, backlinks_data: Dict[str, Any] = None,
+                           llm_recommendations: Dict[str, Any] = None, include_charts: bool = True) -> str:
         """Generate complete HTML SEO report"""
         
         # Generate charts
         charts_html = ""
         if include_charts:
-            charts_html = self._generate_charts(technical_data, content_data, competitor_data)
+            charts_html = self._generate_charts(technical_data, content_data, competitor_data, keywords_data, backlinks_data)
         
-        # Generate executive summary
-        executive_summary = self._generate_executive_summary(technical_data, content_data)
+        # Generate executive summary (now includes LLM insights)
+        executive_summary = self._generate_executive_summary(technical_data, content_data, llm_recommendations)
         
         # Generate technical SEO section
         technical_section = self._generate_technical_section(technical_data)
@@ -29,6 +30,15 @@ class ReportGenerator:
         # Generate content audit section
         content_section = self._generate_content_section(content_data)
         
+        # Generate keywords section
+        keywords_section = self._generate_keywords_section(keywords_data) if keywords_data else ""
+        
+        # Generate backlinks section
+        backlinks_section = self._generate_backlinks_section(backlinks_data) if backlinks_data else ""
+        
+        # Generate LLM recommendations section
+        recommendations_section = self._generate_recommendations_section(llm_recommendations) if llm_recommendations else ""
+        
         # Generate competitor section
         competitor_section = ""
         if competitor_data:
@@ -48,15 +58,19 @@ class ReportGenerator:
             executive_summary=executive_summary,
             technical_section=technical_section,
             content_section=content_section,
+            keywords_section=keywords_section,
+            backlinks_section=backlinks_section,
             competitor_section=competitor_section,
             placeholder_sections=placeholder_sections,
-            recommendations=recommendations
+            recommendations=recommendations,
+            llm_recommendations=recommendations_section
         )
         
         return report_html
     
     def _generate_charts(self, technical_data: Dict[str, Any], content_data: Dict[str, Any], 
-                        competitor_data: List[Dict] = None) -> str:
+                        competitor_data: List[Dict] = None, keywords_data: Dict[str, Any] = None, 
+                        backlinks_data: Dict[str, Any] = None) -> str:
         """Generate interactive charts using Plotly"""
         charts_html = ""
         
@@ -204,7 +218,8 @@ class ReportGenerator:
         
         return charts_html
     
-    def _generate_executive_summary(self, technical_data: Dict[str, Any], content_data: Dict[str, Any]) -> str:
+    def _generate_executive_summary(self, technical_data: Dict[str, Any], content_data: Dict[str, Any], 
+                                   llm_recommendations: Dict[str, Any] = None) -> str:
         """Generate executive summary section"""
         # Calculate overall health score
         mobile_perf = technical_data.get('mobile', {}).get('performance_score', 0)
@@ -650,6 +665,219 @@ class ReportGenerator:
         </div>
         """
     
+    def _generate_keywords_section(self, keywords_data: Dict[str, Any]) -> str:
+        """Generate keywords analysis section"""
+        if keywords_data.get('placeholder'):
+            return f"""
+            <div class="placeholder-section">
+                <h3>🔍 Keyword Rankings</h3>
+                <div class="placeholder-content">
+                    <p><strong>No keyword data available.</strong></p>
+                    <p>{keywords_data.get('message', 'Connect Google Search Console or SERP API to unlock keyword insights.')}</p>
+                </div>
+            </div>
+            """
+        
+        total = keywords_data.get('total_keywords', 0)
+        pos_dist = keywords_data.get('position_distribution', {})
+        best_keywords = keywords_data.get('best_keywords', [])
+        opportunity_keywords = keywords_data.get('opportunity_keywords', [])
+        
+        # Create position distribution chart
+        pos_chart = ""
+        if pos_dist:
+            import plotly.graph_objects as go
+            from plotly.offline import plot
+            
+            labels = ['Top 3', 'Top 10', 'Top 50', 'Beyond 50']
+            values = [
+                pos_dist.get('top_3', 0),
+                pos_dist.get('top_10', 0) - pos_dist.get('top_3', 0),
+                pos_dist.get('top_50', 0) - pos_dist.get('top_10', 0),
+                pos_dist.get('beyond_50', 0)
+            ]
+            
+            fig = go.Figure(data=[go.Pie(labels=labels, values=values, hole=0.4)])
+            fig.update_layout(title="Keyword Position Distribution", height=400)
+            pos_chart = plot(fig, include_plotlyjs=False, output_type='div')
+        
+        best_keywords_html = ""
+        if best_keywords:
+            best_keywords_html = "<h4>🏆 Top Performing Keywords</h4><table class='data-table'><tr><th>Keyword</th><th>Position</th><th>Clicks</th><th>Impressions</th></tr>"
+            for kw in best_keywords[:10]:
+                best_keywords_html += f"""
+                <tr>
+                    <td>{kw.get('keyword', '')}</td>
+                    <td>{kw.get('position', 0)}</td>
+                    <td>{kw.get('clicks', 0)}</td>
+                    <td>{kw.get('impressions', 0)}</td>
+                </tr>
+                """
+            best_keywords_html += "</table>"
+        
+        opportunity_html = ""
+        if opportunity_keywords:
+            opportunity_html = "<h4>🚀 Opportunity Keywords</h4><table class='data-table'><tr><th>Keyword</th><th>Position</th><th>Impressions</th><th>CTR</th></tr>"
+            for kw in opportunity_keywords[:10]:
+                opportunity_html += f"""
+                <tr>
+                    <td>{kw.get('keyword', '')}</td>
+                    <td>{kw.get('position', 0)}</td>
+                    <td>{kw.get('impressions', 0)}</td>
+                    <td>{kw.get('ctr', 0)}%</td>
+                </tr>
+                """
+            opportunity_html += "</table>"
+        
+        return f"""
+        <div class="card">
+            <h3>🔍 Keyword Rankings Analysis</h3>
+            <div class="metrics-grid">
+                <div class="metric-card">
+                    <div class="metric-value">{total}</div>
+                    <div class="metric-label">Total Keywords</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-value">{pos_dist.get('top_10', 0)}</div>
+                    <div class="metric-label">Top 10 Rankings</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-value">{len(opportunity_keywords)}</div>
+                    <div class="metric-label">Opportunities</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-value">{keywords_data.get('data_source', 'Unknown')}</div>
+                    <div class="metric-label">Data Source</div>
+                </div>
+            </div>
+            {pos_chart}
+            {best_keywords_html}
+            {opportunity_html}
+        </div>
+        """
+    
+    def _generate_backlinks_section(self, backlinks_data: Dict[str, Any]) -> str:
+        """Generate backlinks analysis section"""
+        if backlinks_data.get('placeholder'):
+            return f"""
+            <div class="placeholder-section">
+                <h3>🔗 Backlink Profile</h3>
+                <div class="placeholder-content">
+                    <p><strong>No backlink data available.</strong></p>
+                    <p>{backlinks_data.get('message', 'Add RapidAPI key to unlock comprehensive backlink insights.')}</p>
+                </div>
+            </div>
+            """
+        
+        total_backlinks = backlinks_data.get('total_backlinks', 0)
+        total_ref_domains = backlinks_data.get('total_ref_domains', 0)
+        domain_rating = backlinks_data.get('domain_rating', 0)
+        monthly_changes = backlinks_data.get('monthly_changes', {})
+        referring_domains = backlinks_data.get('referring_domains', [])
+        anchor_distribution = backlinks_data.get('anchor_distribution', [])
+        
+        # Create anchor text distribution chart
+        anchor_chart = ""
+        if anchor_distribution:
+            import plotly.graph_objects as go
+            from plotly.offline import plot
+            
+            anchors = [a.get('anchor_text', '')[:30] for a in anchor_distribution[:10]]
+            counts = [a.get('backlinks', 0) for a in anchor_distribution[:10]]
+            
+            fig = go.Figure(data=[go.Bar(x=anchors, y=counts)])
+            fig.update_layout(title="Top Anchor Text Distribution", height=400, xaxis={'tickangle': 45})
+            anchor_chart = plot(fig, include_plotlyjs=False, output_type='div')
+        
+        ref_domains_html = ""
+        if referring_domains:
+            ref_domains_html = "<h4>🏢 Top Referring Domains</h4><table class='data-table'><tr><th>Domain</th><th>Domain Rating</th><th>Backlinks</th><th>First Seen</th></tr>"
+            for rd in referring_domains[:10]:
+                ref_domains_html += f"""
+                <tr>
+                    <td>{rd.get('domain', '')}</td>
+                    <td>{rd.get('domain_rating', 0)}</td>
+                    <td>{rd.get('backlinks', 0)}</td>
+                    <td>{rd.get('first_seen', 'N/A')}</td>
+                </tr>
+                """
+            ref_domains_html += "</table>"
+        
+        return f"""
+        <div class="card">
+            <h3>🔗 Backlink Profile Analysis</h3>
+            <div class="metrics-grid">
+                <div class="metric-card">
+                    <div class="metric-value">{total_backlinks:,}</div>
+                    <div class="metric-label">Total Backlinks</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-value">{total_ref_domains:,}</div>
+                    <div class="metric-label">Referring Domains</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-value">{domain_rating}</div>
+                    <div class="metric-label">Domain Rating</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-value">{monthly_changes.get('net_change', 0):+d}</div>
+                    <div class="metric-label">Monthly Change</div>
+                </div>
+            </div>
+            {anchor_chart}
+            {ref_domains_html}
+        </div>
+        """
+    
+    def _generate_recommendations_section(self, llm_recommendations: Dict[str, Any]) -> str:
+        """Generate LLM-powered recommendations section"""
+        if not llm_recommendations:
+            return ""
+        
+        recommendations = llm_recommendations.get('recommendations', [])
+        executive_insights = llm_recommendations.get('executive_insights', [])
+        priority_actions = llm_recommendations.get('priority_actions', [])
+        
+        insights_html = ""
+        if executive_insights:
+            insights_html = "<div class='executive-insights'><h4>🎯 Executive Insights</h4><ul>"
+            for insight in executive_insights:
+                insights_html += f"<li>{insight}</li>"
+            insights_html += "</ul></div>"
+        
+        priority_html = ""
+        if priority_actions:
+            priority_html = "<div class='priority-actions'><h4>🔥 Priority Actions</h4>"
+            for i, action in enumerate(priority_actions[:3], 1):
+                priority_html += f"""
+                <div class="priority-action">
+                    <div class="action-number">{i}</div>
+                    <div class="action-content">
+                        <div class="action-title">{action.get('title', '')}</div>
+                        <div class="action-description">{action.get('description', '')}</div>
+                        <span class="action-priority">{action.get('priority', 'MEDIUM')}</span>
+                    </div>
+                </div>
+                """
+            priority_html += "</div>"
+        
+        recommendations_html = ""
+        if recommendations:
+            recommendations_html = "<div class='llm-recommendations'><h4>🤖 AI-Generated Recommendations</h4><ul>"
+            for rec in recommendations:
+                recommendations_html += f"<li>{rec}</li>"
+            recommendations_html += "</ul></div>"
+        
+        return f"""
+        <div class="card">
+            <h3>🧠 Smart Recommendations</h3>
+            <p class="data-source">Generated by {llm_recommendations.get('data_source', 'AI Analysis')}</p>
+            {insights_html}
+            {priority_html}
+            {recommendations_html}
+        </div>
+        """
+
     def _get_report_template(self) -> str:
         """Get the HTML template for the report"""
         return """
@@ -1084,6 +1312,16 @@ class ReportGenerator:
                     {content_section}
                 </div>
                 
+                <div class="section">
+                    <h2>🔍 Keywords Analysis</h2>
+                    {keywords_section}
+                </div>
+                
+                <div class="section">
+                    <h2>🔗 Backlinks Profile</h2>
+                    {backlinks_section}
+                </div>
+                
                 {competitor_section}
                 
                 <div class="section">
@@ -1094,6 +1332,8 @@ class ReportGenerator:
                 <div class="section">
                     {recommendations}
                 </div>
+                
+                {llm_recommendations}
             </div>
         </body>
         </html>

requirements.txt

@@ -1,5 +1,9 @@
 # Thinkly Labs SEO - Dependencies
+
+# Core Framework
 flask
+
+# Data Processing & Analysis
 requests
 beautifulsoup4
 pandas
@@ -8,4 +12,14 @@ jinja2
 validators
 urllib3
 lxml
-reportlab
+
+# PDF Generation
+reportlab
+
+# AI/LLM Integration
+groq
+python-dotenv
+
+# API Integrations (Optional - set via environment variables)
+# google-api-python-client  # For Google Search Console
+# oauth2client              # For GSC authentication

simple_pdf_generator.py

@@ -4,6 +4,7 @@ or browser-based PDF conversion instructions
 """
 
 import io
+import re
 from typing import Dict, Any
 
 class SimplePDFGenerator: