Update app.py

app.py

@@ -1,5 +1,5 @@
 """
-Main Streamlit Application - GEO SEO AI Optimizer
+Main Streamlit Application - GEO SEO AI Optimizer with RAG-Enhanced Content Optimization
 Entry point for the application with UI components
 """
 
@@ -8,12 +8,12 @@ import os
 import tempfile
 import json
 from typing import Dict, Any, List
-import time  # Add this if not present
+import time
 
 # Import our custom modules
 from utils.parser import PDFParser, TextParser, WebpageParser
 from utils.scorer import GEOScorer
-from utils.optimizer import ContentOptimizer
+from utils.optimizer import ContentOptimizer  # This will be your enhanced version
 from utils.chunker import VectorChunker
 from utils.export import ResultExporter
 
@@ -46,11 +46,9 @@ class GEOSEOApp:
             temperature=0.1
         )
         
-        # Updated embeddings initialization without the `device` parameter
         self.embeddings = HuggingFaceEmbeddings(
             model_name="sentence-transformers/all-MiniLM-L6-v2",
-            model_kwargs={"device": "cpu"},
-            cache_folder="./hf_cache",
+            model_kwargs={'device': 'cpu'}
         )
     
     def setup_parsers(self):
@@ -60,10 +58,13 @@ class GEOSEOApp:
         self.webpage_parser = WebpageParser()
     
     def setup_components(self):
-        """Initialize processing components"""
+        """Initialize processing components with RAG integration"""
         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):
@@ -75,7 +76,7 @@ class GEOSEOApp:
         )
         
         st.title("🚀 GEO SEO AI Optimizer")
-        st.markdown("*Optimize your content for AI search engines and LLM systems*")
+        st.markdown("*Optimize your content for AI search engines and LLM systems with RAG-enhanced analysis*")
         
         # Sidebar
         self.render_sidebar()
@@ -83,7 +84,7 @@ class GEOSEOApp:
         # Main tabs
         tab1, tab2, tab3 = st.tabs([
             "🌐 Website GEO Analysis",
-            "🔧 Content Enhancement", 
+            "🔧 GEO Content Enhancement", 
             "📄 Document Q&A", 
         ])
         
@@ -91,7 +92,7 @@ class GEOSEOApp:
             self.render_website_analysis_tab()
         
         with tab2:
-            self.render_content_enhancement_tab()
+            self.render_geo_content_enhancement_tab()
         
         with tab3:
             self.render_document_qa_tab()
@@ -100,7 +101,7 @@ class GEOSEOApp:
         """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("- 🔧 RAG-Enhanced Content Optimization")
         st.sidebar.markdown("- 🌐 Website GEO Analysis")
         st.sidebar.markdown("- 📊 AI-First SEO Scoring")
         
@@ -115,299 +116,337 @@ 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("### ℹ️ 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"""
-        st.header("📄 Document Question Answering")
-        st.markdown("Upload documents or paste text to ask questions using RAG.")
-        
-        # File upload
-        uploaded_file = st.file_uploader("Upload a PDF file", type=["pdf"])
-        
-        # Text input
-        pasted_text = st.text_area("Or paste text directly:", height=150)
-        
-        # Question input
-        user_query = st.text_input("Ask a question about the content:")
-        
-        # Submit button
-        if st.button("🔍 Ask Question", key="qa_submit"):
-            if not user_query.strip():
-                st.warning("Please enter a question.")
-                return
-            
-            try:
-                # Parse content
-                documents = []
-                
-                if uploaded_file:
-                    with st.spinner("Processing PDF..."):
-                        # Save uploaded file temporarily
-                        temp_path = self.save_uploaded_file(uploaded_file)
-                        documents = self.pdf_parser.parse(temp_path)
-                        os.unlink(temp_path)  # Clean up
-                
-                elif pasted_text.strip():
-                    with st.spinner("Processing text..."):
-                        documents = self.text_parser.parse(pasted_text)
-                
-                else:
-                    st.warning("Please upload a PDF or paste some text.")
-                    return
-                
-                # Create vector store and answer question
-                with st.spinner("Creating embeddings and searching..."):
-                    qa_chain = self.vector_chunker.create_qa_chain(documents, self.llm)
-                    result = qa_chain({"query": user_query})
-                
-                # Display results
-                st.markdown("### 💬 Answer")
-                st.write(result["result"])
-                
-                # Show sources
-                with st.expander("📄 Source Documents"):
-                    for i, doc in enumerate(result.get("source_documents", [])):
-                        st.write(f"**Source {i+1}:**")
-                        content = doc.page_content
-                        st.write(content[:500] + "..." if len(content) > 500 else content)
-                        if hasattr(doc, 'metadata') and doc.metadata:
-                            st.write(f"*Metadata: {doc.metadata}*")
-                        st.write("---")
-            
-            except Exception as e:
-                st.error(f"An error occurred: {str(e)}")
+        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_content_enhancement_tab(self):
-        """Render Content Enhancement tab with optimization type selector"""
-        st.header("🔧 Content Enhancement")
-        st.markdown("Analyze and optimize your content for better AI/LLM performance.")
+    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="enhancement_input"
+            key="geo_enhancement_input",
+            help="Paste your content here for GEO optimization using RAG-enhanced analysis"
         )
         
