Upload app.py with huggingface_hub

app.py

@@ -14,8 +14,6 @@ from langchain.chains.query_constructor.base import AttributeInfo  # Base classe
 from langchain.retrievers.self_query.base import SelfQueryRetriever  # Base classes for self-querying retrievers
 from langchain.retrievers.document_compressors import LLMChainExtractor, CrossEncoderReranker  # Document compressors
 from langchain.retrievers import ContextualCompressionRetriever  # Contextual compression retrievers
-from langchain_openai import OpenAIEmbeddings, ChatOpenAI
-from langchain_openai import ChatOpenAI
 
 # LangChain community & experimental imports
 from langchain_community.vectorstores import Chroma  # Implementations of vector stores like Chroma
@@ -33,6 +31,8 @@ from langchain_core.prompts import ChatPromptTemplate
 # LangChain OpenAI imports
 from langchain_openai import AzureOpenAIEmbeddings, AzureChatOpenAI  # OpenAI embeddings and models
 from langchain.embeddings.openai import OpenAIEmbeddings  # OpenAI embeddings for text vectors
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_openai import ChatOpenAI
 
 # LlamaParse & LlamaIndex imports
 from llama_parse import LlamaParse  # Document parsing library
@@ -63,6 +63,17 @@ endpoint = os.environ['OPENAI_API_BASE']
 llama_api_key = os.environ['GROQ_API_KEY']
 MEM0_api_key = os.environ['MEM0_API_KEY']
 
+# Storing API credentials in environment variables
+os.environ['OPENAI_API_KEY'] = API_KEY
+os.environ["OPENAI_BASE_URL"] = OPENAI_API_BASE
+
+model_name = "gpt-4o-mini"
+
+client = OpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY"),
+    base_url=os.environ.get("OPENAI_API_BASE")
+)
+
 # Initialize the OpenAI embedding function for Chroma
 embedding_function = chromadb.utils.embedding_functions.OpenAIEmbeddingFunction(
     api_base=endpoint, # Complete the code to define the API base endpoint
@@ -80,6 +91,7 @@ embedding_model = OpenAIEmbeddings(
 )
 
 
+
 # Initialize the Chat OpenAI model
 llm = ChatOpenAI(
     openai_api_base=endpoint,
@@ -87,6 +99,7 @@ llm = ChatOpenAI(
     model="gpt-4o-mini",
     streaming=False
 )
+
 # This initializes the Chat OpenAI model with the provided endpoint, API key, deployment name, and a temperature setting of 0 (to control response variability).
 
 # set the LLM and embedding model in the LlamaIndex settings.
@@ -143,7 +156,7 @@ def expand_query(state):
 # Initialize the Chroma vector store for retrieving documents
 vector_store = Chroma(
     collection_name="nutritional_hypotheticals",
-    persist_directory="./nutritional_db",
+    persist_directory="/nutritional_db",
     embedding_function=embedding_model
 
 )
@@ -436,8 +449,6 @@ def max_iterations_reached(state: Dict) -> Dict:
     state['response'] = response
     return state
 
-
-
 from langgraph.graph import END, StateGraph, START
 
 def create_workflow() -> StateGraph:
@@ -556,250 +567,323 @@ def filter_input_with_llama_guard(user_input, model="llama-guard-3-8b"):
 #============================= Adding Memory to the agent using mem0 ===============================#
 
 class NutritionBot:
-    def __init__(self):
+  def __init__(self):
         """
-        Initialize the NutritionBot class, setting up memory, the LLM client, tools, and the agent executor.
+        Initialize the NutritionBot class with OpenAI client and conversation memory.
         """
+        self.client = client
+        self.conversation_history = {}
 
-        # Initialize a memory client to store and retrieve customer interactions
-        # self.memory = MemoryClient(api_key=userdata.get("MEM0_API_KEY"))  # Complete the code to define the memory client API key
-
-        self.memory = MemoryClient(api_key=MEM0_api_key)  # Complete the code to define the memory client API key
-
-        # endpoint = os.environ['OPENAI_API_BASE']
-        # print("endpoint: ", endpoint)
-
-        # Initialize the OpenAI client using the provided credentials
-        self.client = ChatOpenAI(
-            model_name="gpt-4o-mini",  # Specify the model to use (e.g., GPT-4 optimized version)
-            api_key=api_key,  # API key for authentication
-            endpoint=endpoint,
-            temperature=0  # Controls randomness in responses; 0 ensures deterministic results
-        )
-
-        # Define tools available to the chatbot, such as web search
-        tools = [agentic_rag]
-
-        # 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.
-                          Guidelines for Interaction:
-                          Maintain a polite, professional, and reassuring tone.
-                          Show genuine empathy for customer concerns and health challenges.
-                          Reference past interactions to provide personalized and consistent advice.
-                          Engage with the customer by asking about their food preferences, dietary restrictions, and lifestyle before offering recommendations.
-                          Ensure consistent and accurate information across conversations.
-                          If any detail is unclear or missing, proactively ask for clarification.
-                          Always use the agentic_rag tool to retrieve up-to-date and evidence-based nutrition insights.
-                          Keep track of ongoing issues and follow-ups to ensure continuity in support.
-                          Your primary goal is to help customers make informed nutrition decisions that align with their health conditions and personal preferences.
-
+  def store_customer_interaction(self, user_id: str, message: str, response: str):
         """
+        Store customer interaction in a dictionary for future reference.
+        """
+        if user_id not in self.conversation_history:
+            self.conversation_history[user_id] = []
 
-        # 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
-        ])
-
-        # Create an agent capable of interacting with tools and executing tasks
-        agent = create_tool_calling_agent(self.client, tools, prompt)
-
-        # Wrap the agent in an executor to manage tool interactions and execution flow
-        self.agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
-
+        self.conversation_history[user_id].append({
+            "timestamp": datetime.now().isoformat(),
+            "user": message,
+            "assistant": response
+        })
 
