stay hard

controller.py

@@ -26,7 +26,7 @@ import matplotlib.pyplot as plt
 import matplotlib
 import seaborn as sns
 from intitial_q_handler import if_initial_chart_question, if_initial_chat_question
-from rethink_gemini_agents.gemini_langchain_service import langchain_gemini_csv_chat
+from rethink_gemini_agents.gemini_langchain_service import langchain_gemini_csv_chart, langchain_gemini_csv_chat
 from rethink_gemini_agents.rethink_chart import gemini_llm_chart
 from rethink_gemini_agents.rethink_chat import gemini_llm_chat
 from util_service import _prompt_generator, process_answer
@@ -302,18 +302,19 @@ async def csv_chat(request: Dict, authorization: str = Header(None)):
                 langchain_gemini_csv_chat, decoded_url, query, False
             )
             logger.info("gemini langchain_answer --> ", answer)
+            if(answer and process_answer(answer)):
+                
+             logger.error("Gemini chat initial query failed, trying groq based langchain_csv_chat...")
+              
+             answer = await asyncio.to_thread(
+                langchain_csv_chat, decoded_url, query, False
+             )
+            logger.info("groq langchain_answer --> ", answer)
             return {"answer": jsonable_encoder(answer)}
+         
+         
         
-        gemini_answer = await asyncio.to_thread(gemini_llm_chat, decoded_url, query)
-        logger.info("gemini_answer --> ", gemini_answer)
-        return {"answer": gemini_answer}
 
-        if if_initial_chat_question(query):
-            answer = await asyncio.to_thread(
-                langchain_csv_chat, decoded_url, query, False
-            )
-            logger.info("langchain_answer --> ", answer)
-            return {"answer": jsonable_encoder(answer)}
 
         # Process with groq_chat first
         groq_answer = await asyncio.to_thread(groq_chat, decoded_url, query)
@@ -799,26 +800,32 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         loop = asyncio.get_running_loop()
         # First, try the langchain-based method if the question qualifies
         
-        if if_initial_chat_question(query):
+        
+        if if_initial_chart_question(query):
             langchain_gemini_chart_answer = await asyncio.to_thread(
                 langchain_gemini_csv_chat, csv_url, query, False
             )
             logger.info("gemini langchain_answer --> ", langchain_gemini_chart_answer)
             if isinstance(langchain_gemini_chart_answer, list) and len(langchain_gemini_chart_answer) > 0:
                return FileResponse(langchain_gemini_chart_answer[0], media_type="image/png")
-        
-        gemini_answer = await asyncio.to_thread(gemini_llm_chart, csv_url, query)
-        logger.info("gemini_answer --> ", gemini_answer)
-        return FileResponse(gemini_answer, media_type="image/png")
     
-        if if_initial_chart_question(query):
+            logger.error("Gemini Langchain chart generation failed for initial question, trying groq langchain....")
             langchain_result = await loop.run_in_executor(
                 process_executor, langchain_csv_chart, csv_url, query, True
             )
-            logger.info("Langchain chart result:", langchain_result)
+            logger.info("groq langchain_answer -->", langchain_result)
             if isinstance(langchain_result, list) and len(langchain_result) > 0:
                return FileResponse(langchain_result[0], media_type="image/png")
+           
+        logger.error("Groq Langchain chart generation failed for initial question, trying gemini rethink agent....")
+       
+        # If not initial question then try gemini langchain method   
+        gemini_answer = await asyncio.to_thread(gemini_llm_chart, csv_url, query)
+        logger.info("gemini_answer --> ", gemini_answer)
+        if(isinstance(gemini_answer, str) and gemini_answer != "Chart path not found" and ".png" in gemini_answer):
+          return FileResponse(gemini_answer, media_type="image/png")
         
