Update app.py

app.py

@@ -3,113 +3,85 @@ import re
 import requests
 import gradio as gr
 import pandas as pd
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, tool, VisitWebpageTool
+from groq import Groq
+from duckduckgo_search import DDGS
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+TIMEOUT_PER_QUESTION = 30  # Max 30 seconds per question
 
 # ============================================
-# TOOLS
+# INITIALIZE GROQ CLIENT
 # ============================================
 
-@tool
-def calculator(expression: str) -> str:
-    """
-    Calculates a math expression.
-    
-    Args:
-        expression: Math expression like "2+2" or "10*5"
-    
-    Returns:
-        Result as string
-    """
-    import math
+def get_groq_client():
+    api_key = os.environ.get("GROQ_API_KEY")
+    if not api_key:
+        raise ValueError("GROQ_API_KEY not set!")
+    return Groq(api_key=api_key)
+
+# ============================================
+# TOOL FUNCTIONS
+# ============================================
+
+def web_search(query: str) -> str:
+    """Search the web"""
     try:
-        safe = {"sqrt": math.sqrt, "pow": pow, "abs": abs, "round": round,
-                "sin": math.sin, "cos": math.cos, "pi": math.pi, "log": math.log}
-        return str(eval(expression, {"__builtins__": {}}, safe))
-    except Exception as e:
-        return f"Error: {e}"
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=3))
+        if not results:
+            return "No results"
+        return "\n".join([f"- {r['title']}: {r['body']}" for r in results])
+    except:
+        return "Search failed"
 
 
-@tool
 def wikipedia_search(topic: str) -> str:
-    """
-    Gets Wikipedia summary for a topic.
-    
-    Args:
-        topic: What to search
-    
-    Returns:
-        Wikipedia extract
-    """
+    """Get Wikipedia info"""
     try:
         url = "https://en.wikipedia.org/w/api.php"
         params = {"action": "query", "list": "search", "srsearch": topic, "format": "json", "srlimit": 1}
-        data = requests.get(url, params=params, timeout=10).json()
+        data = requests.get(url, params=params, timeout=5).json()
         
         if not data.get("query", {}).get("search"):
-            return "No Wikipedia article found."
+            return "Not found"
         
         title = data["query"]["search"][0]["title"]
         params2 = {"action": "query", "titles": title, "prop": "extracts", "exintro": True, "explaintext": True, "format": "json"}
-        pages = requests.get(url, params=params2, timeout=10).json().get("query", {}).get("pages", {})
+        pages = requests.get(url, params=params2, timeout=5).json().get("query", {}).get("pages", {})
         
         for page in pages.values():
-            return page.get("extract", "No content")[:3000]
+            return page.get("extract", "")[:2000]
         return "No content"
-    except Exception as e:
-        return f"Error: {e}"
+    except:
+        return "Wikipedia error"
 
 
-@tool
 def get_task_file(task_id: str) -> str:
-    """
-    Gets file content for a GAIA task.
-    
-    Args:
-        task_id: The task ID
-    
-    Returns:
-        File content
-    """
+    """Get GAIA task file"""
     try:
         url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-        response = requests.get(url, timeout=20)
+        response = requests.get(url, timeout=10)
         
         if response.status_code == 404:
-            return "No file for this task."
+            return ""
         
         content_type = response.headers.get('content-type', '').lower()
         
         if 'text' in content_type or 'json' in content_type:
-            return response.text[:5000]
+            return response.text[:4000]
         
-        if 'spreadsheet' in content_type or 'excel' in content_type:
+        if 'excel' in content_type or 'spreadsheet' in content_type:
             try:
                 from io import BytesIO
                 df = pd.read_excel(BytesIO(response.content))
-                return df.to_string()
+                return df.to_string()[:4000]
             except:
-                return "Excel file (cannot read)"
+                return "Excel file"
         
-        return f"Binary file: {content_type}"
-    except Exception as e:
-        return f"Error: {e}"
-
-
-@tool
-def reverse_text(text: str) -> str:
-    """
-    Reverses text.
-    
-    Args:
-        text: Text to reverse
-    
-    Returns:
-        Reversed text
-    """
-    return text[::-1]
+        return f"File type: {content_type}"
+    except:
+        return ""
 
 
 # ============================================
