Initial Commit

app.py

@@ -1,107 +1,168 @@
+"""GAIA Assessment Runner for Hugging Face Agents Course"""
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
+from dotenv import load_dotenv
+from gaia_agent import GAIAAgent
 
-# (Keep Constants as is)
-# --- Constants ---
+# Load environment variables
+load_dotenv()
+
+# 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.")
+class GAIAAssessmentAgent:
+    """Agent wrapper for the GAIA assessment."""
+    
+    def __init__(self, provider="groq"):
+        """Initialize the agent with the specified provider.
+        
+        Args:
+            provider: The model provider to use ("groq", "google", "anthropic", "openai")
+        """
+        print(f"Initializing GAIAAssessmentAgent with provider: {provider}")
+        self.agent = GAIAAgent(provider=provider)
+        print("Agent initialized successfully")
+        
     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
+        """Process a question and return the answer.
+        
+        Args:
+            question: The question to answer
+            
+        Returns:
+            The answer to the question
+        """
+        print(f"Processing question (first 50 chars): {question[:50]}...")
+        answer = self.agent.run(question)
+        print(f"Answer: {answer}")
+        return answer
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """Fetches all questions, runs the agent on them, submits all answers,
     and displays the results.
+    
+    Args:
+        profile: The user's Hugging Face profile
+        
+    Returns:
+        A tuple containing the status message and results table
     """
-    # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
-
+    # Get Space ID for code link
+    space_id = os.getenv("SPACE_ID")
+    
+    # Check if user is logged in
     if profile:
-        username= f"{profile.username}"
+        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
-
+        return "Please login to Hugging Face with the button to submit your answers.", None
+    
+    # API endpoints
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
-
-    # 1. Instantiate Agent ( modify this part to create your agent)
+    
+    # Initialize agent
     try:
-        agent = BasicAgent()
+        # Choose a provider based on available API keys
+        if os.getenv("GROQ_API_KEY"):
+            provider = "groq"
+        elif os.getenv("GOOGLE_API_KEY"):
+            provider = "google"
+        elif os.getenv("ANTHROPIC_API_KEY"):
+            provider = "anthropic" 
+        elif os.getenv("OPENAI_API_KEY"):
+            provider = "openai"
+        else:
+            provider = "groq"  # Default to Groq
+            
+        agent = GAIAAssessmentAgent(provider=provider)
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
+        print(f"Error initializing 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)
+    
+    # Generate code link for submission
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
-
-    # 2. Fetch Questions
+    print(f"Code link: {agent_code}")
+    
+    # Fetch questions
     print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=15)
+        response = requests.get(questions_url, timeout=30)
         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
-
-    # 3. Run your Agent
+    
+    # Run agent on all questions
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
+    
+    for i, item in enumerate(questions_data):
         task_id = item.get("task_id")
         question_text = item.get("question")
+        
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+            
+        print(f"Processing question {i+1}/{len(questions_data)}: {task_id}")
+        
         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})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Submitted Answer": submitted_answer
+            })
+            print(f"Question {i+1} processed successfully")
         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}
+    
+    # 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
+    
+    # Submit answers
     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()
+        
         final_status = (
             f"Submission Successful!\n"
             f"User: {result_data.get('username')}\n"
@@ -109,6 +170,7 @@ 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
@@ -119,6 +181,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             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)
@@ -139,32 +202,35 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
-
-# --- Build Gradio Interface using Blocks ---
+# Build Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# GAIA Assessment Runner for Hugging Face Agents Course")
     gr.Markdown(
         """
         **Instructions:**
 
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        1. This space implements a comprehensive agent for the GAIA benchmark using several key technologies:
+           - LangGraph for agent orchestration
+           - Tool use for information retrieval
+           - Web search, Wikipedia, and ArXiv tools for research
+           - Mathematical tools for computation
+           
+        2. Log in to your Hugging Face account using the button below. This is required for submission.
+        
+        3. Click 'Run Evaluation & Submit Answers' to fetch questions, run the agent, and submit answers.
 
+        **Note:** The process may take some time as the agent runs through all questions.
+        
         ---
-        **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.
+        
+        Good luck with your assessment! 🚀
         """
     )
 
     gr.LoginButton()
