starting final assignment, added some tools

agent.py

@@ -0,0 +1,63 @@
+from typing import Annotated, TypedDict
+
+from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langgraph.graph import START, StateGraph
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from retriever import guest_info_tool
+from tools import (absolute, add, divide, exponential, floor_divide, logarithm,
+                   modulus, multiply, power, square_root, subtract, web_search)
+
+# Generate the chat interface, including the tools
+llm = HuggingFaceEndpoint(
+    repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+    huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN,
+)
+
+chat = ChatHuggingFace(llm=llm, verbose=True)
+tools = [, weather_info_tool, hub_stats_tool]
+tools = [
+    multiply,
+    add,
+    subtract,
+    power,
+    divide,
+    modulus,
+    square_root,
+    floor_divide,
+    absolute,
+    logarithm,
+    exponential,
+    web_search,
+]
+
+chat_with_tools = chat.bind_tools(tools)
+
+# Generate the AgentState and Agent graph
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+
+def assistant(state: AgentState):
+    return {
+        "messages": [chat_with_tools.invoke(state["messages"])],
+    }
+
+## The graph
+builder = StateGraph(AgentState)
+
+# Define nodes: these do the work
+builder.add_node("assistant", assistant)
+builder.add_node("tools", ToolNode(tools))
+
+# Define edges: these determine how the control flow moves
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # If the latest message requires a tool, route to tools
+    # Otherwise, provide a direct response
+    tools_condition,
+)
+builder.add_edge("tools", "assistant")
+alfred = builder.compile()

app.py

@@ -1,8 +1,11 @@
+import inspect
 import os
+
 import gradio as gr
-import requests
-import inspect
 import pandas as pd
+import requests
+from agent import build_graph
+from langchain_core.messages import HumanMessage
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -13,11 +16,14 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
+        self.graph = build_graph()
     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)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        return answer[14:]
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """

requirements.txt

@@ -1,2 +1,9 @@
 gradio
-requests
+requests
+
+# LangChain dependencies
+langchain-core
+
+
+#other
+# inspect

retriever.py

@@ -0,0 +1 @@
+# Nothing

tools.py

@@ -0,0 +1,195 @@
+import math
+
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_core.tools import tool
+
+
+@tool
+def multiply(a: int, b:int) -> int:
+    """Multiplies two integers and returns the product.
+
+    Args:
+        a (int): The first integer.
+        b (int): The second integer.
+
+    Returns:
+        int: The product of the two input integers.
+    """
+    return a * b
+
+
+@tool
+def add(a: int, b:int) -> int:
+    """Adds two integers and returns the sum.
+
+    Args:
+        a (int): The first integer.
+        b (int): The second integer.
+
+    Returns:
+        int: The sum of the two input integers.
+    """
+    return a + b
+
+
+@tool
+def power(a: float, b: float) -> float:
+    """Raises a number to the power of another.
+
+    Args:
+        a (float): The base number.
+        b (float): The exponent.
+
+    Returns:
+        float: The result of raising `a` to the power of `b`.
+    """
+    return a ** b
+
+
+@tool
+def subtract(a: float, b: float) -> float:
+    """Subtracts the second number from the first.
+
+    Args:
+        a (float): The number from which to subtract.
+        b (float): The number to subtract.
+
+    Returns:
+        float: The result of `a` minus `b`.
+    """
+    return a - b
+
+
+@tool
+def divide(a: float, b: float) -> float:
+    """Divides one number by another.
+
+    Args:
+        a (float): The numerator.
+        b (float): The denominator.
+
+    Returns:
+        float: The result of `a` divided by `b`.
+
+    Raises:
+        ValueError: If `b` is zero.
+    """
+    if b == 0:
+        raise ValueError("Divide by zero is not allowed")
+    return a / b
+
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """Returns the remainder of the division of two integers.
+
+    Args:
+        a (int): The dividend.
+        b (int): The divisor.
+
+    Returns:
+        int: The remainder when `a` is divided by `b`.
+
+    Raises:
+        ValueError: If `b` is zero.
+    """
+    if b == 0:
+        raise ValueError("Modulus by zero is not allowed")
+    return a % b
+
+
+@tool
+def square_root(x: float) -> float:
+    """Returns the square root of a number.
+
+    Args:
+        x (float): The input number. Must be non-negative.
+
+    Returns:
+        float: The square root of `x`.
+
+    Raises:
+        ValueError: If `x` is negative.
+    """
+    if x < 0:
+        raise ValueError("Square root of negative number is not allowed")
+    return math.sqrt(x)
+
+
+@tool
+def floor_divide(a: int, b: int) -> int:
+    """Performs integer division (floor division) of two numbers.
+
+    Args:
+        a (int): The dividend.
+        b (int): The divisor.
+
+    Returns:
+        int: The floor of the quotient.
+        Returns the quotient rounded down to the nearest integer.
+
+    Raises:
+        ValueError: If `b` is zero.
+    """
+    if b == 0:
+        raise ValueError("Division by zero is not allowed")
+    return a // b
+
+
+@tool
+def absolute(x: float) -> float:
+    """Returns the absolute value of a number.
+
+    Args:
+        x (float): The input number.
+
+    Returns:
+        float: The absolute value of `x`.
+    """
+    return abs(x)
+
+
+@tool
+def logarithm(x: float, base: float = math.e) -> float:
+    """Returns the logarithm of a number with a given base.
+
+    Args:
+        x (float): The number to take the logarithm of. Must be positive.
+        base (float): The logarithmic base. Must be positive and not equal to 1.
+
+    Returns:
+        float: The logarithm of `x` to the given base.
+
+    Raises:
+        ValueError: If `x <= 0` or `base <= 0` or `base == 1`.
+    """
+    if x <= 0 or base <= 0 or base == 1:
+        raise ValueError("Invalid input for logarithm")
+    return math.log(x, base)
+
+
+@tool
+def exponential(x: float) -> float:
+    """Returns e raised to the power of `x`.
+
+    Args:
+        x (float): The exponent.
+
+    Returns:
+        float: The value of e^x.
+    """
+    return math.exp(x)
+
+@tool
+def web_search(query: str) -> str:
+    """Performs a DuckDuckGo search for the given query and returns the results.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        str: The top search results as a string.
+    """
+    search_tool = DuckDuckGoSearchRun()
+    return search_tool.invoke(query)
+