Upload app.py with huggingface_hub

app.py

@@ -230,7 +230,7 @@ def craft_response(state: Dict) -> Dict:
 
 
 
-def score_groundedness(state: Dict) -> Dict:
+def score_groundness(state: Dict) -> Dict:
     """
     Checks whether the response is grounded in the retrieved context.
 
@@ -255,7 +255,7 @@ def score_groundedness(state: Dict) -> Dict:
     chain = groundedness_prompt | llm | StrOutputParser()
     groundedness_score = float(chain.invoke({
         "context": "\n".join([doc["content"] for doc in state['context']]),
-        "response": state['response'] # Complete the code to define the response
+        "response": state['response'] #
     }))
     print("groundedness_score: ", groundedness_score)
     state['groundedness_loop_count'] += 1
@@ -265,7 +265,6 @@ def score_groundedness(state: Dict) -> Dict:
     return state
 
 
-
 def check_precision(state: Dict) -> Dict:
     """
     Checks whether the response precisely addresses the user’s query.
@@ -288,14 +287,14 @@ def check_precision(state: Dict) -> Dict:
         ("user", "Query: {query}\nResponse: {response}\n\nPrecision score:")
     ])
 
-    chain = precision_prompt | llm | StrOutputParser() # Complete the code to define the chain of processing
+    chain = precision_prompt | llm | StrOutputParser()
     precision_score = float(chain.invoke({
         "query": state['query'],
-        "response":state['response'] # Complete the code to access the response from the state
+        "response": state['response']
     }))
     state['precision_score'] = precision_score
     print("precision_score:", precision_score)
-    state['precision_loop_count'] +=1
+    state['precision_loop_count'] += 1
     print("#########Precision Incremented###########")
     return state
 
@@ -324,7 +323,7 @@ def refine_response(state: Dict) -> Dict:
                  "What improvements can be made to enhance accuracy and completeness?")
     ])
 
-    chain = refine_response_prompt | llm| StrOutputParser()
+    chain = refine_response_prompt | llm | StrOutputParser()
 
     # Store response suggestions in a structured format
     feedback = f"Previous Response: {state['response']}\nSuggestions: {chain.invoke({'query': state['query'], 'response': state['response']})}"
@@ -372,7 +371,7 @@ def should_continue_groundedness(state):
   """Decides if groundedness is sufficient or needs improvement."""
   print("---------should_continue_groundedness---------")
   print("groundedness loop count: ", state['groundedness_loop_count'])
-  if state['groundedness_score'] >= 0.7:  # Complete the code to define the threshold for groundedness
+  if state['groundedness_score'] >= 0.7:  # Threshold for groundedness
       print("Moving to precision")
       return "check_precision"
   else:
@@ -398,13 +397,9 @@ def should_continue_precision(state: Dict) -> str:
 
 
 
-
-def max_iterations_reached(state: Dict) -> Dict:
-    """Handles the case when the maximum number of iterations is reached."""
-    print("---------max_iterations_reached---------")
-    """Handles the case when the maximum number of iterations is reached."""
-    response = "I'm unable to refine the response further. Please provide more context or clarify your question."
-    state['response'] = response
+def max_iterations_reached(state: AgentState) -> AgentState:
+    """Handles the case where max iterations are reached."""
+    state['response'] = "We need more context to provide an accurate answer."
     return state
 
 
@@ -413,32 +408,33 @@ from langgraph.graph import END, StateGraph, START
 
 def create_workflow() -> StateGraph:
     """Creates the updated workflow for the AI nutrition agent."""
-    workflow = StateGraph(AgentState)  # Complete the code to define the initial state of the agent
+    workflow = StateGraph(AgentState)
 
     # Add processing nodes
-    workflow.add_node("expand_query", expand_query)         # Step 1: Expand user query. Complete with the function to expand the query
-    workflow.add_node("retrieve_context", retrieve_context) # Step 2: Retrieve relevant documents. Complete with the function to retrieve context
-    workflow.add_node("craft_response", craft_response)     # Step 3: Generate a response based on retrieved data. Complete with the function to craft a response
-    workflow.add_node("score_groundedness", score_groundedness)  # Step 4: Evaluate response grounding. Complete with the function to score groundedness
-    workflow.add_node("refine_response", refine_response)   # Step 5: Improve response if it's weakly grounded. Complete with the function to refine the response
-    workflow.add_node("check_precision", check_precision)   # Step 6: Evaluate response precision. Complete with the function to check precision
-    workflow.add_node("refine_query", refine_query)         # Step 7: Improve query if response lacks precision. Complete with the function to refine the query
-    workflow.add_node("max_iterations_reached", max_iterations_reached)  # Step 8: Handle max iterations. Complete with the function to handle max iterations
+    workflow.add_node("expand_query", expand_query)         # Step 1: Expand user query.
+    workflow.add_node("retrieve_context", retrieve_context)     # Step 2: Retrieve relevant documents.
+    workflow.add_node("craft_response", craft_response)       # Step 3: Generate a response based on retrieved data.
+    workflow.add_node("score_groundness", score_groundness)   # Step 4: Evaluate response grounding.
+    workflow.add_node("refine_response", refine_response)      # Step 5: Improve response if it's weakly grounded.
+    workflow.add_node("check_precision", check_precision)      # Step 6: Evaluate response precision.
+    workflow.add_node("refine_query", refine_query)         # Step 7: Improve query if response lacks precision.
+    workflow.add_node("max_iterations_reached", max_iterations_reached)  # Step 8: Handle max iterations.
 
     # Main flow edges
     workflow.add_edge(START, "expand_query")
     workflow.add_edge("expand_query", "retrieve_context")
     workflow.add_edge("retrieve_context", "craft_response")
