first working version

.gitignore

@@ -0,0 +1,28 @@
+# 1) Python virtual environment
+.venv/
+venv/
+
+# 2) IDE/editor settings
+.vscode/
+*.suo
+*.swp
+*.idea/
+
+# 3) OS files
+.DS_Store
+Thumbs.db
+
+# 4) Local test outputs or caches
+local_results.csv
+__pycache__/
+*.py[cod]
+
+# 5) Credentials & configs
+# If you’re using config.py or config.yaml to store API keys, do NOT commit your real keys:
+config.py
+config.yaml
+.env
+
+# 6) Any Docker or Kubernetes local files
+docker-compose.override.yml
+*.log

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+
+CMD ["python", "app.py"]

app.py

@@ -3,21 +3,38 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from qa_graph import graph  # my LangGraph-based pipeline
+from langgraph.graph import StateGraph, START, END
 
 # (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 ------
+# # ----- 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
+
+
 class BasicAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("Graph-based agent 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
+        print("Received question:", question)
+        # Prepare the initial state
+        state = {"question": question, "answer": ""}
+        # Execute the graph
+        out = graph.invoke({"question":question,"answer":""})
+        answer = out["answer"]
+        return answer
+    
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -73,6 +90,11 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
+
+    MAX_QUESTIONS = 3
+    questions_data = questions_data[:MAX_QUESTIONS]
+    print(f"Limiting to first {MAX_QUESTIONS} questions.")
+
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")

qa_graph.py

@@ -0,0 +1,43 @@
+# simple_qa_graph.py
+
+from typing import TypedDict
+from langgraph.graph import StateGraph, START, END
+from tools.calculator_tool import calculator_tool
+from tools.search_tool import search_tool
+import re
+
+# 1) Define the shape of our state
+class QAState(TypedDict):
+    question: str   # incoming question
+    answer: str     # place to store the tool’s output
+
+# 2) Define our single agent node
+def QAAgent(state: QAState) -> QAState:
+    q = state["question"].strip()
+    # if it looks like math, use the calculator, else do web search:
+    if re.fullmatch(r"[0-9\s\+\-\*\/\.\(\)]+", q):
+        state["answer"] = calculator_tool(q)
+    else:
+        state["answer"] = search_tool(q)
+    return state
+
+# 3) Wire it up in a graph: START → QAAgent → END
+builder = StateGraph(QAState)
+builder.set_entry_point("QAAgent")
+builder.add_node("QAAgent", QAAgent)
+builder.add_edge(START, "QAAgent")
+builder.add_edge("QAAgent", END)
+
+graph = builder.compile()
+
+# 4) Run it locally
+if __name__ == "__main__":
+    # try a math question
+    s1: QAState = {"question": "2 + 2", "answer": ""}
+    out1 = graph.invoke(s1)
+    print("Q:", s1["question"], "→ A:", out1["answer"])
+
+    # try a search question
+    s2: QAState = {"question": "What is the capital of France?", "answer": ""}
+    out2 = graph.invoke(s2)
+    print("Q:", s2["question"], "→ A:", out2["answer"])

requirements.txt

@@ -1,2 +1,12 @@
 gradio
-requests
+requests
+langgraph
+openai
+tavily-python
+langchain
+pandas
+python-dotenv
+huggingface_hub
+transformers
+langchain-huggingface
+IPython

test_gaia.py

@@ -0,0 +1,8 @@
+from qa_graph import graph
+import requests
+import pandas as pd
+
+QUESTIONS = requests.get("https://agents-course-unit4-scoring.hf.space/questions").json()
+for q in QUESTIONS[:3]:
+    ans = graph.invoke({"question":q["question"],"answer":""})["answer"]
+    print(q["task_id"], ans)

tools/__init__.py

@@ -0,0 +1,2 @@
+from .calculator_tool import calculator_tool
+from .search_tool import search_tool

tools/calculator_tool.py

@@ -0,0 +1,34 @@
+from langchain.tools import tool
+import ast
+import operator
+
+def safe_eval(expr):
+    ops = {
+        ast.Add: operator.add,
+        ast.Sub: operator.sub,
+        ast.Mult: operator.mul,
+        ast.Div: operator.truediv,
+        ast.Pow: operator.pow,
+        ast.USub: operator.neg,
+    }
+
+    def _eval(node):
+        if isinstance(node, ast.Constant):
+            return node.n
+        elif isinstance(node, ast.BinOp):
+            return ops[type(node.op)](_eval(node.left), _eval(node.right))
+        elif isinstance(node, ast.UnaryOp):
+            return ops[type(node.op)](_eval(node.operand))
+        else:
+            raise TypeError(f"Unsupported expression: {node}")
+
+    node = ast.parse(expr, mode='eval').body
+    return _eval(node)
+
+@tool(description="Performs basic arithmetic calculations on a query string and returns the result as a string.")
+def calculator_tool(query: str) -> str:
+    try:
+        result = safe_eval(query)
+        return str(result)
+    except Exception as e:
+        return f"Error evaluating expression: {e}"

tools/search_tool.py

@@ -0,0 +1,23 @@
+from tavily import TavilyClient
+from langchain.tools import tool
+from config import TAVILY_API_KEY
+
+class SearchTool:
+    def __init__(self, api_key: str):
+        self.client = TavilyClient(api_key=api_key)
+
+    def search(self, query: str):
+        response = self.client.search(query)
+        # Extract a string summary of results (you can adapt this as needed)
+        results = response.get("results", [])
+        if not results:
+            return "No results found."
+        # For simplicity, join first 3 results' titles or snippets
+        summaries = [res.get("title", "") or res.get("snippet", "") for res in results[:3]]
+        return " | ".join(summaries)
+
+search_tool_instance = SearchTool(api_key=TAVILY_API_KEY)
+
+@tool(description="Use this tool to search for information on the web using Tavily API and return a summary of results.")
+def search_tool(query: str) -> str:
+    return search_tool_instance.search(query)