-    def store_customer_interaction(self, user_id: str, message: str, response: str, metadata: Dict = None):
+  def get_relevant_history(self, user_id: str) -> str:
         """
-        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.
+        Retrieve past interactions relevant to the user.
         """
-        if metadata is None:
-            metadata = {}
-
-        # Add a timestamp to the metadata for tracking purposes
-        metadata["timestamp"] = datetime.now().isoformat()
-
-        # Format the conversation for storage
-        conversation = [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": response}
-        ]
-
-        # Store the interaction in the memory client
-        self.memory.add(
-            conversation,
-            user_id=user_id,
-            output_format="v1.1",
-            metadata=metadata
+        history = self.conversation_history.get(user_id, [])
+        return "\n".join(
+            [f"User: {entry['user']}\nAssistant: {entry['assistant']}" for entry in history[-5:]]
         )
 
-
-    def get_relevant_history(self, user_id: str, query: str) -> List[Dict]:
+  def handle_customer_query(self, user_id: str, query: str) -> str:
         """
-        Retrieve past interactions relevant to the current query.
-
-        Args:
-            user_id (str): Unique identifier for the customer.
-            query (str): The customer's current query.
-
-        Returns:
-            List[Dict]: A list of relevant past interactions.
+        Process a customer's query and provide a response using OpenAI's API.
         """
-        return self.memory.search(
-            query=query,  # Search for interactions related to the query
-            user_id=user_id,  # Restrict search to the specific user
-            limit=3  # Complete the code to define the limit for retrieved interactions
+        history_context = self.get_relevant_history(user_id)
+        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.\n\n"
+            "Always use available knowledge to guide customers about symptoms, causes, and treatments for nutrition disorders. "
+            "Ask clarifying questions where needed, and maintain a supportive tone."
         )
 
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Past interactions:\n{history_context}\n\nCustomer: {query}"}
+        ]
 
-    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.
-
-        Args:
-            user_id (str): Unique identifier for the customer.
-            query (str): Customer's query.
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages
+        )
 