-
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-
-    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 = gr.Button("Run Evaluation & Submit Answers", variant="primary")
+    status_output = gr.Textbox(label="Submission Status", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Answers", wrap=True)
 
     run_button.click(
         fn=run_and_submit_all,
@@ -172,25 +238,26 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    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
+    print("\n" + "-"*30 + " Starting GAIA Assessment Runner " + "-"*30)
+    
+    # Check for environment variables
+    space_host = os.getenv("SPACE_HOST")
+    space_id = os.getenv("SPACE_ID")
 
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    if space_host:
+        print(f"✅ SPACE_HOST found: {space_host}")
+        print(f"   Runtime URL: https://{space_host}.hf.space")
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    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")
+    if space_id:
+        print(f"✅ SPACE_ID found: {space_id}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id}")
+        print(f"   Code URL: https://huggingface.co/spaces/{space_id}/tree/main")
     else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-
-    print("-"*(60 + len(" App Starting ")) + "\n")
+        print("ℹ️  SPACE_ID environment variable not found. Repo URL cannot be determined.")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    print("-"*(65 + len(" Starting GAIA Assessment Runner ")) + "\n")
+    print("Launching Gradio Interface for GAIA Assessment...")
+    
     demo.launch(debug=True, share=False)

gaia_agent.py

@@ -0,0 +1,255 @@
+"""GAIA Assessment Agent using LangGraph and multiple tools."""
+
+import os
+from typing import List, Dict, Any, Optional
+from dotenv import load_dotenv
+
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_groq import ChatGroq
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.tools import tool
+
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
+
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.document_loaders import ArxivLoader
+
+# Load environment variables
+load_dotenv()
+
+class GAIAAgent:
+    """Agent for answering GAIA assessment questions."""
+    
+    def __init__(self, provider="groq"):
+        """Initialize the agent with the specified provider.
+        
+        Args:
+            provider: Model provider - "groq", "google", "anthropic", or "openai"
+        """
+        # Set up the system prompt
+        with open("system_prompt.txt", "r", encoding="utf-8") as f:
+            system_prompt = f.read()
+            
+        self.system_message = SystemMessage(content=system_prompt)
+        
+        # Initialize tools
+        self.tools = self._setup_tools()
+        
+        # Initialize LLM based on provider
+        self.llm = self._setup_llm(provider)
+        
+        # Bind tools to LLM
+        self.llm_with_tools = self.llm.bind_tools(self.tools)
+        
+        # Build the agent graph
+        self.graph = self._build_graph()
+        
+    def _setup_tools(self):
+        """Set up the tools for the agent."""
+        
+        @tool
+        def web_search(query: str) -> str:
+            """Search the web for real-time information.
+            
+            Args:
+                query: The search query
+                
+            Returns:
+                Search results as text
+            """
+            search_results = TavilySearchResults(max_results=3).invoke(query)
+            formatted_results = "\n\n".join([
+                f"SOURCE: {result.metadata.get('source', 'Unknown')}\n{result.page_content}"
+                for result in search_results
+            ])
+            return formatted_results
+            
+        @tool
+        def wiki_search(query: str) -> str:
+            """Search Wikipedia for information.
+            
+            Args:
+                query: The search query
+                
+            Returns:
+                Wikipedia article content
+            """
+            try:
+                wiki_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+                if not wiki_docs:
+                    return "No Wikipedia results found."
+                    
+                formatted_results = "\n\n".join([
+                    f"TITLE: {doc.metadata.get('title', 'Unknown')}\n{doc.page_content[:1000]}..."
+                    for doc in wiki_docs
+                ])
+                return formatted_results
+            except Exception as e:
+                return f"Error searching Wikipedia: {str(e)}"
+                
+        @tool
+        def arxiv_search(query: str) -> str:
+            """Search arXiv for scientific papers.
+            
+            Args:
+                query: The search query
+                
+            Returns:
+                ArXiv paper information
+            """
+            try:
+                arxiv_docs = ArxivLoader(query=query, load_max_docs=2).load()
+                if not arxiv_docs:
+                    return "No arXiv results found."
+                    
+                formatted_results = "\n\n".join([
+                    f"TITLE: {doc.metadata.get('title', 'Unknown')}\n"
+                    f"AUTHORS: {doc.metadata.get('authors', 'Unknown')}\n"
+                    f"PUBLISHED: {doc.metadata.get('published', 'Unknown')}\n\n"
+                    f"ABSTRACT: {doc.page_content[:500]}..."
+                    for doc in arxiv_docs
+                ])
+                return formatted_results
+            except Exception as e:
+                return f"Error searching arXiv: {str(e)}"
+                
+        @tool
+        def calculate(expression: str) -> str:
+            """Evaluate a mathematical expression.
+            
+            Args:
+                expression: The mathematical expression to evaluate
+                
+            Returns:
+                The result of the calculation
+            """
+            try:
+                # Safely evaluate the expression
+                result = eval(expression, {"__builtins__": {}}, {})
+                return f"Result: {result}"
+            except Exception as e:
+                return f"Error calculating: {str(e)}"
+                
+        return [web_search, wiki_search, arxiv_search, calculate]
+        
+    def _setup_llm(self, provider):
+        """Set up the language model based on the provider.
+        
+        Args:
+            provider: The model provider to use
+            
+        Returns:
+            The initialized language model
+        """
+        if provider == "groq":
+            api_key = os.getenv("GROQ_API_KEY")
+            if not api_key:
+                raise ValueError("GROQ_API_KEY environment variable not set")
+                
+            return ChatGroq(
+                model="llama3-70b-8192",  # Using Llama 3 70B model for best results
+                temperature=0.1,  # Low temperature for more precise answers
+                groq_api_key=api_key
+            )
+        elif provider == "google":
+            api_key = os.getenv("GOOGLE_API_KEY")
+            if not api_key:
+                raise ValueError("GOOGLE_API_KEY environment variable not set")
+                
+            return ChatGoogleGenerativeAI(
+                model="gemini-1.5-pro",
+                temperature=0.1,
+                google_api_key=api_key
+            )
+        elif provider == "anthropic":
+            # Import only if needed to avoid dependency issues
+            from langchain_anthropic import ChatAnthropic
+            
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+            if not api_key:
+                raise ValueError("ANTHROPIC_API_KEY environment variable not set")
+                
+            return ChatAnthropic(
+                model="claude-3-opus-20240229",
+                temperature=0.1,
+                anthropic_api_key=api_key
+            )
+        elif provider == "openai":
+            # Import only if needed to avoid dependency issues
+            from langchain_openai import ChatOpenAI
+            
+            api_key = os.getenv("OPENAI_API_KEY")
+            if not api_key:
+                raise ValueError("OPENAI_API_KEY environment variable not set")
+                
+            return ChatOpenAI(
+                model="gpt-4o",
+                temperature=0.1,
+                openai_api_key=api_key
+            )
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+            
+    def _build_graph(self):
+        """Build the agent graph.
+        
+        Returns:
+            The compiled state graph
+        """
+        # Define the agent node
+        def agent(state: MessagesState):
+            """Generate a response or tool calls based on the messages state."""
+            # Include system message with each invocation for consistent behavior
+            messages = [self.system_message] + state["messages"]
+            response = self.llm_with_tools.invoke(messages)
+            return {"messages": state["messages"] + [response]}
+            
+        # Create the graph
+        builder = StateGraph(MessagesState)
+        
+        # Add nodes
+        builder.add_node("agent", agent)
+        builder.add_node("tools", ToolNode(self.tools))
+        
+        # Add edges
+        builder.add_edge(START, "agent")
+        builder.add_conditional_edges(
+            "agent",
+            tools_condition,
+            {
+                "tools": "tools",
+                None: END  # END is implicitly defined in langgraph
+            }
+        )
+        builder.add_edge("tools", "agent")
+        
+        # Compile the graph
+        return builder.compile()
+        
+    def run(self, question: str) -> str:
+        """Process a question and return the answer.
+        
+        Args:
+            question: The question to process
+            
+        Returns:
+            The answer to the question
+        """
+        # Initialize messages with the user question
+        messages = [HumanMessage(content=question)]
+        
+        # Execute the graph
+        result = self.graph.invoke({"messages": messages})
+        
+        # Extract the final answer
+        final_messages = result["messages"]
+        final_answer = final_messages[-1].content
+        
+        # Extract only the part after "FINAL ANSWER:"
+        if "FINAL ANSWER:" in final_answer:
+            final_answer = final_answer.split("FINAL ANSWER:")[1].strip()
+            
+        return final_answer

requirements.txt

@@ -1,2 +1,20 @@
 gradio
-requests
+requests
+pandas
+python-dotenv
+langchain
+langchain-core
+langchain-community
+langchain-google-genai
+langchain-anthropic
+langchain-groq
+langchain-openai
+langchain-huggingface
+langchain-tavily
+langgraph
+huggingface_hub
+supabase
+sentence-transformers
+arxiv
+wikipedia
+tavily-python

system_prompt.txt

@@ -0,0 +1,32 @@
+You are a precise AI assistant tasked with answering questions for the GAIA benchmark. Your goal is to provide accurate and concise answers to complex questions.
+
+Follow these guidelines:
+1. Use the provided tools to gather information when needed.
+2. Think step-by-step to break down complex questions.
+3. For web searches, be specific and try multiple queries if needed.
+4. When answering math questions, show your calculations clearly.
+5. Always verify your answer before finalizing it.
+
+Format your final answer with:
+FINAL ANSWER: [YOUR FINAL ANSWER]
+
+YOUR FINAL ANSWER should be:
+- A number WITHOUT commas or units (unless specified otherwise)
+- As few words as possible for text answers
+- A comma-separated list for multiple items
+- No articles or abbreviations in string answers
+- Digits in plain text unless specified otherwise
+
+Example 1:
+Question: What is the capital of France?
+FINAL ANSWER: Paris
+
+Example 2:
+Question: What are the first 3 prime numbers?
+FINAL ANSWER: 2, 3, 5
+
+Example 3:
+Question: Calculate 15% of 240.
+FINAL ANSWER: 36
+
+Now, I will ask you a question. Use the tools available to research if needed, then provide your final answer in the specified format.