added together ai agent

controller.py

@@ -343,25 +343,25 @@ async def csv_chat(request: Dict, authorization: str = Header(None)):
         generate_report = request.get("generate_report")
         chat_id = request.get("chat_id")
         
-        # if generate_report is True:
-        #     report_files = await generate_csv_report(csv_url, query, chat_id)
-        #     if report_files is not None:
-        #         return {"answer": jsonable_encoder(report_files)}
-
-        # 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)}
+        if generate_report is True:
+            report_files = await generate_csv_report(csv_url, query, chat_id)
+            if report_files is not None:
+                return {"answer": jsonable_encoder(report_files)}
+
+        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)}
         
-        # # Orchestrate the execution
-        # if detailed_answer is True:
-        #    orchestrator_answer = await asyncio.to_thread(
-        #     csv_orchestrator_chat, decoded_url, query, conversation_history, chat_id
-        #    )
-        #    if orchestrator_answer is not None:
-        #       return {"answer": jsonable_encoder(orchestrator_answer)}
+        # Orchestrate the execution
+        if detailed_answer is True:
+           orchestrator_answer = await asyncio.to_thread(
+            csv_orchestrator_chat, decoded_url, query, conversation_history, chat_id
+           )
+           if orchestrator_answer is not None:
+              return {"answer": jsonable_encoder(orchestrator_answer)}
 
         # Process with groq_chat first
         # groq_answer = await asyncio.to_thread(groq_chat, decoded_url, query)
@@ -369,18 +369,19 @@ async def csv_chat(request: Dict, authorization: str = Header(None)):
         
         result = await query_csv_agent(decoded_url, query, chat_id)
         logger.info("together ai csv answer == >", result)
-        return {"answer": result}
+        if result is not None or result == "":
+            return {"answer": result}
      
         # if process_answer(groq_answer) == "Empty response received.":
         #     return {"answer": "Sorry, I couldn't find relevant data..."}
 
         # if process_answer(groq_answer):
-        #     lang_answer = await asyncio.to_thread(
-        #         langchain_csv_chat, decoded_url, query, False
-        #     )
-        #     if process_answer(lang_answer):
-        #         return {"answer": "error"}
-        #     return {"answer": jsonable_encoder(lang_answer)}
+        lang_answer = await asyncio.to_thread(
+            langchain_csv_chat, decoded_url, query, False
+        )
+        if process_answer(lang_answer):
+            return {"answer": "error"}
+        return {"answer": jsonable_encoder(lang_answer)}
 
         # return {"answer": jsonable_encoder(groq_answer)}
 
@@ -589,35 +590,35 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         generate_report = request.get("generate_report", False)
         chat_id = request.get("chat_id", "")
         
-        # if generate_report is True:
-        #     report_files = await generate_csv_report(csv_url, query, chat_id)
-        #     if report_files is not None:
-        #         return {"orchestrator_response": jsonable_encoder(report_files)}
+        if generate_report is True:
+            report_files = await generate_csv_report(csv_url, query, chat_id)
+            if report_files is not None:
+                return {"orchestrator_response": jsonable_encoder(report_files)}
 
         loop = asyncio.get_running_loop()
-        # # First, try the langchain-based method if the question qualifies
-        # if if_initial_chart_question(query):
-        #     langchain_result = await loop.run_in_executor(
-        #         process_executor, langchain_csv_chart, csv_url, query, True
-        #     )
-        #     logger.info("Langchain chart result:", langchain_result)
-        #     if isinstance(langchain_result, list) and len(langchain_result) > 0:
-        #         unique_file_name =f'{str(uuid.uuid4())}.png'
-        #         logger.info("Uploading the chart to supabase...")
-        #         image_public_url = await upload_file_to_supabase(f"{langchain_result[0]}", unique_file_name, chat_id=chat_id)
-        #         logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
-        #         os.remove(langchain_result[0])
-        #         return {"image_url": image_public_url}
-        #        # return FileResponse(langchain_result[0], media_type="image/png")
+        # First, try the langchain-based method if the question qualifies
+        if if_initial_chart_question(query):
+            langchain_result = await loop.run_in_executor(
+                process_executor, langchain_csv_chart, csv_url, query, True
+            )
+            logger.info("Langchain chart result:", langchain_result)
+            if isinstance(langchain_result, list) and len(langchain_result) > 0:
+                unique_file_name =f'{str(uuid.uuid4())}.png'
+                logger.info("Uploading the chart to supabase...")
+                image_public_url = await upload_file_to_supabase(f"{langchain_result[0]}", unique_file_name, chat_id=chat_id)
+                logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
+                os.remove(langchain_result[0])
+                return {"image_url": image_public_url}
+               # return FileResponse(langchain_result[0], media_type="image/png")
                
