Update app.py

app.py

@@ -39,15 +39,6 @@ def detect_and_translate_to_english(text: str) -> str:
 
 
 # Assume `translated_content` is your PDF or webpage content in text format (after translation)
-vectorstore = create_vectorstore_from_text(translated_content)
-rag_chain = create_rag_chain(vectorstore)
-
-# User input query
-query = st.text_input("Ask a question related to your uploaded content:")
-if query:
-    result = rag_chain.run(query)
-    st.success("Answer from the RAG system:")
-    st.write(result)
 
 
 class GEOSEOApp:
@@ -204,8 +195,12 @@ class GEOSEOApp:
                 
                 # 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})
+                    # Create new vectorstore and update RAG
+                    vectorstore = create_vectorstore_from_text(documents, self.embeddings)
+                    st.session_state.rag_chain = create_rag_chain(self.llm, vectorstore)
+
+                    result = st.session_state.rag_chain.invoke({"question": user_query})
+
                 
                 # Display results
                 st.markdown("### 💬 Answer")
@@ -225,187 +220,211 @@ class GEOSEOApp:
                 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.")
+    """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
             
-            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:
-                if optimized_text :
-                    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"
-                    )
+            # Display results
+            if analyze_only:
+                st.success("Content analysis completed successfully!")  
+                st.markdown("### 📊 Analysis Results")
             
-            except Exception as e:
-                st.error(f"An error occurred: {str(e)}")
+                # 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:
+                st.markdown("#### ✨ Optimized Content")
+                st.text_area(
+                    "Enhanced version:", 
+                    value=optimized_text, 
+                    height=200, 
+                    key="optimized_output"
+                )
+
+            # ✅ Optional RAG-based Q&A on the analyzed content
+            st.markdown("### 💬 Ask a question about the analyzed content:")
+            user_query = st.text_input("Enter your question:", key="enhancement_q")
+
+            if user_query:
+                from langchain.docstore.document import Document
+                new_doc = Document(page_content=optimized_text or input_text)
+                vectorstore = create_vectorstore_from_text([new_doc], self.embeddings)
+                st.session_state.rag_chain = create_rag_chain(self.llm, vectorstore)
+
+                result = st.session_state.rag_chain.invoke({"question": user_query})
+                st.success("Answer:")
+                st.write(result["result"])
+
+            # 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")
-        st.markdown("Analyze websites for Generative Engine Optimization (GEO) performance.")
-        
-        # URL input
-        col1, col2 = st.columns([3, 1])
-        
-        with col1:
-            website_url = st.text_input(
-                "Enter website URL:", 
-                placeholder="https://example.com"
-            )
-        
-        with col2:
-            max_pages = st.selectbox("Pages to analyze:", [1, 3, 5], index=0)
-        
-        # Analysis options
-        col1, col2 = st.columns(2)
-        with col1:
-            include_subpages = st.checkbox("Include subpages", value=False)
-        with col2:
-            detailed_analysis = st.checkbox("Detailed analysis", value=True)
-        
-        # Submit button
-        if st.button("🌐 Analyze Website", key="website_analyze"):
-            if not website_url.strip():
-                st.warning("Please enter a website URL.")
-                return
+   def render_website_analysis_tab(self):
+    """Render Website GEO Analysis tab"""
+    st.header("🌐 Website GEO Analysis")
+    st.markdown("Analyze websites for Generative Engine Optimization (GEO) performance.")
+    
+    # URL input
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        website_url = st.text_input("Enter website URL:", placeholder="https://example.com")
+    with col2:
+        max_pages = st.selectbox("Pages to analyze:", [1, 3, 5], index=0)
+    
+    # Analysis options
+    col1, col2 = st.columns(2)
+    with col1:
+        include_subpages = st.checkbox("Include subpages", value=False)
+    with col2:
+        detailed_analysis = st.checkbox("Detailed analysis", value=True)
+    
+    # Submit button
+    if st.button("🌐 Analyze Website", key="website_analyze"):
+        if not website_url.strip():
+            st.warning("Please enter a website URL.")
+            return
+        
+        try:
+            # Normalize URL
+            if not website_url.startswith(('http://', 'https://')):
+                website_url = 'https://' + website_url
             
-            try:
-                # Normalize URL
-                if not website_url.startswith(('http://', 'https://')):
-                    website_url = 'https://' + website_url
-                
-                with st.spinner(f"Analyzing website: {website_url}"):
-                    # Parse website content
-                    pages_data = self.webpage_parser.parse_website(
-                        website_url, 
-                        max_pages=max_pages,
-                        include_subpages=include_subpages
-                    )
-                    
-                    if not pages_data:
-                        st.error("Could not extract content from the website.")
-                        return
-                    
-                    st.success(f"Successfully extracted content from {len(pages_data)} page(s)")
+            with st.spinner(f"Analyzing website: {website_url}"):
+                # Parse website content
+                pages_data = self.webpage_parser.parse_website(
+                    website_url, 
+                    max_pages=max_pages,
+                    include_subpages=include_subpages
+                )
                 
-                # Analyze GEO scores
-                with st.spinner("Calculating GEO scores..."):
-                    geo_results = []
-                    
-                    for i, page_data in enumerate(pages_data):
-                        with st.spinner(f"Analyzing page {i+1}/{len(pages_data)}..."):
-                            analysis = self.geo_scorer.analyze_page_geo(
-                                page_data['content'],
-                                page_data['title'],
-                                detailed=detailed_analysis
-                            )
-                            
-                            if not analysis.get('error'):
-                                analysis['page_data'] = page_data
-                                geo_results.append(analysis)
-                            else:
-                                st.warning(f"Could not analyze page {i+1}: {analysis['error']}")
-                
-                if not geo_results:
-                    st.error("Could not analyze any pages from the website.")
+                if not pages_data:
+                    st.error("Could not extract content from the website.")
                     return
                 
-                # Display results
-                self.display_geo_results(geo_results, website_url)
-                
-                # Export functionality
-                st.markdown("### 📥 Export Results")
-                if st.button("📊 Generate Full Report"):
-                    report_data = self.result_exporter.export_geo_results(
-                        geo_results, 
-                        website_url
-                    )
-                    
-                    st.download_button(
-                        label="Download GEO Report",
-                        data=json.dumps(report_data, indent=2),
-                        file_name=f"geo_analysis_{website_url.replace('https://', '').replace('/', '_')}.json",
-                        mime="application/json"
-                    )
+                st.success(f"Successfully extracted content from {len(pages_data)} page(s)")
             
-            except Exception as e:
-                st.error(f"An error occurred during website analysis: {str(e)}")
+            # Analyze GEO scores
+            with st.spinner("Calculating GEO scores..."):
+                geo_results = []
+                for i, page_data in enumerate(pages_data):
+                    with st.spinner(f"Analyzing page {i+1}/{len(pages_data)}..."):
+                        analysis = self.geo_scorer.analyze_page_geo(
+                            page_data['content'],
+                            page_data['title'],
+                            detailed=detailed_analysis
+                        )
+                        
+                        if not analysis.get('error'):
+                            analysis['page_data'] = page_data
+                            geo_results.append(analysis)
+                        else:
+                            st.warning(f"Could not analyze page {i+1}: {analysis['error']}")
+            
+            if not geo_results:
+                st.error("Could not analyze any pages from the website.")
+                return
+
+            # Combine all page content for RAG
+            combined_content = "\n\n".join([page['content'] for page in pages_data])
+            from langchain.docstore.document import Document
+            doc = Document(page_content=combined_content)
+
+            vectorstore = create_vectorstore_from_text([doc], self.embeddings)
+            st.session_state.rag_chain = create_rag_chain(self.llm, vectorstore)
+
+            # RAG-based Q&A
+            st.markdown("### 💬 Ask a question about the website:")
+            user_query = st.text_input("Ask here:", key="website_q")
+
+            if user_query:
+                result = st.session_state.rag_chain.invoke({"question": user_query})
+                st.success("Answer:")
+                st.write(result["result"])
+
+            # Display results
+            self.display_geo_results(geo_results, website_url)
+            
+            # Export functionality
+            st.markdown("### 📥 Export Results")
+            if st.button("📊 Generate Full Report"):
+                report_data = self.result_exporter.export_geo_results(
+                    geo_results, 
+                    website_url
+                )
+                st.download_button(
+                    label="Download GEO Report",
+                    data=json.dumps(report_data, indent=2),
+                    file_name=f"geo_analysis_{website_url.replace('https://', '').replace('/', '_')}.json",
+                    mime="application/json"
+                )
+        
+        except Exception as e:
+            st.error(f"An error occurred during website analysis: {str(e)}")
 
     def render_multilingual_tab(self):
         st.markdown("### 🌍 Multilingual Translator")
@@ -560,11 +579,28 @@ class GEOSEOApp:
             return tmp_file.name
 
 
+
 def main():
     """Main entry point"""
+    if "rag_chain" not in st.session_state or st.session_state.rag_chain is None:
+    # Sample base docs to initialize chain (you can also load a default corpus or skip this)
+        from langchain.docstore.document import Document
+        base_docs = [Document(page_content="This is a placeholder document for RAG initialization.")]
+    
+        vectorstore = create_vectorstore_from_text(base_docs, HuggingFaceEmbeddings(
+              model_name="sentence-transformers/all-MiniLM-L6-v2",
+              model_kwargs={"device": "cpu"},
+              cache_folder="./hf_cache",
+    ))
+        st.session_state.rag_chain = create_rag_chain(
+              ChatGroq(api_key=os.getenv("GROQ_API_KEY", "your-groq-api-key"), model_name="llama3-8b-8192", temperature=0.1),
+              vectorstore
+    )
+
+
     app = GEOSEOApp()
     app.run()
 
 
 if __name__ == "__main__":
-    main()
+    main()