@@ -118,56 +90,67 @@ def reverse_text(text: str) -> str:
 
 class BasicAgent:
     def __init__(self):
-        print("Initializing HuggingFace agent...")
-        
-        # Use HfApiModel with a FREE model
-        self.model = HfApiModel(
-            model_id="Qwen/Qwen2.5-72B-Instruct",  # This one should be free
-            token=os.environ.get("HF_TOKEN"),
-        )
-        
-        self.agent = CodeAgent(
-            model=self.model,
-            tools=[
-                DuckDuckGoSearchTool(),
-                VisitWebpageTool(),
-                wikipedia_search,
-                calculator,
-                get_task_file,
-                reverse_text,
-            ],
-            max_steps=5,
-            verbosity_level=2,
-        )
-        print("Agent ready!")
+        print("Initializing Groq agent...")
+        self.client = get_groq_client()
+        print("✅ Agent ready!")
     
     def __call__(self, question: str, task_id: str = None) -> str:
-        print(f"  Processing: {question[:60]}...")
-        
         try:
-            prompt = f"""Answer this question concisely. Use tools if needed.
-If a file is mentioned, use get_task_file("{task_id}").
-Give ONLY the final answer.
+            # Check for file first
+            file_content = ""
+            if task_id:
+                file_content = get_task_file(task_id)
+            
+            # Check if we need to search
+            needs_search = any(word in question.lower() for word in 
+                ["who is", "what is", "when did", "where is", "current", "latest", "recent"])
+            
+            search_results = ""
+            if needs_search and not file_content:
+                # Extract search query from question
+                search_results = web_search(question[:100])
+            
+            # Build context
+            context = ""
+            if file_content:
+                context += f"\n\nFile content:\n{file_content}"
+            if search_results and search_results != "No results":
+                context += f"\n\nSearch results:\n{search_results}"
+            
+            # Ask Groq
+            prompt = f"""Answer this question with ONLY the final answer. No explanation.
+Be precise - just give the exact answer.
+{context}
+
+Question: {question}
 
-Question: {question}"""
+Answer:"""
 
-            result = self.agent.run(prompt)
-            answer = str(result).strip()
+            response = self.client.chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0,
+                max_tokens=200,
+                timeout=TIMEOUT_PER_QUESTION,
+            )
             
-            # Clean up
-            for prefix in ["Answer:", "Final answer:", "The answer is"]:
+            answer = response.choices[0].message.content.strip()
+            
+            # Clean up common prefixes
+            for prefix in ["Answer:", "The answer is:", "Final answer:", "A:"]:
                 if answer.lower().startswith(prefix.lower()):
                     answer = answer[len(prefix):].strip()
             
-            if answer.startswith('"') and answer.endswith('"'):
+            # Remove quotes
+            if (answer.startswith('"') and answer.endswith('"')) or \
+               (answer.startswith("'") and answer.endswith("'")):
                 answer = answer[1:-1]
             
-            print(f"  Answer: {answer[:60]}")
             return answer
             
         except Exception as e:
-            print(f"  Error: {e}")
-            return "Unable to answer"
+            print(f"    Error: {e}")
+            return "unknown"
 
 
 # ============================================
@@ -183,42 +166,61 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     
     print(f"\n{'='*50}")
     print(f"User: {username}")
-    print(f"{'='*50}")
+    
+    # Check API key
+    if not os.environ.get("GROQ_API_KEY"):
+        return "❌ ERROR: Add GROQ_API_KEY to Space secrets!", None
+    
+    print("✅ GROQ_API_KEY found")
+    print(f"{'='*50}\n")
 
     # Init agent
     try:
         agent = BasicAgent()
     except Exception as e:
-        return f"Agent failed to init: {e}", None
+        return f"❌ Agent init failed: {e}", None
 
     # Get questions
     try:
         questions = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15).json()
-        print(f"Fetched {len(questions)} questions\n")
+        print(f"📋 Got {len(questions)} questions\n")
     except Exception as e:
