Update app.py

app.py

@@ -207,25 +207,29 @@ class TranslationService:
     
     def translate_text(self, text: str, src_lang: str, tgt_lang: str) -> str:
         """Translate text using Hugging Face API."""
-        response = requests.post(
-            self.url,
-            headers=self.headers,
-            json={
-                "inputs": text,
-                "parameters": {
-                    "src_lang": src_lang,
-                    "tgt_lang": tgt_lang
+        try:
+            response = requests.post(
+                self.url,
+                headers=self.headers,
+                json={
+                    "inputs": text,
+                    "parameters": {
+                        "src_lang": src_lang,
+                        "tgt_lang": tgt_lang
+                    }
                 }
-            }
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            if isinstance(result, list) and len(result) > 0:
-                return result[0]['translation_text']
-            return result['translation_text']
-        else:
-            print(f"Translation error: {response.status_code}, {response.text}")
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if isinstance(result, list) and len(result) > 0:
+                    return result[0]['translation_text']
+                return result['translation_text']
+            else:
+                print(f"Translation error: {response.status_code}, {response.text}")
+                return text  # Return original text if translation fails
+        except Exception as e:
+            print(f"Translation error: {e}")
             return text  # Return original text if translation fails
 
 
@@ -298,24 +302,28 @@ class UserSession:
             f"5. Keep the message concise and impactful."
         )
         
-        # Use the LLM to generate the message
-        welcome = "".join(self.llm.stream(prompt))
-        
-        # Get translation service and translate welcome message
-        api_token = os.environ.get('Token')
-        translator = TranslationService(api_token)
-        welcome_text = translator.translate_text(welcome, src_lang, tgt_lang)
-        
-        # Format the message with HTML styling
-        self.welcome_message = (
-            f"<div style='font-size: 20px;'>"
-            f"{welcome_text}"
-            f"</div>"
-        )
+        try:
+            # Use the LLM to generate the message
+            welcome = "".join(list(self.llm.stream(prompt)))
+            
+            # Get translation service and translate welcome message
+            api_token = os.environ.get('Token')
+            if not api_token:
+                self.welcome_message = f"Welcome {nickname}! This is a safe space where you can find support and resources."
+                return
+                
+            translator = TranslationService(api_token)
+            welcome_text = translator.translate_text(welcome, src_lang, tgt_lang)
+            
+            # Format the message with HTML styling
+            self.welcome_message = welcome_text
+        except Exception as e:
+            print(f"Error generating welcome message: {e}")
+            self.welcome_message = f"Welcome {nickname}! This is a safe space where you can find support and resources."
     
     def get_welcome_message(self) -> str:
         """Get the welcome message."""
-        return self.welcome_message
+        return self.welcome_message or "Welcome! This is a safe space where you can find support."
     
     def add_to_history(self, role: str, message: str) -> None:
         """Add a message to the conversation history."""
@@ -338,20 +346,35 @@ class GBVSupportChatbot:
     """Main chatbot application class."""
     
     def __init__(self):
-        self.api_key = os.environ.get('V2')
-        self.api_token = os.environ.get('Token')
+        self.api_key = os.environ.get('V2', '')
+        self.api_token = os.environ.get('Token', '')
+        
+        # Add fallback for missing environment variables
+        if not self.api_key:
+            print("Warning: V2 API key not found in environment variables.")
+            self.api_key = "demo_key"  # Use a placeholder value
+            
+        if not self.api_token:
+            print("Warning: Token not found in environment variables.")
+            self.api_token = "demo_token"  # Use a placeholder value
+            
         self.llm_instance = OpenRouterLLM(key=self.api_key)
         self.user_session = UserSession(self.llm_instance)
         self.translator = TranslationService(self.api_token)
         
         # Initialize embedding model
-        self.embed_model = HuggingFaceEmbeddings(model_name="mixedbread-ai/mxbai-embed-large-v1")
-        
-        # Initialize vector store
-        self.vectorstore = Chroma(
-            collection_name="Dataset",
-            embedding_function=self.embed_model,
-        )
+        try:
+            self.embed_model = HuggingFaceEmbeddings(model_name="mixedbread-ai/mxbai-embed-large-v1")
+            
+            # Initialize vector store
+            self.vectorstore = Chroma(
+                collection_name="Dataset",
+                embedding_function=self.embed_model,
+            )
+        except Exception as e:
+            print(f"Error initializing embeddings: {e}")
+            # Create a simple placeholder for vectorstore if initialization fails
+            self.vectorstore = None
         
         # Template for GBV support chatbot
         self.template = """
@@ -400,51 +423,82 @@ class GBVSupportChatbot:
     
     def load_data(self) -> None:
         """Load and process all data sources."""
-        # Process all data sources
-        data_processor = DataProcessor()
-        context_data = data_processor.process_tabular_data()
-        
-        # Process PDFs
-        pdf_documents = data_processor.process_pdf_files()
-        text_chunks = data_processor.split_documents(pdf_documents)
-        
-        # Combine all data
-        all_data = []
-        all_data.extend(context_data)
-        all_data.extend([item for item in text_chunks if item not in all_data])
-        
-        # Add data to vector store
-        self.vectorstore.add_texts(all_data)
+        if not self.vectorstore:
+            print("Warning: Vector store not initialized. Skipping data loading.")
+            return
+            
+        try:
+            # Process all data sources
+            data_processor = DataProcessor()
+            context_data = data_processor.process_tabular_data()
+            
+            # Process PDFs
+            pdf_documents = data_processor.process_pdf_files()
+            text_chunks = data_processor.split_documents(pdf_documents)
+            
+            # Combine all data
+            all_data = []
+            all_data.extend(context_data)
+            all_data.extend([item for item in text_chunks if item not in all_data])
+            
+            if all_data:
+                # Add data to vector store
+                self.vectorstore.add_texts(all_data)
+            else:
+                print("Warning: No data found to load into vector store.")
+        except Exception as e:
+            print(f"Error loading data: {e}")
     
     def create_rag_chain(self):
         """Create RAG chain with user context and conversation history."""
-        retriever = self.vectorstore.as_retriever()
-        rag_prompt = PromptTemplate.from_template(self.template)
-        
-        def stream_func(input_dict):
-            # Get context using the retriever's invoke method
-            context = retriever.invoke(input_dict["question"])
-            context_str = "\n".join([doc.page_content for doc in context])
-            
-            # Get user info from the session
-            user_info = self.user_session.get_user() or {}
-            first_name = user_info.get("Nickname", "User")
+        try:
+            if self.vectorstore:
+                retriever = self.vectorstore.as_retriever()
+            else:
+                # Create a simple fallback if vectorstore is not available
+                retriever = FallbackRetriever()
+                
+            rag_prompt = PromptTemplate.from_template(self.template)
             
-            # Get conversation history
-            conversation_history = self.user_session.get_formatted_history()
+            def stream_func(input_dict):
+                try:
+                    # Get context using the retriever's invoke method
+                    if self.vectorstore:
+                        context = retriever.invoke(input_dict["question"])
+                        context_str = "\n".join([doc.page_content for doc in context])
+                    else:
+                        context_str = "No specific information available on this topic."
+                    
+                    # Get user info from the session
+                    user_info = self.user_session.get_user() or {}
+                    first_name = user_info.get("Nickname", "User")
+                    
+                    # Get conversation history
+                    conversation_history = self.user_session.get_formatted_history()
+                    
+                    # Format prompt with user context and conversation history
+                    prompt = rag_prompt.format(
+                        context=context_str,
+                        question=input_dict["question"],
+                        first_name=first_name,
+                        conversation_history=conversation_history
+                    )
+                    
+                    # Stream response
+                    return self.llm_instance.stream(prompt)
+                except Exception as e:
+                    print(f"Error in RAG chain: {e}")
+                    yield f"I apologize, but I'm having trouble processing your request. Please try again or rephrase your question."
             
-            # Format prompt with user context and conversation history
-            prompt = rag_prompt.format(
-                context=context_str,
-                question=input_dict["question"],
-                first_name=first_name,
-                conversation_history=conversation_history
-            )
+            return stream_func
+        except Exception as e:
+            print(f"Error creating RAG chain: {e}")
             
-            # Stream response
-            return self.llm_instance.stream(prompt)
-        
-        return stream_func
+            # Return a simple fallback function
+            def fallback_func(input_dict):
+                yield "I apologize, but I'm having technical difficulties. Please try again later."
+                
+            return fallback_func
     
     def collect_user_info(self, nickname: str):
         """Collect and process user information."""
@@ -463,34 +517,63 @@ class GBVSupportChatbot:
         # Generate welcome message
         welcome_message = self.user_session.get_welcome_message()
         
-        # For the standard Chatbot component, the history format is different
-        chat_history = [(None, welcome_message)]
+        # Create welcome message in the new messages format for Gradio chatbot
+        chat_history = [{"role": "assistant", "content": welcome_message}]
         
         # Return welcome message and update UI
         return welcome_message, gr.update(visible=True), gr.update(visible=False), chat_history
     
     def rag_memory_stream(self, message: str, history):
         """Process user message, translate, and generate response."""
-        # Translate user message to English (from Kinyarwanda by default)
-        english_message = self.translator.translate_text(message, "kin_Latn", "eng_Latn")
-        
-        # Add translated message to history
-        self.user_session.add_to_history("user", english_message)
-        
-        # Generate response using RAG chain
-        full_response = ""
-        rag_chain = self.create_rag_chain()
-        
-        for new_text in rag_chain({"question": english_message}):
-            full_response += new_text
-        
-        # Translate response back to user language (Kinyarwanda by default)
-        translated_response = self.translator.translate_text(full_response, "eng_Latn", "kin_Latn")
-        
-        # Add response to history
-        self.user_session.add_to_history("assistant", full_response)
-        
-        yield translated_response
+        try:
+            # First, yield the current history to show user message
+            history_copy = history.copy()
+            history_copy.append({"role": "user", "content": message})
+            yield history_copy, ""
+            
+            # Translate user message to English (from Kinyarwanda by default)
+            try:
+                english_message = self.translator.translate_text(message, "kin_Latn", "eng_Latn")
+            except Exception as e:
+                print(f"Translation error: {e}")
+                english_message = message  # Fallback to original message if translation fails
+            
+            # Add translated message to history
+            self.user_session.add_to_history("user", english_message)
+            
+            # Generate response using RAG chain
+            full_response = ""
+            rag_chain = self.create_rag_chain()
+            
+            # Generate chunks of response and update as they come
+            for new_text in rag_chain({"question": english_message}):
+                full_response += new_text
+                
+                # Translate response back to user language (Kinyarwanda by default)
+                try:
+                    translated_response = self.translator.translate_text(full_response, "eng_Latn", "kin_Latn")
+                except Exception as e:
+                    print(f"Translation error: {e}")
+                    translated_response = full_response  # Fallback to original message if translation fails
+                
+                # Update history with current response
+                current_history = history_copy.copy()
+                current_history.append({"role": "assistant", "content": translated_response})
+                yield current_history, ""
+            
+            # Add final response to session history
+            self.user_session.add_to_history("assistant", full_response)
+            
+        except Exception as e:
+            print(f"Error in chat processing: {e}")
+            # Provide a fallback response if something goes wrong
+            error_history = history.copy()
+            error_history.append({"role": "user", "content": message})
+            error_history.append({
+                "role": "assistant", 
+                "content": "I apologize, but I'm having trouble processing your request. Please try again."
+            })
+            yield error_history, ""
     
     def create_chatbot_interface(self):
         """Create and configure the chatbot UI."""
@@ -514,12 +597,13 @@ class GBVSupportChatbot:
             
             # Chatbot section (initially hidden)
             with gr.Column(visible=False, elem_id="chatbot_container") as chatbot_container:
-                # Replace ChatInterface with standard Chatbot
+                # Use the new messages format for the chatbot
                 chatbot = gr.Chatbot(
                     label="Chat with GBVR",
                     height=500,
                     show_label=True,
-                    elem_id="chat_interface"
+                    elem_id="chat_interface",
+                    type="messages"  # Use messages format instead of tuples
                 )
                 
                 with gr.Row():
@@ -532,27 +616,22 @@ class GBVSupportChatbot:
                     )
                     send_btn = gr.Button("Send", variant="primary", scale=1)
                 
-                # Set up the chat behavior
-                def chat_response(message, history):
-                    # Clear input
-                    yield history, ""
-                    # Process message and generate response
-                    for response in self.rag_memory_stream(message, history):
-                        history.append((message, response))
-                        yield history, ""
-                
                 # Configure event handlers
-                msg.submit(
-                    chat_response,
+                msg_event = msg.submit(
+                    self.rag_memory_stream,
                     inputs=[msg, chatbot],
                     outputs=[chatbot, msg]
                 )
-                send_btn.click(
-                    chat_response,
+                send_event = send_btn.click(
+                    self.rag_memory_stream,
                     inputs=[msg, chatbot],
                     outputs=[chatbot, msg]
                 )
                 
+                # Clear textbox after sending
+                msg_event.then(lambda: "", None, msg)
+                send_event.then(lambda: "", None, msg)
+                
                 # Footer with version info
                 gr.Markdown("Ijwi ry'Ubufasha Chatbot v1.0.0 © 2025")
             
@@ -573,7 +652,7 @@ class GBVSupportChatbot:
         body, .gradio-container {
             margin: 0;
             padding: 0;
-            width: 100vw;
+            width: 100%;
             height: 100vh;
             display: flex;
             flex-direction: column;
@@ -631,17 +710,29 @@ class GBVSupportChatbot:
         
         return demo
 
+
+# Fallback retriever class for when vectorstore is not available
+class FallbackRetriever:
+    def invoke(self, query):
+        # Return a list of document-like objects with empty content
+        return [Document(page_content="No specific information available on this topic.", metadata={})]
+
+
 # Main execution function
 def main():
     # Initialize the chatbot
     chatbot = GBVSupportChatbot()
     
-    # Load data
-    chatbot.load_data()
-    
-    # Create and launch the interface
-    demo = chatbot.create_chatbot_interface()
-    demo.launch(share=True)
+    try:
+        # Load data
+        chatbot.load_data()
+        
+        # Create and launch the interface
+        demo = chatbot.create_chatbot_interface()
+        demo.launch(share=True)
+    except Exception as e:
+        print(f"Error in main execution: {e}")
+        
 
 if __name__ == "__main__":
     main()