JAM

app.py

@@ -1,5 +1,5 @@
 """
-Main Streamlit Application - GEO SEO AI Optimizer with RAG-Enhanced Content Optimization
+Main Streamlit Application - GEO SEO AI Optimizer
 Entry point for the application with UI components
 """
 
@@ -8,20 +8,17 @@ import os
 import tempfile
 import json
 from typing import Dict, Any, List
-import time
 
 # Import our custom modules
 from utils.parser import PDFParser, TextParser, WebpageParser
 from utils.scorer import GEOScorer
-from utils.optimizer import ContentOptimizer  # This will be your enhanced version
+from utils.optimizer import ContentOptimizer
 from utils.chunker import VectorChunker
 from utils.export import ResultExporter
 
 # Import LangChain components
 from langchain_groq import ChatGroq
 from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
-from langchain_core.messages import AIMessage, HumanMessage
 
 class GEOSEOApp:
     """Main application class that orchestrates all components"""
@@ -44,16 +41,13 @@ class GEOSEOApp:
         """Initialize LLM and embedding models"""
         self.llm = ChatGroq(
             api_key=self.groq_api_key,
-            model_name="llama-3.1-8b-instant",
+            model_name="llama3-8b-8192",
             temperature=0.1
         )
         
         self.embeddings = HuggingFaceEmbeddings(
-             model_name="sentence-transformers/all-MiniLM-L6-v2",
-             model_kwargs={"device": "cpu"} 
-            # model_name="sentence-transformers/all-MiniLM-L6-v2",
-            # model_kwargs={"device": "cpu"},
-            # cache_folder="./hf_caches",
+            model_name="sentence-transformers/all-MiniLM-L6-v2",
+            cache_folder="./hf_cache",
         )
     
     def setup_parsers(self):
@@ -63,13 +57,10 @@ class GEOSEOApp:
         self.webpage_parser = WebpageParser()
     
     def setup_components(self):
-        """Initialize processing components with RAG integration"""
+        """Initialize processing components"""
         self.geo_scorer = GEOScorer(self.llm)
+        self.content_optimizer = ContentOptimizer(self.llm)
         self.vector_chunker = VectorChunker(self.embeddings)
-        
-        # Enhanced content optimizer with RAG capabilities
-        self.content_optimizer = ContentOptimizer(self.llm, self.vector_chunker)
-        
         self.result_exporter = ResultExporter()
     
     def run(self):
@@ -81,39 +72,39 @@ class GEOSEOApp:
         )
         
         st.title("🚀 GEO SEO AI Optimizer")
-        st.markdown("*Optimize your content for AI search engines and LLM systems with RAG-enhanced analysis*")
+        st.markdown("*Optimize your content for AI search engines and LLM systems*")
         
         # Sidebar
         self.render_sidebar()
         
         # Main tabs
