corrected analyze_page_geo in utils/scorer.py

utils/scorer.py

@@ -1,501 +1,493 @@
-"""
-GEO Scoring Module
-Analyzes content for Generative Engine Optimization (GEO) performance
-"""
-
-import json
-from typing import Dict, Any, List
-from langchain.prompts import ChatPromptTemplate
-
-
-class GEOScorer:
-    """Main class for calculating GEO scores and analysis"""
-    
-    def __init__(self, llm):
-        self.llm = llm
-        self.setup_prompts()
-    
-    def setup_prompts(self):
-        """Initialize prompts for different types of analysis"""
-        
-        # Main GEO analysis prompt
-        self.geo_analysis_prompt = """You are a Generative Engine Optimizer (GEO) specialist. Analyze the provided content for its effectiveness in AI-powered search engines and LLM systems.
-
-Evaluate the content based on these GEO criteria (score 1-10 each):
-
-1. **AI Search Visibility**: How likely is this content to be surfaced by AI search engines?
-2. **Query Intent Matching**: How well does the content match common user queries?
-3. **Factual Accuracy & Authority**: How trustworthy and authoritative is the information?
-4. **Conversational Readiness**: How suitable is the content for AI chat responses?
-5. **Semantic Richness**: How well does the content use relevant semantic keywords?
-6. **Context Completeness**: Does the content provide complete, self-contained answers?
-7. **Citation Worthiness**: How likely are AI systems to cite this content?
-8. **Multi-Query Coverage**: Does the content answer multiple related questions?
-
-Also identify:
-- Primary topics and entities
-- Missing information gaps
-- Optimization opportunities
-- Specific enhancement recommendations
-
-Format your response as JSON:
-
-```json
-{
-  "geo_scores": {
-    "ai_search_visibility": 7.5,
-    "query_intent_matching": 8.0,
-    "factual_accuracy": 9.0,
-    "conversational_readiness": 6.5,
-    "semantic_richness": 7.0,
-    "context_completeness": 8.5,
-    "citation_worthiness": 7.8,
-    "multi_query_coverage": 6.0
-  },
-  "overall_geo_score": 7.5,
-  "primary_topics": ["topic1", "topic2"],
-  "entities": ["entity1", "entity2"],
-  "missing_gaps": ["gap1", "gap2"],
-  "optimization_opportunities": [
-    {
-      "type": "semantic_enhancement",
-      "description": "Add more related terms",
-      "priority": "high"
-    }
-  ],
-  "recommendations": [
-    "Specific actionable recommendation 1",
-    "Specific actionable recommendation 2"
-  ]
-}
-```"""
-        
-        # Quick scoring prompt for faster analysis
-        self.quick_score_prompt = """Analyze this content for AI search optimization. Provide scores (1-10) for:
-
-1. AI Search Visibility
-2. Query Intent Matching  
-3. Conversational Readiness
-4. Citation Worthiness
-
-Respond in JSON format:
-```json
-{
-  "scores": {
-    "ai_search_visibility": 7.5,
-    "query_intent_matching": 8.0,
-    "conversational_readiness": 6.5,
-    "citation_worthiness": 7.8
-  },
-  "overall_score": 7.5,
-  "top_recommendation": "Most important improvement needed"
-}
-```"""
-        
-        # Competitive analysis prompt
-        self.competitive_prompt = """Compare these content pieces for GEO performance. Identify which performs better for AI search and why.
-
-Content A: {content_a}
-
-Content B: {content_b}
-
-Provide analysis in JSON:
-```json
-{
-  "winner": "A" or "B",
-  "score_comparison": {
-    "content_a_score": 7.5,
-    "content_b_score": 8.2
-  },
-  "key_differences": ["difference1", "difference2"],
-  "improvement_suggestions": {
-    "content_a": ["suggestion1"],
-    "content_b": ["suggestion1"]
-  }
-}
-```"""
-    
-    def analyze_page_geo(self, content: str, title: str, detailed: bool = True) -> Dict[str, Any]:
-        """
-        Analyze a single page for GEO performance
-        
-        Args:
-            content (str): Page content to analyze
-            title (str): Page title
-            detailed (bool): Whether to perform detailed analysis
-            
-        Returns:
-            Dict: GEO analysis results
-        """
-        try:
-            # Choose prompt based on detail level
-            if detailed:
-                prompt_template = ChatPromptTemplate.from_messages([
-                    ("system", self.geo_analysis_prompt),
-                    ("user", f"Title: {title}\n\nContent: {content[:8000]}")  # Limit content length
-                ])
-            else:
-                prompt_template = ChatPromptTemplate.from_messages([
-                    ("system", self.quick_score_prompt),
-                    ("user", f"Title: {title}\n\nContent: {content[:4000]}")
-                ])
-            
-            # Run analysis
-            chain = prompt_template | self.llm
-            result = chain.invoke({})
-            
-            # Extract and parse result
-            result_content = result.content if hasattr(result, 'content') else str(result)
-            parsed_result = self._parse_llm_response(result_content)
-            
-            # Add metadata
-            parsed_result.update({
-                'analyzed_title': title,
-                'content_length': len(content),
-                'word_count': len(content.split()),
-                'analysis_type': 'detailed' if detailed else 'quick'
-            })
-            
-            return parsed_result
-            
-        except Exception as e:
-            return {'error': f"GEO analysis failed: {str(e)}"}
-    
-    def analyze_multiple_pages(self, pages_data: List[Dict[str, Any]], detailed: bool = True) -> List[Dict[str, Any]]:
-        """
-        Analyze multiple pages and return consolidated results
-        
-        Args:
-            pages_data (List[Dict]): List of page data with content and metadata
-            detailed (bool): Whether to perform detailed analysis
-            
-        Returns:
-            List[Dict]: List of GEO analysis results
-        """
-        results = []
-        
-        for i, page_data in enumerate(pages_data):
-            try:
-                content = page_data.get('content', '')
-                title = page_data.get('title', f'Page {i+1}')
-                
-                analysis = self.analyze_page_geo(content, title, detailed)
-                
-                # Add page-specific metadata
-                analysis.update({
-                    'page_url': page_data.get('url', ''),
-                    'page_index': i,
-                    'source_word_count': page_data.get('word_count', 0)
-                })
-                
-                results.append(analysis)
-                
-            except Exception as e:
-                results.append({
-                    'page_index': i,
-                    'page_url': page_data.get('url', ''),
-                    'error': f"Analysis failed: {str(e)}"
-                })
-        
-        return results
-    
-    def compare_content_geo(self, content_a: str, content_b: str, titles: tuple = None) -> Dict[str, Any]:
-        """
-        Compare two pieces of content for GEO performance
-        
-        Args:
-            content_a (str): First content to compare
-            content_b (str): Second content to compare  
-            titles (tuple): Optional titles for the content pieces
-            
-        Returns:
-            Dict: Comparison analysis results
-        """
-        try:
-            title_a, title_b = titles if titles else ("Content A", "Content B")
-            
-            prompt_template = ChatPromptTemplate.from_messages([
-                ("system", self.competitive_prompt),
-                ("user", "")
-            ])
-            
-            # Format the competitive analysis prompt
-            formatted_prompt = self.competitive_prompt.format(
-                content_a=f"Title: {title_a}\nContent: {content_a[:4000]}",
-                content_b=f"Title: {title_b}\nContent: {content_b[:4000]}"
-            )
-            
-            chain = ChatPromptTemplate.from_messages([
-                ("system", formatted_prompt),
-                ("user", "Perform the comparison analysis.")
-            ]) | self.llm
-            
-            result = chain.invoke({})
-            result_content = result.content if hasattr(result, 'content') else str(result)
-            
-            return self._parse_llm_response(result_content)
-            
-        except Exception as e:
-            return {'error': f"Comparison analysis failed: {str(e)}"}
-    
-    def calculate_aggregate_scores(self, individual_results: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """
-        Calculate aggregate GEO scores from multiple page analyses
-        
-        Args:
-            individual_results (List[Dict]): List of individual page analysis results
-            
-        Returns:
-            Dict: Aggregate scores and insights
-        """
-        try:
-            valid_results = [r for r in individual_results if 'geo_scores' in r and not r.get('error')]
-            
-            if not valid_results:
-                return {'error': 'No valid results to aggregate'}
-            
-            # Calculate average scores
-            score_keys = list(valid_results[0]['geo_scores'].keys())
-            avg_scores = {}
-            
-            for key in score_keys:
-                scores = [r['geo_scores'][key] for r in valid_results if key in r['geo_scores']]
-                avg_scores[key] = sum(scores) / len(scores) if scores else 0
-            
-            overall_avg = sum(avg_scores.values()) / len(avg_scores) if avg_scores else 0
-            
-            # Collect all recommendations and opportunities
-            all_recommendations = []
-            all_opportunities = []
-            all_topics = []
-            all_entities = []
-            
-            for result in valid_results:
-                all_recommendations.extend(result.get('recommendations', []))
-                all_opportunities.extend(result.get('optimization_opportunities', []))
-                all_topics.extend(result.get('primary_topics', []))
-                all_entities.extend(result.get('entities', []))
-            
-            # Remove duplicates and prioritize
-            unique_recommendations = list(set(all_recommendations))
-            unique_topics = list(set(all_topics))
-            unique_entities = list(set(all_entities))
-            
-            # Find highest and lowest performing areas
-            best_score = max(avg_scores.items(), key=lambda x: x[1]) if avg_scores else ('none', 0)
-            worst_score = min(avg_scores.items(), key=lambda x: x[1]) if avg_scores else ('none', 0)
-            
-            return {
-                'aggregate_scores': avg_scores,
-                'overall_score': overall_avg,
-                'pages_analyzed': len(valid_results),
-                'best_performing_metric': {
-                    'metric': best_score[0],
-                    'score': best_score[1]
-                },
-                'lowest_performing_metric': {
-                    'metric': worst_score[0],
-                    'score': worst_score[1]
-                },
-                'consolidated_recommendations': unique_recommendations[:10],
-                'all_topics': unique_topics,
-                'all_entities': unique_entities,
-                'high_priority_opportunities': [
-                    opp for opp in all_opportunities 
-                    if opp.get('priority') == 'high'
-                ][:5],
-                'score_distribution': self._calculate_score_distribution(avg_scores)
-            }
-            
-        except Exception as e:
-            return {'error': f"Aggregation failed: {str(e)}"}
-    
-    def generate_geo_report(self, analysis_results: Dict[str, Any], website_url: str = None) -> Dict[str, Any]:
-        """
-        Generate a comprehensive GEO report
-        
-        Args:
-            analysis_results (Dict): Results from aggregate analysis
-            website_url (str): Optional website URL for context
-            
-        Returns:
-            Dict: Comprehensive GEO report
-        """
-        try:
-            report = {
-                'report_metadata': {
-                    'generated_at': self._get_timestamp(),
-                    'website_url': website_url,
-                    'analysis_type': 'GEO Performance Report'
-                },
-                'executive_summary': self._generate_executive_summary(analysis_results),
-                'detailed_scores': analysis_results.get('aggregate_scores', {}),
-                'performance_insights': self._generate_performance_insights(analysis_results),
-                'actionable_recommendations': self._prioritize_recommendations(
-                    analysis_results.get('consolidated_recommendations', [])
-                ),
-                'optimization_roadmap': self._create_optimization_roadmap(analysis_results),
-                'competitive_position': self._assess_competitive_position(analysis_results),
-                'technical_details': {
-                    'pages_analyzed': analysis_results.get('pages_analyzed', 0),
-                    'overall_score': analysis_results.get('overall_score', 0),
-                    'score_distribution': analysis_results.get('score_distribution', {})
-                }
-            }
-            
-            return report
-            
-        except Exception as e:
-            return {'error': f"Report generation failed: {str(e)}"}
-    
-    def _parse_llm_response(self, response_text: str) -> Dict[str, Any]:
-        """Parse LLM response and extract JSON content"""
-        try:
-            # Find JSON content in the response
-            json_start = response_text.find('{')
-            json_end = response_text.rfind('}') + 1
-            
-            if json_start != -1 and json_end != -1:
-                json_str = response_text[json_start:json_end]
-                return json.loads(json_str)
-            else:
-                # If no JSON found, return the raw response
-                return {'raw_response': response_text, 'parsing_error': 'No JSON found'}
-                
-        except json.JSONDecodeError as e:
-            return {'raw_response': response_text, 'parsing_error': f'JSON decode error: {str(e)}'}
-        except Exception as e:
-            return {'raw_response': response_text, 'parsing_error': f'Unexpected error: {str(e)}'}
-    
-    def _calculate_score_distribution(self, scores: Dict[str, float]) -> Dict[str, Any]:
-        """Calculate distribution of scores for insights"""
-        if not scores:
-            return {}
-        
-        score_values = list(scores.values())
-        
-        return {
-            'highest_score': max(score_values),
-            'lowest_score': min(score_values),
-            'average_score': sum(score_values) / len(score_values),
-            'score_range': max(score_values) - min(score_values),
-            'scores_above_7': len([s for s in score_values if s >= 7.0]),
-            'scores_below_5': len([s for s in score_values if s < 5.0])
-        }
-    
-    def _generate_executive_summary(self, analysis_results: Dict[str, Any]) -> str:
-        """Generate executive summary based on analysis results"""
-        overall_score = analysis_results.get('overall_score', 0)
-        pages_analyzed = analysis_results.get('pages_analyzed', 0)
-        
-        if overall_score >= 8.0:
-            performance = "excellent"
-        elif overall_score >= 6.5:
-            performance = "good"
-        elif overall_score >= 5.0:
-            performance = "moderate"
-        else:
-            performance = "needs improvement"
-        
-        return f"Analysis of {pages_analyzed} pages shows {performance} GEO performance with an overall score of {overall_score:.1f}/10. Key opportunities exist in {analysis_results.get('lowest_performing_metric', {}).get('metric', 'multiple areas')}."
-    
-    def _generate_performance_insights(self, analysis_results: Dict[str, Any]) -> List[str]:
-        """Generate performance insights based on analysis"""
-        insights = []
-        
-        best_metric = analysis_results.get('best_performing_metric', {})
-        worst_metric = analysis_results.get('lowest_performing_metric', {})
-        
-        if best_metric.get('score', 0) >= 8.0:
-            insights.append(f"Strong performance in {best_metric.get('metric', 'unknown')} (score: {best_metric.get('score', 0):.1f})")
-        
-        if worst_metric.get('score', 10) < 6.0:
-            insights.append(f"Significant improvement needed in {worst_metric.get('metric', 'unknown')} (score: {worst_metric.get('score', 0):.1f})")
-        
-        score_dist = analysis_results.get('score_distribution', {})
-        if score_dist.get('score_range', 0) > 3.0:
-            insights.append("High variability in scores indicates inconsistent optimization across metrics")
-        
-        return insights
-    
-    def _prioritize_recommendations(self, recommendations: List[str]) -> List[Dict[str, Any]]:
-        """Prioritize recommendations based on impact potential"""
-        prioritized = []
-        
-        # Simple prioritization based on keywords
-        high_impact_keywords = ['semantic', 'structure', 'authority', 'factual']
-        medium_impact_keywords = ['readability', 'clarity', 'format']
-        
-        for i, rec in enumerate(recommendations):
-            priority = 'low'
-            if any(keyword in rec.lower() for keyword in high_impact_keywords):
-                priority = 'high'
-            elif any(keyword in rec.lower() for keyword in medium_impact_keywords):
-                priority = 'medium'
-            
-            prioritized.append({
-                'recommendation': rec,
-                'priority': priority,
-                'order': i + 1
-            })
-        
-        # Sort by priority
-        priority_order = {'high': 1, 'medium': 2, 'low': 3}
-        prioritized.sort(key=lambda x: priority_order[x['priority']])
-        
-        return prioritized
-    
-    def _create_optimization_roadmap(self, analysis_results: Dict[str, Any]) -> Dict[str, List[str]]:
-        """Create a phased optimization roadmap"""
-        roadmap = {
-            'immediate_actions': [],
-            'short_term_goals': [],
-            'long_term_strategy': []
-        }
-        
-        overall_score = analysis_results.get('overall_score', 0)
-        worst_metric = analysis_results.get('lowest_performing_metric', {})
-        
-        # Immediate actions based on worst performing metric
-        if worst_metric.get('score', 10) < 5.0:
-            roadmap['immediate_actions'].append(f"Address critical issues in {worst_metric.get('metric', 'low-scoring areas')}")
-        
-        # Short-term goals
-        if overall_score < 7.0:
-            roadmap['short_term_goals'].append("Improve overall GEO score to above 7.0")
-            roadmap['short_term_goals'].append("Enhance content structure and semantic richness")
-        
-        # Long-term strategy
-        roadmap['long_term_strategy'].append("Establish consistent GEO optimization process")
-        roadmap['long_term_strategy'].append("Monitor and track AI search performance")
-        
-        return roadmap
-    
-    def _assess_competitive_position(self, analysis_results: Dict[str, Any]) -> Dict[str, Any]:
-        """Assess competitive position based on scores"""
-        overall_score = analysis_results.get('overall_score', 0)
-        
-        if overall_score >= 8.5:
-            position = "market_leader"
-            description = "Content is highly optimized for AI search engines"
-        elif overall_score >= 7.0:
-            position = "competitive"
-            description = "Content performs well but has room for improvement"
-        elif overall_score >= 5.5:
-            position = "average"
-            description = "Content meets basic standards but lacks optimization"
-        else:
-            position = "needs_work"
-            description = "Content requires significant optimization for AI search"
-        
-        return {
-            'position': position,
-            'description': description,
-            'score': overall_score,
-            'percentile_estimate': min(overall_score * 10, 100)  # Rough percentile estimate
-        }
-    
-    def _get_timestamp(self) -> str:
-        """Get current timestamp"""
-        from datetime import datetime
+"""
+GEO Scoring Module
+Analyzes content for Generative Engine Optimization (GEO) performance
+"""
+
+import json
+from typing import Dict, Any, List
+from langchain.prompts import ChatPromptTemplate
+
+
+class GEOScorer:
+    """Main class for calculating GEO scores and analysis"""
+    
+    def __init__(self, llm):
+        self.llm = llm
+        self.setup_prompts()
+    
+    def setup_prompts(self):
+        """Initialize prompts for different types of analysis"""
+        
+        # Main GEO analysis prompt
+        self.geo_analysis_prompt = """You are a Generative Engine Optimizer (GEO) specialist. Analyze the provided content for its effectiveness in AI-powered search engines and LLM systems.
+
+Evaluate the content based on these GEO criteria (score 1-10 each):
+
+1. **AI Search Visibility**: How likely is this content to be surfaced by AI search engines?
+2. **Query Intent Matching**: How well does the content match common user queries?
+3. **Factual Accuracy & Authority**: How trustworthy and authoritative is the information?
+4. **Conversational Readiness**: How suitable is the content for AI chat responses?
+5. **Semantic Richness**: How well does the content use relevant semantic keywords?
+6. **Context Completeness**: Does the content provide complete, self-contained answers?
+7. **Citation Worthiness**: How likely are AI systems to cite this content?
+8. **Multi-Query Coverage**: Does the content answer multiple related questions?
+
+Also identify:
+- Primary topics and entities
+- Missing information gaps
+- Optimization opportunities
+- Specific enhancement recommendations
+
+Format your response as JSON:
+
+```json
+{
+  "geo_scores": {
+    "ai_search_visibility": 7.5,
+    "query_intent_matching": 8.0,
+    "factual_accuracy": 9.0,
+    "conversational_readiness": 6.5,
+    "semantic_richness": 7.0,
+    "context_completeness": 8.5,
+    "citation_worthiness": 7.8,
+    "multi_query_coverage": 6.0
+  },
+  "overall_geo_score": 7.5,
+  "primary_topics": ["topic1", "topic2"],
+  "entities": ["entity1", "entity2"],
+  "missing_gaps": ["gap1", "gap2"],
+  "optimization_opportunities": [
+    {
+      "type": "semantic_enhancement",
+      "description": "Add more related terms",
+      "priority": "high"
+    }
+  ],
+  "recommendations": [
+    "Specific actionable recommendation 1",
+    "Specific actionable recommendation 2"
+  ]
+}
+```"""
+        
+        # Quick scoring prompt for faster analysis
+        self.quick_score_prompt = """Analyze this content for AI search optimization. Provide scores (1-10) for:
+
+1. AI Search Visibility
+2. Query Intent Matching  
+3. Conversational Readiness
+4. Citation Worthiness
+
+Respond in JSON format:
+```json
+{
+  "scores": {
+    "ai_search_visibility": 7.5,
+    "query_intent_matching": 8.0,
+    "conversational_readiness": 6.5,
+    "citation_worthiness": 7.8
+  },
+  "overall_score": 7.5,
+  "top_recommendation": "Most important improvement needed"
+}
+```"""
+        
+        # Competitive analysis prompt
+        self.competitive_prompt = """Compare these content pieces for GEO performance. Identify which performs better for AI search and why.
+
+Content A: {content_a}
+
+Content B: {content_b}
+
+Provide analysis in JSON:
+```json
+{
+  "winner": "A" or "B",
+  "score_comparison": {
+    "content_a_score": 7.5,
+    "content_b_score": 8.2
+  },
+  "key_differences": ["difference1", "difference2"],
+  "improvement_suggestions": {
+    "content_a": ["suggestion1"],
+    "content_b": ["suggestion1"]
+  }
+}
+```"""
+    
+    def analyze_page_geo(self, content: str, title: str, detailed: bool = True) -> Dict[str, Any]:
+        """
+        Analyze a single page for GEO performance
+        """
+        try:
+            # Choose prompt based on detail level
+            if detailed:
+                system_prompt = self.geo_analysis_prompt
+                user_message = f"Title: {title}\n\nContent: {content[:8000]}"
+            else:
+                system_prompt = self.quick_score_prompt
+                user_message = f"Title: {title}\n\nContent: {content[:4000]}"
+
+            # Build prompt and run analysis
+            prompt_template = ChatPromptTemplate.from_messages([
+                ("system", system_prompt),
+                ("user", user_message)
+            ])
+            chain = prompt_template | self.llm
+            result = chain.invoke({})  # No variables needed
+
+            # Extract and parse result
+            result_content = result.content if hasattr(result, 'content') else str(result)
+            parsed_result = self._parse_llm_response(result_content)
+
+            # Add metadata
+            parsed_result.update({
+                'analyzed_title': title,
+                'content_length': len(content),
+                'word_count': len(content.split()),
+                'analysis_type': 'detailed' if detailed else 'quick'
+            })
+
+            return parsed_result
+
+        except Exception as e:
+            return {'error': f"GEO analysis failed: {str(e)}"}
+    
+    def analyze_multiple_pages(self, pages_data: List[Dict[str, Any]], detailed: bool = True) -> List[Dict[str, Any]]:
+        """
+        Analyze multiple pages and return consolidated results
+        
+        Args:
+            pages_data (List[Dict]): List of page data with content and metadata
+            detailed (bool): Whether to perform detailed analysis
+            
+        Returns:
+            List[Dict]: List of GEO analysis results
+        """
+        results = []
+        
+        for i, page_data in enumerate(pages_data):
+            try:
+                content = page_data.get('content', '')
+                title = page_data.get('title', f'Page {i+1}')
+                
+                analysis = self.analyze_page_geo(content, title, detailed)
+                
+                # Add page-specific metadata
+                analysis.update({
+                    'page_url': page_data.get('url', ''),
+                    'page_index': i,
+                    'source_word_count': page_data.get('word_count', 0)
+                })
+                
+                results.append(analysis)
+                
+            except Exception as e:
+                results.append({
+                    'page_index': i,
+                    'page_url': page_data.get('url', ''),
+                    'error': f"Analysis failed: {str(e)}"
+                })
+        
+        return results
+    
+    def compare_content_geo(self, content_a: str, content_b: str, titles: tuple = None) -> Dict[str, Any]:
+        """
+        Compare two pieces of content for GEO performance
+        
+        Args:
+            content_a (str): First content to compare
+            content_b (str): Second content to compare  
+            titles (tuple): Optional titles for the content pieces
+            
+        Returns:
+            Dict: Comparison analysis results
+        """
+        try:
+            title_a, title_b = titles if titles else ("Content A", "Content B")
+            
+            prompt_template = ChatPromptTemplate.from_messages([
+                ("system", self.competitive_prompt),
+                ("user", "")
+            ])
+            
+            # Format the competitive analysis prompt
+            formatted_prompt = self.competitive_prompt.format(
+                content_a=f"Title: {title_a}\nContent: {content_a[:4000]}",
+                content_b=f"Title: {title_b}\nContent: {content_b[:4000]}"
+            )
+            
+            chain = ChatPromptTemplate.from_messages([
+                ("system", formatted_prompt),
+                ("user", "Perform the comparison analysis.")
+            ]) | self.llm
+            
+            result = chain.invoke({})
+            result_content = result.content if hasattr(result, 'content') else str(result)
+            
+            return self._parse_llm_response(result_content)
+            
+        except Exception as e:
+            return {'error': f"Comparison analysis failed: {str(e)}"}
+    
+    def calculate_aggregate_scores(self, individual_results: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Calculate aggregate GEO scores from multiple page analyses
+        
+        Args:
+            individual_results (List[Dict]): List of individual page analysis results
+            
+        Returns:
+            Dict: Aggregate scores and insights
+        """
+        try:
+            valid_results = [r for r in individual_results if 'geo_scores' in r and not r.get('error')]
+            
+            if not valid_results:
+                return {'error': 'No valid results to aggregate'}
+            
+            # Calculate average scores
+            score_keys = list(valid_results[0]['geo_scores'].keys())
+            avg_scores = {}
+            
+            for key in score_keys:
+                scores = [r['geo_scores'][key] for r in valid_results if key in r['geo_scores']]
+                avg_scores[key] = sum(scores) / len(scores) if scores else 0
+            
+            overall_avg = sum(avg_scores.values()) / len(avg_scores) if avg_scores else 0
+            
+            # Collect all recommendations and opportunities
+            all_recommendations = []
+            all_opportunities = []
+            all_topics = []
+            all_entities = []
+            
+            for result in valid_results:
+                all_recommendations.extend(result.get('recommendations', []))
+                all_opportunities.extend(result.get('optimization_opportunities', []))
+                all_topics.extend(result.get('primary_topics', []))
+                all_entities.extend(result.get('entities', []))
+            
+            # Remove duplicates and prioritize
+            unique_recommendations = list(set(all_recommendations))
+            unique_topics = list(set(all_topics))
+            unique_entities = list(set(all_entities))
+            
+            # Find highest and lowest performing areas
+            best_score = max(avg_scores.items(), key=lambda x: x[1]) if avg_scores else ('none', 0)
+            worst_score = min(avg_scores.items(), key=lambda x: x[1]) if avg_scores else ('none', 0)
+            
+            return {
+                'aggregate_scores': avg_scores,
+                'overall_score': overall_avg,
+                'pages_analyzed': len(valid_results),
+                'best_performing_metric': {
+                    'metric': best_score[0],
+                    'score': best_score[1]
+                },
+                'lowest_performing_metric': {
+                    'metric': worst_score[0],
+                    'score': worst_score[1]
+                },
+                'consolidated_recommendations': unique_recommendations[:10],
+                'all_topics': unique_topics,
+                'all_entities': unique_entities,
+                'high_priority_opportunities': [
+                    opp for opp in all_opportunities 
+                    if opp.get('priority') == 'high'
+                ][:5],
+                'score_distribution': self._calculate_score_distribution(avg_scores)
+            }
+            
+        except Exception as e:
+            return {'error': f"Aggregation failed: {str(e)}"}
+    
+    def generate_geo_report(self, analysis_results: Dict[str, Any], website_url: str = None) -> Dict[str, Any]:
+        """
+        Generate a comprehensive GEO report
+        
+        Args:
+            analysis_results (Dict): Results from aggregate analysis
+            website_url (str): Optional website URL for context
+            
+        Returns:
+            Dict: Comprehensive GEO report
+        """
+        try:
+            report = {
+                'report_metadata': {
+                    'generated_at': self._get_timestamp(),
+                    'website_url': website_url,
+                    'analysis_type': 'GEO Performance Report'
+                },
+                'executive_summary': self._generate_executive_summary(analysis_results),
+                'detailed_scores': analysis_results.get('aggregate_scores', {}),
+                'performance_insights': self._generate_performance_insights(analysis_results),
+                'actionable_recommendations': self._prioritize_recommendations(
+                    analysis_results.get('consolidated_recommendations', [])
+                ),
+                'optimization_roadmap': self._create_optimization_roadmap(analysis_results),
+                'competitive_position': self._assess_competitive_position(analysis_results),
+                'technical_details': {
+                    'pages_analyzed': analysis_results.get('pages_analyzed', 0),
+                    'overall_score': analysis_results.get('overall_score', 0),
+                    'score_distribution': analysis_results.get('score_distribution', {})
+                }
+            }
+            
+            return report
+            
+        except Exception as e:
+            return {'error': f"Report generation failed: {str(e)}"}
+    
+    def _parse_llm_response(self, response_text: str) -> Dict[str, Any]:
+        """Parse LLM response and extract JSON content"""
+        try:
+            # Find JSON content in the response
+            json_start = response_text.find('{')
+            json_end = response_text.rfind('}') + 1
+            
+            if json_start != -1 and json_end != -1:
+                json_str = response_text[json_start:json_end]
+                return json.loads(json_str)
+            else:
+                # If no JSON found, return the raw response
+                return {'raw_response': response_text, 'parsing_error': 'No JSON found'}
+                
+        except json.JSONDecodeError as e:
+            return {'raw_response': response_text, 'parsing_error': f'JSON decode error: {str(e)}'}
+        except Exception as e:
+            return {'raw_response': response_text, 'parsing_error': f'Unexpected error: {str(e)}'}
+    
+    def _calculate_score_distribution(self, scores: Dict[str, float]) -> Dict[str, Any]:
+        """Calculate distribution of scores for insights"""
+        if not scores:
+            return {}
+        
+        score_values = list(scores.values())
+        
+        return {
+            'highest_score': max(score_values),
+            'lowest_score': min(score_values),
+            'average_score': sum(score_values) / len(score_values),
+            'score_range': max(score_values) - min(score_values),
+            'scores_above_7': len([s for s in score_values if s >= 7.0]),
+            'scores_below_5': len([s for s in score_values if s < 5.0])
+        }
+    
+    def _generate_executive_summary(self, analysis_results: Dict[str, Any]) -> str:
+        """Generate executive summary based on analysis results"""
+        overall_score = analysis_results.get('overall_score', 0)
+        pages_analyzed = analysis_results.get('pages_analyzed', 0)
+        
+        if overall_score >= 8.0:
+            performance = "excellent"
+        elif overall_score >= 6.5:
+            performance = "good"
+        elif overall_score >= 5.0:
+            performance = "moderate"
+        else:
+            performance = "needs improvement"
+        
+        return f"Analysis of {pages_analyzed} pages shows {performance} GEO performance with an overall score of {overall_score:.1f}/10. Key opportunities exist in {analysis_results.get('lowest_performing_metric', {}).get('metric', 'multiple areas')}."
+    
+    def _generate_performance_insights(self, analysis_results: Dict[str, Any]) -> List[str]:
+        """Generate performance insights based on analysis"""
+        insights = []
+        
+        best_metric = analysis_results.get('best_performing_metric', {})
+        worst_metric = analysis_results.get('lowest_performing_metric', {})
+        
+        if best_metric.get('score', 0) >= 8.0:
+            insights.append(f"Strong performance in {best_metric.get('metric', 'unknown')} (score: {best_metric.get('score', 0):.1f})")
+        
+        if worst_metric.get('score', 10) < 6.0:
+            insights.append(f"Significant improvement needed in {worst_metric.get('metric', 'unknown')} (score: {worst_metric.get('score', 0):.1f})")
+        
+        score_dist = analysis_results.get('score_distribution', {})
+        if score_dist.get('score_range', 0) > 3.0:
+            insights.append("High variability in scores indicates inconsistent optimization across metrics")
+        
+        return insights
+    
+    def _prioritize_recommendations(self, recommendations: List[str]) -> List[Dict[str, Any]]:
+        """Prioritize recommendations based on impact potential"""
+        prioritized = []
+        
+        # Simple prioritization based on keywords
+        high_impact_keywords = ['semantic', 'structure', 'authority', 'factual']
+        medium_impact_keywords = ['readability', 'clarity', 'format']
+        
+        for i, rec in enumerate(recommendations):
+            priority = 'low'
+            if any(keyword in rec.lower() for keyword in high_impact_keywords):
+                priority = 'high'
+            elif any(keyword in rec.lower() for keyword in medium_impact_keywords):
+                priority = 'medium'
+            
+            prioritized.append({
+                'recommendation': rec,
+                'priority': priority,
+                'order': i + 1
+            })
+        
+        # Sort by priority
+        priority_order = {'high': 1, 'medium': 2, 'low': 3}
+        prioritized.sort(key=lambda x: priority_order[x['priority']])
+        
+        return prioritized
+    
+    def _create_optimization_roadmap(self, analysis_results: Dict[str, Any]) -> Dict[str, List[str]]:
+        """Create a phased optimization roadmap"""
+        roadmap = {
+            'immediate_actions': [],
+            'short_term_goals': [],
+            'long_term_strategy': []
+        }
+        
+        overall_score = analysis_results.get('overall_score', 0)
+        worst_metric = analysis_results.get('lowest_performing_metric', {})
+        
+        # Immediate actions based on worst performing metric
+        if worst_metric.get('score', 10) < 5.0:
+            roadmap['immediate_actions'].append(f"Address critical issues in {worst_metric.get('metric', 'low-scoring areas')}")
+        
+        # Short-term goals
+        if overall_score < 7.0:
+            roadmap['short_term_goals'].append("Improve overall GEO score to above 7.0")
+            roadmap['short_term_goals'].append("Enhance content structure and semantic richness")
+        
+        # Long-term strategy
+        roadmap['long_term_strategy'].append("Establish consistent GEO optimization process")
+        roadmap['long_term_strategy'].append("Monitor and track AI search performance")
+        
+        return roadmap
+    
+    def _assess_competitive_position(self, analysis_results: Dict[str, Any]) -> Dict[str, Any]:
+        """Assess competitive position based on scores"""
+        overall_score = analysis_results.get('overall_score', 0)
+        
+        if overall_score >= 8.5:
+            position = "market_leader"
+            description = "Content is highly optimized for AI search engines"
+        elif overall_score >= 7.0:
+            position = "competitive"
+            description = "Content performs well but has room for improvement"
+        elif overall_score >= 5.5:
+            position = "average"
+            description = "Content meets basic standards but lacks optimization"
+        else:
+            position = "needs_work"
+            description = "Content requires significant optimization for AI search"
+        
+        return {
+            'position': position,
+            'description': description,
+            'score': overall_score,
+            'percentile_estimate': min(overall_score * 10, 100)  # Rough percentile estimate
+        }
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp"""
+        from datetime import datetime
         return datetime.now().strftime('%Y-%m-%d %H:%M:%S')