Upload 10 files

app.py

@@ -1,34 +1,27 @@
-import os
 import gradio as gr
+import os
 import requests
-import inspect
+
 import pandas as pd
 
+from src.agent import Agent
+
 # (Keep Constants as is)
 # --- 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.")
-    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
-
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- 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 the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -40,11 +33,12 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = Agent()
     except Exception as e:
         print(f"Error instantiating 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)
+    # 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)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
 
@@ -55,16 +49,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         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
@@ -81,18 +75,38 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             continue
         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})
+            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}"})
+            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)
+        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}
+    # 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)
 
@@ -175,7 +189,8 @@ 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
+    # Get SPACE_ID at startup
+    space_id_startup = os.getenv("SPACE_ID")
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -193,4 +208,4 @@ if __name__ == "__main__":
     print("-"*(60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

prompts/system_prompt.txt

@@ -0,0 +1,9 @@
+You are a helpful agent capable of answering the provided questions. To provide proper answers you must:
+
+1. Think step by step and feel free to write down your whole thought.
+2. Reason about your reply.
+3. Use the provided tools if necessary.
+4. The format of your reply should be in json containing two fields, one called "reasoning" that will include your whole though and one called "answer" containing the final answer. Remember, WE NEED A VALID JSON, no markdown fence arround it!
+5. The "answer" field should include just the answer and nothing more, no explaination, no units after any number, JUST THE ANSWER! 
+6. In the "reasoning" field, be precise on what tools you use in the process.
+7. Do not come up with information that you do not know or you are not sure about. If you don't know something, search for it in the web using the provided tools.

requirements.txt

@@ -1,2 +1,7 @@
+duckduckgo_search==8.0.4
 gradio
+langchain==0.3.26
+langchain-community==0.3.26
+langfuse==3.0.5
+langgraph==0.4.8
 requests

src/agent.py

@@ -0,0 +1,145 @@
+import json
+
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_openai.chat_models import ChatOpenAI
+from langfuse import Langfuse, get_client
+from langfuse.langchain import CallbackHandler
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
+
+
+class Agent:
+    """
+    Class representing a basic agent that can answer questions.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        tools: list,
+        system_prompt_path: str,
+        openai_api_key: str = None,
+        langfuse_callback_handler: CallbackHandler = None
+    ):
+        """
+        Initialize the agent object.
+        :param model: The OpenAI model to use.
+        :param tools: List of tools the agent can use.
+        :param system_prompt_path: Path to the system prompt file.
+        :param openai_api_key: OpenAI API key for authentication.
+        :param langfuse_callback_handler: Langfuse callback handler for
+            tracking and logging interactions.
+        """
+        self.chat_model = ChatOpenAI(
+            model=model,
+            api_key=openai_api_key,
+        )
+        with open(system_prompt_path, "r") as file:
+            self.system_prompt = file.read()
+        self.tools = tools
+        if langfuse_callback_handler is not None:
+            self.chat_model.callbacks = [langfuse_callback_handler]
+        self.chat_model_with_tools = self.chat_model.bind_tools(
+            tools=tools,
+            parallel_tool_calls=False
+        )
+        self.graph = self.__build_graph()
+
+    def __call__(self, question: str) -> str:
+        """
+        Call the agent with a question.
+        :param question: The question to ask the agent.
+        :return: The agent's response.
+        """
+        reply = self.reply(question)
+        reply = json.loads(reply)
+        answer = reply.get("answer", "")
+        return answer
+
+    def reply(self, question: str) -> str:
+        """
+        Reply to a question using the agent and return the agents full reply
+        with reasoning included.
+        :param question: The question to ask the agent.
+        :return: The agent's response.
+        """
+        final_state = self.graph.invoke(
+            input={
+                "messages": [
+                    SystemMessage(content=self.system_prompt),
+                    HumanMessage(content=question)
+                ]
+            },
+            config={
+                "callbacks": self.chat_model.callbacks
+            }
+        )
+        return final_state["messages"][-1].content
+
+    def __build_graph(self):
+        """
+        Build the graph for the agent.
+        """
+        builder = StateGraph(MessagesState)
+
+        # Define nodes: these do the work
+        builder.add_node("assistant", self.__assistant)
+        builder.add_node("tools", ToolNode(self.tools))
+
+        # Define edges: these determine how the control flow moves
+        builder.add_edge(START, "assistant")
+        builder.add_conditional_edges(
+            "assistant",
+            tools_condition,
+        )
+        builder.add_edge("tools", "assistant")
+        return builder.compile()
+
+    def __assistant(self, state: MessagesState) -> MessagesState:
+        """
+        The assistant function that processes the state and returns a response.
+        :param state: The current state of the agent.
+        :return: Updated state with the assistant's response.
+        """
+        response = self.chat_model_with_tools.invoke(state["messages"])
+        return {"messages": [response]}
+
+
+if __name__ == "__main__":
+
+    import os
+    from langchain_community.tools import DuckDuckGoSearchResults
+
+    from tools import multiply, add, subtract, divide, modulus
+
+    # Initialize Langfuse client with constructor arguments
+    Langfuse(
+        public_key=os.environ.get("LANGFUSE_PUBLIC_KEY"),
+        secret_key=os.environ.get("LANGFUSE_SECRET_KEY"),
+        host='https://cloud.langfuse.com'
+    )
+
+    # Get the configured client instance
+    langfuse = get_client()
+
+    # Initialize the Langfuse handler
+    langfuse_handler = CallbackHandler()
+
+    tools = [multiply, add, subtract, divide, modulus]
+    tools.append(
+        DuckDuckGoSearchResults()
+    )
+    agent = Agent(
+        model="gpt-4o",
+        tools=tools,
+        system_prompt_path="prompts/system_prompt.txt",
+        openai_api_key=os.environ.get("OPENAI_API_KEY"),
+        langfuse_callback_handler=langfuse_handler
+    )
+    response = agent(
+        question="""
+            Search for Tom Cruise and summarize the results for me.
+        """
+    )
+    print(response)

src/tools.py

@@ -0,0 +1,62 @@
+from langchain_core.tools import tool
+
+
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a * b
+
+
+@tool
+def add(a: int, b: int) -> int:
+    """
+    Add two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a + b
+
+
+@tool
+def subtract(a: int, b: int) -> int:
+    """
+    Subtract two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a - b
+
+
+@tool
+def divide(a: int, b: int) -> int:
+    """
+    Divide two numbers.
+
+    Args:
+        a: numerator
+        b: denominator
+    """
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """
+    Get the modulus of two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a % b