feat: Added langgraph agent

agent.py

@@ -0,0 +1,113 @@
+from langgraph.prebuilt import ToolNode
+from retriever import (
+    get_file,
+    extract_image_info,
+    file_retriever_tool,
+    fetch_text_from_url,
+    excel_data_retriever,
+    download_file_from_url,
+    image_decoder,
+    csv_data_retriever,
+)
+from tools import (
+    search_tool,
+    calc,
+    wiki_search,
+    arxiv_search,
+    run_python_code,
+    get_image_captioning,
+)
+from typing import List, TypedDict, Annotated, Optional
+from langchain_core.messages import AnyMessage, SystemMessage
+from langgraph.graph.message import add_messages
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
+
+MODEL_NAME = "Qwen/Qwen3-Next-80B-A3B-Thinking"
+
+SYSTEM_PROMPT = """
+You are a literary data assistant.
+
+## Capabilities
+
+- `fetch_text_from_url`: loads document text from a URL into the conversation.
+- `search_tool`: search tool to access information from internet
+- `calc`: Calulate expression
+- `run_python_code`: execute given python code and return result of execution
+- `wiki_search`: search documets on Wikipedia
+- `arxiv_search`: Search research papaers on arxiv
+- `download_file_from_url`: download and stoere file from url
+- `extract_image_info`: extract information from image
+- `file_retriever_tool`: extract file from GAIA API for given task_id
+- `fetch_text_from_url`: fetch textual info from URL
+- `excel_data_retriever`: retreieve data from excel file
+- `image_decoder`: convert image from url to base64 decoded image
+- `get_image_captioning`: get captioning for gibven image urls
+- `csv_data_retriever`: retrieve data from csv file
+"""
+
+llm = HuggingFaceEndpoint(
+    repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+)
+
+
+class AgentState(TypedDict):
+    # The document provided
+    input_file: Optional[str]  # Contains file path (PDF/PNG)
+    file_name: Optional[str]
+    task_id: Optional[str]
+    messages: Annotated[list[AnyMessage], add_messages]
+
+
+tools = [
+    search_tool,
+    calc,
+    run_python_code,
+    wiki_search,
+    arxiv_search,
+    download_file_from_url,
+    extract_image_info,
+    file_retriever_tool,
+    fetch_text_from_url,
+    excel_data_retriever,
+    image_decoder,
+    get_image_captioning,
+    csv_data_retriever,
+]
+
+tool_node = ToolNode(tools)
+
+
+def assistant(state: AgentState):
+    sys_msg = SystemMessage(content=SYSTEM_PROMPT)
+    return {
+        "messages": [chat_with_tools.invoke([sys_msg] + state["messages"])],
+        "input_file": state["input_file"],
+        "file_name": state["file_name"],
+        "task_id": state["task_id"],
+    }
+
+
+chat = ChatHuggingFace(llm=llm, verbose=True)
+chat_with_tools = chat.bind_tools(tools)
+
+
+def build_agent():
+    ## The graph
+    builder = StateGraph(AgentState)
+
+    # Define nodes: these do the work
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+
+    # Define edges: these determine how the control flow moves
+    builder.add_edge(START, "assistant")
+    builder.add_conditional_edges(
+        "assistant",
+        # If the latest message requires a tool, route to tools
+        # Otherwise, provide a direct response
+        tools_condition,
+    )
+    builder.add_edge("tools", "assistant")
+    return builder.compile()

app.py

@@ -3,32 +3,43 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from agent import build_agent
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
 
 # (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.")
+        self.agent = build_agent()
+
     def __call__(self, question: 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(content=question)]
+        fixed_answer = self.agent.invoke(messages)
+        if not isinstance(fixed_answer, dict):
+            return "Graph returned an unexpected result format."
+
+        if "messages" in fixed_answer:
+            return fixed_answer["messages"][-1].content
+        return f"Graph returned: {fixed_answer} (missing 'messages')"
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -55,16 +66,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
         print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
     except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
@@ -81,18 +92,36 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             continue
         try:
             submitted_answer = agent(question_text)
