switched to Langgrah

app.py

@@ -1,249 +1,44 @@
+""" Basic Agent Evaluation Runner"""
 import os
+import inspect
 import gradio as gr
-import pandas as pd
 import requests
-import subprocess
-import json
-import csv
-import openpyxl
-import whisper
-from typing import Optional
-from bs4 import BeautifulSoup
-from duckduckgo_search import DDGS
-from smolagents import CodeAgent, tool
-
-# (Keep Constants as is)
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-# --- Basic Agent Definition ---
-# ----- THIS IS WHERE YOU CAN BUILD WHAT YOU WANT ------
-class ClaudeServerModel:
-    """
-    ClaudeServerModel wraps Anthropic Claude API for smolagents-style usage.
-    """
-
-    def __init__(self, api_key: str, model_id: str = "claude-3-opus-20240229", temperature: float = 0.0):
-        self.api_key = api_key
-        self.model_id = model_id
-        self.temperature = temperature
-
-    def complete(self, prompt: str, stop_sequences: list[str] = None) -> str:
-        headers = {
-            "x-api-key": self.api_key,
-            "anthropic-version": "2023-06-01",
-            "content-type": "application/json"
-        }
-
-        body = {
-            "model": self.model_id,
-            "max_tokens": 1024,
-            "temperature": self.temperature,
-            "prompt": f"\n\nHuman: {prompt}\n\nAssistant:"
-        }
-
-        # Claude expects stop_sequences as "stop_sequences", if passed
-        if stop_sequences:
-            body["stop_sequences"] = stop_sequences
+import pandas as pd
+import time
+from langchain_core.messages import HumanMessage
+from agent import build_graph
 
-        response = requests.post("https://api.anthropic.com/v1/complete", headers=headers, json=body)
-        response.raise_for_status()
-        return response.json()["completion"].strip()
 
-    def __call__(self, prompt: str, stop_sequences: list[str] = None) -> str:
-        return self.complete(prompt, stop_sequences=stop_sequences)
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-def download_file(file_name: str) -> None:
-    if not os.path.exists(file_name):
-        url = f"{DEFAULT_API_URL}/files/{file_name.split('.')[0]}"
-        r = requests.get(url)
-        with open(file_name, "wb") as f:
-            f.write(r.content)
-
-@tool
-def open_file_as_text(file_name: str, filetype: Optional[str] = "txt") -> str:
-    """
-    Opens and reads a file based on its type.
-
-    Args:
-        file_name (str): The name of the file to open (should be available after download).
-        filetype (Optional[str]): The type of file - one of 'txt', 'json', 'csv', 'xlsx', or 'mp3'. Defaults to 'txt'.
-
-    Returns:
-        str: File content as text, or transcription if an audio file.
-    """
-    download_file(file_name)
-    try:
-        if filetype == "txt":
-            with open(file_name, "r", encoding="utf-8") as f:
-                return f.read()
-        elif filetype == "json":
-            with open(file_name, "r", encoding="utf-8") as f:
-                data = json.load(f)
-            return json.dumps(data, indent=2)
-        elif filetype == "csv":
-            with open(file_name, "r", encoding="utf-8") as f:
-                reader = csv.reader(f)
-                rows = list(reader)
-            return "\n".join([", ".join(row) for row in rows])
-        elif filetype == "xlsx":
-            wb = openpyxl.load_workbook(file_name, data_only=True)
-            sheet = wb.active
-            content = []
-            for row in sheet.iter_rows(values_only=True):
-                content.append(", ".join(str(cell) if cell is not None else "" for cell in row))
-            return "\n".join(content)
-        elif filetype == "mp3":
-            w = whisper.load_model("base")
-            res = w.transcribe(file_name)
-            return res["text"]
-        else:
-            return f"Unsupported filetype '{filetype}'."
-    except Exception as e:
-        return f"Error opening file '{file_name}': {str(e)}"
-
-
-@tool
-def web_search(query: str) -> str:
-    """
-    Performs a web search using DuckDuckGo and returns the top results.
-
-    Args:
-        query (str): Search query string.
-
-    Returns:
-        str: Top search results formatted as title, snippet, and URL.
-    """
-    try:
-        with DDGS() as ddgs:
-            results = ddgs.text(query, max_results=3)
-            if not results:
-                return "No results found."
-            return "\n\n".join([f"Title: {r['title']}\nSnippet: {r['body']}\nURL: {r['href']}" for r in results])
-    except Exception as e:
-        return f"Error during search: {str(e)}"
-
-
-@tool
-def read_wikipedia_page(url: str) -> str:
-    """
-    Reads and extracts clean text content from a Wikipedia page.
-
-    Args:
-        url (str): Full URL to the Wikipedia page.
-
-    Returns:
-        str: Sectioned and readable content from the page, including paragraphs, lists, and tables.
-    """
-    headers = {"User-Agent": "Mozilla/5.0"}
-    resp = requests.get(url, headers=headers, timeout=10)
-    resp.raise_for_status()
-    soup = BeautifulSoup(resp.text, "html.parser")
-    content_div = soup.find('div', id='mw-content-text')
-    parts = []
-    for elem in content_div.find_all(['h2', 'h3', 'p', 'ul', 'ol', 'table']):
-        if elem.name in ['h2', 'h3']:
-            parts.append("\n\n" + elem.get_text(strip=True) + "\n")
-        elif elem.name in ['p', 'ul', 'ol']:
-            parts.append(elem.get_text(strip=True))
-        elif elem.name == 'table':
-            parts.append(parse_wikipedia_table(elem))
-    return "\n".join(parts)
-
-
-@tool
-def smart_paginate_around_query(full_text: str, query: str) -> list:
-    """
-    Splits full text into focused windows surrounding the query keyword.
-
-    Args:
-        full_text (str): The large text content to paginate.
-        query (str): Keyword or phrase to center each window on.
-
-    Returns:
-        list: List of substrings centered around the query within the original text.
-    """
-    before_chars = 1000
-    after_chars = 3000
-    q = query.lower()
-    text_lower = full_text.lower()
-    pages = []
-    start = 0
-    while True:
-        idx = text_lower.find(q, start)
-        if idx == -1:
-            break
-        s = max(0, idx - before_chars)
-        e = min(len(full_text), idx + len(q) + after_chars)
-        pages.append(full_text[s:e])
-        start = e
-    return pages
-
-
-@tool
-def reverse_sentence(text: str) -> str:
-    """
-    Reverses the input text string.
-
-    Args:
-        text (str): A string to reverse.
-
-    Returns:
-        str: Reversed string.
-    """
-    return text[::-1]
-
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 
-@tool
-def run_python_code(file_name: str) -> str:
-    """
-    Executes a Python script and returns the output.
 
-    Args:
-        file_name (str): Name of the Python file to execute.
+class BasicAgent:
+    """A langgraph agent."""
+    def __init__(self):
+        print("BasicAgent initialized.")
+        self.graph = build_graph()
 
-    Returns:
-        str: Printed standard output or error message from the script.
-    """
-    download_file(file_name)
-    try:
-        result = subprocess.run(["python", file_name], capture_output=True, text=True, timeout=10)
-        if result.returncode != 0:
-            return f"Error: {result.stderr.strip()}"
-        return result.stdout.strip()
-    except Exception as e:
-        return f"Execution failed: {e}"
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        return answer[14:]
 
