Update app.py

app.py

@@ -1,12 +1,48 @@
 import os
+import re
+import json
 import gradio as gr
 import requests
 import pandas as pd
 
 from groq import Groq
+from duckduckgo_search import DDGS
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+# ---------------------------------------------------
+# WEB SEARCH TOOL
+# ---------------------------------------------------
+class WebSearchTool:
+
+    def __init__(self):
+        self.ddgs = DDGS()
+
+    def search(self, query, max_results=5):
+
+        try:
+
+            results = self.ddgs.text(
+                query,
+                max_results=max_results
+            )
+
+            snippets = []
+
+            for r in results:
+                body = r.get("body", "")
+                title = r.get("title", "")
+                snippets.append(f"{title}: {body}")
+
+            return "\n".join(snippets[:5])
+
+        except Exception as e:
+
+            print(f"Search error: {e}")
+
+            return ""
+
+
 # ---------------------------------------------------
 # AGENT
 # ---------------------------------------------------
@@ -18,8 +54,13 @@ class BasicAgent:
             api_key=os.getenv("GROQ_API_KEY")
         )
 
-        print("Groq client initialized.")
+        self.search_tool = WebSearchTool()
+
+        print("Agent initialized.")
 
+    # ---------------------------------------------------
+    # CLEAN ANSWER
+    # ---------------------------------------------------
     def clean_answer(self, text):
 
         if text is None:
@@ -31,55 +72,128 @@ class BasicAgent:
         text = text.replace("FINAL ANSWER:", "")
         text = text.replace("Answer:", "")
 
+        text = re.sub(r"\s+", " ", text)
+
         text = text.strip()
 
+        # first line only
         text = text.split("\n")[0]
 
-        return text[:200]
-
+        return text[:300]
+
+    # ---------------------------------------------------
+    # DETECT SEARCH NEED
+    # ---------------------------------------------------
+    def needs_search(self, question):
+
+        keywords = [
+            "who",
+            "when",
+            "where",
+            "latest",
+            "current",
+            "search",
+            "find",
+            "look up",
+            "verify",
+            "paper",
+            "award",
+            "actor",
+            "country",
+            "city",
+            "population",
+            "website",
+            "nasa",
+            "movie",
+            "song",
+            "audio",
+            "youtube",
+            "wikipedia"
+        ]
+
+        q = question.lower()
+
+        return any(k in q for k in keywords)
+
+    # ---------------------------------------------------
+    # MAIN CALL
+    # ---------------------------------------------------
     def __call__(self, question: str) -> str:
 
         try:
 
+            web_context = ""
+
+            # ---------------------------------------------------
+            # WEB SEARCH
+            # ---------------------------------------------------
+            if self.needs_search(question):
+
+                print(f"\nSearching web for: {question}")
+
+                web_context = self.search_tool.search(question)
+
+            # ---------------------------------------------------
+            # PROMPT
+            # ---------------------------------------------------
+            system_prompt = """
+You are an advanced GAIA benchmark solving assistant.
+
+Rules:
+- Return ONLY the final answer.
+- No reasoning.
+- No markdown.
+- No explanations.
+- Be concise.
+- If the answer is a list, format correctly.
+- If unsure, still provide your best answer.
+"""
+
+            user_prompt = f"""
+QUESTION:
+{question}
+
+WEB SEARCH RESULTS:
+{web_context}
+"""
+
+            # ---------------------------------------------------
+            # GROQ CALL
+            # ---------------------------------------------------
             completion = self.client.chat.completions.create(
-                model="llama-3.1-8b-instant",
+                model="llama-3.3-70b-versatile",
                 messages=[
                     {
                         "role": "system",
-                        "content": (
-                            "You are solving benchmark questions. "
-                            "Return ONLY the final answer. "
-                            "No explanations. "
-                            "Be concise."
-                        )
+                        "content": system_prompt
                     },
                     {
                         "role": "user",
-                        "content": question
+                        "content": user_prompt
                     }
                 ],
                 temperature=0,
-                max_tokens=64
+                max_tokens=128
             )
 
             answer = completion.choices[0].message.content
 
             cleaned = self.clean_answer(answer)
 
-            print(f"\nQ: {question}")
-            print(f"A: {cleaned}")
+            print(f"\nQUESTION:\n{question}")
+            print(f"\nANSWER:\n{cleaned}")
 
             return cleaned
 
         except Exception as e:
 
-            print(f"ERROR: {e}")
+            print(f"Agent error: {e}")
 
             return ""
 
 
 # ---------------------------------------------------
-# MAIN
+# MAIN EVALUATION
 # ---------------------------------------------------
 def run_and_submit_all(profile: gr.OAuthProfile | None):
 
@@ -91,7 +205,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{DEFAULT_API_URL}/questions"
     submit_url = f"{DEFAULT_API_URL}/submit"
 
-    # init agent
+    # ---------------------------------------------------
+    # INIT AGENT
+    # ---------------------------------------------------
     try:
 
         agent = BasicAgent()
@@ -100,7 +216,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
         return f"Agent init error: {e}", None
 
-    # fetch questions
+    # ---------------------------------------------------
+    # FETCH QUESTIONS
+    # ---------------------------------------------------
     try:
 
         response = requests.get(
@@ -108,6 +226,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             timeout=30
         )
 
+        response.raise_for_status()
+
         questions_data = response.json()
 
     except Exception as e:
@@ -117,12 +237,18 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     answers_payload = []
     results_log = []
 
-    # run questions
-    for item in questions_data:
+    # ---------------------------------------------------
+    # RUN QUESTIONS
+    # ---------------------------------------------------
+    for idx, item in enumerate(questions_data):
 
         task_id = item.get("task_id")
         question = item.get("question")
 
+        print(f"\n========================")
+        print(f"TASK {idx+1}")
+        print(f"========================")
+
         try:
 
             answer = agent(question)
@@ -146,7 +272,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                 "Answer": f"ERROR: {e}"
             })
 
-    # submit
+    # ---------------------------------------------------
+    # SUBMIT
+    # ---------------------------------------------------
     try:
 
         submission = {
@@ -165,7 +293,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
         status = (
             f"Score: {result.get('score')}%\n"
-            f"Correct: {result.get('correct_count')}/"
+            f"Correct: "
+            f"{result.get('correct_count')}/"
             f"{result.get('total_attempted')}"
         )
 
@@ -183,6 +312,12 @@ with gr.Blocks() as demo:
 
     gr.Markdown("# HF Agents Course Assignment")
 
+    gr.Markdown("""
+Tools enabled:
+- Groq Llama 3.3 70B
+- DuckDuckGo Search
+""")
+
     gr.LoginButton()
 
     btn = gr.Button("Run Evaluation")
@@ -205,4 +340,6 @@ with gr.Blocks() as demo:
 # ---------------------------------------------------
 if __name__ == "__main__":
 
+    print("Launching app...")
+
     demo.launch()