-        # Optimization type selector
-        st.markdown("### ⚙️ Optimization Settings")
+        # GEO Optimization type selector
+        st.markdown("### ⚙️ GEO Optimization Settings")
         col1, col2 = st.columns(2)
         
         with col1:
             optimization_type = st.selectbox(
-                "Select Optimization Type:",
+                "Select GEO Optimization Type:",
                 options=[
-                    "standard", 
-                    "seo", 
-                    # "competitive", 
-                    # "voice_search", 
-                    # "batch_optimize",
-                    # "content_variations",
-                    "readability_analysis",
-                    # "entity_extraction"
+                    "geo_standard", 
+                    "competitive_geo", 
+                    "geo_readability",
+                    "geo_entity_extraction",
+                    "geo_variations",
+                    "geo_batch_optimize"
                 ],
                 format_func=lambda x: {
-                    "standard": "🔧 Standard Enhancement",
-                    "seo": "🌐 SEO-Focused Optimization", 
-                    # "competitive": "📊 Competitive Analysis",
-                    # "voice_search": "🎤 Voice Search Optimization",
-                    # "batch_optimize": "📦 Batch Optimization",
-                    # "content_variations": "🔄 Content Variations",
-                    "readability_analysis": "📖 Readability Analysis",
-                    # "entity_extraction": "🏷️ Entity Extraction"
+                    "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 optimization to apply to your content"
+                help="Choose the type of GEO optimization powered by RAG analysis"
             )
         
         with col2:
             # Additional options based on optimization type
-            if optimization_type in ["standard", "seo", "competitive", "readability_analysis"]:
+            if optimization_type in ["geo_standard", "competitive_geo"]:
                 analyze_only = st.checkbox("Analysis only (no rewriting)", value=False)
-                include_keywords = st.checkbox("Include keyword suggestions", value=True)
-            # elif optimization_type == "batch_optimize":
-            #     st.info("For batch optimization, separate multiple content pieces with '---' in the text area above")
-            # elif optimization_type == "content_variations":
-            #     num_variations = st.slider("Number of variations", min_value=1, max_value=5, value=3)
+                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_keywords = True
-                # num_variations = 3
+                include_rag_context = True
         
         # Show description based on optimization type
         optimization_descriptions = {
-            "standard": "General content enhancement focusing on clarity, structure, and AI answerability.",
-            "seo": "SEO-focused optimization for AI search engines with semantic keyword analysis.",
-            # "competitive": "Competitive analysis against AI search best practices with gap identification.",
-            # "voice_search": "Optimization for voice search and conversational AI systems.",
-            # "batch_optimize": "Process multiple content pieces simultaneously.",
-            # "content_variations": "Generate multiple optimized variations of the same content.",
-            "readability_analysis": "Detailed readability analysis specifically for AI systems.",
-            # "entity_extraction": "Extract key entities, topics, and concepts for optimization insights."
+            "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", key="enhancement_submit"):
+        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} optimization..."):
-                    # Handle different optimization types
-                    if optimization_type == "standard":
-                        result = self.content_optimizer.optimize_content(
+                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,
-                            analyze_only=analyze_only,
-                            include_keywords=include_keywords,
-                            optimization_type="standard"
+                            optimization_type="geo_standard",
+                            analyze_only=analyze_only
                         )
                     