-        # # Use orchestrator to handle the user's chart query first
-        # if detailed_answer is True:
-        #    orchestrator_answer = await asyncio.to_thread(
-        #      csv_orchestrator_chat, csv_url, query, conversation_history, chat_id
-        #    )
+        # Use orchestrator to handle the user's chart query first
+        if detailed_answer is True:
+           orchestrator_answer = await asyncio.to_thread(
+             csv_orchestrator_chat, csv_url, query, conversation_history, chat_id
+           )
         
-        #    if orchestrator_answer is not None:
-        #      return {"orchestrator_response": jsonable_encoder(orchestrator_answer)}
+           if orchestrator_answer is not None:
+             return {"orchestrator_response": jsonable_encoder(orchestrator_answer)}
         
         # Next, try the groq-based method
         # groq_result = await loop.run_in_executor(
@@ -632,28 +633,30 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         #     os.remove(groq_result)
         #     return {"image_url": image_public_url}
             # return FileResponse(groq_result, media_type="image/png")
-            
+        
+        logger.info("Trying together ai llama...")
         result = await query_csv_agent(csv_url, query, chat_id)
         logger.info("together ai result ==>", result)
-        return {"orchestrator_response": jsonable_encoder(result)}
+        if result is not None and result != "":
+         return {"orchestrator_response": jsonable_encoder(result)}
           
         # Fallback: try langchain-based again
-        # logger.error("Groq chart generation failed, trying langchain....")
-        # langchain_paths = await loop.run_in_executor(
-        #     process_executor, langchain_csv_chart, csv_url, query, True
-        # )
-        # logger.info("Fallback langchain chart result:", langchain_paths)
-        # if isinstance(langchain_paths, list) and len(langchain_paths) > 0:
-        #    unique_file_name =f'{str(uuid.uuid4())}.png'
-        #    logger.info("Uploading the chart to supabase...")
-        #    image_public_url = await upload_file_to_supabase(f"{langchain_paths[0]}", unique_file_name, chat_id=chat_id)
-        #    logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
-        #    os.remove(langchain_paths[0])
-        #    return {"image_url": image_public_url}
-           # return FileResponse(langchain_paths[0], media_type="image/png")
-        # else:
-        #    logger.error("All chart generation methods failed")
-        #    return {"answer": "error"}
+        logger.error("Together ai llama response 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)
+        if isinstance(langchain_paths, list) and len(langchain_paths) > 0:
+           unique_file_name =f'{str(uuid.uuid4())}.png'
+           logger.info("Uploading the chart to supabase...")
+           image_public_url = await upload_file_to_supabase(f"{langchain_paths[0]}", unique_file_name, chat_id=chat_id)
+           logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
+           os.remove(langchain_paths[0])
+           return {"image_url": image_public_url}
+           return FileResponse(langchain_paths[0], media_type="image/png")
+        else:
+           logger.error("All chart generation methods failed")
+           return {"answer": "error"}
 
     except Exception as e:
         logger.error(f"Critical chart error: {str(e)}")

orchestrator_functions.py

@@ -572,7 +572,7 @@ async def csv_chat(csv_url: str, query: str):
 async def csv_chart(csv_url: str, query: str, chat_id: str):
     """
     Generate a chart based on the provided CSV URL and query.
-    Prioritizes OpenAI, then raw Groq, then LangChain Gemini, and finally LangChain Groq as fallback.
+    Prioritizes PandasAI Groq, then LangChain Gemini, and finally LangChain Groq as fallback.
     
     Parameters:
     - csv_url (str): The URL of the CSV file.
@@ -599,18 +599,19 @@ async def csv_chart(csv_url: str, query: str, chat_id: str):
         return {"image_url": public_url}
 
     try:
-        try:
-            # --- 1. First Attempt: OpenAI ---
-            openai_result = await asyncio.to_thread(openai_chart, csv_url, query)
-            logger.info(f"OpenAI chart result:", openai_result)
+        # Commented out for now because aiml api is not working
+        # try:
+        #     # --- 1. First Attempt: OpenAI ---
+        #     openai_result = await asyncio.to_thread(openai_chart, csv_url, query)
+        #     logger.info(f"OpenAI chart result:", openai_result)
 
-            if openai_result and openai_result != 'Chart not generated':
-                return await upload_and_return(openai_result, chat_id)
+        #     if openai_result and openai_result != 'Chart not generated':
+        #         return await upload_and_return(openai_result, chat_id)
 
-            raise Exception("OpenAI failed to generate chart")
+        #     raise Exception("OpenAI failed to generate chart")
 
-        except Exception as openai_error:
-            logger.info(f"OpenAI failed ({str(openai_error)}), trying raw Groq...")
+        # except Exception as openai_error:
+        #     logger.info(f"OpenAI failed ({str(openai_error)}), trying raw Groq...")
             # --- 2. Second Attempt: Raw Groq ---
             try:
                 groq_result = await asyncio.to_thread(groq_chart, csv_url, query)