Update app.py

inproved handle_query function to give creative response for the already cached data

app.py

@@ -360,7 +360,7 @@ def store_in_cache(query: str, answer: str):
 ###############################################################################
 def handle_query(query: str, detail: bool = False) -> str:
     """
-    Main function to process the query. 
+    Main function to process the query.
     :param query: The user's question.
     :param detail: Whether the user wants a more detailed response.
     :return: Response string from Daily Wellness AI.
@@ -369,55 +369,87 @@ def handle_query(query: str, detail: bool = False) -> str:
         return "Please provide a valid question."
 
     try:
-        # 1) Check the cache first (ADDED for speed)
-        cached_answer = get_cached_answer(query)
-        if cached_answer:
-            return cached_answer
-
-        # 2) Sanity Check: Determine if the question is relevant to daily wellness
+        # 1) Sanity Check: Determine if the question is relevant to daily wellness
         is_relevant = sanity_checker.is_relevant(query)
         if not is_relevant:
             return "Your question seems out of context or not related to daily wellness. Please ask a wellness-related question."
 
-        # 3) Proceed with retrieval
+        # 2) Proceed with retrieval from the knowledge base
         retrieved = retriever.retrieve(query)
+
+        # 3) Check the cache
+        cached_answer = get_cached_answer(query)
+
+        # 4) If no retrieved data from the knowledge base
         if not retrieved:
+            # If we do have a cached answer, return it
+            if cached_answer:
+                logger.info("No relevant entries found in knowledge base. Returning cached answer.")
+                return cached_answer
+            # Otherwise, no KB results and no cache => no answer
             return "I'm sorry, I couldn't find an answer to your question."
 
-        # 4) Check similarity threshold
+        # 5) We have retrieved data; let's check for similarity threshold
         top_score = retrieved[0][1]  # Assuming the list is sorted descending
         similarity_threshold = 0.3  # Adjust this threshold based on empirical results
 
         if top_score < similarity_threshold:
-            # Perform web search using manager_agent
+            # (Low similarity) Perform web search using manager_agent
             logger.info("Similarity score below threshold. Performing web search.")
             web_search_response = manager_agent.run(query)
             logger.debug(f"Web search response: {web_search_response}")
 
-            # Optionally, process the web_search_response if needed
-            # For simplicity, return the web search response directly
-            answer = (
-                f"**Daily Wellness AI**\n\n"
-                f"{web_search_response}\n\n"
-                "Disclaimer: This information is retrieved from the web and is not a substitute for professional medical advice.\n\n"
-                "Wishing you a calm and wonderful day!"
+            # Combine any cached answer (if it exists) with the web result
+            if cached_answer:
+                blend_prompt = (
+                    f"You previously provided the following answer:\n\n"
+                    f"{cached_answer}\n\n"
+                    f"Now, we also have these web results:\n\n"
+                    f"{web_search_response}\n\n"
+                    "Please combine them into a more creative and accurate response. "
+                    "Add positivity and end with a short inspirational note."
+                )
+                final_answer = llm._call(blend_prompt).strip()
+            else:
+                # If no cache, just return the web response
+                final_answer = (
+                    f"**Daily Wellness AI**\n\n"
+                    f"{web_search_response}\n\n"
+                    "Disclaimer: This information is retrieved from the web and is not a substitute for professional medical advice.\n\n"
+                    "Wishing you a calm and wonderful day!"
+                )
+
+            # Store in cache
+            store_in_cache(query, final_answer)
+            return final_answer
+
+        # 6) If similarity is sufficient, we will finalize an answer from the knowledge base
+        responses = [ans[0] for ans in retrieved]
+
+        # 6a) If we have a cached answer, let's blend it with the new knowledge base data
+        if cached_answer:
+            blend_prompt = (
+                f"You provided this answer previously:\n\n"
+                f"{cached_answer}\n\n"
+                f"Now, here are some newly retrieved answers:\n\n"
+                f"{chr(10).join(f'- {r}' for r in responses)}\n\n"
+                "Please synthesize these together, adding new insights, creativity, and a short inspirational note at the end."
             )
-            # Store in cache before returning
-            store_in_cache(query, answer)
-            return answer
+            final_answer = llm._call(blend_prompt).strip()
+        else:
+            # 6b) No cache => proceed with normal expansions
+            final_answer = answer_expander.expand(query, responses, detail=detail)
 
-        # 5) Proceed with answer expansion using retrieved_answers
-        responses = [ans[0] for ans in retrieved]
-        expanded_answer = answer_expander.expand(query, responses, detail=detail)
+        # 7) Store new or blended answer in cache
+        store_in_cache(query, final_answer)
+        return final_answer
 
-        # 6) Store in cache (ADDED)
-        store_in_cache(query, expanded_answer)
-        return expanded_answer
     except Exception as e:
         logger.error(f"Error handling query: {e}")
         logger.debug("Exception details:", exc_info=True)
         return "An error occurred while processing your request."
 
+
 ###############################################################################
 # 11) Gradio Interface
 ###############################################################################