-                    elif optimization_type == "seo":
-                        result = self.content_optimizer.optimize_content(
+                    elif optimization_type == "competitive_geo":
+                        result = self.content_optimizer.optimize_content_with_rag(
                             input_text,
-                            analyze_only=analyze_only,
-                            include_keywords=include_keywords,
-                            optimization_type="seo"
+                            optimization_type="competitive_geo",
+                            analyze_only=analyze_only
                         )
                     
-                    # elif optimization_type == "competitive":
-                    #     result = self.content_optimizer.optimize_content(
-                    #         input_text,
-                    #         optimization_type="competitive"
-                    #     )
-                    
-                    # elif optimization_type == "voice_search":
-                    #     result = self.content_optimizer.optimize_for_voice_search(input_text)
+                    elif optimization_type == "geo_readability":
+                        result = self.content_optimizer.analyze_geo_readability(input_text)
                     
-                    # elif optimization_type == "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_content(content_pieces)
-                    #     else:
-                    #         st.warning("For batch optimization, please separate content pieces with '---'")
-                    #         return
+                    elif optimization_type == "geo_entity_extraction":
+                        result = self.content_optimizer.extract_geo_entities(input_text)
                     
-                    # elif optimization_type == "content_variations":
-                    #     result = self.content_optimizer.generate_content_variations(
-                    #         input_text, 
-                    #         num_variations=num_variations
-                    #     )
-                    
-                    elif optimization_type == "readability_analysis":
-                        result = self.content_optimizer.analyze_content_readability(input_text)
+                    elif optimization_type == "geo_variations":
+                        result = self.content_optimizer.generate_geo_variations(
+                            input_text, 
+                            num_variations=num_variations
+                        )
                     
-                    # elif optimization_type == "entity_extraction":
-                    #     result = self.content_optimizer.extract_key_entities(input_text)
+                    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 result.get("error"):
+                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_enhancement_results(result, optimization_type, input_text)
+                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_enhancement_results(self, result, optimization_type, original_text):
-        """Display results based on optimization type"""
-        st.success(f"{optimization_type.title()} optimization completed successfully!")
-        
-        # if optimization_type == "batch_optimize":
-        #     self.display_batch_results(result)
-        # elif optimization_type == "content_variations":
-        #     self.display_variation_results(result)
-        if optimization_type == "readability_analysis":
-            self.display_readability_results(result)
-        # elif optimization_type == "entity_extraction":
-        #     self.display_entity_results(result)
-        # elif optimization_type == "voice_search":
-        #     self.display_voice_search_results(result)
+    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_results(result, optimization_type)
+            self.display_standard_geo_results(result, optimization_type, include_rag_context)
         
         # Export functionality
-        self.display_export_options(result, optimization_type, original_text)
+        self.display_geo_export_options(result, optimization_type, original_text)
 
-    def display_standard_results(self, result, optimization_type):
-        """Display results for standard, SEO, and competitive optimizations"""
-        st.markdown("### 📊 Analysis Results")
-        
-        # Show scores if available
-        scores = result.get("scores", {})
-        if scores:
+    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:
-                clarity = scores.get("clarity", 0)
-                st.metric("Clarity", f"{clarity}/10")
+                query_matching = geo_analysis.get("query_intent_matching", 0)
+                st.metric("Query Intent Match", f"{query_matching}/10")
             
             with col2:
-                structure = scores.get("structuredness", 0)
-                st.metric("Structure", f"{structure}/10")
+                conversational = geo_analysis.get("conversational_readiness", 0)
+                st.metric("Conversational Ready", f"{conversational}/10")
             
             with col3:
-                answerability = scores.get("answerability", 0)
-                st.metric("Answerability", f"{answerability}/10")
-        
-        # Show SEO analysis if available
-        if "seo_analysis" in result:
-            st.markdown("#### 🌐 SEO Analysis")
-            seo_data = result["seo_analysis"]
-            if "readability_score" in seo_data:
-                st.metric("Readability Score", f"{seo_data['readability_score']}/10")
-            if "semantic_gaps" in seo_data:
-                st.write("**Semantic Gaps:**", ", ".join(seo_data["semantic_gaps"]))
-        
-        # Show competitive analysis if available
-        if "competitive_analysis" in result:
-            st.markdown("#### 📊 Competitive Analysis")
-            comp_data = result["competitive_analysis"]
-            for key, value in comp_data.items():
-                if isinstance(value, list):
-                    st.write(f"**{key.replace('_', ' ').title()}:**", ", ".join(value))
-                else:
-                    st.write(f"**{key.replace('_', ' ').title()}:**", value)
+                context_complete = geo_analysis.get("context_completeness", 0)
+                st.metric("Context Complete", f"{context_complete}/10")
         
-        # Show keywords
-        keywords = result.get("keywords", [])
-        if keywords:
-            st.markdown("#### 🔑 Key Terms")
-            st.write(", ".join(keywords))
+        # 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_text") or result.get("optimized_content", {}).get("enhanced_content", "")
+        optimized_content = result.get("optimized_content", {})
         if optimized_content:
-            st.markdown("#### ✨ Optimized Content")
-            st.text_area(
-                "Enhanced version:", 
-                value=optimized_content, 
-                height=200, 
-                key="optimized_output"
-            )
+            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("#### 💡 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_batch_results(self, results):
-        """Display batch optimization results"""
-        st.markdown("### 📦 Batch Processing Results")
+    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')]
@@ -428,28 +467,29 @@ class GEOSEOApp:
             if result.get('error'):
                 st.error(f"Processing failed: {result['error']}")
             else:
-                # Show scores
-                scores = result.get("scores", {})
-                if scores:
+                # Show GEO scores
+                geo_analysis = result.get("geo_analysis", {})
+                if geo_analysis:
                     col1, col2, col3 = st.columns(3)
                     with col1:
-                        st.metric("Clarity", f"{scores.get('clarity', 0)}/10")
+                        st.metric("GEO Score", f"{geo_analysis.get('current_geo_score', 0):.1f}")
                     with col2:
-                        st.metric("Structure", f"{scores.get('structuredness', 0)}/10") 
+                        st.metric("AI Visibility", f"{geo_analysis.get('ai_search_visibility', 0):.1f}")
                     with col3:
-                        st.metric("Answerability", f"{scores.get('answerability', 0)}/10")
+                        st.metric("Citation Worthy", f"{geo_analysis.get('citation_worthiness', 0):.1f}")
                 
                 # Show optimized content if available
-                optimized = result.get("optimized_text", "")
-                if optimized:
-                    with st.expander("View optimized content"):
-                        st.text_area("", value=optimized, height=150, key=f"batch_output_{idx}")
+                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_variation_results(self, variations):
-        """Display content variation results"""
-        st.markdown("### 🔄 Content Variations")
+    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'):
@@ -457,19 +497,26 @@ class GEOSEOApp:
                 continue
             
             variation_type = variation.get('variation_type', f'Variation {i+1}')
-            st.markdown(f"#### {variation_type.title()} Version")
+            st.markdown(f"#### {variation_type.replace('_', ' ').title()} Version")
             
-            # Show variation details
-            target_use_case = variation.get('target_use_case', '')
-            if target_use_case:
-                st.info(f"**Target Use Case:** {target_use_case}")
+            # 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 key changes
-            key_changes = variation.get('key_changes', [])
-            if key_changes:
-                st.write("**Key Changes:**")
-                for change in key_changes:
-                    st.write(f"• {change}")
+            # 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', '')
@@ -477,118 +524,95 @@ class GEOSEOApp:
                 st.text_area(
                     f"{variation_type} content:", 
                     value=optimized_content, 
-                    height=150, 
-                    key=f"variation_{i}"
+                    height=200, 
+                    key=f"geo_variation_{i}"
                 )
             
             st.write("---")
 
-    def display_readability_results(self, result):
-        """Display readability analysis results"""
-        st.markdown("### 📖 Readability Analysis")
-        
-        # Basic metrics
-        basic_metrics = result.get('basic_metrics', {})
-        if basic_metrics:
-            st.markdown("#### 📊 Basic Metrics")
+    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", basic_metrics.get('total_words', 0))
+                st.metric("Total Words", geo_metrics.get('total_words', 0))
             with col2:
-                st.metric("Sentences", basic_metrics.get('total_sentences', 0))
+                st.metric("Questions", geo_metrics.get('questions_count', 0))
             with col3:
-                st.metric("Paragraphs", basic_metrics.get('total_paragraphs', 0))
+                st.metric("Headings", geo_metrics.get('headings_count', 0))
             with col4:
-                st.metric("AI Readability", f"{result.get('ai_readability_score', 0)}/10")
+                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")
         
-        # Complexity indicators
-        complexity = result.get('complexity_indicators', {})
-        if complexity:
-            st.markdown("#### 🎯 Complexity Analysis")
+        # 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:
-                st.metric("Long Sentences", f"{complexity.get('long_sentences_percentage', 0):.1f}%")
+                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:
-                st.metric("Complex Words", f"{complexity.get('complex_words_percentage', 0):.1f}%")
-        
-        # Recommendations
-        recommendations = result.get('recommendations', [])
-        if recommendations:
-            st.markdown("#### 💡 Readability Recommendations")
-            for i, rec in enumerate(recommendations, 1):
+                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_entity_results(self, result):
-        """Display entity extraction results"""
-        st.markdown("### 🏷️ Entity Analysis")
-        
-        # Named entities
-        named_entities = result.get('named_entities', [])
-        if named_entities:
-            st.markdown("#### 👥 Named Entities")
-            st.write(", ".join(named_entities))
-        
-        # Key topics
-        key_topics = result.get('key_topics', [])
-        if key_topics:
-            st.markdown("#### 📋 Key Topics")
-            st.write(", ".join(key_topics))
-        
-        # Technical terms
-        technical_terms = result.get('technical_terms', [])
-        if technical_terms:
-            st.markdown("#### 🔧 Technical Terms")
-            st.write(", ".join(technical_terms))
-        
-        # Semantic keywords
-        semantic_keywords = result.get('semantic_keywords', [])
-        if semantic_keywords:
-            st.markdown("#### 🔍 Semantic Keywords")
-            st.write(", ".join(semantic_keywords))
-        
-        # Question opportunities
-        questions = result.get('question_opportunities', [])
-        if questions:
-            st.markdown("#### ❓ Question Opportunities")
-            for q in questions:
-                st.write(f"• {q}")
+    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_voice_search_results(self, result):
-    #     """Display voice search optimization results"""
-    #     st.markdown("### 🎤 Voice Search Optimization")
-        
-    #     # Conversational score
-    #     conv_score = result.get('conversational_score', 0)
-    #     if conv_score:
-    #         st.metric("Conversational Score", f"{conv_score}/10")
-        
-    #     # Question-answer pairs
-    #     qa_pairs = result.get('question_answer_pairs', [])
-    #     if qa_pairs:
-    #         st.markdown("#### ❓ Question-Answer Pairs")
-    #         for qa in qa_pairs:
-    #             st.write(f"**Q:** {qa.get('question', '')}")
-    #             st.write(f"**A:** {qa.get('answer', '')}")
-    #             st.write("---")
-        
-    #     # Featured snippet candidates
-    #     snippets = result.get('featured_snippet_candidates', [])
-    #     if snippets:
-    #         st.markdown("#### 🌟 Featured Snippet Candidates")
-    #         for i, snippet in enumerate(snippets, 1):
-    #             st.write(f"**{i}.** {snippet}")
-        
-    #     # Voice optimized content
-    #     voice_content = result.get('voice_optimized_content', '')
-    #     if voice_content:
-    #         st.markdown("#### 🎤 Voice-Optimized Content")
-    #         st.text_area("Conversational version:", value=voice_content, height=200, key="voice_output")
-
-    def display_export_options(self, result, optimization_type, original_text):
-        """Display export options for results"""
-        st.markdown("### 📥 Export Results")
+    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 = {
@@ -596,19 +620,85 @@ class GEOSEOApp:
             'optimization_type': optimization_type,
             'original_text': original_text,
             'original_word_count': len(original_text.split()),
-            'results': result
+            '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)
+        export_json = json.dumps(export_data, indent=2, default=str)
         
-        # Add download button for direct download
+        # Add download button
         st.download_button(
-            label="📥 Download Analysis Report",
+            label="📥 Download GEO Analysis Report",
             data=export_json,
-            file_name=f"{optimization_type}_analysis_{int(time.time())}.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)
+    
+    def render_document_qa_tab(self):
+        """Render Document Q&A tab"""
+        st.header("📄 Document Question Answering")
+        st.markdown("Upload documents or paste text to ask questions using RAG.")
+        
+        # File upload
+        uploaded_file = st.file_uploader("Upload a PDF file", type=["pdf"])
+        
+        # Text input
+        pasted_text = st.text_area("Or paste text directly:", height=150)
+        
+        # Question input
+        user_query = st.text_input("Ask a question about the content:")
+        
+        # Submit button
+        if st.button("🔍 Ask Question", key="qa_submit"):
+            if not user_query.strip():
+                st.warning("Please enter a question.")
+                return
+            
+            try:
+                # Parse content
+                documents = []
+                
+                if uploaded_file:
+                    with st.spinner("Processing PDF..."):
+                        # Save uploaded file temporarily
+                        temp_path = self.save_uploaded_file(uploaded_file)
+                        documents = self.pdf_parser.parse(temp_path)
+                        os.unlink(temp_path)  # Clean up
+                
+                elif pasted_text.strip():
+                    with st.spinner("Processing text..."):
+                        documents = self.text_parser.parse(pasted_text)
+                
+                else:
+                    st.warning("Please upload a PDF or paste some text.")
+                    return
+                
+                # Create vector store and answer question
+                with st.spinner("Creating embeddings and searching..."):
+                    qa_chain = self.vector_chunker.create_qa_chain(documents, self.llm)
+                    result = qa_chain({"query": user_query})
+                
+                # Display results
+                st.markdown("### 💬 Answer")
+                st.write(result["result"])
+                
+                # Show sources
+                with st.expander("📄 Source Documents"):
+                    for i, doc in enumerate(result.get("source_documents", [])):
+                        st.write(f"**Source {i+1}:**")
+                        content = doc.page_content
+                        st.write(content[:500] + "..." if len(content) > 500 else content)
+                        if hasattr(doc, 'metadata') and doc.metadata:
+                            st.write(f"*Metadata: {doc.metadata}*")
+                        st.write("---")
+            
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
     
     def render_website_analysis_tab(self):
         """Render Website GEO Analysis tab"""