-        Returns:
-            str: Chatbot's response.
-        """
-        print("handle_customer_query start, query: ", query)
+        reply = response.choices[0].message.content.strip()
+        self.store_customer_interaction(user_id, query, reply)
+        return reply
 
-        # Retrieve relevant past interactions for context
-        relevant_history = self.get_relevant_history(user_id, query)
+def nutrition_disorder_agent():
+    """
+    A conversational agent for answering nutrition disorder-related questions.
+    """
+    print("Welcome to the Nutrition Disorder Specialist Agent!")
+    print("You can ask me anything about nutrition disorders, such as symptoms, causes, treatments, and more.")
+    print("Type 'exit' to end the conversation.\n")
 
-        # Build a context string from the relevant history
-        context = "Previous relevant interactions:\n"
-        for memory in relevant_history:
-            context += f"Customer: {memory['memory']}\n"  # Customer's past messages
-            context += f"Support: {memory['memory']}\n"  # Chatbot's past responses
-            context += "---\n"
+    chatbot = NutritionBot()
+    print("Login by providing customer name:")
+    user_id = input().strip()
 
-        # Print context for debugging purposes
-        print("Context: ", context)
+    while True:
+        print("How can I help you?")
+        user_query = input("You: ").strip()
 
-        # Prepare a prompt combining past context and the current query
-        prompt = f"""
-        Context:
-        {context}
+        if user_query.lower() == "exit":
+            print("Agent: Goodbye! Feel free to return if you have more questions.")
+            break
 
-        Current customer query: {query}
+        # Input moderation (optional, if llama guard logic exists)
+        filtered_result = filter_input_with_llama_guard(user_query).replace("\n", " ")
+        print(filtered_result)
 
