Update chatbot.py

chatbot.py

@@ -3,143 +3,110 @@ import streamlit as st
 import pandas as pd
 import os
 import tempfile
-
-try:
-    import google.generativeai as genai
-    GEMINI_AVAILABLE = True
-except ImportError:
-    GEMINI_AVAILABLE = False
+import google.generativeai as genai
+from typing import List, Dict, Optional
 
 class ChatbotManager:
     def __init__(self):
-        if GEMINI_AVAILABLE and 'GEMINI_API_KEY' in os.environ:
-            genai.configure(api_key=os.environ['GEMINI_API_KEY'])
-            self.model = genai.GenerativeModel('gemini-pro')
-        else:
-            self.model = None
-        
+        # Configure Gemini
+        self.configure_gemini()
         self.initialize_chat()
     
+    def configure_gemini(self):
+        """Configure the Gemini API"""
+        try:
+            # Try to get API key from environment variable
+            api_key = os.getenv('GEMINI_API_KEY')
+            if not api_key:
+                # Fallback to Streamlit secrets if available
+                try:
+                    api_key = st.secrets['GEMINI_API_KEY']
+                except:
+                    pass
+            
+            if api_key:
+                genai.configure(api_key=api_key)
+                self.model = genai.GenerativeModel('gemini-pro')
+                self.chat = self.model.start_chat(history=[])
+            else:
+                self.model = None
+                self.chat = None
+                st.warning("Gemini API key not found. Using limited functionality mode.")
+        except Exception as e:
+            st.error(f"Error configuring Gemini: {str(e)}")
+            self.model = None
+            self.chat = None
+    
     def initialize_chat(self):
         """Initialize chat session state variables"""
-        if 'uploaded_df' not in st.session_state:
-            st.session_state.uploaded_df = None
         if 'chat_history' not in st.session_state:
             st.session_state.chat_history = []
-    
-    def render_chat(self):
-        """Main chat interface compatible with your pages.py structure"""
-        st.header("💬 AI Business Mentor")
-        
-        # File upload section
-        uploaded_file = st.file_uploader("Upload your business data (CSV)", type=['csv'])
         
-        if uploaded_file is not None:
-            self._process_uploaded_file(uploaded_file)
-        
-        # Chat interface
-        if st.session_state.uploaded_df is not None:
-            self._render_chat_window()
-        else:
-            st.info("Upload a CSV file to chat with your data")
+        # Initialize Gemini chat if not already done
+        if self.model and not hasattr(self, 'chat'):
+            self.chat = self.model.start_chat(history=[])
+    
+    def clear_chat(self):
+        """Clear the chat history"""
+        st.session_state.chat_history = []
+        if self.model:
+            self.chat = self.model.start_chat(history=[])
+        st.success("Chat history cleared!")
+    
+    def add_message(self, role: str, content: str):
+        """Add a message to the chat history"""
+        st.session_state.chat_history.append({
+            "role": role,
+            "content": content
+        })
     
-    def _process_uploaded_file(self, uploaded_file):
-        """Process the uploaded CSV file"""
+    def get_chat_history(self) -> List[Dict]:
+        """Get the chat history"""
+        return st.session_state.chat_history
+    
+    def generate_business_response(self, prompt: str) -> str:
+        """Generate a response to a business-related prompt"""
         try:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as tmp:
