Upload app.py with huggingface_hub

app.py

@@ -52,6 +52,12 @@ from mem0 import MemoryClient
 import streamlit as st
 from datetime import datetime
 
+import traceback
+import time
+import random
+from datetime import datetime
+from typing import Dict, List
+
 #====================================SETUP=====================================#
 # Fetch secrets from Hugging Face Spaces
 api_key = os.environ['api_key']
@@ -563,44 +569,89 @@ def filter_input_with_llama_guard(user_input, model="llama-guard-3-8b"):
 
 #============================= Adding Memory to the agent using mem0 ===============================#
 
-# NutritionBot class
 class NutritionBot:
-    def __init__(self):
+    def __init__(self, api_key: str, api_base: str):
         """
-        Initialize the NutritionBot class, setting up memory, the LLM client, tools, and the agent executor.
+        Initialize the NutritionBot class, setting up memory and the LLM client.
+
+        Args:
+            api_key (str): The OpenAI API key for authenticating requests.
+            api_base (str): The custom OpenAI API base endpoint.
         """
+        print(f"Initializing NutritionBot with OpenAI API key: {api_key}")
+        print(f"Using custom OpenAI API base: {api_base}")
 
         # Initialize a memory client to store and retrieve customer interactions
-        self.memory = MemoryClient(api_key="mock_memory_api_key")  # Replace with actual API key
+        self.memory = MemoryClient(api_key=userdata.get("mem0_api_key"))
+        print("Memory client initialized.")
 
-        # Initialize the OpenAI client using the provided credentials
+        # Initialize the OpenAI client using the provided credentials, custom API base, and model
         self.client = ChatOpenAI(
-            model_name="gpt-4",  # Specify the model to use (e.g., GPT-4)
-            api_key="mock_openai_api_key"  # Replace with actual API key
+            model_name="gpt-4o-mini",  # Correct model name
+            api_key=api_key,
+            openai_api_base=api_base,
+            temperature=0.7,  # Controls randomness in responses
+            verbose=True  # Enable verbose logging for debugging
         )
+        print("OpenAI client initialized with custom API base and model gpt-4o-mini.")
 
-        # Define tools available to the chatbot, including agentic_rag
-        tools = [agentic_rag]
+    def get_relevant_history(self, user_id: str, query: str) -> List[Dict]:
+        """
+        Retrieve past interactions relevant to the current query.
 
-        # Define the system prompt to set the behavior of the chatbot
-        system_prompt = """You are a caring and knowledgeable Medical Support Agent, specializing in nutrition disorder-related guidance. Your goal is to provide accurate, empathetic, and tailored nutritional recommendations while ensuring a seamless customer experience."""
+        Args:
+            user_id (str): Unique identifier for the customer.
+            query (str): The customer's current query.
 
-        # Build the prompt template for the agent
-        prompt = ChatPromptTemplate.from_messages([
-            ("system", system_prompt),  # System instructions
-            ("human", "{input}"),  # Placeholder for human input
-            ("placeholder", "{agent_scratchpad}")  # Placeholder for intermediate reasoning steps
-        ])
+        Returns:
+            List[Dict]: A list of relevant past interactions.
+        """
+        print("Entering get_relevant_history function...")
+        try:
+            history = self.memory.search(
+                query=query,
+                user_id=user_id,
+                limit=3
+            )
+            print("Relevant history retrieved:", history)
+            return history
+        except Exception as e:
+            print(f"Error retrieving history: {e}")
+            traceback.print_exc()
+            return []
+
+    def query_model(self, prompt: str) -> str:
+        """
+        Query the OpenAI model directly using the prompt.
 
-        # Create an agent capable of interacting with tools and executing tasks
-        agent = create_tool_calling_agent(self.client, tools, prompt)
+        Args:
+            prompt (str): The input prompt for the model.
 
-        # Wrap the agent in an executor to manage tool interactions and execution flow
-        self.agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+        Returns:
+            str: The assistant's response.
+        """
+        print("Querying the OpenAI model...")
+        try:
+            # Use the correct input format for ChatOpenAI
+            messages = [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt}
+            ]
+            response = self.client.invoke(messages)  # Use the `invoke()` method
+            print("Raw response from OpenAI API:", response)
+
+            # Since the response is an AIMessage object, extract the content directly
+            content = response.content  # Access the `content` property of the AIMessage
+            print("Extracted response content:", content)
+            return content
+        except Exception as e:
+            print(f"Error querying the model: {e}")
+            traceback.print_exc()
+            return "I'm sorry, I couldn't process your request. Please try again later."
 
     def handle_customer_query(self, user_id: str, query: str) -> str:
         """
-        Process a customer's query and provide a response, taking into account past interactions.
+        Process a customer's query and provide a response, incorporating past interactions for context.
 
         Args:
             user_id (str): Unique identifier for the customer.
@@ -609,15 +660,92 @@ class NutritionBot:
         Returns:
             str: Chatbot's response.
         """
-        # Use the agentic_rag tool to process the query
+        print("Entering handle_customer_query function...")
+
+        # Retrieve relevant history for the user
+        relevant_history = self.get_relevant_history(user_id, query)
+
+        # Build context from past interactions
+        context = "Previous relevant interactions:\n"
+        for memory in relevant_history:
+            context += f"Customer: {memory['query']}\n"
+            context += f"Support: {memory['response']}\n---\n"
+
+        # Create the prompt
+        prompt = f"""
+        Context:
+        {context}
+
+        Current customer query: {query}
+
+        Provide a helpful response that takes into account any relevant past interactions.
+        """
+        print("Final prompt being sent to the model:")
+        print(prompt)
+
+        # Retry logic with exponential backoff
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                print(f"Querying model (attempt {attempt + 1})...")
+                response_content = self.query_model(prompt)
+                if not response_content:
+                    raise ValueError("Model returned an empty response.")
+
+                # Store the interaction
+                self.store_customer_interaction(
+                    user_id=user_id,
+                    message=query,
+                    response=response_content,
+                    metadata={"type": "support_query"}
+                )
+                return response_content
+
+            except Exception as e:
+                print(f"Error querying the model (attempt {attempt + 1}): {e}")
+                traceback.print_exc()
+                if attempt < max_retries - 1:
+                    wait_time = (2 ** attempt) + random.uniform(0, 1)  # Exponential backoff with jitter
+                    print(f"Retrying in {wait_time:.2f} seconds...")
+                    time.sleep(wait_time)
+                else:
+                    return "I'm sorry, I couldn't process your request. Please try again later."
+
+    def store_customer_interaction(self, user_id: str, message: str, response: str, metadata: Dict = None):
+        """
+        Store customer interaction in memory for future reference.
+
+        Args:
+            user_id (str): Unique identifier for the customer.
+            message (str): Customer's query or message.
+            response (str): Chatbot's response.
+            metadata (Dict, optional): Additional metadata for the interaction.
+        """
+        print("Entering store_customer_interaction function...")
+
+        if metadata is None:
+            metadata = {}
+
+        # Add timestamp to metadata
+        metadata["timestamp"] = datetime.now().isoformat()
+
+        # Format the interaction for storage
+        conversation = [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": response}
+        ]
+
         try:
-            # Call the agentic_rag tool directly
-            result = agentic_rag(query)
-            response = result.get("response", "I'm sorry, I couldn't generate a response.")
-            return response
+            self.memory.add(
+                conversation,
+                user_id=user_id,
+                output_format="v1.1",
+                metadata=metadata
+            )
+            print("Interaction stored successfully.")
         except Exception as e:
-            return f"An error occurred while processing your query: {str(e)}"
-
+            print(f"Error storing interaction: {e}")
+            traceback.print_exc()
 
 #=====================User Interface using streamlit ===========================#
 def nutrition_disorder_streamlit():