-        Provide a helpful response that takes into account any relevant past interactions.
-        """
+        if filtered_result in ["safe", "unsafe S7", "unsafe S6"]:
+            try:
+                response = chatbot.handle_customer_query(user_id, user_query)
+                print(f"Agent: {response}\n")
+            except Exception as e:
+                print("Agent: Sorry, I encountered an error while processing your query. Please try again.")
+                print(f"Error: {e}\n")
+        else:
+            print("Agent: I apologize, but I cannot process that input as it may be inappropriate. Please try again.")
+
+
+nutrition_disorder_agent()
+
+    # def __init__(self):
+    #     """
+    #     Initialize the NutritionBot class, setting up memory, the LLM client, tools, and the agent executor.
+    #     """
+
+    #     # Initialize a memory client to store and retrieve customer interactions
+    #     # self.memory = MemoryClient(api_key=userdata.get("MEM0_API_KEY"))  # Complete the code to define the memory client API key
+
+    #     self.memory = MemoryClient(api_key=MEM0_api_key)  # Complete the code to define the memory client API key
+
+    #     # Initialize the OpenAI client using the provided credentials
+    #     self.client = ChatOpenAI(
+    #         model_name="gpt-4o-mini",  # Specify the model to use (e.g., GPT-4 optimized version)
+    #         api_key=api_key,  # API key for authentication
+    #         endpoint = endpoint,
+    #         temperature=0  # Controls randomness in responses; 0 ensures deterministic results
+    #     )
+
+    #     # Define tools available to the chatbot, such as web search
+    #     tools = [agentic_rag]
+
+    #     # 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.
+    #                       Guidelines for Interaction:
+    #                       Maintain a polite, professional, and reassuring tone.
+    #                       Show genuine empathy for customer concerns and health challenges.
+    #                       Reference past interactions to provide personalized and consistent advice.
+    #                       Engage with the customer by asking about their food preferences, dietary restrictions, and lifestyle before offering recommendations.
+    #                       Ensure consistent and accurate information across conversations.
+    #                       If any detail is unclear or missing, proactively ask for clarification.
+    #                       Always use the agentic_rag tool to retrieve up-to-date and evidence-based nutrition insights.
+    #                       Keep track of ongoing issues and follow-ups to ensure continuity in support.
+    #                       Your primary goal is to help customers make informed nutrition decisions that align with their health conditions and personal preferences.
+
+    #     """
+
+    #     # 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
+    #     ])
+
+    #     # Create an agent capable of interacting with tools and executing tasks
+    #     agent = create_tool_calling_agent(self.client, tools, prompt)
+
+    #     # Wrap the agent in an executor to manage tool interactions and execution flow
+    #     self.agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+
+    # 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.
+    #     """
+    #     if metadata is None:
+    #         metadata = {}
+
+    #     # Add a timestamp to the metadata for tracking purposes
+    #     metadata["timestamp"] = datetime.now().isoformat()
+
+    #     # Format the conversation for storage
+    #     conversation = [
+    #         {"role": "user", "content": message},
+    #         {"role": "assistant", "content": response}
+    #     ]
+
+    #     # Store the interaction in the memory client
+    #     self.memory.add(
+    #         conversation,
+    #         user_id=user_id,
+    #         output_format="v1.1",
+    #         metadata=metadata
+    #     )
+
+
+    # def get_relevant_history(self, user_id: str, query: str) -> List[Dict]:
+    #     """
+    #     Retrieve past interactions relevant to the current query.
+
+    #     Args:
+    #         user_id (str): Unique identifier for the customer.
+    #         query (str): The customer's current query.
+
+    #     Returns:
+    #         List[Dict]: A list of relevant past interactions.
+    #     """
+    #     return self.memory.search(
+    #         query=query,  # Search for interactions related to the query
+    #         user_id=user_id,  # Restrict search to the specific user
+    #         limit=3  # Complete the code to define the limit for retrieved interactions
+    #     )
+
+
+    # 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.
+
+    #     Args:
+    #         user_id (str): Unique identifier for the customer.
+    #         query (str): Customer's query.
+
+    #     Returns:
+    #         str: Chatbot's response.
+    #     """
+
+    #     # Retrieve relevant past interactions for context
+    #     relevant_history = self.get_relevant_history(user_id, query)
+
+    #     # Build a context string from the relevant history
+    #     context = "Previous relevant interactions:\n"
+    #     for memory in relevant_history:
+    #         context += f"Customer: {memory['memory']}\n"  # Customer's past messages
+    #         context += f"Support: {memory['memory']}\n"  # Chatbot's past responses
+    #         context += "---\n"
+
+    #     # Print context for debugging purposes
+    #     print("Context: ", context)
+
+    #     # Prepare a prompt combining past context and the current query
+    #     prompt = f"""
+    #     Context:
+    #     {context}
+
+    #     Current customer query: {query}
 
-        # Generate a response using the agent
-        response = self.agent_executor.invoke({"input": prompt})
+    #     Provide a helpful response that takes into account any relevant past interactions.
+    #     """
 
-        # Store the current interaction for future reference
-        self.store_customer_interaction(
-            user_id=user_id,
-            message=query,
-            response=response["output"],
-            metadata={"type": "support_query"}
-        )
-        print("handle_customer_query end")
+    #     # Generate a response using the agent
+    #     response = self.agent_executor.invoke({"input": prompt})
+
+    #     # Store the current interaction for future reference
+    #     self.store_customer_interaction(
+    #         user_id=user_id,
+    #         message=query,
+    #         response=response["output"],
+    #         metadata={"type": "support_query"}
+    #     )
 
-        # Return the chatbot's response
-        return response['output']
+    #     # Return the chatbot's response
+    #     return response['output']
 
 
 #=====================User Interface using streamlit ===========================#
