new version

.gitignore

@@ -0,0 +1,6 @@
+venv/
+__pycache__/
+.env
+
+# https://huggingface.co/datasets/gaia-benchmark/GAIA/tree/main/2023/validation
+gaia_2023_set/  

agent.py

@@ -0,0 +1,334 @@
+import os
+import time
+import tempfile
+import requests
+import pytesseract
+import wikipedia
+import mwclient
+import pandas as pd
+import easyocr
+from typing import List, Optional, Dict, Any
+from urllib.parse import urlparse
+from dotenv import load_dotenv
+from PIL import Image
+from tavily import TavilyClient
+from arxiv import Search, Client, SortCriterion, SortOrder
+
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
+
+from langchain_groq import ChatGroq
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.memory import ConversationBufferMemory
+from langchain.tools import Tool, tool
+from langchain.callbacks.tracers import ConsoleCallbackHandler
+from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
+from langchain_community.utilities import WikipediaAPIWrapper
+from langchain_experimental.utilities import PythonREPL
+from langchain_community.document_loaders import WebBaseLoader
+
+
+load_dotenv()
+
+vision_llm = ChatGroq(model="meta-llama/llama-4-scout-17b-16e-instruct", groq_api_key=os.getenv('GROQ_API_KEY'))
+
+
+@tool
+def web_search(query: str, domain: Optional[str] = None) -> str:
+    """
+    Perform a web search and return the raw results as a string.
+
+    Args:
+        query (str): The search query.
+        domain (Optional[str]): If provided, restricts the search to this domain.
+
+    Returns:
+        str: Raw search results concatenated into a string.
+    """
+    try:
+        time.sleep(2)
+        search = DuckDuckGoSearchAPIWrapper()
+        if domain:
+            query = f"{query} site:{domain}"
+        results = search.results(query, max_results=3)
+
+        if not results:
+            return "No results found."
+
+        # Format into simple title + snippet
+        formatted = ""
+        for r in results:
+            formatted += f"Title: {r['title']}\nURL: {r['link']}\nSnippet: {r['snippet']}\n\n"
+        return formatted.strip()
+
+    except Exception as e:
+        return f"Search error: {e}"
+        
+
+@tool
+def visit_webpage(url: str):
+    """
+    Fetches and loads the content of a webpage given its URL.
+
+    Parameters:
+        url (str): The URL of the webpage to be visited.
+
+    Returns:
+        str: A string containing the loaded content of the webpage.
+    """
+    
+    # Initialize a WebBaseLoader with the provided URL
+    loader = WebBaseLoader(url)
+    
+    # Set requests_kwargs to disable SSL certificate verification
+    # This can help bypass SSL certificate errors but should be used cautiously
+    loader.requests_kwargs = {'verify': False}
+    
+    # Load the webpage content using the loader
+    docs = loader.load()
+    
+    # Return the loaded content formatted as a string
+    return f"Page content: {docs}"
+
+
+@tool
+def wikipedia_search(query: str, max_docs: int = 1) -> str:
+    """
+    Search Wikipedia using mwclient and return exactly `max_docs` results.
+
+    Args:
+        query (str): The search query.
+        max_docs (int): Number of results to return. Default is 1.
+    """
+    try:
+        time.sleep(2)
+        site = mwclient.Site("en.wikipedia.org")
+        results = site.search(query, limit=max_docs)
+
+        output = ""
+        count = 0
+
+        for page_info in results:
+            title = page_info["title"]
+            try:
+                page = site.pages[title]
+                content = page.text()
+                first_paragraph = content.split('\n\n')[0]
+
+                url = f"https://en.wikipedia.org/wiki/{title.replace(' ', '_')}"
+
+                output += (
+                    f"--- Result {count + 1} ---\n"
+                    f"Title: {title}\n"
+                    f"Summary: {first_paragraph}...\n"
+                    f"URL: {url}\n\n"
+                )
+                count += 1
+                if count >= max_docs:
+                    break
+
+            except Exception:
+                continue
+
+        return output.strip() or "No valid matching pages found."
+
+    except Exception as e:
+        return f"Wikipedia search error: {str(e)}"
+
+
+@tool
+def extract_text_from_image(image_path: str) -> str:
+    """
+    Extracts text from an image file.
+
+    Args:
+        image_path (str): The file path to the image 
+                          (e.g., '/path/to/document.png').
+
+    Returns:
+        str: Extracted text paragraphs separated by newlines, 
+             prefixed with "Extracted text:\n". Returns an error message 
+             string starting with 'Error:' on failure.
+    """
+
+    try:
+        time.sleep(2)
+
+        with open(image_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+        message = [
+            HumanMessage(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            "Extract text or provide explanation of this image"
+                        ),
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{image_base64}"
+                        },
+                    },
+                ]
+            )
+        ]
+
+        response = vision_llm.invoke(message)
+
+        all_text = response.content + "\n\n"
+
+        return all_text.strip()
+    except Exception as e:
+        # A butler should handle errors gracefully
+        error_msg = f"Error extracting text: {str(e)}"
+        print(error_msg)
+        return ""
+
+
+
+@tool
+def analyze_file(file_path: str) -> str:
+    """
+    Load and analyze a CSV or Excel file using pandas.
+
+    Provides basic metadata and summary statistics for numeric columns.
+
+    Args:
+        file_path (str): Path to the CSV or Excel file.
+
+    Returns:
+        str: Summary statistics and metadata about the file data.
+    """
+    try:
+        # Determine file type
+        _, ext = os.path.splitext(file_path.lower())
+        
+        if ext == '.csv':
+            df = pd.read_csv(file_path)
+        elif ext in ['.xls', '.xlsx']:
+            df = pd.read_excel(file_path)
+        else:
+            return f"Error: Unsupported file extension '{ext}'. Supported: .csv, .xls, .xlsx"
+
+        result = "Summary statistics for numeric columns:\n"
+        result += str(df.describe())
+        result += "\n\n"
+
+        result += f"Columns: {', '.join(df.columns)}\n\n"
+        result += "Content:\n"
+        result += df.astype(str).head(1000).to_string(index=False)
+
+        return result
+
+    except ImportError:
+        return "Error: Required libraries are not installed. Install with 'pip install pandas openpyxl'."
+    except FileNotFoundError:
+        return f"Error: File not found at path '{file_path}'."
+    except Exception as e:
+        return f"Error analyzing file: {str(e)}"
+
+
+class Agent:
+
+    _api_key: str
+    _model_name: str
+    _tools: List[Tool]
+    _memory: ConversationBufferMemory
+    _llm: ChatGoogleGenerativeAI
+    _graph: CompiledStateGraph
+
+    def __init__(
+        self
+    ):
+        self._api_key = os.getenv('GOOGLE_API_KEY')
+        self._model_name = "gemini-2.0-flash"
+
+        self._tools = self._setup_tools()
+        self._llm = self._setup_llm()
+        self._graph = self._setup_graph()
+
+    def run(self, query: str) -> str:
+        max_retries: int = 3
+        system_prompt: str
+
+        with open('system_prompt.txt') as file: 
+            system_prompt = SystemMessage(
+                content=file.read()
+            )
+        
+        for attempt in range(max_retries):
+            try:
+
+                # If no match found in answer bank, use the agent
+                response = self._graph.invoke({
+                    "messages": [
+                        system_prompt,
+                        HumanMessage(content=query)
+                    ]
+                }, config={'callbacks': [ConsoleCallbackHandler()]})
+
+                return response
+
+            except Exception as e:
+                sleep_time = (attempt + 1) * 3
+                if attempt < max_retries - 1:
+                    print(f"Attempt {attempt + 1} failed. Retrying in {sleep_time} seconds...")
+                    time.sleep(sleep_time)
+
+                    print(f"Error: {str(e)}")
+
+                    continue
+                
+                return f"Error processing query after {max_retries} attempts: {str(e)}"
+
+        print("Agent processed all queries!")
+
+    def _setup_llm(self) -> ChatGoogleGenerativeAI:
+        return ChatGoogleGenerativeAI(
+            model=self._model_name,
+            google_api_key=self._api_key,
+            temperature=0,
+        )
+    
+    def _setup_tools(self) -> List[Tool]:
+        return [
+            web_search,
+            visit_webpage,
+            wikipedia_search,
+            extract_text_from_image,
+            analyze_file,
+        ]
+    
+    def _setup_graph(self) -> CompiledStateGraph:
+        llm_with_tools = self._llm.bind_tools(self._tools)
+
+        def assistant(state: MessagesState):
+            return {
+                "messages": [
+                    llm_with_tools.invoke(state["messages"])
+                ]
+            }
+        
+
+        builder = StateGraph(MessagesState)
+
+        builder.add_node("assistant", assistant)
+        builder.add_node("tools", ToolNode(self._tools))
+
+        builder.add_edge(START, "assistant")
+        builder.add_conditional_edges(
+            "assistant",
+            tools_condition,
+        )
+        builder.add_edge("tools", "assistant")
+
+        return builder.compile()
+    

