Upload app.py with huggingface_hub

app.py

@@ -1,4 +1,5 @@
 
+
 # Import necessary libraries
 import os  # Interacting with the operating system (reading/writing files)
 import chromadb  # High-performance vector database for storing/querying dense vectors
@@ -61,7 +62,7 @@ MEM0_api_key = os.getenv("MEM0_API_KEY")
 embedding_function = chromadb.utils.embedding_functions.OpenAIEmbeddingFunction(
     api_base=endpoint, # Complete the code to define the API base endpoint
     api_key=api_key, # Complete the code to define the API key
-    model_name='text-embedding-ada-002' # This is a fixed value and does not need modification
+    model_name='text-embedding-3-small' # This is a fixed value and does not need modification
 )
 
 # This initializes the OpenAI embedding function for the Chroma vectorstore, using the provided endpoint and API key.
@@ -70,7 +71,7 @@ embedding_function = chromadb.utils.embedding_functions.OpenAIEmbeddingFunction(
 embedding_model = OpenAIEmbeddings(
     openai_api_base=endpoint,
     openai_api_key=api_key,
-    model='text-embedding-ada-002'
+    model='text-embedding-3-small'
 )
 
 
@@ -111,48 +112,51 @@ def expand_query(state):
         Dict: The updated state with the expanded query.
     """
     print("---------Expanding Query---------")
-    system_message = '''You are a query-expansion engine for a medical retrieval system.
+    system_message = """
+You are a query-expansion engine for a medical retrieval system.
 
-      Your job:
-      1. Expand the user's query into 6–8 alternative questions that could retrieve the same medical information.
+Your job:
+1. Expand the user's query into 6–8 alternative questions that could retrieve the same medical information.
 
-      Rules:
-      - Do NOT answer the query.
-      - Keep output in the same language as input.
-      - Preserve key entities (e.g., vitamins, disorders, nutrients).
-      - Each query must be ≤ 16 words.
-      - Output strict JSON only. No explanation. No extra text.
+Rules:
+- Do NOT answer the query.
+- Keep output in the same language as input.
+- Preserve key entities (e.g., vitamins, disorders, nutrients).
+- Each query must be ≤ 16 words.
+- Output strict JSON only. No explanation. No extra text.
 
-      Schema:
-      {{
-        "queries": ["...", "..."]
-      }}'''
+Schema:
+{{
+  "queries": ["...", "..."]
+}}
+"""
 
     expand_prompt = ChatPromptTemplate.from_messages([
         ("system", system_message),
         ("user", "Expand this query: {query} using the feedback: {query_feedback}")
-
     ])
 
     chain = expand_prompt | llm | StrOutputParser()
-    expanded_query = chain.invoke({"query": state['query'], "query_feedback":state["query_feedback"]})
+    expanded_query = chain.invoke({"query": state['query'], "query_feedback": state["query_feedback"]})
     print("expanded_query", expanded_query)
     state["expanded_query"] = expanded_query
     return state
 
 
+
 # Initialize the Chroma vector store for retrieving documents
 vector_store = Chroma(
-    collection_name="nutritional_hypotheticals",
-    persist_directory="./nutritional_db",
-    embedding_function=embedding_model
-
+    collection_name='nutritional_hypotheticals',  # Complete the code to define the collection name
+    persist_directory='./nutritional_db',  # Complete the code to define the directory for persistence
+    embedding_function=embedding_model  # Complete the code to define the embedding function
 )
 
 # Create a retriever from the vector store
+
+# this is the provided code but I want to use the structured retriever
 retriever = vector_store.as_retriever(
-    search_type='similarity',
-    search_kwargs={'k': 3}
+    search_type='similarity',  # Complete the code to define the search type
+    search_kwargs={'k': 6}  # Complete the code to define the number of results to retrieve
 )
 
 def retrieve_context(state):
@@ -166,18 +170,21 @@ def retrieve_context(state):
         Dict: The updated state with the retrieved context.
     """
     print("---------retrieve_context---------")
-    query = state['expanded_query']  # Complete the code to define the key for the expanded query
+    query = state.get('expanded_query') or state.get('query') # Complete the code to define the key for the expanded query
+
     #print("Query used for retrieval:", query)  # Debugging: Print the query
 
-    # Retrieve documents from the vector store
+    # Retrieve hypothetical questions from the vector store
     docs = retriever.invoke(query)
     print("Retrieved documents:", docs)  # Debugging: Print the raw docs object
 
+
+
     # Extract both page_content and metadata from each document
     context= [
-        {
-            "content": doc.page_content,  # The actual content of the document
-            "metadata": doc.metadata  # The metadata (e.g., source, page number, etc.)
+         {
+            "content": doc.metadata.get("original_content", ""),
+            "metadata": doc.metadata
         }
         for doc in docs
     ]
@@ -199,7 +206,8 @@ def craft_response(state: Dict) -> Dict:
         Dict: The updated state with the generated response.
     """
     print("---------craft_response---------")
-    system_message = '''You are a medical assistant specializing in nutritional disorders.
+    system_message = '''
+    You are a medical assistant specializing in nutritional disorders.
 
     Your job is to generate concise, accurate answers strictly based on the provided context from a textbook or trusted source.
 
@@ -218,20 +226,22 @@ def craft_response(state: Dict) -> Dict:
         ("system", system_message),
         ("user", "Query: {query}\nContext: {context}\n\nfeedback: {feedback}")
     ])
+    context_docs = state.get("context", [])
+    context_string = "\n\n".join(doc["metadata"].get("original_content", "") for doc in context_docs)
 
+    feedback_text = state.get("feedback", "None")
     chain = response_prompt | llm
     response = chain.invoke({
         "query": state['query'],
-        "context": "\n".join([doc["content"] for doc in state['context']]),
-        "feedback": state.get('feedback', '') # add feedback to the prompt
+        "context": context_string,
+        "feedback": feedback_text # add feedback to the prompt
     })
-    state['response'] = response.content
-    print("intermediate response: ", response.content)
+    state['response'] = response
+    print("intermediate response: ", response)
 
     return state
 
 
-
 def score_groundedness(state: Dict) -> Dict:
     """
     Checks whether the response is grounded in the retrieved context.
@@ -265,7 +275,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"] # Complete the code to define the response
     }))
     print("groundedness_score: ", groundedness_score)
     state['groundedness_loop_count'] += 1
@@ -275,10 +285,9 @@ def score_groundedness(state: Dict) -> Dict:
     return state
 
 
-
 def check_precision(state: Dict) -> Dict:
     """
-    Checks whether the response precisely addresses the user's query.
+    Checks whether the response precisely addresses the user’s query.
 
     Args:
         state (Dict): The current state of the workflow, containing the query and response.
@@ -308,7 +317,7 @@ def check_precision(state: Dict) -> Dict:
     chain = precision_prompt | llm | StrOutputParser() # Complete the code to define the chain of processing
     precision_score = float(chain.invoke({
         "query": state['query'],
-        "response": state['response'] # Complete the code to access the response from the state
+        "response":state['response'] # Complete the code to access the response from the state
     }))
     state['precision_score'] = precision_score
     print("precision_score:", precision_score)
@@ -317,7 +326,6 @@ def check_precision(state: Dict) -> Dict:
     return state
 
 
-
 def refine_response(state: Dict) -> Dict:
     """
     Suggests improvements for the generated response.
@@ -357,7 +365,6 @@ def refine_response(state: Dict) -> Dict:
     return state
 
 
-
 def refine_query(state: Dict) -> Dict:
     """
     Suggests improvements for the expanded query.
@@ -401,25 +408,24 @@ 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'] >= 7.0:  # Complete the code to define the threshold for groundedness
+  if state['groundedness_score'] >= 0.85:  # Complete the code to define the threshold for groundedness
       print("Moving to precision")
       return "check_precision"
   else:
-      if state["groundedness_loop_count"] > state['loop_max_iter']:
+      if state["groundedness_loop_count"] >= state['loop_max_iter']:
         return "max_iterations_reached"
       else:
         print(f"---------Groundedness Score Threshold Not met. Refining Response-----------")
         return "refine_response"
 
-
 def should_continue_precision(state: Dict) -> str:
     """Decides if precision is sufficient or needs improvement."""
     print("---------should_continue_precision---------")
-    print("precision loop count: ", state['precision_loop_count'])
-    if state['precision_score'] >= 7.0:  # Threshold for precision
+    print("precision loop count: ", state["precision_loop_count"])
+    if  state["precision_score"] >= 0.85:  # Threshold for precision
         return "pass"  # Complete the workflow
     else:
-        if state['precision_loop_count'] > state['loop_max_iter']:  # Maximum allowed loops
+        if state["precision_loop_count"] >= state["loop_max_iter"]:  # Maximum allowed loops
             return "max_iterations_reached"
         else:
             print(f"---------Precision Score Threshold Not met. Refining Query-----------")  # Debugging