Update app.py

app.py

@@ -1,100 +1,78 @@
-"""
-Advanced Agent Evaluation Runner with Custom LangGraph Implementation
-"""
 import os
 import gradio as gr
 import requests
 import pandas as pd
-from typing import Dict, List, Optional
 from datetime import datetime
-from langgraph.graph import StateGraph, END
-from langchain_core.messages import HumanMessage, AIMessage
+from transformers import pipeline, Tool
+from transformers.agents import Agent
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Custom Agent State Definition ---
-class AgentState(Dict):
-    messages: List[Dict]
-    question: str
-    response: Optional[str]
-
-# --- Custom Tool Implementations ---
-class MathTool:
-    def execute(self, expression: str) -> str:
+# --- Custom Tools ---
+class CalculatorTool(Tool):
+    name = "calculator"
+    description = "Performs mathematical calculations"
+    inputs = ["text"]
+    outputs = ["text"]
+    
+    def __call__(self, expression: str) -> str:
         try:
-            return f"Calculation result: {eval(expression)}"
+            return str(eval(expression))
         except:
-            return "Error: Invalid mathematical expression"
-
-class TimeTool:
-    def execute(self) -> str:
-        return f"Current time: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}"
+            return "Error: Could not evaluate the expression"
 
-# --- Custom Agent Graph Builder ---
-def create_agent_workflow():
-    workflow = StateGraph(AgentState)
-    
-    # Define nodes
-    def route_question(state: AgentState):
-        question = state["question"].lower()
-        if any(op in question for op in ["+", "-", "*", "/", "calculate"]):
-            return "math_tool"
-        elif "time" in question or "current time" in question:
-            return "time_tool"
-        return "llm_response"
-    
-    def math_node(state: AgentState):
-        tool = MathTool()
-        return {"response": tool.execute(state["question"])}
-    
-    def time_node(state: AgentState):
-        tool = TimeTool()
-        return {"response": tool.execute()}
-    
-    def llm_node(state: AgentState):
-        # Simulated LLM response
-        return {"response": f"AI response to: {state['question']}"}
-    
-    # Build graph
-    workflow.add_node("math_tool", math_node)
-    workflow.add_node("time_tool", time_node)
-    workflow.add_node("llm_response", llm_node)
-    
-    workflow.add_conditional_edges(
-        "start",
-        route_question,
-        {
-            "math_tool": "math_tool",
-            "time_tool": "time_tool",
-            "llm_response": "llm_response"
-        }
-    )
-    
-    workflow.add_edge("math_tool", END)
-    workflow.add_edge("time_tool", END)
-    workflow.add_edge("llm_response", END)
+class TimeTool(Tool):
+    name = "current_time"
+    description = "Gets current UTC time"
+    inputs = []
+    outputs = ["text"]
     
-    workflow.set_entry_point("start")
-    return workflow.compile()
+    def __call__(self) -> str:
+        return datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
 
-# --- Custom Agent Class ---
-class CustomLangGraphAgent:
+# --- Enhanced Agent ---
+class HFLocalAgent:
     def __init__(self):
-        self.workflow = create_agent_workflow()
-        print("Custom LangGraph agent initialized")
-    
+        print("Initializing local Hugging Face agent...")
+        self.tools = {
+            "calculator": CalculatorTool(),
+            "time": TimeTool()
+        }
+        
+        # Load local model (small but efficient)
+        self.llm = pipeline(
+            "text-generation",
+            model="HuggingFaceH4/zephyr-7b-beta",
+            device="cpu"  # Change to "cuda" if GPU available
+        )
+        
     def __call__(self, question: str) -> str:
+        print(f"Processing: {question[:100]}...")
+        question_lower = question.lower()
+        
+        # Math questions
+        if any(word in question_lower for word in ["calculate", "what is", "how much is", "+", "-", "*", "/"]):
+            return self.tools["calculator"](question.replace("?", ""))
+        
+        # Time questions
+        if any(word in question_lower for word in ["time", "current time"]):
+            return self.tools["time"]()
+        
+        # Fallback to local LLM
         try:
-            state = {"question": question, "messages": [], "response": None}
-            result = self.workflow.invoke(state)
-            return result["response"]
+            response = self.llm(
+                f"Answer concisely: {question}",
+                max_new_tokens=100,
+                temperature=0.7
+            )
+            return response[0]['generated_text'].split(":")[-1].strip()
         except Exception as e:
-            print(f"Agent error: {e}")
-            return "Error processing question"
+            print(f"LLM error: {e}")
+            return "I couldn't process this question."
 
 # --- Evaluation Runner ---
-def run_evaluation(profile: gr.OAuthProfile | None):
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     if not profile:
         return "Please login first", None
     
@@ -102,7 +80,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     api_url = os.getenv("API_URL", DEFAULT_API_URL)
     
     try:
-        agent = CustomLangGraphAgent()
+        agent = HFLocalAgent()
         questions = requests.get(f"{api_url}/questions", timeout=15).json()
         
         results = []
@@ -133,10 +111,10 @@ def run_evaluation(profile: gr.OAuthProfile | None):
         return f"Evaluation failed: {e}", None
 
 # --- Gradio Interface ---
-with gr.Blocks(title="Custom LangGraph Agent Evaluator") as app:
+with gr.Blocks(title="Local HF Agent Evaluator") as app:
     gr.Markdown("""
-    ## Custom LangGraph Agent Evaluation
-    Test your agent against the benchmark questions
+    ## Local Hugging Face Agent Evaluation
+    Uses completely free/local models - no API keys required
     """)
     
     gr.LoginButton()
@@ -145,7 +123,7 @@ with gr.Blocks(title="Custom LangGraph Agent Evaluator") as app:
     results = gr.DataFrame(label="Details")
     
     run_btn.click(
-        fn=run_evaluation,
+        fn=run_and_submit_all,
         outputs=[output, results]
     )