-    workflow.add_edge("craft_response", "score_groundedness")
+    workflow.add_edge("craft_response", "score_groundness")
+
 
     # Conditional edges based on groundedness check
     workflow.add_conditional_edges(
-        "score_groundedness",
+        "score_groundness",
         should_continue_groundedness,  # Use the conditional function
         {
-            "check_precision": check_precision,  # If well-grounded, proceed to precision check.
-            "refine_response": refine_response,  # If not, refine the response.
-            "max_iterations_reached": max_iterations_reached  # If max loops reached, exit.
+            "check_precision": "check_precision",  # If well-grounded, proceed to precision check.
+            "refine_response": "refine_response",  # If not, refine the response.
+            "max_iterations_reached": "max_iterations_reached"  # If max loops reached, exit.
         }
     )
 
@@ -456,7 +452,6 @@ def create_workflow() -> StateGraph:
     )
 
     workflow.add_edge("refine_query", "expand_query")  # Refined queries go through expansion again.
-
     workflow.add_edge("max_iterations_reached", END)
 
     return workflow
@@ -479,19 +474,33 @@ def agentic_rag(query: str):
     """
     # Initialize state with necessary parameters
     inputs = {
-        "query": query,  # Current user query
-        "expanded_query": "",  # Complete the code to define the expanded version of the query
-        "context": [],  # Retrieved documents (initially empty)
-        "response": "",  # Complete the code to define the AI-generated response
-        "precision_score": 0.0,  # Complete the code to define the precision score of the response
-        "groundedness_score": 0.0,  # Complete the code to define the groundedness score of the response
-        "groundedness_loop_count": 0,  # Complete the code to define the counter for groundedness loops
-        "precision_loop_count": 0,  # Complete the code to define the counter for precision loops
-        "feedback": "",  # Complete the code to define the feedback
-        "query_feedback": "",  # Complete the code to define the query feedback
-        "loop_max_iter": 3  # Complete the code to define the maximum number of iterations for loops
+        "query": query,
+        "expanded_query": "",
+        "context": [],
+        "response": "",
+        "precision_score": 0.0,
+        "groundedness_score": 0.0,
+        "groundedness_loop_count": 0,
+        "precision_loop_count": 0,
+        "feedback": "",
+        "query_feedback": "",
+        "loop_max_iter": 3  # Set a reasonable maximum number of iterations
     }
 
+    # Initialize the Chroma vector store for retrieving documents with the correct collection
+    vector_store = Chroma(
+        collection_name="semantic_chunks",  # Use the collection with semantic chunks
+        persist_directory="./research_db",
+        embedding_function=embedding_model
+    )
+
+    # Create a retriever from the vector store
+    retriever = vector_store.as_retriever(
+        search_type='similarity',
+        search_kwargs={'k': 3}
+    )
+
+
     output = WORKFLOW_APP.invoke(inputs)
 
     return output
@@ -506,7 +515,7 @@ def filter_input_with_llama_guard(user_input, model="meta-llama/llama-guard-4-12
 
     Parameters:
     - user_input: The input provided by the user.
-    - model: The Llama Guard model to be used for filtering (default is "llama-guard-3-8b").
+    - model: The Llama Guard model to be used for filtering (default is "meta-llama/llama-guard-4-12b").
 
     Returns:
     - The filtered and safe input.
@@ -538,12 +547,14 @@ class NutritionBot:
         # 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=config.get("API_KEY"),  # API key for authentication
-            endpoint = config.get("OPENAI_API_BASE"),
-            #openai_api_base = config.get("OPENAI_API_BASE"),
+            openai_api_key=config.get("API_KEY"),  # API key for authentication
+            #openai_endpoint = config.get("OPENAI_API_BASE"),
+            openai_api_base = config.get("OPENAI_API_BASE"),
             temperature=0  # Controls randomness in responses; 0 ensures deterministic results
         )
 
+
+
         # Define tools available to the chatbot, such as web search
         tools = [agentic_rag]