-        return f"Failed to fetch questions: {e}", None
+        return f"❌ Failed to fetch questions: {e}", None
 
     # Process each question
     results = []
     answers = []
     
+    import time
+    start_time = time.time()
+    
     for i, q in enumerate(questions):
         task_id = q.get("task_id")
         question = q.get("question", "")
         
-        print(f"[{i+1}/{len(questions)}] {task_id}")
+        q_start = time.time()
+        print(f"[{i+1}/{len(questions)}] {question[:70]}...")
         
         try:
             answer = agent(question, task_id)
+            q_time = time.time() - q_start
+            print(f"    ✓ {answer[:50]}... ({q_time:.1f}s)")
         except Exception as e:
-            answer = "Error"
-            print(f"  Failed: {e}")
+            answer = "unknown"
+            print(f"    ✗ Error: {e}")
         
         answers.append({"task_id": task_id, "submitted_answer": answer})
-        results.append({"#": i+1, "Question": question[:50]+"...", "Answer": answer[:80]})
+        results.append({
+            "#": i+1, 
+            "Question": question[:50]+"...", 
+            "Answer": answer[:60]
+        })
+
+    total_time = time.time() - start_time
+    print(f"\n⏱️ Total time: {total_time:.1f}s ({total_time/60:.1f} min)")
 
     # Submit
-    print(f"\nSubmitting {len(answers)} answers...")
+    print(f"\n📤 Submitting {len(answers)} answers...")
     
     try:
         submission = {
@@ -232,13 +234,22 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         correct = result.get('correct_count', 0)
         total = result.get('total_attempted', 0)
         
-        status = f"✅ Done!\n\nScore: {score}% ({correct}/{total})\n\n"
-        status += "🎉 PASSED!" if score >= 30 else f"Need {30-score}% more to pass"
+        status = f"✅ Done in {total_time:.0f}s!\n\n"
+        status += f"🎯 Score: {score}% ({correct}/{total} correct)\n\n"
+        
+        if score >= 30:
+            status += "🎉 PASSED! You got 30%+!"
+        else:
+            status += f"📈 Need {30-score}% more to pass"
+        
+        print(f"\n{'='*50}")
+        print(f"SCORE: {score}% ({correct}/{total})")
+        print(f"{'='*50}")
         
         return status, pd.DataFrame(results)
         
     except Exception as e:
-        return f"Submit failed: {e}", pd.DataFrame(results)
+        return f"❌ Submit failed: {e}", pd.DataFrame(results)
 
 
 # ============================================
@@ -247,16 +258,32 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 with gr.Blocks() as demo:
     gr.Markdown("# 🎯 GAIA Agent - Unit 4")
-    gr.Markdown("Using **HuggingFace** + **Qwen 72B**")
+    gr.Markdown("""
+    **Powered by Groq + Llama 3.3 70B**
+    
+    ⚡ Fast: ~5-10 minutes for all 20 questions
+    
+    **Setup:**
+    1. Add `GROQ_API_KEY` to Space secrets
+    2. Log in below
+    3. Click Run!
+    """)
 
     gr.LoginButton()
-    run_btn = gr.Button("🚀 Run Evaluation", variant="primary")
-    status = gr.Textbox(label="Status", lines=5)
+    run_btn = gr.Button("🚀 Run Evaluation", variant="primary", size="lg")
+    status = gr.Textbox(label="Status", lines=6)
     table = gr.DataFrame(label="Results")
 
     run_btn.click(run_and_submit_all, outputs=[status, table])
 
 if __name__ == "__main__":
-    print("Starting GAIA Agent (HuggingFace)...")
-    print(f"HF_TOKEN: {'✅ Found' if os.environ.get('HF_TOKEN') else '❌ Missing'}")
+    print("="*50)
+    print("🎯 GAIA Agent - Groq Edition")
+    print("="*50)
+    
+    if os.environ.get("GROQ_API_KEY"):
+        print("✅ GROQ_API_KEY found")
+    else:
+        print("❌ GROQ_API_KEY missing - add to secrets!")
+    
     demo.launch()