maybe I start to understand something

app.py

@@ -1,168 +1,273 @@
 import os
+import re
 import gradio as gr
 import requests
 import pandas as pd
 import torch
-import base64
-from io import BytesIO
-import numexpr  # Using a dedicated and safe math library
-
-from llama_index.core.tools import FunctionTool
-from llama_index.llms.huggingface import HuggingFaceLLM
-from llama_index.core.agent import ReActAgent
-from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
-from youtube_transcript_api import YouTubeTranscriptApi
-from PIL import Image
+from transformers import pipeline
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFacePipeline
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.tools import tool
+from langgraph.graph import StateGraph, END
+from typing import TypedDict, Annotated, List
+from langchain_community.document_loaders.youtube import YoutubeLoader
+import numexpr
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-IMAGE_ANALYSIS_API_URL = (
-    "https://api-inference.huggingface.co/models/llava-hf/llava-1.5-7b-hf"
-)
+SYSTEM_PROMPT = """You are a helpful assistant tasked with answering questions.
+
+You have access to a set of tools to help you. The question you receive may require you to use these tools.
+When you receive a question, you should first think about what steps you need to take.
+Based on your plan, you can then call the necessary tools.
+After calling a tool, you will get a result. You should analyze the result and decide if you need to call another tool or if you have enough information to answer the question.
+
+When you have the final answer, you must output it in the following format:
+FINAL ANSWER: [YOUR FINAL ANSWER]
 
-# --- Helper Functions for Tools ---
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma-separated list of numbers and/or strings.
+- If you are asked for a number, do not use commas for thousands separators or units like '$' or '%' unless specified.
+- If you are asked for a string, do not use articles or abbreviations (e.g., for cities).
+- If you are asked for a comma-separated list, apply the above rules to each element.
 
-# HF_TOKEN must be set as a Space Secret in Hugging Face
-HF_TOKEN = os.getenv("HF_TOKEN")
+Example:
+Question: What is the capital of France?
+Your thought process: I need to find the capital of France. I will use the web search tool.
+Tool call: web_search("capital of France")
+Tool output: Paris is the capital of France.
+Your final answer: FINAL ANSWER: Paris
+"""
+
+# --- Tool Definitions ---
 
 
-def get_video_transcript(youtube_url: str):
-    """Fetches the transcript of a YouTube video given its URL."""
+@tool
+def web_search(query: str):
+    """Searches the web using DuckDuckGo."""
+    print(f"--- Calling Web Search Tool with query: {query} ---")
+    search = DuckDuckGoSearchRun()
+    return search.run(query)
+
+
+@tool
+def math_calculator(expression: str):
+    """Calculates the result of a mathematical expression."""
+    print(f"--- Calling Math Calculator Tool with expression: {expression} ---")
     try:
-        if "v=" not in youtube_url:
-            return "Error: Invalid YouTube URL, missing 'v='."
-        video_id = youtube_url.split("v=")[1].split("&")[0]
-        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
-        transcript = " ".join([d["text"] for d in transcript_list])
-        return transcript
+        # Use numexpr for safe evaluation
+        result = numexpr.evaluate(expression).item()
+        return result
     except Exception as e:
-        return f"Error fetching transcript: {e}"
+        return f"Error evaluating expression: {e}"
 
 
-def analyze_image_url(image_url: str, question: str):
-    """Analyzes an image from a URL using the Hugging Face Inference API."""
-    if not HF_TOKEN:
-        return (
-            "Error: Hugging Face token is not set. Cannot use the image analysis tool."
-        )
+@tool
+def image_analyzer(image_url: str):
+    """Analyzes an image and returns a description."""
+    print(f"--- Calling Image Analyzer Tool with URL: {image_url} ---")
     try:
-        response = requests.get(image_url)
-        response.raise_for_status()
-        image_bytes = BytesIO(response.content).getvalue()
-        headers = {"Authorization": f"Bearer {HF_TOKEN}", "Content-Type": "image/png"}
-        response = requests.post(
-            IMAGE_ANALYSIS_API_URL, headers=headers, data=image_bytes
+        # Using a CPU-friendly image-to-text model
+        image_to_text = pipeline(
+            "image-to-text", model="Salesforce/blip-image-captioning-base"
         )
-        response.raise_for_status()
-        result = response.json()
-        generated_text = result[0].get("generated_text", "").strip()
-        final_answer = generated_text.split("ASSISTANT:")[-1].strip()
-        return f"The image description is: {final_answer}. Now, answer the original question based on this."
+        description = image_to_text(image_url)[0]["generated_text"]
+        return description
     except Exception as e:
         return f"Error analyzing image: {e}"
 
 
-# NEW: A custom, reliable math tool using a safe evaluator
-def evaluate_math_expression(expression: str):
-    """Evaluates a mathematical expression safely."""
+@tool
+def youtube_transcript_reader(youtube_url: str):
+    """Reads the transcript of a YouTube video."""
+    print(f"--- Calling YouTube Transcript Reader Tool with URL: {youtube_url} ---")
     try:
-        # Using numexpr for safe evaluation of numerical expressions
-        result = numexpr.evaluate(expression).item()
-        return result
+        loader = YoutubeLoader.from_youtube_url(youtube_url, add_video_info=False)
+        docs = loader.load()
+        transcript = " ".join([doc.page_content for doc in docs])
+        # Return a manageable chunk of the transcript
+        return transcript[:4000]
     except Exception as e:
-        return f"Error evaluating expression: {e}"
+        return f"Error reading YouTube transcript: {e}"
 
 
-# --- Tool Definitions ---
-youtube_tool = FunctionTool.from_defaults(
-    fn=get_video_transcript,
-    name="youtube_transcript_tool",
-    description="Use this tool to get the transcript of a YouTube video.",
-)
-image_analyzer_tool = FunctionTool.from_defaults(
-    fn=analyze_image_url,
-    name="image_analyzer_tool",
-    description="Use this tool to analyze an image when you are given a URL. Provide both the image URL and the question about the image.",
-)
-math_tool = FunctionTool.from_defaults(
-    fn=evaluate_math_expression,
-    name="math_evaluator_tool",
-    description="Use this tool to evaluate simple mathematical expressions (e.g., '3 * (4 + 2)').",
-)
-
-
-# --- LlamaIndex Agent Definition ---
-class LlamaIndexAgent:
+# --- Agent State Definition ---
+class AgentState(TypedDict):
+    question: str
+    messages: Annotated[list, lambda x, y: x + y]
+    sender: str
+
+
+# --- LangGraph Agent Definition ---
+class GaiaAgent:
     def __init__(self):
-        print("Initializing LlamaIndexAgent with Final Tools...")
-        ddg_spec = DuckDuckGoSearchToolSpec()
+        print("Initializing GaiaAgent...")
         self.tools = [
-            youtube_tool,
-            image_analyzer_tool,
-            math_tool,
-        ] + ddg_spec.to_tool_list()
-        system_prompt = """
-        You are a helpful assistant tasked with answering questions.
-        You have access to a set of tools to help you. These tools include:
-        - A web search tool.
-        - A YouTube video transcriber.
-        - An image analyzer for URLs.
-        - A safe calculator for mathematical expressions.
-        Use a tool if it is helpful. When you have the final answer, you MUST use the following template: FINAL ANSWER: [YOUR FINAL ANSWER].
-        YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list.
-        """
-        self.llm = HuggingFaceLLM(
-            model_name="HuggingFaceH4/zephyr-7b-beta",
-            tokenizer_name="HuggingFaceH4/zephyr-7b-beta",
-            device_map="auto",
-            model_kwargs={"torch_dtype": torch.float16, "load_in_8bit": True},
+            web_search,
+            math_calculator,
+            image_analyzer,
+            youtube_transcript_reader,
+        ]
+
+        # Initialize the LLM
+        print("Loading LLM...")
+        llm = HuggingFacePipeline.from_model_id(
+            model_id="HuggingFaceH4/zephyr-7b-beta",
+            task="text-generation",
+            pipeline_kwargs={
+                "max_new_tokens": 512,
+                "top_k": 50,
+                "temperature": 0.1,
+                "do_sample": False,
+                "torch_dtype": torch.bfloat16,
+                "device_map": "auto",
+            },
+        )
+        print("LLM loaded.")
+
+        # Create the agent graph
+        prompt = PromptTemplate(
+            template=SYSTEM_PROMPT
+            + """
+Here is the current conversation:
+{messages}
+
+Question: {question}
+""",
+            input_variables=["messages", "question"],
+        )
+
+        self.agent = prompt | llm | StrOutputParser()
+        self.graph = self._create_graph()
+        print("GaiaAgent initialized.")
+
+    def _create_graph(self):
+        graph = StateGraph(AgentState)
+        graph.add_node("agent", self._call_agent)
+        graph.add_node("tools", self._call_tools)
+        graph.add_conditional_edges(
+            "agent", self._decide_action, {"tools": "tools", END: END}
         )
-        self.agent = ReActAgent.from_tools(
-            tools=self.tools, llm=self.llm, verbose=True, system_prompt=system_prompt
+        graph.add_edge("tools", "agent")
+        graph.set_entry_point("agent")
+        return graph.compile()
+
+    def _call_agent(self, state: AgentState):
+        print("--- Calling Agent ---")
+        message_history = "\n".join(state["messages"])
+        response = self.agent.invoke(
+            {"messages": message_history, "question": state["question"]}
         )
-        print("LlamaIndexAgent initialized successfully.")
+        return {"messages": [response], "sender": "agent"}
+
+    def _decide_action(self, state: AgentState):
+        print("--- Deciding Action ---")
+        response = state["messages"][-1]
+        if "FINAL ANSWER:" in response:
+            return END
+        else:
+            return "tools"
+
+    def _call_tools(self, state: AgentState):
+        print("--- Calling Tools ---")
+        raw_tool_call = state["messages"][-1]
+
+        # Simple regex to find tool calls like tool_name("argument")
+        tool_call_match = re.search(r"(\w+)\((.*?)\)", raw_tool_call)
+        if not tool_call_match:
+            return {"messages": ["No valid tool call found."], "sender": "tools"}
+
+        tool_name = tool_call_match.group(1).strip()
+        tool_input_str = tool_call_match.group(2).strip()
+
+        # Remove quotes from the input string if they exist
+        if tool_input_str.startswith('"') and tool_input_str.endswith('"'):
+            tool_input = tool_input_str[1:-1]
+        else:
+            tool_input = tool_input_str
+
+        tool_to_call = next((t for t in self.tools if t.name == tool_name), None)
+
+        if tool_to_call:
+            try:
+                result = tool_to_call.run(tool_input)
+                return {"messages": [str(result)], "sender": "tools"}
+            except Exception as e:
+                return {
+                    "messages": [f"Error executing tool {tool_name}: {e}"],
+                    "sender": "tools",
+                }
+        else:
+            return {"messages": [f"Tool '{tool_name}' not found."], "sender": "tools"}
 
     def __call__(self, question: str) -> str:
-        print(f"Agent received question: {question[:80]}...")
-        response = self.agent.chat(question)
-        answer = str(response).strip()
-        if "FINAL ANSWER:" in answer:
-            final_answer = answer.split("FINAL ANSWER:")[-1].strip()
+        print(f"Agent received question: {question[:100]}...")
+
+        initial_state = {"question": question, "messages": [], "sender": "user"}
+
+        final_state = self.graph.invoke(initial_state, {"recursion_limit": 10})
+
+        final_answer = final_state["messages"][-1]
+
+        # Extract the answer after "FINAL ANSWER:"
+        match = re.search(
+            r"FINAL ANSWER:\s*(.*)", final_answer, re.IGNORECASE | re.DOTALL
+        )
+        if match:
+            extracted_answer = match.group(1).strip()
+            print(f"Agent returning final answer: {extracted_answer}")
+            return extracted_answer
         else:
-            print(
-                f"Warning: Agent did not use the 'FINAL ANSWER:' template. Raw output: {answer}"
-            )
-            final_answer = answer
-        return final_answer
+            print("Agent could not find a final answer in the required format.")
+            # Return a fallback answer if parsing fails
+            return "Could not determine the final answer."
 
 
-# --- Main Gradio App Logic ---
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    if not HF_TOKEN:
-        return (
-            "ERROR: The `HF_TOKEN` secret is not set in this Space. The image analysis tool will fail. Please set it in Settings > Secrets.",
-            None,
-        )
-    space_id = os.getenv("SPACE_ID")
-    if profile:
-        username = f"{profile.username}"
-    else:
+    """
+    Fetches all questions, runs the GaiaAgent on them, submits all answers,
+    and displays the results.
+    """
+    if not profile:
+        print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
+
+    username = profile.username
+    print(f"User logged in: {username}")
+
+    space_id = os.getenv("SPACE_ID")
+    if not space_id:
+        return "SPACE_ID environment variable is not set. Cannot proceed.", None
+
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Agent
     try:
-        # We instantiate our new powerful agent instead of the BasicAgent
-        agent = LlamaIndexAgent()
+        agent = GaiaAgent()
     except Exception as e:
+        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
+
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"Agent code URL: {agent_code}")
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=15)
+        response = requests.get(questions_url, timeout=20)
         response.raise_for_status()
         questions_data = response.json()
-    except Exception as e:
+        if not questions_data:
+            return "Fetched questions list is empty.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
         return f"Error fetching questions: {e}", None
+
+    # 3. Run your Agent
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
@@ -171,6 +276,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         question_text = item.get("question")
         if not task_id or question_text is None:
             continue
+
         try:
             submitted_answer = agent(question_text)
             answers_payload.append(
@@ -184,6 +290,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                 }
             )
         except Exception as e:
+            print(f"Error running agent on task {task_id}: {e}")
             results_log.append(
                 {
                     "Task ID": task_id,
@@ -191,15 +298,19 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                     "Submitted Answer": f"AGENT ERROR: {e}",
                 }
             )
+
     if not answers_payload:
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+        return "Agent did not produce any answers.", pd.DataFrame(results_log)
+
+    # 4. Prepare and Submit
     submission_data = {
         "username": username.strip(),
         "agent_code": agent_code,
         "answers": answers_payload,
     }
+    print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=180)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
@@ -209,46 +320,46 @@ 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.")
         return final_status, pd.DataFrame(results_log)
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}. Detail: {e.response.text}"
+        return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
     except Exception as e:
         return f"An unexpected error occurred during submission: {e}", pd.DataFrame(
             results_log
         )
 
 
-# --- Build Gradio Interface using Blocks ---
-# UI HAS BEEN REVERTED TO THE INITIAL TEMPLATE AS REQUESTED
+# --- Build Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# GAIA Agent Evaluation Runner")
     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 contains a `langgraph`-based agent equipped with tools for web search, math, image analysis, and YouTube transcript reading.
