Update chatbot.py

chatbot.py

@@ -1,123 +1,86 @@
 # chatbot.py
 import streamlit as st
-import pandas as pd
-import os
-import tempfile
-import google.generativeai as genai
-from typing import List, Dict, Optional
+from transformers import pipeline, BlenderbotTokenizer, BlenderbotForConditionalGeneration
+import torch
+from typing import List, Dict
 
 class ChatbotManager:
     def __init__(self):
-        # Configure Gemini
-        self.configure_gemini()
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = None
+        self.tokenizer = None
+        self.load_model()
         self.initialize_chat()
     
-    def configure_gemini(self):
-        """Configure the Gemini API"""
+    def load_model(self):
+        """Load Blenderbot model locally"""
         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)
-                # Updated model name to 'gemini-1.0-pro'
-                self.model = genai.GenerativeModel('gemini-1.0-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.")
+            with st.spinner("Loading AI model (this may take a minute)..."):
+                model_name = "facebook/blenderbot-400M-distill"
+                self.tokenizer = BlenderbotTokenizer.from_pretrained(model_name)
+                self.model = BlenderbotForConditionalGeneration.from_pretrained(model_name).to(self.device)
+            st.success("Model loaded successfully!")
         except Exception as e:
-            st.error(f"Error configuring Gemini: {str(e)}")
+            st.error(f"⚠️ Failed to load model: {str(e)}")
             self.model = None
-            self.chat = None
     
     def initialize_chat(self):
-        """Initialize chat session state variables"""
-        if 'chat_history' not in st.session_state:
+        """Initialize chat session state"""
+        if "chat_history" not in st.session_state:
             st.session_state.chat_history = []
-        
-        # 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"""
+        """Reset 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
-        })
+        """Add a message to chat history"""
+        st.session_state.chat_history.append({"role": role, "content": content})
     
     def get_chat_history(self) -> List[Dict]:
-        """Get the chat history"""
+        """Retrieve chat history"""
         return st.session_state.chat_history
     
-    def generate_business_response(self, prompt: str) -> str:
-        """Generate a response to a business-related prompt"""
+    def generate_response(self, prompt: str) -> str:
+        """Generate AI response using Blenderbot"""
+        if not self.model:
+            return "Model not loaded. Please try again later."
+        
         try:
-            if self.chat:
-                # Use Gemini chat for contextual responses
-                response = self.chat.send_message(
-                    self._create_business_prompt(prompt),
-                    stream=True
-                )
-                return "".join([chunk.text for chunk in response])
-            else:
-                # Fallback response if Gemini isn't available
-                return self._generate_fallback_response(prompt)
-        except genai.types.generation_types.BlockedPromptException:
-            return "⚠️ My response was blocked for safety reasons. Please try rephrasing your question."
+            # Format prompt with business context
+            business_prompt = f"""You are a professional business advisor. Provide helpful, concise advice on:
+            - Business strategy
+            - Marketing
+            - Product development
+            - Startup growth
+            
+            User Question: {prompt}
+            
+            Answer:"""
+            
+            inputs = self.tokenizer([business_prompt], return_tensors="pt").to(self.device)
+            reply_ids = self.model.generate(**inputs, max_length=200)
+            response = self.tokenizer.decode(reply_ids[0], skip_special_tokens=True)
+            
+            return response
         except Exception as e:
             return f"⚠️ Error generating response: {str(e)}"
     
-    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
-- Never provide financial, legal, or medical advice
-
-User query: {user_input}
-
-Please provide a comprehensive response that addresses the user's needs:"""
-    
-    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": "For financial questions, consult with a qualified financial advisor.",
-            "product": "Product development should start with customer needs validation before building."
-        }
-        
-        prompt_lower = prompt.lower()
-        for topic, response in business_topics.items():
-            if topic in prompt_lower:
-                return response
-        
-        return "I can provide advice on business strategy, marketing, and product development. Please ask a specific question about one of these areas."
-
     def render_chat_interface(self):
-        """Render the complete chat interface"""
-        st.header("💬 AI Business Mentor")
+        """Render the complete chat UI"""
+        st.header("💬 AI Business Mentor (Blenderbot)")
+        
+        # Sidebar controls
+        with st.sidebar:
+            st.subheader("Settings")
+            if st.button("Clear Chat"):
+                self.clear_chat()
+                st.rerun()
+            
+            st.markdown("---")
+            st.caption("Model: facebook/blenderbot-400M-distill")
+            st.caption(f"Device: {self.device.upper()}")
         
         # Display chat history
         for message in self.get_chat_history():
@@ -125,21 +88,21 @@ Please provide a comprehensive response that addresses the user's needs:"""
                 st.markdown(message["content"])
         
         # User input
-        if prompt := st.chat_input("Ask about business strategy, marketing, or products..."):
+        if prompt := st.chat_input("Ask about business..."):
             self.add_message("user", prompt)
             
             # Display user message immediately
             with st.chat_message("user"):
                 st.markdown(prompt)
             
-            # Generate and display assistant response
+            # Generate and display AI response
             with st.chat_message("assistant"):
-                with st.spinner("Analyzing..."):
-                    response = self.generate_business_response(prompt)
+                with st.spinner("Thinking..."):
+                    response = self.generate_response(prompt)
                     st.markdown(response)
             
-            # Add assistant response to history
+            # Add response to history
             self.add_message("assistant", response)
             
-            # Auto-rerun to update the display
+            # Auto-refresh to show new messages
             st.rerun()