-            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})
+            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:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append(
+                {
+                    "Task ID": task_id,
+                    "Question": question_text,
+                    "Submitted Answer": f"AGENT ERROR: {e}",
+                }
+            )
 
     if not answers_payload:
         print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    # 4. Prepare Submission
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
@@ -143,8 +172,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
-    gr.Markdown(
-        """
+    gr.Markdown("""
         **Instructions:**
 
         1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
@@ -155,27 +183,25 @@ with gr.Blocks() as demo:
         **Disclaimers:**
         Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
         This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
-        """
-    )
+        """)
 
     gr.LoginButton()
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    status_output = gr.Textbox(
+        label="Run Status / Submission Result", lines=5, interactive=False
+    )
     # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+    space_id_startup = os.getenv("SPACE_ID")  # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -183,14 +209,18 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    if space_id_startup:  # Print repo URLs if SPACE_ID is found
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+        print(
+            f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main"
+        )
     else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+        print(
+            "ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined."
+        )
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("-" * (60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

requirements.txt

@@ -1,2 +1,11 @@
 gradio
-requests
+requests
+langchain-huggingface
+langchain-community
+langchain-core
+langchain_openai
+langgraph
+ddgs
+pandas
+openpyxl
+pytesseract

retriever.py

@@ -0,0 +1,215 @@
+import requests
+from langchain_core.tools import Tool, tool
+from typing import Optional
+from PIL import Image
+from io import BytesIO
+import base64
+import mimetypes
+import urllib.error
+import urllib.request
+from urllib.parse import urlparse
+import tempfile
+import os
+import pytesseract
+import uuid
+import pandas as pd
+
+local_filename = "downloaded_data.xlsx"
+
+
+# GAIA File Retriver for task_id
+def get_file(task_id: str) -> str:
+    """fetches the file from GAIA API for given task_id"""
+    response = requests.get(
+        f"https://agents-course-unit4-scoring.hf.space/files/{task_id}", timeout=120
+    )
+    return response.content
+
+
+file_retriever_tool = Tool(
+    name="get_file",
+    description="fetches the file from Agent API for given task_id",
+    func=get_file,
+)
+
+
+@tool
+def download_file_from_url(url: str, filename: Optional[str] = None) -> str:
+    """
+    Download a file from a URL and save it to a temporary location.
+    Args:
+        url (str): the URL of the file to download.
+        filename (str, optional): the name of the file. If not provided, a random name file will be created.
+    """
+    try:
+        # Parse URL to get filename if not provided
+        if not filename:
+            path = urlparse(url).path
+            filename = os.path.basename(path)
+            if not filename:
+                filename = f"downloaded_{uuid.uuid4().hex[:8]}"
+
+        # Create temporary file
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, filename)
+
+        # Download the file
+        response = requests.get(url, stream=True, timeout=120)
+        response.raise_for_status()
+
+        # Save the file
+        with open(filepath, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+        return f"File downloaded to {filepath}. You can read this file to process its contents."
+    except Exception as e:
+        return f"Error downloading file: {str(e)}"
+
+
+# text file retriever
+@tool
+def fetch_text_from_url(url: str) -> str:
+    """Fetch the document from a URL"""
+    req = urllib.request.Request(
+        url,
+        headers={"User-Agent": "Mozilla/5.0 (compatible; quickstart-research/1.0)"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=120) as resp:
+            raw = resp.read()
+    except urllib.error.URLError as e:
+        return f"Fetch failed: {e}"
+    text = raw.decode("utf-8", errors="replace")
+    return text
+
+
+# YT Video Frame Retriever
+
+
+# Image Retriever
+@tool
+def image_decoder(img_url: str) -> str:
+    """downaload image from url and generate base64 decoded image url to read in local
+    Args:
+        img_url: url of image to download
+    """
+    try:
+        buffered = BytesIO()
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"
+        }
+        response = requests.get(img_url, headers, timeout=120)
+        mime, _ = mimetypes.guess_type(img_url)
+        image = Image.open(BytesIO(response.content))
+        img_mime = (
+            mime if mime else f"image/{image.format}" if image.format else "image/png"
+        )
+        img_format = image.format if image.format else "PNG"
+        image.save(buffered, format=img_format)
+        img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+        buffered.close()
+        return f"data:{img_mime};base64,{img_base64}"
+    except Exception as e:
+        raise Exception(f"Error fetching image details from {img_url}: {str(e)}")
+
+
+# @tool
+# def extract_image_info(image_url: str) -> dict:
+#     """
+#     Extract text from an image file using a multimodal model.
+
+#     Args:
+#         image_url: The URL of the image to analyze
+
+#     Returns:
+#         A dictionary containing the description, table, and table content
+#     """
+#     try:
+#         img_url = image_decoder(image_url)
+#         all_text = ""
+#         message = [
+#             HumanMessage(
+#                 content=[
+#                     {
+#                         "type": "text",
+#                         "text": (
+#                             "Extract all the text from this image. "
+#                             "Return only the extracted text, no explanations."
+#                         ),
+#                     },
+#                     {
+#                         "type": "image_url",
+#                         "image_url": {"url": img_url},
+#                     },
+#                 ]
+#             )
+#         ]
+
+#         response = vision_llm.invoke(message)
+#         all_text += response.content + "\n\n"
+#         return all_text.strip()
+#     except Exception as e:
+#         return f"Error extracting image details from {image_url}: {str(e)}"
+
+
+@tool
+def extract_image_info(image_url: str) -> str:
+    """
+    Extract text from an image file using a OCR library pytesseract (if available).
+
+    Args:
+        image_url: The URL of the image to analyze
+
+    Returns:
+        A text containing the description of image
+    """
+    # 1. Fetch the image from the URL
+    response = requests.get(image_url, timeout=120)
+
+    # 2. Open the image from the downloaded bytes
+    img = Image.open(BytesIO(response.content))
+
+    # 3. Perform OCR
+    text = pytesseract.image_to_string(img)
+    return text
+
+
+# Excel File Reader
+@tool
+def excel_data_retriever(file_path: str):
+    """Download and read the excel file using given excel file url.
+
+    Args:
+        file_path: path of excel file to process
+    """
+    try:
+        df = pd.read_excel(file_path)
+        df_json = df.to_json()
+        result = (
+            f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+        )
+        result += f"Detailed Info of records as given in JSON format: \n Here the JSON is created by columns, so each key in JOSN represent column names with its values\n {df_json}"
+        print(df.to_json())
+        return result
+    except Exception as e:
+        return f"Error reading excel file {file_path}: {str(e)}"
+
+
+# CSV File Reader
+@tool
+def csv_data_retriever(file_path: str):
+    """Download and read the csv file using given csv file url.
+
+    Args:
+        file_path: path of csv file to process
+    """
+    try:
+        df = pd.read_csv(file_path)
+        df_json = df.to_json()
+        result = f"CSV file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+        result += f"Detailed Info of records as given in JSON format: \n Here the JSON is created by columns, so each key in JOSN represent column names with its values\n {df_json}"
+        print(df.to_json())
+        return result
+    except Exception as e:
+        return f"Error reading CSV file {file_path}: {str(e)}"

tools.py

@@ -0,0 +1,96 @@
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.document_loaders import (
+    WikipediaLoader,
+    ArxivLoader,
+    ImageCaptionLoader,
+)
+from langchain_core.tools import tool
+from typing import List
+import math
+
+# Web_search Tool
+search_tool = DuckDuckGoSearchRun()
+
+
+# Calulator Tool
+@tool(
+    "calculator",
+    description="Performs arithmetic calculations. Use this for any math problems.",
+)
+def calc(expression: str) -> str:
+    """Evaluate mathematical expressions.
+    Args:
+        expression: expression to evaluate
+    """
+    try:
+        cleaned = expression.replace("^", "**").replace(",", "")
+        safe_ns = {k: getattr(math, k) for k in dir(math) if not k.startswith("_")}
+        safe_ns["__builtins__"] = {}
+        result = eval(cleaned, safe_ns)
+        return str(result)
+    except Exception as e:
+        return f"Calculation error: {e}"
+
+
+@tool
+def wiki_search(query: str) -> str:
+    """
+    Search Wikipedia for a query and return maximum 2 results.
+    Args:
+        query: The search query.
+    """
+    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    formatted_search_docs = "\n\n----\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"wiki_results": formatted_search_docs}
+
+
+@tool
+def arxiv_search(query: str) -> str:
+    """
+    Search Arxiv for a query and return maximum 3 result.
+    Args:
+        query: The search query.
+    """
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    formatted_search_docs = "\n\n----\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"arxiv_results": formatted_search_docs}
+
+
+@tool
+def run_python_code(code_str: str) -> str:
+    """Executes the provided Python code string and returns the result."""
+    try:
+        exec_globals = {}
+        exec(code_str, exec_globals)
+        return str(exec_globals.get("result", "Execution successful"))
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+@tool
+def get_image_captioning(list_image_urls: List[str]) -> str:
+    """
+    generate captions for images
+
+    Args:
+        list_image_urls: list of image urls to process
+    """
+    try:
+        loader = ImageCaptionLoader(images=list_image_urls)
+        list_docs = loader.load()
+        result = "Captions for given images: \n"
+        for doc in list_docs:
+            result += f"Image: {doc.metadata.__str__()}, Caption:{doc.page_content}"
+        return result
+    except Exception as e:
+        return f"Image captioning failied: {str(e)}"