Update app.py

app.py

@@ -1,8 +1,25 @@
 import os
+from dotenv import load_dotenv
 import gradio as gr
+import re
 import requests
 import inspect
 import pandas as pd
+from typing import TypedDict, Annotated
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
+from langgraph.prebuilt import tools_condition
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_openai import ChatOpenAI
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.utilities import WikipediaAPIWrapper
+from langchain.tools import tool
+from langchain_core.tools import Tool
+from langgraph.prebuilt import ToolNode, tools_condition
+
+load_dotenv()
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -10,14 +27,118 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+@tool
+def python_calc(expr: str) -> str:
+    """Safely evaluate a numeric Python expression."""
+    allowed = {"__builtins__": {}}
+    return str(eval(expr, allowed, {}))
+
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+    evidence: list[str]
+
 class BasicAgent:
     def __init__(self):
+
         print("BasicAgent initialized.")
+        # Generate the chat interface, including the tools
+        llm = ChatOpenAI(model="gpt-4.1")
+        search_tool = DuckDuckGoSearchRun()
+        wiki = WikipediaQueryRun(
+            api_wrapper=WikipediaAPIWrapper(top_k_results=3, doc_content_chars_max=4000)
+        )
+        search_tools = [search_tool, wiki]
+
+        calc_tools = [python_calc]
+
+        self.retrieve_tools = llm.bind_tools(search_tools)
+        self.calc_tools = llm.bind_tools(calc_tools)
+
+        ## The graph
+        builder = StateGraph(AgentState)
+
+        # Define nodes: these do the work
+        builder.add_node("retriever", self.retriever)
+        builder.add_node("retrieve_tools", ToolNode(search_tools))
+        builder.add_node("solver", self.solver)
+        builder.add_node("calc_tools", ToolNode(calc_tools))
+
+        # Define edges: these determine how the control flow moves
+        # START → retriever
+        builder.add_edge(START, "retriever")
+
+        # retriever tool loop
+        builder.add_conditional_edges(
+            "retriever",
+            tools_condition,
+            {
+                "tools": "retrieve_tools",  # if LLM emitted a tool call
+                END: "solver",               # if no tool call
+            },
+        )
+        builder.add_edge("retrieve_tools", "retriever")
+
+        builder.add_conditional_edges(
+            "solver",
+            tools_condition,
+            {
+                "tools": "calc_tools",
+                END: END,
+            },
+        )
+        builder.add_edge("calc_tools", "solver")
+
+        self.agent = builder.compile()
+
     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)]
+        response = self.agent.invoke({"messages": messages})
+        print(response["messages"][-1].content)
+        return response["messages"][-1].content
+    
+    def retriever(self, state: AgentState):
+        system = SystemMessage(
+            content=(
+                "You are a retrieval agent for the GAIA benchmark.\n"
+                "Your task is to gather factual evidence needed to answer the question.\n"
+                "Use search or Wikipedia tools if helpful.\n"
+                "Return relevant factual text only.\n"
+                "Do NOT compute, infer, or answer the question.\n"
+                "Once you have sufficient evidence, STOP and do not call more tools."
+            )
+        )
+
+        msg = self.retrieve_tools.invoke([system] + state["messages"])
+        return {
+            "messages": [msg],
+            "evidence": state.get("evidence", []) + [msg.content],
+        }
+
+    def solver(self, state: AgentState):
+        system = SystemMessage(
+            content=(
+                "You are solving a GAIA benchmark question.\n"
+                "Determine the final answer based ONLY on the evidence.\n"
+                "The final answer must be either:\n"
+                "• a single number, OR\n"
+                "• a single word (no spaces), OR\n"
+                "• a comma-separated list of numbers (no spaces).\n\n"
+                "Output ONLY the final answer.\n"
+                "Do NOT include explanations or extra text.\n"
+                "If the answer cannot be determined with certainty, output 0.\n"
+                "You MUST NOT call the calculator more than once."
+            )
+        )
+
+        human = HumanMessage(
+            content="\n\n".join(state["evidence"])
+        )
+
+        msg = self.calc_tools.invoke([system, human])
+        return {
+            "messages": [msg],
+        }
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """