inital agent build

.gitignore

@@ -0,0 +1 @@
+.env

app.py

@@ -3,10 +3,16 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from dotenv import load_dotenv
+
+from langchain_core.messages import HumanMessage
+
+from src.gaia_agent import GaiaAgent
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+load_dotenv()  # Load environment variables from .env file
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -29,7 +35,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = GaiaAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -69,64 +75,71 @@ 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)
+            print(f"Running agent on task {task_id}: {question_text}")
+            submitted_answer = agent.graph.invoke({"messages": [HumanMessage(content=question_text)]})
+            print(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}"})
+        
+        break
 
     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)
+    
+    print(f"Agent finished running on {len(answers_payload)} questions.")
+    print(f"Results log: {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()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            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
+    # 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()
+    #     final_status = (
+    #         f"Submission Successful!\n"
+    #         f"User: {result_data.get('username')}\n"
+    #         f"Overall Score: {result_data.get('score', 'N/A')}% "
+    #         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
 
 
 # --- Build Gradio Interface using Blocks ---

gaia_agent.py

@@ -1,3 +0,0 @@
-class GaiaAgent:
-    def __init__(self):
-        pass

requirements.txt

@@ -1,3 +1,7 @@
 gradio
 requests
-langchain
+python-dotenv
+langchain
+langchain-google-genai
+langchain-tavily
+langgraph

src/config.py

@@ -0,0 +1,66 @@
+"""Define the configurable parameters for the agent."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from typing import Annotated
+
+from langchain_core.runnables import ensure_config
+from langgraph.config import get_config
+
+from src.prompts import SYSTEM_PROMPT
+
+
+@dataclass(kw_only=True)
+class Configuration:
+    """The configuration for the agent."""
+
+    system_prompt: str = field(
+        default=SYSTEM_PROMPT,
+        metadata={
+            "description": "The system prompt to use for the agent's interactions. "
+            "This prompt sets the context and behavior for the agent."
+        },
+    )
+    
+    google_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="gemini-2.0-flash",
+        metadata={
+            "description": "The name of the Google AI language model to use for the agent's main interactions. "
+            "Should be in the form: model-name."
+        },
+    )
+
+    max_iter: int = field(
+        default=5,
+        metadata={
+            "description": "The maximum number of iterations to run."
+        },
+    )
+    
+    max_search_results: int = field(
+        default=5,
+        metadata={
+            "description": "The maximum number of search results to return for each search query."
+        },
+    )
+    
+    temperature: float = field(
+        default=0.2,
+        metadata={
+            "description": "The temperature to use for the model's responses. "
+            "Higher values result in more random outputs, while lower values make the output more deterministic."
+        },
+    )
+
+    @classmethod
+    def from_context(cls) -> Configuration:
+        """Create a Configuration instance from a RunnableConfig object."""
+        try:
+            config = get_config()
+        except RuntimeError:
+            config = None
+        config = ensure_config(config)
+        configurable = config.get("configurable") or {}
+        _fields = {f.name for f in fields(cls) if f.init}
+        return cls(**{k: v for k, v in configurable.items() if k in _fields})

src/gaia_agent.py

@@ -0,0 +1,84 @@
+from typing import Dict, List, cast
+
+from langchain_core.messages import AIMessage
+from langgraph.graph import StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from src.config import Configuration
+from src.model import GoogleModel
+from src.state import InputState, State
+from src.tools import TOOLS
+
+class GaiaAgent:
+    def __init__(self):
+        self.graph = self._build_graph()
+    
+    def _build_graph(self) -> StateGraph:
+        builder = StateGraph(State, input=InputState, config_schema=Configuration)
+
+        # Define the two nodes we will cycle between
+        builder.add_node("call_model", self._call_model)
+        builder.add_node("tools", ToolNode(TOOLS))
+
+        # Set the entrypoint as `call_model`
+        # This means that this node is the first one called
+        builder.add_edge("__start__", "call_model")
+        builder.add_conditional_edges(
+            "call_model",
+            # If the latest message requires a tool, route to tools
+            # Otherwise, provide a direct response
+            tools_condition,
+        )
+        builder.add_edge("tools", "call_model")
+        
+        graph = builder.compile(name="GAIA Agent", debug=True)
+        
+        return graph
+        
+    def _call_model(self, state: State) -> Dict[str, List[AIMessage]]:
+        """Call the LLM powering our "agent".
+
+        This function prepares the prompt, initializes the model, and processes the response.
+
+        Args:
+            state (State): The current state of the conversation.
+            config (RunnableConfig): Configuration for the model run.
+
+        Returns:
+            dict: A dictionary containing the model's response message.
+        """
+        configuration = Configuration.from_context()
+
+        # Initialize the model with tool binding. Change the model or add more tools here.
+        model = GoogleModel(
+            model=configuration.google_model, 
+            temperature=configuration.temperature,
+            tools=TOOLS
+        )
+
+        # Format the system prompt. Customize this to change the agent's behavior.
+        system_message = configuration.system_prompt
+
+        # Get the model's response
+        response = cast(
+            AIMessage,
+            model.llm.invoke(
+                [{"role": "system", "content": system_message}, *state.messages]
+            ),
+        )
+        
+        print(response.tool_calls)
+
+        # Handle the case when it's the last step and the model still wants to use a tool
+        if state.is_last_step and response.tool_calls:
+            return {
+                "messages": [
+                    AIMessage(
+                        id=response.id,
+                        content="Sorry, I could not find an answer to your question in the specified number of steps.",
+                    )
+                ]
+            }
+
+        # Return the model's response as a list to be added to existing messages
+        return {"messages": [response]}

src/model.py

@@ -0,0 +1,28 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+class GoogleModel:
+    def __init__(
+        self,
+        model: str = "gemini-2.0-flash",
+        temperature: int = 0.2,
+        tools: list = None,
+    ):  
+        """Initialize the GoogleModel with the specified model name and temperature.
+        """
+        
+        if tools:
+            self.llm = ChatGoogleGenerativeAI(
+                model=model,
+                temperature=temperature,
+                max_tokens=None,
+                timeout=None,
+                max_retries=1,
+            ).bind_tools(tools=tools)
+        else:
+            self.llm = ChatGoogleGenerativeAI(
+                model=model,
+                temperature=temperature,
+                max_tokens=None,
+                timeout=None,
+                max_retries=1,
+            )

src/prompts.py

@@ -0,0 +1,7 @@
+SYSTEM_PROMPT = (
+    "You are a helpful AI assistant.\n"
+    "Please answer the question to the best of your ability.\n"
+    "Use the tools provided to you to find the answer.\n"
+    "Do not ask for permission to use the tools.\n"
+    "If you think you should use a tool, do so.\n"
+)

src/state.py

@@ -0,0 +1,60 @@
+"""Define the state structures for the agent."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Sequence
+
+from langchain_core.messages import AnyMessage
+from langgraph.graph import add_messages
+from langgraph.managed import IsLastStep
+from typing_extensions import Annotated
+
+
+@dataclass
+class InputState:
+    """Defines the input state for the agent, representing a narrower interface to the outside world.
+
+    This class is used to define the initial state and structure of incoming data.
+    """
+
+    messages: Annotated[Sequence[AnyMessage], add_messages] = field(
+        default_factory=list
+    )
+    """
+    Messages tracking the primary execution state of the agent.
+
+    Typically accumulates a pattern of:
+    1. HumanMessage - user input
+    2. AIMessage with .tool_calls - agent picking tool(s) to use to collect information
+    3. ToolMessage(s) - the responses (or errors) from the executed tools
+    4. AIMessage without .tool_calls - agent responding in unstructured format to the user
+    5. HumanMessage - user responds with the next conversational turn
+
+    Steps 2-5 may repeat as needed.
+
+    The `add_messages` annotation ensures that new messages are merged with existing ones,
+    updating by ID to maintain an "append-only" state unless a message with the same ID is provided.
+    """
+
+
+@dataclass
+class State(InputState):
+    """Represents the complete state of the agent, extending InputState with additional attributes.
+
+    This class can be used to store any information needed throughout the agent's lifecycle.
+    """
+
+    is_last_step: IsLastStep = field(default=False)
+    """
+    Indicates whether the current step is the last one before the graph raises an error.
+
+    This is a 'managed' variable, controlled by the state machine rather than user code.
+    It is set to 'True' when the step count reaches recursion_limit - 1.
+    """
+
+    # Additional attributes can be added here as needed.
+    # Common examples include:
+    # retrieved_documents: List[Document] = field(default_factory=list)
+    # extracted_entities: Dict[str, Any] = field(default_factory=dict)
+    # api_connections: Dict[str, Any] = field(default_factory=dict)

src/tools.py

@@ -0,0 +1,19 @@
+from typing import Any, Callable, List, Optional, cast
+
+from langchain_tavily import TavilySearch  # type: ignore[import-not-found]
+
+from src.config import Configuration
+
+def search(query: str) -> Optional[dict[str, Any]]:
+    """Search for general web results.
+
+    This function performs a search using the Tavily search engine, which is designed
+    to provide comprehensive, accurate, and trusted results. It's particularly useful
+    for answering questions about current events.
+    """
+    configuration = Configuration.from_context()
+    wrapped = TavilySearch(max_results=configuration.max_search_results)
+    return cast(dict[str, Any], wrapped.invoke({"query": query}))
+
+
+TOOLS: List[Callable[..., Any]] = [search]