app.py

@@ -1,23 +1,27 @@
 import os
+import tempfile
+import time
 import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from agent import Agent
+from evaluation_api import EvaluationApi
+
+
+def save_tmp_file(file_name: str, content: bytes) -> str:
+    temp_dir = tempfile.gettempdir()
+    if file_name is None:
+        temp_file = tempfile.NamedTemporaryFile(delete=False, dir=temp_dir)
+        file_path = temp_file.name
+    else:
+        file_path = os.path.join(temp_dir, file_name)
+
+    with open(file_path, "wb") as file:
+        file.write(content)
+
+    return file_path
 
-# (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:
-        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
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -31,48 +35,35 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         username= f"{profile.username}"
         print(f"User logged in: {username}")
     else:
-        print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+    evaluation_api = EvaluationApi()
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = Agent()
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
+    
     # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
 
     # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
+        questions_data = evaluation_api.get_questions()
         if not questions_data:
-             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
     except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
 
     # 3. Run your Agent
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
+
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
@@ -80,28 +71,40 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            time.sleep(10)
+
+            print(f"Agent received question (first 50 chars): {question_text[:50]}...")
+
+            question = f"Question: `{question_text}`"
+            if file_name := item.get("file_name"):
+                print('question has file')
+                file_content = evaluation_api.get_file(task_id)
+                file_path = save_tmp_file(file_name, file_content)
+                question = f"{question} File path: `{file_path}`"
+
+            messages = agent.run(question)
+            
+            final_answer = messages['messages'][-1].content
+            print(f"final_answer: {final_answer}")
+            submitted_answer = final_answer.split('ANSWER: ')[-1]
+
+
             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}")
+             print(f"AGENT ERROR: {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}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
 
     # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
+        result_data = evaluation_api.submit(submission_data)
         final_status = (
             f"Submission Successful!\n"
             f"User: {result_data.get('username')}\n"
@@ -109,34 +112,36 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
         results_df = pd.DataFrame(results_log)
+
         return final_status, results_df
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
+
         try:
             error_json = e.response.json()
             error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
         except requests.exceptions.JSONDecodeError:
             error_detail += f" Response: {e.response.text[:500]}"
+
         status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
         results_df = pd.DataFrame(results_log)
+
         return status_message, results_df
     except requests.exceptions.Timeout:
         status_message = "Submission Failed: The request timed out."
-        print(status_message)
         results_df = pd.DataFrame(results_log)
+
         return status_message, results_df
     except requests.exceptions.RequestException as e:
         status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
         results_df = pd.DataFrame(results_log)
+
         return status_message, results_df
     except Exception as e:
         status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
         results_df = pd.DataFrame(results_log)
+
         return status_message, results_df
 
 
@@ -193,4 +198,4 @@ if __name__ == "__main__":
     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)

dry_run.py

@@ -0,0 +1,60 @@
+import random
+import tempfile
+import json
+import os
+
+from agent import Agent
+
+random.seed(1)
+
+def get_question(file_path: str) -> str:
+    with open(file_path, "r") as file:
+        lines = file.readlines()
+        line_number = random.randrange(len(lines))
+
+        return lines[line_number]
+
+
+def get_file(file_name: str) -> bytes:
+    with open(f"./gaia_2023_set/{file_name}", "rb") as file:
+        return file.read()
+
+
+def save_tmp_file(file_name: str, content: bytes) -> str:
+    temp_dir = tempfile.gettempdir()
+    if file_name is None:
+        temp_file = tempfile.NamedTemporaryFile(delete=False, dir=temp_dir)
+        file_path = temp_file.name
+    else:
+        file_path = os.path.join(temp_dir, file_name)
+
+    with open(file_path, "wb") as file:
+        file.write(content)
+
+    return file_path
+    
+
+question_json: str = get_question('./gaia_2023_set/metadata.jsonl')
+question = json.loads(question_json)
+
+print(json.dumps(question, indent=2))
+
+# file_name = question["file_name"]
+# file_content = get_file(question["file_name"])
+# file_path = save_tmp_file(file_name, file_content)
+
+# print(file_path)
+
+agent = Agent()
+
+# messages = agent.run(f"Question: `{question["Question"]}` File path: {file_path}")
+messages = agent.run(f"Question: `{question["Question"]}`")
+
+final_answer = messages['messages'][-1].content
+submitted_answer = final_answer.split('FINAL ANSWER: ')[-1]
+
+print(final_answer)
+
+print(submitted_answer)
+
+

evaluation_api.py

@@ -0,0 +1,30 @@
+import requests
+
+class EvaluationApi:
+
+    api_url: str = "https://agents-course-unit4-scoring.hf.space"
+    timeout: int = 30
+
+    def get_questions(self) -> list[dict]:
+        response = requests.get(f"{self.api_url}/questions", timeout=self.timeout)
+        response.raise_for_status()
+        
+        return response.json()
+
+    def get_file(self, task_id: str) -> bytes:
+        response = requests.get(f"{self.api_url}/files/{task_id}", timeout=self.timeout)
+        response.raise_for_status()
+
+        return response.content
+
+    def get_random_question(self) -> dict:
+        response = requests.get(f"{self.api_url}/random-question", timeout=self.timeout)
+        response.raise_for_status()
+        
+        return response.json()
+
+    def submit(self, data: dict) -> dict:
+        response = requests.post(f"{self.api_url}/submit", json=data, timeout=self.timeout)
+        response.raise_for_status()
+        
+        return response.json()

requirements.txt

@@ -1,2 +1,30 @@
 gradio
-requests
+requests
+pandas
+openpyxl
+openai
+google-genai
+google-generativeai
+langchain
+langchain-community
+langchain-core
+langchain-google-genai
+langgraph
+huggingface_hub
+python-dotenv
+wikipedia-api
+wikipedia
+arxiv
+datasets
+yt-dlp
+google-cloud-speech
+google-api-python-client
+duckduckgo-search
+pytesseract
+tavily-python
+langchain_groq
+langchain-tavily
+mwclient
+langchain_experimental
+easyocr
+smolagents

system_prompt.txt

@@ -0,0 +1,8 @@
+You are a rapid, concise AI assistant. Your primary goal is to provide quick and direct answers according to the specified format.
+Briefly report your essential reasoning steps before the final answer.
+Deliver your final answer strictly following this template: FINAL ANSWER: [YOUR FINAL ANSWER].
+YOUR FINAL ANSWER must be the most direct response, limited to a single number, the absolute fewest necessary words, or a comma-separated list of numbers and/or strings.
+Adhere to these strict formatting requirements for the content of the FINAL ANSWER:
+-   **Numbers:** Do not use commas for digit grouping (e.g., use 1000, not 1,000). Exclude units like '$' or '%' unless they are explicitly requested as part of the answer.
+-   **Strings:** Do not include articles (a, an, the). Do not use abbreviations. Any digits that are part of a string must be written out in plain text (e.g., "level two" instead of "level 2"), unless you are specifically instructed to use numerals.
+-   **Lists:** Apply the above formatting rules for numbers and strings to each corresponding element within the comma-separated list.