-# Agent Setup
-tools = [
-    open_file_as_text,
-    web_search,
-    read_wikipedia_page,
-    smart_paginate_around_query,
-    reverse_sentence,
-    run_python_code
-]
-
-model = ClaudeServerModel(
-    api_key=os.getenv("CLAUDE_API_KEY"),
-    model_id="claude-3-opus-20240229"
-)
-
-agent = CodeAgent(
-    model=model,
-    tools=tools,
-    additional_authorized_imports=["pandas", "numpy", "datetime", "json", "re", "math", "os", "requests", "csv", "urllib"]
-)
 
 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
+    # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
     if profile:
@@ -257,18 +52,13 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # Instantiate Agent ( modify this part to create your agent)
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = CodeAgent(
-            model=model,
-            tools=tools,
-            additional_authorized_imports=["pandas", "numpy", "datetime", "json", "re", "math", "os", "requests", "csv",
-                                           "urllib"]
-        )
+        agent = BasicAgent()
     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 (useful 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)
 
@@ -300,37 +90,14 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
-        file_name = item.get("file_name")
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+        
+        # time.sleep(10)
+        
         try:
-            full_prompt = f"""
-You are a precise answering agent optimized for exact-match benchmarks like GAIA.
-
-Your job is to:
-- Use tools (e.g., `web_search`, `read_wikipedia_page`, `smart_paginate_around_query`, `reverse_sentence`, `open_file_as_text`, etc.) only when needed.
-- Never make assumptions. Do not guess.
-- Use `read_wikipedia_page` to read full content if snippets from `web_search` are not enough.
-- Use `smart_paginate_around_query` with 1-3 keyword terms — never full questions.
-- Use `reverse_sentence` for any reverse operation, never do it manually.
-- Use the provided `file_name` field for file tasks, not filenames inside the question.
-- Output formats:
-  - Numbers: Digits only, no commas, $, or %.
-  - Strings: No articles, abbreviations, or spelled-out numbers unless required.
-  - Lists: Comma separated, single space after each comma.
-- At the end, print only the final answer. No explanation, no reasoning.
-
-Example:
-If asked, “What is the capital of France?”
-Respond:
-print("Paris")
-
-Question:
-{question_text}
-
-File to use (if needed): {file_name}"""
-            submitted_answer = agent.run(full_prompt)
+            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})
         except Exception as e:

requirements.txt

@@ -1,11 +1,5 @@
-gradio==5.28.0
-smolagents==1.14.0
-pandas==2.2.3
-requests==2.32.3
-beautifulsoup4==4.13.4
-duckduckgo-search==8.0.1
-openpyxl==3.1.5
-whisper==1.1.10
-torch==2.1.0 
-ffmpeg-python==0.2.0
-python-dotenv==1.1.0
+langgraph
+langchain-core
+gradio
+pandas
+requests