-        tab1, tab2, tab3, tab4 = st.tabs([
+        tab1, tab2, tab3 = st.tabs([
             "🌐 Website GEO Analysis",
-            "🔧 GEO Content Enhancement", 
-            "📄 Document Q&A",
-            "🧠 Generate GEO Content", 
+            "🔧 Content Enhancement", 
+            "📄 Document Q&A", 
         ])
         
         with tab1:
             self.render_website_analysis_tab()
         
         with tab2:
-            self.render_geo_content_enhancement_tab()
+            self.render_content_enhancement_tab()
         
         with tab3:
             self.render_document_qa_tab()
-        with tab4:
-            self.render_generate_geo_content_tab()
-
     
     def render_sidebar(self):
         """Render sidebar with information and controls"""
         st.sidebar.title("🛠️ GEO Tools")
+        st.sidebar.markdown("- 📄 Document Q&A with RAG")
+        st.sidebar.markdown("- 🔧 Content Enhancement")
         st.sidebar.markdown("- 🌐 Website GEO Analysis")
-        st.sidebar.markdown("- 🔧 RAG-Enhanced Content Optimization")
         st.sidebar.markdown("- 📊 AI-First SEO Scoring")
-        st.sidebar.markdown("- 📄 Document Q&A with RAG")
-        st.sidebar.markdown("- 🧠 Generate GEO Content")
+        
+        st.sidebar.markdown("---")
+        st.sidebar.markdown("### 🔧 Configuration")
+        st.sidebar.markdown("Set your API keys:")
+        st.sidebar.code("export GROQ_API_KEY='your-key'")
         
         st.sidebar.markdown("---")
         st.sidebar.markdown("### 📖 GEO Metrics")
@@ -121,528 +112,14 @@ class GEOSEOApp:
         st.sidebar.markdown("**Query Intent Matching**: How well content matches user queries")
         st.sidebar.markdown("**Conversational Readiness**: Suitability for AI chat responses")
         st.sidebar.markdown("**Citation Worthiness**: Probability of being cited by AI")
-        st.sidebar.markdown("**Context Completeness**: How self-contained the content is")
-        st.sidebar.markdown("**Semantic Richness**: Depth of topic coverage")
         
         st.sidebar.markdown("---")
-        st.sidebar.markdown("### 🧠 RAG Enhancement")
-        st.sidebar.markdown("- **Knowledge Base**: GEO best practices")
-        st.sidebar.markdown("- **Contextual Analysis**: AI-informed optimization")
-        st.sidebar.markdown("- **Entity Extraction**: AI-powered entity recognition")
-        st.sidebar.markdown("- **Competitive Analysis**: Gap identification")
-    
-    def render_geo_content_enhancement_tab(self):
-        """Render GEO Content Enhancement tab with RAG integration"""
-        st.header("🔧 GEO Content Enhancement with RAG")
-        st.markdown("Analyze and optimize your content using AI-powered Generative Engine Optimization with RAG-enhanced knowledge base.")
-        
-        # Content input
-        input_text = st.text_area(
-            "Enter content to analyze and enhance:", 
-            height=200, 
-            key="geo_enhancement_input",
-            help="Paste your content here for GEO optimization using RAG-enhanced analysis"
-        )
-        
-        # GEO Optimization type selector
-        st.markdown("### ⚙️ GEO Optimization Settings")
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            optimization_type = st.selectbox(
-                "Select GEO Optimization Type:",
-                options=[
-                    "geo_standard", 
-                    # "competitive_geo", 
-                    # "geo_readability",
-                    # "geo_entity_extraction",
-                    # "geo_variations",
-                    # "geo_batch_optimize"
-                ],
-                format_func=lambda x: {
-                    "geo_standard": "🔧 Standard GEO Enhancement",
-                    # "competitive_geo": "📊 Competitive GEO Analysis", 
-                    # "geo_readability": "📖 GEO Readability Analysis",
-                    # "geo_entity_extraction": "🏷️ GEO Entity Extraction",
-                    # "geo_variations": "🔄 GEO Content Variations",
-                    # "geo_batch_optimize": "📦 Batch GEO Optimization"
-                }[x],
-                index=0,
-                help="Choose the type of GEO optimization powered by RAG analysis"
-            )
-        
-        with col2:
-            # Additional options based on optimization type
-            if optimization_type in ["geo_standard", "competitive_geo"]:
-                analyze_only = st.checkbox("Analysis", value=True)
-                include_rag_context = st.checkbox("Include RAG context details", value=True)
-            # elif optimization_type == "geo_variations":
-            #     num_variations = st.slider("Number of variations", min_value=1, max_value=3, value=2)
-            #     analyze_only = False
-            #     include_rag_context = True
-            # elif optimization_type == "geo_batch_optimize":
-            #     st.info("For batch optimization, separate multiple content pieces with '---' divider")
-            #     analyze_only = False
-            #     include_rag_context = True
-            else:
-                analyze_only = False
-                include_rag_context = True
-        
-        # Show description based on optimization type
-        optimization_descriptions = {
-            "geo_standard": "🔧 RAG-enhanced GEO optimization focusing on AI search visibility, conversational readiness, and citation worthiness using knowledge base guidance.",
-            # "competitive_geo": "📊 Competitive GEO analysis against best practices with gap identification and actionable recommendations using RAG context.",
-            # "geo_readability": "📖 Detailed readability analysis specifically optimized for AI systems and LLM consumption patterns.",
-            # "geo_entity_extraction": "🏷️ AI-powered extraction of key entities, topics, and concepts relevant for GEO optimization.",
-            # "geo_variations": "🔄 Generate multiple GEO-optimized variations (FAQ, conversational, authoritative) using RAG knowledge.",
-            # "geo_batch_optimize": "📦 Process multiple content pieces simultaneously with consistent GEO optimization."
-        }
-        
-        st.info(f"**{optimization_descriptions[optimization_type]}**")
-        
-        # Knowledge base status
-        if hasattr(self.content_optimizer, 'geo_knowledge'):
-            st.success(f"✅ RAG Knowledge Base Loaded: {len(self.content_optimizer.geo_knowledge)} GEO best practice documents")
-        else:
-            st.warning("⚠️ RAG Knowledge Base not available - falling back to standard optimization")
-        
-        # Submit button
-        if st.button("🚀 Process Content with GEO+RAG", key="geo_enhancement_submit"):
-            if not input_text.strip():
-                st.warning("Please enter some content to analyze.")
-                return
-            
-            try:
-                with st.spinner(f"Processing content with {optimization_type} using RAG-enhanced GEO analysis..."):
-                    # Handle different GEO optimization types
-                    if optimization_type == "geo_standard":
-                        result = self.content_optimizer.optimize_content_with_rag(
-                            input_text,
-                            optimization_type="geo_standard",
-                            analyze_only=analyze_only
-                        )
-                    
-                    elif optimization_type == "competitive_geo":
-                        result = self.content_optimizer.optimize_content_with_rag(
-                            input_text,
-                            optimization_type="competitive_geo",
-                            analyze_only=analyze_only
-                        )
-                    
-                    elif optimization_type == "geo_readability":
-                        result = self.content_optimizer.analyze_geo_readability(input_text)
-                    
-                    elif optimization_type == "geo_entity_extraction":
-                        result = self.content_optimizer.extract_geo_entities(input_text)
-                    
-                    elif optimization_type == "geo_variations":
-                        result = self.content_optimizer.generate_geo_variations(
-                            input_text, 
-                            num_variations=num_variations
-                        )
-                    
-                    elif optimization_type == "geo_batch_optimize":
-                        # Split content by '---' separator
-                        content_pieces = [piece.strip() for piece in input_text.split('---') if piece.strip()]
-                        if len(content_pieces) > 1:
-                            result = self.content_optimizer.batch_optimize_with_rag(content_pieces)
-                        else:
-                            st.warning("For batch optimization, please separate content pieces with '---'")
-                            return
-                
-                if isinstance(result, list):
-                    # Handle list results (variations, batch)
-                    if any(r.get("error") for r in result):
-                        failed_results = [r for r in result if r.get("error")]
-                        st.error(f"Some processing failed: {len(failed_results)} out of {len(result)} items")
-                    else:
-                        st.success("All content processed successfully!")
-                elif result.get("error"):
-                    st.error(f"Processing failed: {result['error']}")
-                    return
-                else:
-                    st.success(f"{optimization_type.replace('_', ' ').title()} completed successfully!")
-                
-                # Display results based on optimization type
-                self.display_geo_enhancement_results(result, optimization_type, input_text, include_rag_context)
-                
-            except Exception as e:
-                st.error(f"An error occurred: {str(e)}")
-
-    def display_geo_enhancement_results(self, result, optimization_type, original_text, include_rag_context=True):
-        """Display results based on GEO optimization type"""
-        
-        if optimization_type == "geo_batch_optimize":
-            self.display_geo_batch_results(result)
-        elif optimization_type == "geo_variations":
-            self.display_geo_variation_results(result)
-        elif optimization_type == "geo_readability":
-            self.display_geo_readability_results(result)
-        elif optimization_type == "geo_entity_extraction":
-            self.display_geo_entity_results(result)
-        else:
-            self.display_standard_geo_results(result, optimization_type, include_rag_context)
-        
-        # Export functionality
-        self.display_geo_export_options(result, optimization_type, original_text)
-
-    def display_standard_geo_results(self, result, optimization_type, include_rag_context):
-        """Display results for standard and competitive GEO optimizations"""
-        st.markdown("### 📊 GEO Analysis Results")
-        
-        # Show GEO scores if available
-        geo_analysis = result.get("geo_analysis", {})
-        if geo_analysis:
-            st.markdown("#### 🎯 GEO Performance Metrics")
-            
-            col1, col2, col3 = st.columns(3)
-            with col1:
-                current_score = geo_analysis.get("current_geo_score", 0)
-                st.metric("Overall GEO Score", f"{current_score}/10")
-            
-            with col2:
-                ai_visibility = geo_analysis.get("ai_search_visibility", 0)
-                st.metric("AI Search Visibility", f"{ai_visibility}/10")
-            
-            with col3:
-                citation_worthy = geo_analysis.get("citation_worthiness", 0)
-                st.metric("Citation Worthiness", f"{citation_worthy}/10")
-            
-            # Second row of metrics
-            col1, col2, col3 = st.columns(3)
-            with col1:
-                query_matching = geo_analysis.get("query_intent_matching", 0)
-                st.metric("Query Intent Match", f"{query_matching}/10")
-            
-            with col2:
-                conversational = geo_analysis.get("conversational_readiness", 0)
-                st.metric("Conversational Ready", f"{conversational}/10")
-            
-            with col3:
-                context_complete = geo_analysis.get("context_completeness", 0)
-                st.metric("Context Complete", f"{context_complete}/10")
-        
-        # Show optimization opportunities
-        opportunities = result.get("optimization_opportunities", [])
-        if opportunities:
-            st.markdown("#### 🚀 Optimization Opportunities")
-            
-            high_priority = [opp for opp in opportunities if opp.get('priority') == 'high']
-            medium_priority = [opp for opp in opportunities if opp.get('priority') == 'medium']
-            
-            if high_priority:
-                st.markdown("##### 🔴 High Priority")
-                for opp in high_priority:
-                    st.write(f"**{opp.get('type', 'Optimization')}**: {opp.get('description', '')}")
-                    if opp.get('expected_impact'):
-                        st.write(f"*Expected Impact: {opp.get('expected_impact')}*")
-                    st.write("---")
-            
-            if medium_priority:
-                st.markdown("##### 🟡 Medium Priority")
-                for opp in medium_priority:
-                    st.write(f"**{opp.get('type', 'Optimization')}**: {opp.get('description', '')}")
-                    if opp.get('expected_impact'):
-                        st.write(f"*Expected Impact: {opp.get('expected_impact')}*")
-                    st.write("---")
-        
-        # Show GEO keywords and entities
-        geo_keywords = result.get("geo_keywords", {})
-        if geo_keywords:
-            st.markdown("#### 🔑 GEO Keywords & Entities")
-            
-            col1, col2 = st.columns(2)
-            with col1:
-                primary_entities = geo_keywords.get("primary_entities", [])
-                if primary_entities:
-                    st.write("**Primary Entities:**")
-                    st.write(", ".join(primary_entities))
-                
-                semantic_terms = geo_keywords.get("semantic_terms", [])
-                if semantic_terms:
-                    st.write("**Semantic Terms:**")
-                    st.write(", ".join(semantic_terms))
-            
-            with col2:
-                question_patterns = geo_keywords.get("question_patterns", [])
-                if question_patterns:
-                    st.write("**Question Patterns:**")
-                    for q in question_patterns:
-                        st.write(f"• {q}")
-                
-                related_concepts = geo_keywords.get("related_concepts", [])
-                if related_concepts:
-                    st.write("**Related Concepts:**")
-                    st.write(", ".join(related_concepts))
-        
-        # Show optimized content
-        optimized_content = result.get("optimized_content", {})
-        if optimized_content:
-            enhanced_text = optimized_content.get("enhanced_text", "")
-            if enhanced_text:
-                st.markdown("#### ✨ GEO-Optimized Content")
-                st.text_area(
-                    "Enhanced version:", 
-                    value=enhanced_text, 
-                    height=250, 
-                    key="geo_optimized_output"
-                )
-            
-            # Show structural improvements
-            structural_improvements = optimized_content.get("structural_improvements", [])
-            if structural_improvements:
-                st.markdown("**Structural Improvements:**")
-                for improvement in structural_improvements:
-                    st.write(f"• {improvement}")
-            
-            # Show semantic enhancements
-            semantic_enhancements = optimized_content.get("semantic_enhancements", [])
-            if semantic_enhancements:
-                st.markdown("**Semantic Enhancements:**")
-                for enhancement in semantic_enhancements:
-                    st.write(f"• {enhancement}")
-        
-        # Show competitive analysis if available
-        if "competitive_gaps" in result:
-            st.markdown("#### 📊 Competitive GEO Analysis")
-            competitive_gaps = result["competitive_gaps"]
-            
-            col1, col2 = st.columns(2)
-            with col1:
-                missing_questions = competitive_gaps.get("missing_question_patterns", [])
-                if missing_questions:
-                    st.write("**Missing Question Patterns:**")
-                    for q in missing_questions:
-                        st.write(f"• {q}")
-                
-                entity_gaps = competitive_gaps.get("entity_gaps", [])
-                if entity_gaps:
-                    st.write("**Entity Gaps:**")
-                    st.write(", ".join(entity_gaps))
-            
-            with col2:
-                semantic_opportunities = competitive_gaps.get("semantic_opportunities", [])
-                if semantic_opportunities:
-                    st.write("**Semantic Opportunities:**")
-                    st.write(", ".join(semantic_opportunities))
-                
-                structural_weaknesses = competitive_gaps.get("structural_weaknesses", [])
-                if structural_weaknesses:
-                    st.write("**Structural Weaknesses:**")
-                    for weakness in structural_weaknesses:
-                        st.write(f"• {weakness}")
-        
-        # Show recommendations
-        recommendations = result.get("recommendations", [])
-        if recommendations:
-            st.markdown("#### 💡 GEO Recommendations")
-            for i, rec in enumerate(recommendations, 1):
-                st.write(f"**{i}.** {rec}")
-        
-        # RAG context information
-        if include_rag_context and result.get("rag_enhanced"):
-            with st.expander("🧠 RAG Enhancement Details"):
-                st.write("**RAG Status:** ✅ Knowledge base successfully applied")
-                st.write(f"**Knowledge Sources:** {result.get('knowledge_sources', 'Multiple')} GEO best practice documents")
-                st.write(f"**Enhancement Type:** {result.get('optimization_type', 'Standard')}")
-                
-                if result.get('parsing_error'):
-                    st.warning(f"**Parsing Note:** {result['parsing_error']}")
-
-    def display_geo_batch_results(self, results):
-        """Display batch GEO optimization results"""
-        st.markdown("### 📦 Batch GEO Processing Results")
-        
-        successful_results = [r for r in results if not r.get('error')]
-        failed_results = [r for r in results if r.get('error')]
-        
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            st.metric("Total Pieces", len(results))
-        with col2:
-            st.metric("Successful", len(successful_results))
-        with col3:
-            st.metric("Failed", len(failed_results))
-        
-        # Show individual results
-        for result in results:
-            idx = result.get('batch_index', 0)
-            st.markdown(f"#### Content Piece {idx + 1}")
-            
-            if result.get('error'):
-                st.error(f"Processing failed: {result['error']}")
-            else:
-                # Show GEO scores
-                geo_analysis = result.get("geo_analysis", {})
-                if geo_analysis:
-                    col1, col2, col3 = st.columns(3)
-                    with col1:
-                        st.metric("GEO Score", f"{geo_analysis.get('current_geo_score', 0):.1f}")
-                    with col2:
-                        st.metric("AI Visibility", f"{geo_analysis.get('ai_search_visibility', 0):.1f}")
-                    with col3:
-                        st.metric("Citation Worthy", f"{geo_analysis.get('citation_worthiness', 0):.1f}")
-                
-                # Show optimized content if available
-                optimized_content = result.get("optimized_content", {})
-                enhanced_text = optimized_content.get("enhanced_text", "")
-                if enhanced_text:
-                    with st.expander("View GEO-optimized content"):
-                        st.text_area("", value=enhanced_text[:500] + "...", height=150, key=f"batch_geo_output_{idx}")
-            
-            st.write("---")
-
-    def display_geo_variation_results(self, variations):
-        """Display GEO content variation results"""
-        st.markdown("### 🔄 GEO Content Variations")
-        
-        for i, variation in enumerate(variations):
-            if variation.get('error'):
-                st.error(f"Variation {i+1} failed: {variation['error']}")
-                continue
-            
-            variation_type = variation.get('variation_type', f'Variation {i+1}')
-            st.markdown(f"#### {variation_type.replace('_', ' ').title()} Version")
-            
-            # Show GEO improvements
-            geo_improvements = variation.get('geo_improvements', [])
-            if geo_improvements:
-                st.write("**GEO Improvements:**")
-                for improvement in geo_improvements:
-                    st.write(f"• {improvement}")
-            
-            # Show target AI systems
-            target_ai_systems = variation.get('target_ai_systems', [])
-            if target_ai_systems:
-                st.write(f"**Optimized For:** {', '.join(target_ai_systems)}")
-            
-            # Show expected benefits
-            expected_benefits = variation.get('expected_geo_benefits', [])
-            if expected_benefits:
-                st.write("**Expected GEO Benefits:**")
-                for benefit in expected_benefits:
-                    st.write(f"• {benefit}")
-            
-            # Show optimized content
-            optimized_content = variation.get('optimized_content', '')
-            if optimized_content:
-                st.text_area(
-                    f"{variation_type} content:", 
-                    value=optimized_content, 
-                    height=200, 
-                    key=f"geo_variation_{i}"
-                )
-            
-            st.write("---")
-
-    def display_geo_readability_results(self, result):
-        """Display GEO readability analysis results"""
-        st.markdown("### 📖 GEO Readability Analysis")
-        
-        # Basic GEO metrics
-        geo_metrics = result.get('geo_readability_metrics', {})
-        if geo_metrics:
-            st.markdown("#### 📊 GEO Content Metrics")
-            col1, col2, col3, col4 = st.columns(4)
-            
-            with col1:
-                st.metric("Total Words", geo_metrics.get('total_words', 0))
-            with col2:
-                st.metric("Questions", geo_metrics.get('questions_count', 0))
-            with col3:
-                st.metric("Headings", geo_metrics.get('headings_count', 0))
-            with col4:
-                st.metric("Lists", geo_metrics.get('lists_count', 0))
-            
-            # Second row
-            col1, col2, col3, col4 = st.columns(4)
-            with col1:
-                st.metric("Entity Mentions", geo_metrics.get('entity_mentions', 0))
-            with col2:
-                st.metric("Data Points", geo_metrics.get('numeric_data_points', 0))
-            with col3:
-                st.metric("Paragraphs", geo_metrics.get('total_paragraphs', 0))
-            with col4:
-                geo_score = result.get('geo_readability_score', 0)
-                st.metric("GEO Readability", f"{geo_score}/10")
-        
-        # AI optimization indicators
-        ai_indicators = result.get('ai_optimization_indicators', {})
-        if ai_indicators:
-            st.markdown("#### 🤖 AI Optimization Indicators")
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                question_ratio = ai_indicators.get('question_ratio', 0)
-                st.metric("Question Ratio", f"{question_ratio:.2%}")
-                structure_score = ai_indicators.get('structure_score', 0)
-                st.metric("Structure Score", f"{structure_score:.1f}/10")
-            
-            with col2:
-                entity_density = ai_indicators.get('entity_density', 0)
-                st.metric("Entity Density", f"{entity_density:.2%}")
-                data_richness = ai_indicators.get('data_richness', 0)
-                st.metric("Data Richness", f"{data_richness:.2%}")
-        
-        # GEO recommendations
-        geo_recommendations = result.get('geo_recommendations', [])
-        if geo_recommendations:
-            st.markdown("#### 💡 GEO Optimization Recommendations")
-            for i, rec in enumerate(geo_recommendations, 1):
-                st.write(f"**{i}.** {rec}")
-
-    def display_geo_entity_results(self, result):
-        """Display GEO entity extraction results"""
-        st.markdown("### 🏷️ GEO Entity Analysis")
-        
-        if result.get('error'):
-            st.error(f"Entity extraction failed: {result['error']}")
-            return
-        
-        geo_entities = result.get('geo_entities', {})
-        if geo_entities:
-            # Display extracted entities
-            for entity_type, entity_data in geo_entities.items():
-                if entity_data:
-                    st.markdown(f"#### {entity_type.replace('_', ' ').title()}")
-                    st.write(entity_data)
-                    st.write("---")
-        
-        # Extraction metadata
-        extraction_success = result.get('extraction_success', False)
-        if extraction_success:
-            st.success("✅ Entity extraction completed successfully")
-            st.write(f"**Content Length:** {result.get('content_length', 0)} characters")
-            st.write(f"**Extraction Method:** {result.get('extraction_method', 'Unknown')}")
-
-    def display_geo_export_options(self, result, optimization_type, original_text):
-        """Display export options for GEO results"""
-        st.markdown("### 📥 Export GEO Results")
-        
-        # Prepare export data
-        export_data = {
-            'timestamp': time.time(),
-            'optimization_type': optimization_type,
-            'original_text': original_text,
-            'original_word_count': len(original_text.split()),
-            'geo_results': result,
-            'rag_enhanced': result.get('rag_enhanced', False) if not isinstance(result, list) else any(r.get('rag_enhanced', False) for r in result),
-            'knowledge_sources': result.get('knowledge_sources', 0) if not isinstance(result, list) else 'multiple'
-        }
-        
-        # Serialize data to JSON
-        export_json = json.dumps(export_data, indent=2, default=str)
-        
-        # Add download button
-        st.download_button(
-            label="📥 Download GEO Analysis Report",
-            data=export_json,
-            file_name=f"geo_{optimization_type}_analysis_{int(time.time())}.json",
-            mime="application/json"
-        )
-
-    # Keep existing methods for other tabs (render_document_qa_tab, render_website_analysis_tab, etc.)
-    # ... (rest of the methods remain the same as in your original code)
+        st.sidebar.markdown("### ℹ️ Components")
+        st.sidebar.markdown("- **Parser**: Extract content from various sources")
+        st.sidebar.markdown("- **Scorer**: Analyze GEO performance")
+        st.sidebar.markdown("- **Optimizer**: Enhance content for AI")
+        st.sidebar.markdown("- **Chunker**: Create vector embeddings")
+        st.sidebar.markdown("- **Exporter**: Generate reports")
     
     def render_document_qa_tab(self):
         """Render Document Q&A tab"""
@@ -705,6 +182,96 @@ class GEOSEOApp:
             except Exception as e:
                 st.error(f"An error occurred: {str(e)}")
     
+    def render_content_enhancement_tab(self):
+        """Render Content Enhancement tab"""
+        st.header("🔧 Content Enhancement")
+        st.markdown("Analyze and optimize your content for better AI/LLM performance.")
+        
+        # Content input
+        input_text = st.text_area(
+            "Enter content to analyze and enhance:", 
+            height=200, 
+            key="enhancement_input"
+        )
+        
+        # Analysis options
+        col1, col2 = st.columns(2)
+        with col1:
+            analyze_only = st.checkbox("Analysis only (no rewriting)", value=False)
+        with col2:
+            include_keywords = st.checkbox("Include keyword suggestions", value=True)
+        
+        # Submit button
+        if st.button("🔧 Analyze & Enhance", key="enhancement_submit"):
+            if not input_text.strip():
+                st.warning("Please enter some content to analyze.")
+                return
+            
+            try:
+                with st.spinner("Analyzing content..."):
+                    # Run content analysis and optimization
+                    result = self.content_optimizer.optimize_content(
+                        input_text,
+                        analyze_only=analyze_only,
+                        include_keywords=include_keywords
+                    )
+                
+                if result.get("error"):
+                    st.error(f"Analysis failed: {result['error']}")
+                    return
+                
+                # Display results
+                if analyze_only:
+                    st.success("Content analysis and enhancement completed successfully!")  
+                    st.markdown("### 📊 Analysis Results")
+                
+                    # Show scores
+                    scores = result.get("scores", {})
+                    if scores:
+                        col1, col2, col3 = st.columns(3)
+
+                        with col1:
+                            clarity = scores.get("clarity", 0)
+                            st.metric("Clarity", f"{clarity}/10")
+
+                        with col2:
+                            structure = scores.get("structuredness", 0)
+                            st.metric("Structure", f"{structure}/10")
+
+                        with col3:
+                            answerability = scores.get("answerability", 0)
+                            st.metric("Answerability", f"{answerability}/10")
+
+                # Show keywords
+                keywords = result.get("keywords", [])
+                if keywords:
+                    st.markdown("#### 🔑 Key Terms")
+                    st.write(", ".join(keywords))
+                
+                # Show optimized content
+                optimized_text = result.get("optimized_text", "")
+                # if optimized_text and not analyze_only:
+                st.markdown("#### ✨ Optimized Content")
+                st.text_area(
+                    "Enhanced version:", 
+                    value=optimized_text, 
+                    height=200, 
+                    key="optimized_output"
+                )
+                
+                # Export option
+                if st.button("📥 Export Results"):
+                    export_data = self.result_exporter.export_enhancement_results(result)
+                    st.download_button(
+                        label="Download Analysis Report",
+                        data=json.dumps(export_data, indent=2),
+                        file_name=f"content_analysis_{int(time.time())}.json",
+                        mime="application/json"
+                    )
+            
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
+    
     def render_website_analysis_tab(self):
         """Render Website GEO Analysis tab"""
         st.header("🌐 Website GEO Analysis")
@@ -932,46 +499,6 @@ class GEOSEOApp:
             tmp_file.write(uploaded_file.read())
             return tmp_file.name
 
-    def render_generate_geo_content_tab(self):
-        """Tab to generate fresh GEO-optimized content using system prompts"""
-        st.header("🧠 Generate GEO Content")
-        st.markdown("Use this tool to generate AI-optimized content from scratch based on your topic or query.")
-
-        # User input
-        user_prompt = st.text_area("Describe the content you want (e.g., topic, style, target audience):", height=150)
-
-        # Continue chat option
-        if "chat_history" not in st.session_state:
-            st.session_state.chat_history = []
-
-        if st.button("🧠 Generate Content"):
-            if not user_prompt.strip():
-                st.warning("Please enter a topic or description.")
-                return
-
-            # Add user message to chat history
-            st.session_state.chat_history.append(HumanMessage(content=user_prompt))
-
-            # Define system prompt for GEO content generation
-            system_prompt = (
-                "You are a Generative Engine Optimization (GEO) content creation specialist. "
-                "Create content that is highly optimized for AI systems, LLMs, and generative search engines. "
-                "Ensure the content includes rich semantics, clear structure, relevant keywords, and is suitable for conversational use, citations, and AI summaries."
-            )
-            st.session_state.chat_history.insert(0, SystemMessagePromptTemplate.from_template(system_prompt).format())
-
-            with st.spinner("Generating GEO-optimized content..."):
-                response = self.llm.invoke(st.session_state.chat_history)
-                st.session_state.chat_history.append(AIMessage(content=response.content))
-                st.success("✅ Content generated successfully!")
-
-        # Display chat history
-        for msg in st.session_state.chat_history:
-            if isinstance(msg, HumanMessage):
-                st.markdown(f"**🧑 You:** {msg.content}")
-            elif isinstance(msg, AIMessage):
-                st.markdown(f"**🤖 Assistant:** {msg.content}")
-
 
 def main():
     """Main entry point"""

requirements.txt

@@ -13,4 +13,8 @@ requests
 numpy
 pandas
 openpyxl
-torch
+torch
+langdetect
+transformers
+sentencepiece
+openai-whisper

utils/lang_utils.py

@@ -0,0 +1,14 @@
+from langdetect import detect
+from transformers import pipeline
+
+# Detect language of the input text
+def detect_language(text: str) -> str:
+    try:
+        return detect(text)
+    except:
+        return "unknown"
+
+# Translate text to English (or another target language)
+def translate_text(text: str, target_lang: str = "en") -> str:
+    translator = pipeline("translation", model="Helsinki-NLP/opus-mt-mul-en")
+    return translator(text)[0]["translation_text"]

utils/optimizer.py

@@ -1,354 +1,562 @@
-# Enhanced Content Optimization Module with RAG for GEO
-# Integrates RAG functionality for better Generative Engine Optimization
+"""
+Content Optimization Module
+Enhances content for better AI/LLM performance and GEO scores
+"""
 
 import json
 import re
 from typing import Dict, Any, List, Optional
 from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
-from langchain.schema import Document
 
 
 class ContentOptimizer:
-    """Enhanced Content Optimizer with RAG capabilities for GEO"""
+    """Main class for optimizing content for AI search engines"""
 
-    def __init__(self, llm, vector_chunker=None):
+    def __init__(self, llm):
         self.llm = llm
-        self.vector_chunker = vector_chunker
         self.setup_prompts()
-        self.setup_geo_knowledge_base()
-
-    def setup_geo_knowledge_base(self):
-        """Initialize GEO best practices knowledge base"""
-        self.geo_knowledge = [
-            """
-            Generative Engine Optimization (GEO) Best Practices:
-            
-            1. Structure for AI Consumption:
-            - Use clear headings and subheadings
-            - Include bullet points and numbered lists
-            - Provide direct, concise answers to common questions
-            - Use schema markup when possible
-            
-            2. Content Format for LLMs:
-            - Answer questions directly in the first sentence
-            - Use "what, why, how" question patterns
-            - Include relevant entities and proper nouns
-            - Maintain factual accuracy with citations
-            
-            3. Semantic Optimization:
-            - Include related terms and synonyms
-            - Use entity-rich content (people, places, organizations)
-            - Connect concepts with clear relationships
-            - Optimize for topic clusters, not just keywords
-            """,
-            
-            """
-            AI Search Visibility Optimization:
-            
-            1. Query Intent Matching:
-            - Address user intent explicitly
-            - Use natural language patterns
-            - Include question-answer pairs
-            - Optimize for conversational queries
-            
-            2. Citation Worthiness:
-            - Include authoritative sources and data
-            - Use specific facts and statistics
-            - Provide expert opinions and insights
-            - Maintain consistent tone and expertise
-            
-            3. Multi-Query Coverage:
-            - Address related questions in the same content
-            - Use comprehensive topic coverage
-            - Include long-tail and specific queries
-            - Provide context for complex topics
-            """,
-            
-            """
-            Content Structure for AI Systems:
-            
-            1. Information Architecture:
-            - Lead with key information
-            - Use inverted pyramid structure
-            - Include table of contents for long content
-            - Break complex topics into digestible sections
-            
-            2. Conversational Readiness:
-            - Write in active voice
-            - Use clear, direct language
-            - Include transitional phrases
-            - Optimize sentence length (12-20 words)
-            
-            3. Context Completeness:
-            - Define technical terms
-            - Provide background information
-            - Include relevant examples
-            - Connect to broader topic context
-            """
-        ]
 
     def setup_prompts(self):
-        """Initialize optimization prompts with RAG integration"""
-        self.rag_enhancement_prompt = """
-            You are a Generative Engine Optimization (GEO) specialist with access to best practices knowledge.
-            
-            Based on the provided GEO knowledge and the user's content, optimize the content for:
-            1. AI search engines (ChatGPT, Claude, Gemini)
-            2. LLM-based question answering systems
-            3. Conversational AI interfaces
-            4. Citation and reference systems
-            
-            Use the knowledge base to inform your optimization decisions.
-            
-            Knowledge Base Context:
-            {context}
-            
-            Original Content:
-            {content}
-            
-            Provide comprehensive GEO optimization in JSON format:
-            ```json
-            {{
-              "geo_analysis": {{
-                "current_geo_score": 7.5,
-                "ai_search_visibility": 8.0,
-                "query_intent_matching": 7.0,
-                "conversational_readiness": 8.5,
-                "citation_worthiness": 6.5,
-                "context_completeness": 7.5
-              }},
-              "optimization_opportunities": [
-                {{
-                  "type": "Structure Enhancement",
-                  "description": "Add clear headings and Q&A format",
-                  "priority": "high",
-                  "expected_impact": "Improve AI parsing by 25%"
-                }}
-              ],
-              "optimized_content": {{
-                "enhanced_text": "Your optimized content here...",
-                "structural_improvements": ["Added FAQ section", "Improved headings"],
-                "semantic_enhancements": ["Added related terms", "Improved entity density"]
-              }},
-              "geo_keywords": {{
-                "primary_entities": ["entity1", "entity2"],
-                "semantic_terms": ["term1", "term2"],
-                "question_patterns": ["What is...", "How does..."],
-                "related_concepts": ["concept1", "concept2"]
-              }},
-              "recommendations": [
-                "Add more specific examples",
-                "Include authoritative citations",
-                "Improve conversational flow"
-              ]
-            }}
-            ```
-        """.strip()
-        
-        self.competitive_geo_prompt = """
-            Analyze the content against GEO best practices and identify competitive optimization opportunities.
-
-            GEO Knowledge Base:
-            {context}
+        """Initialize optimization prompts"""
 
-            Content to Analyze:
-            {content}
+        # Main content enhancement prompt
+        self.enhancement_prompt = (
+            "You are an AI Content Enhancement Specialist. Your purpose is to optimize user-provided text to maximize its effectiveness for large language models (LLMs) in search, question-answering, and conversational AI systems.\n\n"
+            "Evaluate the input text based on the following criteria, assigning a score from 1-10 for each:\n"
+            "- Clarity: How easily can the content be understood?\n"
+            "- Structuredness: How well-organized and coherent is the content?\n"
+            "- LLM Answerability: How easily can an LLM extract precise answers from the content?\n\n"
+            "Identify the most salient keywords.\n\n"
+            "Rewrite the text to improve:\n"
+            "- Clarity and precision\n"
+            "- Logical structure and flow\n"
+            "- Suitability for LLM-based information retrieval\n\n"
+            "Present your analysis and optimized text in the following JSON format:\n"
+            "```json\n"
+            "{{\n"
+            "  \"scores\": {{\n"
+            "    \"clarity\": 8.5,\n"
+            "    \"structuredness\": 7.0,\n"
+            "    \"answerability\": 9.0\n"
+            "  }},\n"
+            "  \"keywords\": [\"example\", \"installation\", \"setup\"],\n"
+            "  \"optimized_text\": \"...\"\n"
+            "}}\n"
+            "```"
+        )
 
-            Provide competitive GEO analysis:
-            ```json
-            {{
-              "competitive_gaps": {{
-                "missing_question_patterns": ["What questions aren't covered"],
-                "entity_gaps": ["Important entities not mentioned"],
-                "semantic_opportunities": ["Related terms to include"],
-                "structural_weaknesses": ["Formatting issues for AI"]
-              }},
-              "benchmark_comparison": {{
-                "current_performance": {{
-                  "ai_answerability": 6.5,
-                  "semantic_richness": 7.0,
-                  "structural_clarity": 8.0
-                }},
-                "optimization_potential": {{
-                  "ai_answerability": 9.0,
-                  "semantic_richness": 8.5,
-                  "structural_clarity": 9.5
-                }}
-              }},
-              "action_plan": [
-                {{
-                  "priority": "high",
-                  "action": "Add FAQ section",
-                  "rationale": "Improves direct question answering"
-                }}
-              ]
-            }}
-            ```
-        """.strip()
+        # SEO-style optimization prompt
+        self.seo_style_prompt = (
+            "You are an AI-first SEO specialist. Optimize this content for AI search engines and LLM systems. "
+            "Focus on:\n"
+            "1. Semantic keyword optimization\n"
+            "2. Question-answer format enhancement\n"
+            "3. Factual accuracy and authority signals\n"
+            "4. Conversational readiness\n"
+            "5. Citation-worthy structure\n"
+            "Provide analysis and optimization in JSON:\n"
+            "```json\n"
+            "{{\n"
+            "  \"seo_analysis\": {{\n"
+            "    \"keyword_density\": \"analysis of current keywords\",\n"
+            "    \"semantic_gaps\": [\"missing semantic terms\"],\n"
+            "    \"readability_score\": 8.5,\n"
+            "    \"authority_signals\": [\"credentials\", \"citations\"]\n"
+            "  }},\n"
+            "  \"optimized_content\": {{\n"
+            "    \"title_suggestions\": [\"optimized title 1\", \"optimized title 2\"],\n"
+            "    \"meta_description\": \"AI-optimized meta description\",\n"
+            "    \"enhanced_content\": \"full optimized content...\",\n"
+            "    \"structured_data_suggestions\": [\"schema markup recommendations\"]\n"
+            "  }},\n"
+            "  \"improvement_summary\": {{\n"
+            "    \"changes_made\": [\"change 1\", \"change 2\"],\n"
+            "    \"expected_impact\": \"description of expected improvements\"\n"
+            "  }}\n"
+            "}}\n"
+            "```"
+        )
 
-
-    def optimize_content_with_rag(self, content: str, optimization_type: str = "geo_standard", analyze_only: bool = False) -> Dict[str, Any]:
+        # Competitive content analysis prompt
+        self.competitive_analysis_prompt = (
+            "Compare this content against best practices for AI search optimization. Identify gaps and opportunities.\n"
+            "Original Content: {content}\n"
+            "Analyze against these AI search factors:\n"
+            "- Entity recognition and linking\n"
+            "- Question coverage completeness\n"
+            "- Factual statement clarity\n"
+            "- Conversational flow\n"
+            "- Semantic relationship mapping\n\n"
+            "Provide competitive analysis in JSON format with specific recommendations:\n"
+            "{{\n"
+            "  \"competitive_analysis\": {{\n"
+            "    \"entity_gaps\": [\"gap1\", \"gap2\"],\n"
+            "    \"question_coverage\": \"summary of coverage\",\n"
+            "    \"factual_clarity\": \"assessment\",\n"
+            "    \"conversational_flow\": \"assessment\",\n"
+            "    \"semantic_relationships\": [\"relationship1\", \"relationship2\"]\n"
+            "  }},\n"
+            "  \"recommendations\": [\"recommendation 1\", \"recommendation 2\"]\n"
+            "}}\n"
+        )
+    
+    def optimize_content(self, content: str, analyze_only: bool = False, 
+                        include_keywords: bool = True, optimization_type: str = "standard") -> Dict[str, Any]:
+        """
+            Main content optimization function
+            Args:
+                content (str): Content to optimize
+                analyze_only (bool): If True, only analyze without rewriting
+                include_keywords (bool): Whether to include keyword analysis
+                optimization_type (str): Type of optimization ("standard", "seo", "competitive")  
+            Returns:
+                Dict: Optimization results with scores and enhanced content
+        """
         try:
-            knowledge_docs = [Document(page_content=k, metadata={"source": "geo_best_practices"}) for k in self.geo_knowledge]
-            context = "\n\n".join(self.geo_knowledge)
-
-            if self.vector_chunker:
-                qa_chain = self.vector_chunker.create_qa_chain(knowledge_docs, self.llm)
-                geo_query = f"How to optimize this type of content for AI search engines: {content[:500]}"
-                context_result = qa_chain({"query": geo_query})
-                context = context_result.get("result", context)
-
-            return self._competitive_geo_optimization(content, context) if optimization_type == "competitive_geo" else self._standard_geo_optimization(content, context, analyze_only)
-
+            # Choose optimization approach
+            if optimization_type == "seo":
+                return self._seo_style_optimization(content, analyze_only)
+            elif optimization_type == "competitive":
+                return self._competitive_optimization(content)
+            else:
+                return self._standard_optimization(content, analyze_only, include_keywords)
+                
         except Exception as e:
-            return {"error": f"RAG-enhanced optimization failed: {str(e)}"}
-
-    def _standard_geo_optimization(self, content: str, context: str, analyze_only: bool) -> Dict[str, Any]:
+            return {'error': f"Optimization failed: {str(e)}"}
+    
+    def _standard_optimization(self, content: str, analyze_only: bool, include_keywords: bool) -> Dict[str, Any]:
+        """Standard content optimization using enhancement prompt"""
         try:
-            prompt = ChatPromptTemplate.from_messages([
-                SystemMessagePromptTemplate.from_template(self.rag_enhancement_prompt),
-                HumanMessagePromptTemplate.from_template("Optimize this content using GEO best practices.")
+            # Modify prompt based on options
+            prompt_text = self.enhancement_prompt
+            
+            if analyze_only:
+                prompt_text = prompt_text.replace(
+                    "Rewrite the text to improve:",
+                    "Analyze the text for potential improvements in:"
+                ).replace(
+                    '"optimized_text": "..."',
+                    '"optimization_suggestions": ["suggestion 1", "suggestion 2"]'
+                )
+            
+            if not include_keywords:
+                prompt_text = prompt_text.replace(
+                    '"keywords": ["example", "installation", "setup"],',
+                    ''
+                )
+            
+            # Create and run chain
+            prompt_template = ChatPromptTemplate.from_messages([
+                 SystemMessagePromptTemplate.from_template(prompt_text),
+                HumanMessagePromptTemplate.from_template(content[:6000])  # Limit content length
             ])
-            result = (prompt | self.llm).invoke({"context": context, "content": content[:5000]})
-            parsed = self._parse_optimization_result(getattr(result, 'content', str(result)))
-            parsed.update({
-                'optimization_type': 'geo_standard',
-                'rag_enhanced': True,
+                # ("system", prompt_text),
+                # ("user", content[:6000])  # Limit content length
+            
+            chain = prompt_template | self.llm
+            result = chain.invoke({})
+            
+            # Parse result
+            result_content = result.content if hasattr(result, 'content') else str(result)
+            parsed_result = self._parse_optimization_result(result_content)
+            
+            # Add metadata
+            parsed_result.update({
+                'optimization_type': 'standard',
                 'analyze_only': analyze_only,
                 'original_length': len(content),
-                'knowledge_sources': len(self.geo_knowledge)
+                'original_word_count': len(content.split())
             })
-            return parsed
+            
+            return parsed_result
+            
         except Exception as e:
-            return {"error": f"Standard GEO optimization failed: {str(e)}"}
-
-    def _competitive_geo_optimization(self, content: str, context: str) -> Dict[str, Any]:
+            return {'error': f"Standard optimization failed: {str(e)}"}
+    
+    def _seo_style_optimization(self, content: str, analyze_only: bool) -> Dict[str, Any]:
+        """SEO-focused optimization for AI search engines"""
+        try:
+            prompt_template = ChatPromptTemplate.from_messages([
+                ("system", self.seo_style_prompt),
+                ("user", f"Optimize this content for AI search engines:\n\n{content[:6000]}")
+            ])
+            
+            chain = prompt_template | self.llm
+            result = chain.invoke({})
+            
+            result_content = result.content if hasattr(result, 'content') else str(result)
+            parsed_result = self._parse_optimization_result(result_content)
+            
+            # Add SEO-specific metadata
+            parsed_result.update({
+                'optimization_type': 'seo',
+                'analyze_only': analyze_only,
+                'seo_focused': True
+            })
+            
+            return parsed_result
+            
+        except Exception as e:
+            return {'error': f"SEO optimization failed: {str(e)}"}
+    
+    def _competitive_optimization(self, content: str) -> Dict[str, Any]:
+        """Competitive analysis-based optimization"""
         try:
-            prompt = ChatPromptTemplate.from_messages([
-                SystemMessagePromptTemplate.from_template(self.competitive_geo_prompt),
-                HumanMessagePromptTemplate.from_template("Perform competitive GEO analysis.")
+            formatted_prompt = self.competitive_analysis_prompt.format(content=content[:5000])
+            
+            prompt_template = ChatPromptTemplate.from_messages([
+                ("system", formatted_prompt),
+                ("user", "Perform the competitive analysis and provide optimization recommendations.")
             ])
-            result = (prompt | self.llm).invoke({"context": context, "content": content[:5000]})
-            parsed = self._parse_optimization_result(getattr(result, 'content', str(result)))
-            parsed.update({
-                'optimization_type': 'competitive_geo',
-                'rag_enhanced': True,
+            
+            chain = prompt_template | self.llm
+            result = chain.invoke({})
+            
+            result_content = result.content if hasattr(result, 'content') else str(result)
+            parsed_result = self._parse_optimization_result(result_content)
+            
+            parsed_result.update({
+                'optimization_type': 'competitive',
                 'competitive_analysis': True
             })
-            return parsed
+            
+            return parsed_result
+            
         except Exception as e:
-            return {"error": f"Competitive GEO optimization failed: {str(e)}"}
-
-    def batch_optimize_with_rag(self, content_list: List[str], optimization_type: str = "geo_standard") -> List[Dict[str, Any]]:
+            return {'error': f"Competitive optimization failed: {str(e)}"}
+    
+    def batch_optimize_content(self, content_list: List[str], optimization_type: str = "standard") -> List[Dict[str, Any]]:
+        """
+        Optimize multiple pieces of content in batch
+        
+        Args:
+            content_list (List[str]): List of content pieces to optimize
+            optimization_type (str): Type of optimization to apply
+            
+        Returns:
+            List[Dict]: List of optimization results
+        """
         results = []
+        
         for i, content in enumerate(content_list):
             try:
-                result = self.optimize_content_with_rag(content, optimization_type)
+                result = self.optimize_content(
+                    content, 
+                    optimization_type=optimization_type
+                )
                 result['batch_index'] = i
                 results.append(result)
+                
             except Exception as e:
                 results.append({
                     'batch_index': i,
-                    'error': f"Batch GEO optimization failed: {str(e)}"
+                    'error': f"Batch optimization failed: {str(e)}"
                 })
+        
         return results
+    
+    def generate_content_variations(self, content: str, num_variations: int = 3) -> List[Dict[str, Any]]:
+        """
+        Generate multiple optimized variations of the same content
+        
+        Args:
+            content (str): Original content
+            num_variations (int): Number of variations to generate
+            
+        Returns:
+            List[Dict]: List of content variations with analysis
+        """
+        variations = []
+        
+        variation_prompts = [
+            "Create a more conversational version optimized for AI chat responses",
+            "Create a more authoritative version optimized for citations",
+            "Create a more structured version optimized for question-answering"
+        ]
+        
+        for i in range(min(num_variations, len(variation_prompts))):
+            try:
+                custom_prompt = f"""You are optimizing content for AI systems. {variation_prompts[i]}.
 
-    def analyze_geo_readability(self, content: str) -> Dict[str, Any]:
+Original content: {content[:4000]}
+
+Provide the optimized variation in JSON format:
+```json
+{{
+"variation_type": "conversational/authoritative/structured",
+"optimized_content": "the rewritten content...",
+"key_changes": ["change 1", "change 2"],
+"target_use_case": "description of ideal use case"
+}}
+```"""
+                
+                prompt_template = ChatPromptTemplate.from_messages([
+                    ("system", custom_prompt),
+                    ("user", "Generate the variation.")
+                ])
+                
+                chain = prompt_template | self.llm
+                result = chain.invoke({})
+                
+                result_content = result.content if hasattr(result, 'content') else str(result)
+                parsed_result = self._parse_optimization_result(result_content)
+                
+                parsed_result.update({
+                    'variation_index': i,
+                    'variation_prompt': variation_prompts[i]
+                })
+                
+                variations.append(parsed_result)
+                
+            except Exception as e:
+                variations.append({
+                    'variation_index': i,
+                    'error': f"Variation generation failed: {str(e)}"
+                })
+        
+        return variations
+    
+    def analyze_content_readability(self, content: str) -> Dict[str, Any]:
+        """
+        Analyze content readability for AI systems
+        
+        Args:
+            content (str): Content to analyze
+            
+        Returns:
+            Dict: Readability analysis results
+        """
         try:
+            # Basic readability metrics
             words = content.split()
-            sentences = [s.strip() for s in re.split(r'[.!?]+', content) if s.strip()]
+            sentences = re.split(r'[.!?]+', content)
+            sentences = [s.strip() for s in sentences if s.strip()]
+            
             paragraphs = [p.strip() for p in content.split('\n\n') if p.strip()]
-
-            metrics = {
-                'questions': len(re.findall(r'\?', content)),
-                'headings': len(re.findall(r'^#+\s', content, re.MULTILINE)),
-                'lists': len(re.findall(r'^\s*[-*+]\s', content, re.MULTILINE)),
-                'entities': len(re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', content)),
-                'numbers': len(re.findall(r'\b\d+\.?\d*\b', content)),
-                'sentence_count': len(sentences),
-                'word_count': len(words)
-            }
-
-            geo_score = self._calculate_geo_readability_score({
-                'avg_words_per_sentence': metrics['word_count'] / metrics['sentence_count'] if metrics['sentence_count'] else 0,
-                'questions_ratio': metrics['questions'] / metrics['sentence_count'] if metrics['sentence_count'] else 0,
-                'structure_elements': metrics['headings'] + metrics['lists'],
-                'entity_density': metrics['entities'] / metrics['word_count'] if metrics['word_count'] else 0,
-                'numeric_data': metrics['numbers'] / metrics['word_count'] if metrics['word_count'] else 0
-            })
-
+            
+            # Calculate metrics
+            avg_words_per_sentence = len(words) / len(sentences) if sentences else 0
+            avg_sentences_per_paragraph = len(sentences) / len(paragraphs) if paragraphs else 0
+            
+            # Character-based metrics
+            avg_word_length = sum(len(word) for word in words) / len(words) if words else 0
+            
+            # Complexity indicators
+            long_sentences = [s for s in sentences if len(s.split()) > 20]
+            complex_words = [w for w in words if len(w) > 6]
+            
             return {
-                'geo_readability_metrics': metrics,
-                'geo_readability_score': geo_score,
-                'geo_recommendations': self._generate_geo_recommendations(metrics)
+                'basic_metrics': {
+                    'total_words': len(words),
+                    'total_sentences': len(sentences),
+                    'total_paragraphs': len(paragraphs),
+                    'avg_words_per_sentence': avg_words_per_sentence,
+                    'avg_sentences_per_paragraph': avg_sentences_per_paragraph,
+                    'avg_word_length': avg_word_length
+                },
+                'complexity_indicators': {
+                    'long_sentences_count': len(long_sentences),
+                    'long_sentences_percentage': len(long_sentences) / len(sentences) * 100 if sentences else 0,
+                    'complex_words_count': len(complex_words),
+                    'complex_words_percentage': len(complex_words) / len(words) * 100 if words else 0
+                },
+                'ai_readability_score': self._calculate_ai_readability_score({
+                    'avg_words_per_sentence': avg_words_per_sentence,
+                    'avg_word_length': avg_word_length,
+                    'complex_words_percentage': len(complex_words) / len(words) * 100 if words else 0
+                }),
+                'recommendations': self._generate_readability_recommendations({
+                    'avg_words_per_sentence': avg_words_per_sentence,
+                    'long_sentences_percentage': len(long_sentences) / len(sentences) * 100 if sentences else 0,
+                    'complex_words_percentage': len(complex_words) / len(words) * 100 if words else 0
+                })
             }
+            
         except Exception as e:
-            return {'error': f"GEO readability analysis failed: {str(e)}"}
+            return {'error': f"Readability analysis failed: {str(e)}"}
+    
+    def extract_key_entities(self, content: str) -> Dict[str, Any]:
+        """
+        Extract key entities and topics for optimization
+        
+        Args:
+            content (str): Content to analyze
+            
+        Returns:
+            Dict: Extracted entities and topics
+        """
+        try:
+            entity_prompt = """Extract key entities, topics, and concepts from this content for AI optimization.
 
-    def _calculate_geo_readability_score(self, m: Dict[str, float]) -> float:
+Content: {content}
+
+Identify:
+1. Named entities (people, places, organizations)
+2. Key concepts and topics
+3. Technical terms and jargon
+4. Potential semantic keywords
+5. Question-answer opportunities
+
+Format as JSON:
+```json
+{{
+"named_entities": ["entity1", "entity2"],
+"key_topics": ["topic1", "topic2"],
+"technical_terms": ["term1", "term2"],
+"semantic_keywords": ["keyword1", "keyword2"],
+"question_opportunities": ["What is...", "How does..."],
+"entity_relationships": ["relationship descriptions"]
+}}
+```"""
+            
+            prompt_template = ChatPromptTemplate.from_messages([
+                ("system", entity_prompt.format(content=content[:5000])),
+                ("user", "Extract the entities and topics.")
+            ])
+            
+            chain = prompt_template | self.llm
+            result = chain.invoke({})
+            
+            result_content = result.content if hasattr(result, 'content') else str(result)
+            return self._parse_optimization_result(result_content)
+            
+        except Exception as e:
+            return {'error': f"Entity extraction failed: {str(e)}"}
+    
+    def optimize_for_voice_search(self, content: str) -> Dict[str, Any]:
+        """
+        Optimize content specifically for voice search and conversational AI
+        
+        Args:
+            content (str): Content to optimize
+            
+        Returns:
+            Dict: Voice search optimization results
+        """
         try:
-            score = (
-                max(0, 10 - abs(m['avg_words_per_sentence'] - 15) * 0.3) * 0.2 +
-                min(10, m['questions_ratio'] * 50) * 0.25 +
-                min(10, m['structure_elements'] * 1.5) * 0.25 +
-                min(10, m['entity_density'] * 100) * 0.15 +
-                min(10, m['numeric_data'] * 200) * 0.15
-            )
-            return round(score, 1)
-        except Exception:
-            return 5.0
+            voice_prompt = """Optimize this content for voice search and conversational AI systems.
 
-    def _generate_geo_recommendations(self, m: Dict[str, int]) -> List[str]:
-        r = []
-        if m['questions'] == 0:
-            r.append("Add FAQ section or question-based headings.")
-        if m['headings'] < 2:
-            r.append("Use more structured headings.")
-        if m['lists'] == 0:
-            r.append("Include bullet points or numbered lists.")
-        if m['entities'] < 5:
-            r.append("Add named or topical entities.")
-        if m['questions'] / m['sentence_count'] < 0.1:
-            r.append("Transform statements into Q&A pairs.")
-        return r
+Focus on:
+1. Natural language patterns
+2. Question-based structure
+3. Conversational tone
+4. Clear, direct answers
+5. Featured snippet optimization
 
-    def _clean_json_string(self, json_str: str) -> str:
-        json_str = json_str.replace("...", "")
-        json_str = re.sub(r",\s*([}\]])", r"\\1", json_str)
-        json_str = json_str.strip('`')
-        return json_str
+Original content: {content}
 
+Provide optimization in JSON:
+```json
+{{
+"voice_optimized_content": "conversational version...",
+"question_answer_pairs": [
+  {{"question": "What is...", "answer": "Direct answer..."}},
+  {{"question": "How does...", "answer": "Step by step..."}}
+],
+"featured_snippet_candidates": ["snippet 1", "snippet 2"],
+"natural_language_improvements": ["improvement 1", "improvement 2"],
+"conversational_score": 8.5
+}}
+```"""
+            
+            prompt_template = ChatPromptTemplate.from_messages([
+                ("system", voice_prompt.format(content=content[:4000])),
+                ("user", "Optimize for voice search.")
+            ])
+            
+            chain = prompt_template | self.llm
+            result = chain.invoke({})
+            
+            result_content = result.content if hasattr(result, 'content') else str(result)
+            parsed_result = self._parse_optimization_result(result_content)
+            
+            parsed_result.update({
+                'optimization_type': 'voice_search',
+                'voice_optimized': True
+            })
+            
+            return parsed_result
+            
+        except Exception as e:
+            return {'error': f"Voice search optimization failed: {str(e)}"}
+    
     def _parse_optimization_result(self, response_text: str) -> Dict[str, Any]:
+        """Parse LLM response and extract structured results"""
         try:
-            start = response_text.find('{')
-            end = response_text.rfind('}') + 1
-            if start != -1 and end != -1:
-                json_str = self._clean_json_string(response_text[start:end])
-                return json.loads(json_str)
-            return {
-                'raw_response': response_text,
-                'parsing_error': 'No JSON structure found in response',
-                'geo_analysis': {},
-                'recommendations': []
-            }
+            # 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]
+                parsed = json.loads(json_str)
+                
+                # Ensure consistent structure
+                if 'scores' not in parsed and 'score' in parsed:
+                    parsed['scores'] = parsed['score']
+                
+                return parsed
+            else:
+                # If no JSON found, return raw response with error flag
+                return {
+                    'raw_response': response_text,
+                    'parsing_error': 'No JSON structure found in response',
+                    'scores': {'clarity': 0, 'structuredness': 0, 'answerability': 0}
+                }
+                
         except json.JSONDecodeError as e:
             return {
                 'raw_response': response_text,
                 'parsing_error': f'JSON decode error: {str(e)}',
-                'geo_analysis': {},
-                'recommendations': []
+                'scores': {'clarity': 0, 'structuredness': 0, 'answerability': 0}
             }
         except Exception as e:
             return {
                 'raw_response': response_text,
-                'parsing_error': f'Unexpected error: {str(e)}',
-                'geo_analysis': {},
-                'recommendations': []
+                'parsing_error': f'Unexpected parsing error: {str(e)}',
+                'scores': {'clarity': 0, 'structuredness': 0, 'answerability': 0}
             }
-
-    # Legacy support methods
-    def optimize_content(self, content: str, analyze_only: bool = False, include_keywords: bool = True, optimization_type: str = "standard") -> Dict[str, Any]:
-        return self.optimize_content_with_rag(content, optimization_type, analyze_only)
-
-    def analyze_content_readability(self, content: str) -> Dict[str, Any]:
-        return self.analyze_geo_readability(content)
+    
+    def _calculate_ai_readability_score(self, metrics: Dict[str, float]) -> float:
+        """Calculate AI-specific readability score"""
+        try:
+            # Optimal ranges for AI consumption
+            optimal_words_per_sentence = 15  # Sweet spot for AI processing
+            optimal_word_length = 5  # Balance of complexity and clarity
+            optimal_complex_words_percentage = 15  # Some complexity is good for authority
+            
+            # Calculate deviations from optimal
+            sentence_score = max(0, 10 - abs(metrics['avg_words_per_sentence'] - optimal_words_per_sentence) * 0.5)
+            word_length_score = max(0, 10 - abs(metrics['avg_word_length'] - optimal_word_length) * 2)
+            complexity_score = max(0, 10 - abs(metrics['complex_words_percentage'] - optimal_complex_words_percentage) * 0.3)
+            
+            # Weighted average
+            overall_score = (sentence_score * 0.4 + word_length_score * 0.3 + complexity_score * 0.3)
+            
+            return round(overall_score, 1)
+            
+        except Exception:
+            return 5.0  # Default neutral score
+    
+    def _generate_readability_recommendations(self, metrics: Dict[str, float]) -> List[str]:
+        """Generate specific readability improvement recommendations"""
+        recommendations = []
+        
+        try:
+            if metrics['avg_words_per_sentence'] > 20:
+                recommendations.append("Break down long sentences for better AI processing")
+            elif metrics['avg_words_per_sentence'] < 8:
+                recommendations.append("Consider combining very short sentences for better context")
+            
+            if metrics['long_sentences_percentage'] > 30:
+                recommendations.append("Reduce the number of complex sentences (>20 words)")
+            
+            if metrics['complex_words_percentage'] > 25:
+                recommendations.append("Simplify vocabulary where possible for broader accessibility")
+            elif metrics['complex_words_percentage'] < 5:
+                recommendations.append("Add more specific terminology to establish authority")
+            
+            return recommendations
+            
+        except Exception:
+            return ["Unable to generate specific recommendations"]