+        logger.error("Gemini chart generation failed, trying groq....")
         # Next, try the groq-based method
         groq_result = await loop.run_in_executor(
             process_executor, groq_chart, csv_url, query
@@ -828,13 +835,19 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
             return FileResponse(groq_result, media_type="image/png")
           
         # Fallback: try langchain-based again
-        logger.error("Groq chart generation failed, trying langchain....")
+        logger.error("Groq chart generation failed, trying langchain (Groq)....")
         langchain_paths = await loop.run_in_executor(
             process_executor, langchain_csv_chart, csv_url, query, True
         )
-        logger.info("Fallback langchain chart result:", langchain_paths)
+        logger.info("Groq langchain image paths -->", langchain_paths)
         if isinstance(langchain_paths, list) and len(langchain_paths) > 0:
            return FileResponse(langchain_paths[0], media_type="image/png")
+       
+        # Fallback: try gemini-based again
+        logger.error("Groq langchain chart generation failed, trying Gemini Langchain agent....")
+        gemini_paths = await asyncio.to_thread(langchain_gemini_csv_chart, csv_url, query, True)
+        if isinstance(gemini_paths, list) and len(gemini_paths) > 0:
+           return FileResponse(gemini_paths[0], media_type="image/png")
         else:
            logger.error("All chart generation methods failed")
            return {"error": "All chart generation methods failed"}

rethink_gemini_agents/rethink_chart.py

@@ -232,10 +232,10 @@ def gemini_llm_chart(csv_url: str, query: str) -> str:
         return chart_path
      else:
         print("Chart path not found")
-        return None
+        return "Chart path not found"
     else:
      print("Unexpected result format:", type(result))
-     return None
+     return "Chart path not found"
 
 
 

rethink_gemini_agents/rethink_chat.py

@@ -212,31 +212,36 @@ class RethinkAgent(BaseModel):
 
 
 def gemini_llm_chat(csv_url: str, query: str) -> str:
+    
+    try:
     # Assuming clean_data and RethinkAgent are defined elsewhere
-    df = clean_data(csv_url)
-    agent = RethinkAgent(df=df)
+     df = clean_data(csv_url)
+     agent = RethinkAgent(df=df)
     
-    # Assuming API_KEYS is defined elsewhere
-    if not agent.initialize_model(API_KEYS):
-        print("Failed to initialize model with provided keys")
-        exit(1)
+     # Assuming API_KEYS is defined elsewhere
+     if not agent.initialize_model(API_KEYS):
+         print("Failed to initialize model with provided keys")
+         exit(1)
 
-    result = agent.execute_query(query)
+     result = agent.execute_query(query)
     
-    # Process different response types
-    if isinstance(result, pd.DataFrame):
-        processed = result.apply(handle_out_of_range_float).to_dict(orient="records")
-    elif isinstance(result, pd.Series):
+     # Process different response types
+     if isinstance(result, pd.DataFrame):
+         processed = result.apply(handle_out_of_range_float).to_dict(orient="records")
+     elif isinstance(result, pd.Series):
         processed = result.apply(handle_out_of_range_float).to_dict()
-    elif isinstance(result, list):
-        processed = [handle_out_of_range_float(item) for item in result]
-    elif isinstance(result, dict):
-        processed = {k: handle_out_of_range_float(v) for k, v in result.items()}
-    else:
-        processed = {"answer": str(handle_out_of_range_float(result))}
+     elif isinstance(result, list):
+         processed = [handle_out_of_range_float(item) for item in result]
+     elif isinstance(result, dict):
+         processed = {k: handle_out_of_range_float(v) for k, v in result.items()}
+     else:
+         processed = {"answer": str(handle_out_of_range_float(result))}
 
-    logger.info(f"gemini processed result: {processed}")
-    return processed
+     logger.info(f"gemini processed result: {processed}")
+     return processed
+    except Exception as e:
+        logger.error(f"Error in gemini_llm_chat: {str(e)}")
+        return None
 
 # uvicorn controller:app --host localhost --port 8000 --reload
 

util_service.py

@@ -1,7 +1,7 @@
 from langchain_core.prompts import ChatPromptTemplate
 import numpy as np
 
-keywords = ["unfortunately", "unsupported", "error", "sorry", "response", "unable", "because"]
+keywords = ["unfortunately", "unsupported", "error", "sorry", "response", "unable", "because", "too many"]
 
 def contains_keywords(text, keywords):
     return any(keyword.lower() in text.lower() for keyword in keywords)