+        2.  Log in to your Hugging Face account using the button below. Your HF username is used for the submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch the questions, run the agent, submit the answers, and see your score.
         ---
-        **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.
+        **Disclaimer:**
+        -   Once you click the submit button, please be patient. The agent needs time to process all the questions, which can take several minutes depending on the model and hardware.
         """
     )
+
     gr.LoginButton()
+
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(
         label="Run Status / Submission Result", lines=5, interactive=False
     )
     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],
+        api_name="run_evaluation",
+    )
 
 if __name__ == "__main__":
     print("\n" + "-" * 30 + " App Starting " + "-" * 30)
-    if not HF_TOKEN:
-        print(
-            "⚠️ WARNING: The `HF_TOKEN` secret is not set. The image analysis tool will be unavailable."
-        )
-    else:
-        print("✅ `HF_TOKEN` secret is set.")
-    print("Launching Gradio Interface...")
     demo.launch(debug=True, share=False)

requirements.txt

@@ -1,15 +1,17 @@
 gradio
 requests
 pandas
-llama-index
 torch
 transformers
 accelerate
 bitsandbytes
+langchain
+langgraph
+langchain-community
+langchain-huggingface
+duckduckgo-search
 youtube-transcript-api
-beautifulsoup4
-llama-index-tools-duckduckgo
-llama-index-llms-huggingface
-# A reliable library for safe math evaluation
+pytube
 numexpr
-gradio[oauth]
+Pillow
+sentence-transformers