-                tmp.write(uploaded_file.getvalue())
-                tmp_path = tmp.name
-            
-            df = pd.read_csv(tmp_path)
-            st.session_state.uploaded_df = df
-            st.success("Data loaded successfully!")
-            
-            with st.expander("View Data Preview"):
-                st.dataframe(df.head())
-            
-            # Clean up temp file
-            os.unlink(tmp_path)
-            
-            # Initial analysis if Gemini is available
-            if self.model:
-                initial_prompt = (
-                    f"Provide a 2-3 sentence overview of this dataset with {len(df)} rows and {len(df.columns)} columns. "
-                    "Then suggest 3 specific business insights we could extract."
+            if self.chat:
+                # Use Gemini chat for contextual responses
+                response = self.chat.send_message(
+                    self._create_business_prompt(prompt),
+                    stream=True
                 )
-                response = self._generate_response(initial_prompt)
-                st.session_state.chat_history.append({
-                    "role": "assistant", 
-                    "content": response
-                })
-                
+                return "".join([chunk.text for chunk in response])
+            else:
+                # Fallback response if Gemini isn't available
+                return self._generate_fallback_response(prompt)
         except Exception as e:
-            st.error(f"Error processing file: {str(e)}")
+            return f"⚠️ Error generating response: {str(e)}"
     
-    def _render_chat_window(self):
-        """Render the chat conversation window"""
-        st.subheader("Chat About Your Business Data")
-        
-        # Display chat history
-        for message in st.session_state.chat_history:
-            with st.chat_message(message["role"]):
-                st.markdown(message["content"])
-        
-        # User input
-        if prompt := st.chat_input("Ask about your business data..."):
-            self._handle_user_input(prompt)
+    def _create_business_prompt(self, user_input: str) -> str:
+        """Create a detailed prompt for business-related queries"""
+        return f"""You are an expert business advisor AI. Provide detailed, actionable advice in response to the following query. 
+
+Rules:
+- Always maintain a professional tone
+- Break complex concepts into simple terms
+- Provide concrete examples when possible
+- Structure responses with clear sections when appropriate
+- Suggest next steps or additional considerations
+
+User query: {user_input}
+
+Please provide a comprehensive response that addresses the user's needs:"""
     
-    def _handle_user_input(self, prompt):
-        """Handle user input and generate response"""
-        # Add user message to chat history
-        st.session_state.chat_history.append({"role": "user", "content": prompt})
-        
-        # Display user message
-        with st.chat_message("user"):
-            st.markdown(prompt)
+    def _generate_fallback_response(self, prompt: str) -> str:
+        """Generate a fallback response when Gemini isn't available"""
+        business_topics = {
+            "strategy": "For business strategy, consider analyzing your market position, competitors, and unique value proposition.",
+            "marketing": "Marketing tips: Focus on your target audience, create valuable content, and measure campaign performance.",
+            "finance": "Financial planning should include budgeting, cash flow management, and scenario planning.",
+            "product": "Product development should start with customer needs validation before building."
+        }
         
-        # Generate and display assistant response
-        with st.chat_message("assistant"):
-            with st.spinner("Analyzing..."):
-                response = self._generate_response(prompt)
-                st.markdown(response)
-        
-        # Add assistant response to chat history
-        st.session_state.chat_history.append({"role": "assistant", "content": response})
-    
-    def _generate_response(self, prompt: str) -> str:
-        """Generate response using available backend"""
-        df = st.session_state.uploaded_df
+        prompt_lower = prompt.lower()
+        for topic, response in business_topics.items():
+            if topic in prompt_lower:
+                return response
         
-        if self.model:
-            # Use Gemini if available
-            try:
-                data_summary = (
-                    f"Dataset shape: {df.shape}\n"
-                    f"Columns: {', '.join(df.columns)}\n"
-                    f"First 3 rows:\n{df.head(3).to_markdown()}"
-                )
-                full_prompt = (
-                    "You're a business data analyst. The user has uploaded this data:\n"
-                    f"{data_summary}\n\n"
-                    f"User question: {prompt}\n\n"
-                    "Provide a detailed, professional response with actionable insights. "
-                    "If appropriate, include:\n"
-                    "- Key statistics\n"
-                    "- Business implications\n"
-                    "- Recommended visualizations\n"
-                    "- Potential next steps"
-                )
-                response = self.model.generate_content(full_prompt)
-                return response.text
-            except Exception as e:
-                return f"⚠️ Analysis error: {str(e)}"
-        else:
-            # Fallback basic analysis
-            if "summary" in prompt.lower():
-                return f"📊 Basic Statistics:\n{df.describe().to_markdown()}"
-            elif "columns" in prompt.lower():
-                return f"📋 Columns:\n{', '.join(df.columns)}"
-            elif "missing" in prompt.lower():
-                return f"🔍 Missing Values:\n{df.isnull().sum().to_markdown()}"
-            else:
-                return "💡 Ask me about: data summary, columns, or missing values"
+        return "I can provide advice on business strategy, marketing, finance, and product development. Please ask a specific question about one of these areas."