-def nutrition_disorder_streamlit():
-    """
-    A Streamlit-based UI for the Nutrition Disorder Specialist Agent.
-    """
-    st.title("Nutrition Disorder Specialist")
-    st.write("Ask me anything about nutrition disorders, symptoms, causes, treatments, and more.")
-    st.write("Type 'exit' to end the conversation.")
-
-    # Initialize session state for chat history and user_id if they don't exist
-    if 'chat_history' not in st.session_state:
-        st.session_state.chat_history = []
-    if 'user_id' not in st.session_state:
-        st.session_state.user_id = None
-
-    # Login form: Only if user is not logged in
-    if st.session_state.user_id is None:
-        with st.form("login_form", clear_on_submit=True):
-            user_id = st.text_input("Please enter your name to begin:")
-            submit_button = st.form_submit_button("Login")
-            if submit_button and user_id:
-                st.session_state.user_id = user_id
-                st.session_state.chat_history.append({
-                    "role": "assistant",
-                    "content": f"Welcome, {user_id}! How can I help you with nutrition disorders today?"
-                })
-                st.session_state.login_submitted = True  # Set flag to trigger rerun
-        if st.session_state.get("login_submitted", False):
-            st.session_state.pop("login_submitted")
-            st.rerun()
-    else:
-        # Display chat history
-        print("Chat history: ", st.session_state.chat_history)
-        print("User ID: ", st.session_state.user_id)
-        for message in st.session_state.chat_history:
-            with st.chat_message(message["role"]):
-                st.write(message["content"])
-
-        # Chat input with custom placeholder text
-        user_query = st.chat_input("Type your question here (or 'exit' to end")  # Blank #1: Fill in the chat input prompt (e.g., "Type your question here (or 'exit' to end)...")
-        print("user_query: ", user_query)
-        if user_query:
-            if user_query.lower() == "exit":
-                st.session_state.chat_history.append({"role": "user", "content": "exit"})
-                with st.chat_message("user"):
-                    st.write("exit")
-                goodbye_msg = "Goodbye! Feel free to return if you have more questions about nutrition disorders."
-                st.session_state.chat_history.append({"role": "assistant", "content": goodbye_msg})
-                with st.chat_message("assistant"):
-                    st.write(goodbye_msg)
-                st.session_state.user_id = None
-                st.rerun()
-                return
-            print("User query...", user_query)
-
-            st.session_state.chat_history.append({"role": "user", "content": user_query})
-            with st.chat_message("user"):
-                st.write(user_query)
-                print("User query...", user_query)
-
-            # # Filter input using Llama Guard
-            # filtered_result = filter_input_with_llama_guard(user_query)  # Blank #2: Fill in with the function name for filtering input (e.g., filter_input_with_llama_guard)
-            # # filtered_result = filtered_result.replace("\n", " ")  # Normalize the result
-
-            # if filtered_result is None:
-            #   print("Agent: I'm currently unable to moderate inputs due to a configuration issue. Proceeding without input filtering.")
-            #   filtered_result = "safe"
-            # else:
-            #   filtered_result = filtered_result.replace("\n", " ")
-
-            # # Check if input is safe based on allowed statuses
-            # if filtered_result in ["safe", "unsafe S7", "unsafe S6"]:  # Blanks #3, #4, #5: Fill in with allowed safe statuses (e.g., "safe", "unsafe S7", "unsafe S6")
-            try:
-                if 'chatbot' not in st.session_state:
-                    print("Initializing chatbot...")
-                    st.session_state.chatbot = NutritionBot()  # Blank #6: Fill in with the chatbot class initialization (e.g., NutritionBot)
-                    print("Initializing chatbot end...")
-
-                response = st.session_state.chatbot.handle_customer_query(st.session_state.user_id, user_query)
-                # Blank #7: Fill in with the method to handle queries (e.g., handle_customer_query)
-                st.write(response)
-                st.session_state.chat_history.append({"role": "assistant", "content": response})
-            except Exception as e:
-                error_msg = f"Sorry, I encountered an error while processing your query. Please try again. Error: {str(e)}"
-                st.write(error_msg)
-                st.session_state.chat_history.append({"role": "assistant", "content": error_msg})
-            # else:
-            #     inappropriate_msg = "I apologize, but I cannot process that input as it may be inappropriate. Please try again."
-            #     st.write(inappropriate_msg)
-            #     st.session_state.chat_history.append({"role": "assistant", "content": inappropriate_msg})
-
-if __name__ == "__main__":
-    nutrition_disorder_streamlit()
+# def nutrition_disorder_streamlit():
+#     """
+#     A Streamlit-based UI for the Nutrition Disorder Specialist Agent.
+#     """
+#     st.title("Nutrition Disorder Specialist")
+#     st.write("Ask me anything about nutrition disorders, symptoms, causes, treatments, and more.")
+#     st.write("Type 'exit' to end the conversation.")
+
+#     # Initialize session state for chat history and user_id if they don't exist
+#     if 'chat_history' not in st.session_state:
+#         st.session_state.chat_history = []
+#     if 'user_id' not in st.session_state:
+#         st.session_state.user_id = None
+
+#     # Login form: Only if user is not logged in
+#     if st.session_state.user_id is None:
+#         with st.form("login_form", clear_on_submit=True):
+#             user_id = st.text_input("Please enter your name to begin:")
+#             submit_button = st.form_submit_button("Login")
+#             if submit_button and user_id:
+#                 st.session_state.user_id = user_id
+#                 st.session_state.chat_history.append({
+#                     "role": "assistant",
+#                     "content": f"Welcome, {user_id}! How can I help you with nutrition disorders today?"
+#                 })
+#                 st.session_state.login_submitted = True  # Set flag to trigger rerun
+#         if st.session_state.get("login_submitted", False):
+#             st.session_state.pop("login_submitted")
+#             st.rerun()
+#     else:
+#         # Display chat history
+#         for message in st.session_state.chat_history:
+#             with st.chat_message(message["role"]):
+#                 st.write(message["content"])
+
+#         # Chat input with custom placeholder text
+#         user_query = st.chat_input("Type your question here (or 'exit' to end")  # Blank #1: Fill in the chat input prompt (e.g., "Type your question here (or 'exit' to end)...")
+#         if user_query:
+#             if user_query.lower() == "exit":
+#                 st.session_state.chat_history.append({"role": "user", "content": "exit"})
+#                 with st.chat_message("user"):
+#                     st.write("exit")
+#                 goodbye_msg = "Goodbye! Feel free to return if you have more questions about nutrition disorders."
+#                 st.session_state.chat_history.append({"role": "assistant", "content": goodbye_msg})
+#                 with st.chat_message("assistant"):
+#                     st.write(goodbye_msg)
+#                 st.session_state.user_id = None
+#                 st.rerun()
+#                 return
+
+#             st.session_state.chat_history.append({"role": "user", "content": user_query})
+#             with st.chat_message("user"):
+#                 st.write(user_query)
+
+#             # Filter input using Llama Guard
+#             filtered_result = filter_input_with_llama_guard(user_query)  # Blank #2: Fill in with the function name for filtering input (e.g., filter_input_with_llama_guard)
+#             filtered_result = filtered_result.replace("\n", " ")  # Normalize the result
+
+#             # Check if input is safe based on allowed statuses
+#             if filtered_result in ["safe", "unsafe S7", "unsafe S6"]:  # Blanks #3, #4, #5: Fill in with allowed safe statuses (e.g., "safe", "unsafe S7", "unsafe S6")
+#                 try:
+#                     if 'chatbot' not in st.session_state:
+#                         st.session_state.chatbot = NutritionBot()  # Blank #6: Fill in with the chatbot class initialization (e.g., NutritionBot)
+#                     response = st.session_state.chatbot.handle_customer_query(st.session_state.user_id, user_query)
+#                     # Blank #7: Fill in with the method to handle queries (e.g., handle_customer_query)
+#                     st.write(response)
+#                     st.session_state.chat_history.append({"role": "assistant", "content": response})
+#                 except Exception as e:
+#                     error_msg = f"Sorry, I encountered an error while processing your query. Please try again. Error: {str(e)}"
+#                     st.write(error_msg)
+#                     st.session_state.chat_history.append({"role": "assistant", "content": error_msg})
+#             else:
+#                 inappropriate_msg = "I apologize, but I cannot process that input as it may be inappropriate. Please try again."
+#                 st.write(inappropriate_msg)
+#                 st.session_state.chat_history.append({"role": "assistant", "content": inappropriate_msg})
+
+# if __name__ == "__main__":
+#     nutrition_disorder_streamlit()