Updated agent

.gitignore

@@ -0,0 +1,3 @@
+.venv
+.env
+.gitattributes

app.py

@@ -3,21 +3,232 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from langgraph.graph import StateGraph, START, END
+from typing_extensions import TypedDict
+from typing import List, TypedDict, Annotated, Optional
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
+from langgraph.graph.message import add_messages
+from langchain_community.tools import DuckDuckGoSearchRun
+from langgraph.prebuilt import ToolNode, tools_condition
+from PIL import Image
+import requests
+from io import BytesIO
+import PyPDF2
+import base64
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.tools import tool
+from dotenv import load_dotenv
+import time
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper
+from langchain_community.tools import BraveSearch
+
+load_dotenv(".env", override=True)
+BRAVE_API_KEY = os.getenv("BRAVE_API")
+
+class State(TypedDict):
+    file_path : str
+    file: Optional[str]
+    parsed_file: Optional[str]
+    messages: Annotated[list[AnyMessage], add_messages]
+    parsed_file_message: dict
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
+
+        # tools initialization
+        #internet_search = DuckDuckGoSearchRun()
+        
+        tools = [BasicAgent.search_tool, BasicAgent.revert_string, BasicAgent.download_file_tool, BasicAgent.answer_question_tool_from_file]
+
+        #llm = ChatOllama(model="llama3.2", temperature=0)
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-2.0-flash",
+            temperature=0)
+        self.llm_with_tools = llm.bind_tools(tools)
+
+        builder = StateGraph(State)
+
+        builder.add_node("assistant", self.assistant)
+        builder.add_node("tools", ToolNode(tools))
+        #builder.add_node("download_file", BasicAgent.download_file_node)
+        #builder.add_node("parse_img", BasicAgent.parse_image)
+        #builder.add_node("parse_pdf", BasicAgent.parse_pdf)
+        #builder.add_node("parse_audio", BasicAgent.parse_audio)
+        #builder.add_node("extract_data", BasicAgent.extract_data_from_file)
+
+        builder.add_edge(START, "assistant")
+        #builder.add_conditional_edges("download_file", BasicAgent.determine_file_type,
+        #    {"img": "parse_img", "pdf": "parse_pdf", "audio": "parse_audio", "end": END})
+        #builder.add_edge("parse_img", "assistant")
+        #builder.add_edge("parse_pdf", "assistant")
+        #builder.add_edge("parse_audio", "assistant")
+        builder.add_conditional_edges("assistant", tools_condition)
+        builder.add_edge("tools", "assistant")
+
+        self.react_graph = builder.compile()
+
+
+    def __call__(self, question: str, file_name: Optional[str]) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        
+        messages = [HumanMessage(question)]
+        messages = self.react_graph.invoke({"messages": messages, "file_path": file_name})
+
+        for m in messages['messages']:
+            m.pretty_print()
+
+        
+        final_answer = messages["messages"][-1].content
+        print(f"Final answer is {final_answer}")
+        return final_answer
+
+    def search_tool(query: str):
+        """
+        This function looks for the provided query online and gives you information about it.
+        """
+
+        search_tool = BraveSearch.from_api_key(api_key=BRAVE_API_KEY, search_kwargs={"count": 3})
+        res = search_tool.run(query)
+
+        return res
+
+
+    def assistant(self, state: State):
+        if state["file_path"]:
+            file_name = state["file_path"].split(".")[0]
+            file_extension = state["file_path"].split(".")[1]
+        else:
+            file_extension = None
+        
+        prompt = f"""
+        You are a helpful assistant. 
+        You have access to some optional documents. The file name of the file you have access is: {file_name} and it is a {file_extension} file. The DEFAULT_API_URL to fetch this file is {DEFAULT_API_URL}.
+        If you need to fetch a file, call the download_file tool with exactly the filename in the format {DEFAULT_API_URL}/files/file_name or URL. Once you have the bytes back (and the Base64), continue.
+        You need to answer the given question EXACTLY in the SPECIFIC WAY it is asked in the user question. DO NOT ADD ANYTHING NOT NEEDED IN THE ANSWER.")
+        """
+
+        sys_msg = SystemMessage(content=prompt)
+        
+        time.sleep(5)
+        return {"messages": [self.llm_with_tools.invoke([sys_msg] + state["messages"])]}
+
+    def file_to_download_exists(state: State) -> ["download", "apply_tools"]:
+        """
+            This function checks whether there is a file that needs to be downloaded
+        """
+        return state["file_path"] != ""
+
+    
+    def download_file_tool(file_url: str) -> dict:
+        """
+            This tool downloads a file (image, pdf, etc.) given the name of the file. The url for the request will be composed in the function so ONLY the name of the file should be passed in.
+
+            You may have to download a file in 2 different scenarios:
+            - A file given already as part of the task. In this case the format of the url must be: {DEFAULT_API_URL}/files/{file_name} THE EXTENSION OF THE FILE MUST NOT(!!) BE INCLUDED!
+            - A url retrieved from the internet in the format https://some_url. In that case, you simply need to provide the url of the file that needs to be retrieved.
+
+            Args: 
+                file_name: the name of the file to be retrieved
+
+            Output:
+                A tuple made of:
+                1) The file in bytes
+                2) The file in Base64 encoding
+                3) The result of the call 
+        """
+        #task_id = file_.split(".")[0]
+        #print("Downloading the file")
+
+        response = requests.get(file_url)
+        if response.status_code == 200:
+            msg = "File downloaded successfully!!"
+            print(msg)
+            file = response.content
+            b64_file = base64.b64encode(state["file"]).decode("utf-8")
+        else:
+            msg = "There was an error downloading the file."
+            print(msg)
+            file = None
+            b64_file = None
+
+        return {
+            "bytes": file,
+            "base64": b64_file,
+            "status": response.status_code,
+        }
+
+    def determine_file_type(state: State) -> ["pdf", "img", "audio", "end"]:
+        if state["file"] is None:
+            return "end"
+        
+        file_extension = state["file_path"].split(".")[1]
+        if file_extension in ["png", "jpg"]:
+            return "img"
+        elif file_extension == "pdf":
+            return "pdf"
+        elif file_extension in ["mp3", "wav"]:
+            return "audio"
+        
+        return "end"    
+
+    def answer_question_tool_from_file(question: str, encoded_file: str, file_extension: str) -> str:
+        """
+        This tool allows you to answer a question taking into account information that were provided inside a file.
+
+        Args:
+            The question that needs to be answered.
+            The file from which you want to get some information.
+            The file extension of the file that is being processed.
+        """
+
+        if file_extension in ["png", "jpg"]:
+            message = {"type": "image_url", "image_url": f"data:image/png;base64,{encoded_file}"}
+        elif file_extension == "pdf":
+            message = {"type": "image_url",  # Assuming the LLM accepts PDF under this key, you might need to verify this
+                    "image_url": f"data:application/pdf;base64,{encoded_file}"
+                  }
+        elif file_extension in ["mp3", "wav"]:
+            message = {"type": "media", "data": encoded_file,  # Use base64 string directly
+            "mime_type": "audio/mpeg",
+        }
+
+        message_local = HumanMessage(
+            content=[
+                {"type": "text", "text": question},
+                message,
+            ]
+        )
+
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-2.0-flash",
+            temperature=0)
+
+        response = llm.invoke(message_local)
+
+        return response
+
+    
+    def revert_string(input_str: str) -> str:
+        """
+        This function inverst the order of the characters within a sentence. It is particularly useful if you can't understand the content
+        in any language.
+
+        Args:
+            input_str: the string to invert
+        
+        Returns:
+            The inverted string
+        """
+
+        return input_str[::-1]
+
+
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -76,11 +287,12 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
+        file_name = item.get("file_name")
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent(question_text, file_name)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e: