Update app.py

app.py

@@ -4,6 +4,9 @@ import requests
 import inspect
 import pandas as pd
 import re
+import sympy as sp
+import wikipedia
+from bs4 import BeautifulSoup
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -12,62 +15,136 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
-        self.api_url = "https://api-inference.huggingface.co/models/mixtral-7b-instruct-v0.3"
+        self.api_url = "https://api-inference.huggingface.co/models/distilbert-base-uncased"
         self.api_token = os.getenv("HF_TOKEN")
+        print(f"HF_TOKEN: {self.api_token}")  # Display token for verification
         if not self.api_token:
             raise ValueError("HF_TOKEN environment variable not set.")
         self.headers = {"Authorization": f"Bearer {self.api_token}"}
-        print("BasicAgent initialized with Mistral-7B-Instruct-v0.3.")
+        print("BasicAgent initialized with DistilBERT, SymPy, Wikipedia, and DuckDuckGo search.")
 
     def __call__(self, question: str) -> tuple[str, str]:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
+        reasoning = []
+        
+        # Step 1: Try to identify if the question is mathematical
+        is_math = any(keyword in question.lower() for keyword in ["calculate", "solve", "what is", "+", "-", "*", "/", "=", "equation"])
+        if is_math:
+            try:
+                expr = question.lower().replace("what is", "").replace("calculate", "").replace("solve", "").strip()
+                if "=" in expr:
+                    left, right = expr.split("=")
+                    eq = sp.Eq(sp.sympify(left.strip()), sp.sympify(right.strip()))
+                    solution = sp.solve(eq)
+                    concise_answer = str(solution[0]) if solution else "No solution"
+                    reasoning.append(f"Math Solver (SymPy): Parsed equation '{expr}'. Solution: {concise_answer}")
+                else:
+                    result = sp.sympify(expr).evalf()
+                    concise_answer = str(result)
+                    reasoning.append(f"Math Solver (SymPy): Evaluated expression '{expr}'. Result: {concise_answer}")
+                if concise_answer != "No solution":
+                    print(f"Agent returning concise answer (math): {concise_answer}")
+                    return concise_answer, "\n".join(reasoning)
+            except Exception as e:
+                reasoning.append(f"Math Solver (SymPy) failed: {e}")
+
+        # Step 2: Try Wikipedia for factual questions
+        try:
+            wikipedia.set_lang("en")
+            key_terms = " ".join(question.split()[:3]).strip("?")
+            wiki_summary = wikipedia.summary(key_terms, sentences=2, auto_suggest=True)
+            prompt = (
+                f"Question: {question}\n"
+                f"Context: {wiki_summary}\n"
+                "Provide a concise answer (e.g., a number or short phrase) based on the context."
+            )
+            wiki_answer = self._query_llm(prompt)
+            answer_match = re.search(r"Answer: (.*?)(?:\nReasoning: (.*))?$", wiki_answer, re.DOTALL)
+            if answer_match:
+                concise_answer = answer_match.group(1).strip()
+                wiki_reasoning = answer_match.group(2).strip() if answer_match.group(2) else wiki_answer
+            else:
+                concise_answer = self._extract_concise_answer(wiki_answer)
+                wiki_reasoning = wiki_answer
+            reasoning.append(f"Wikipedia: Searched '{key_terms}'. Summary: {wiki_summary[:100]}... Answer: {concise_answer}")
+            print(f"Agent returning concise answer (Wikipedia): {concise_answer}")
+            return concise_answer, "\n".join(reasoning)
+        except wikipedia.exceptions.DisambiguationError:
+            reasoning.append("Wikipedia: Disambiguation error, multiple results found.")
+        except Exception as e:
+            reasoning.append(f"Wikipedia failed: {e}")
+
+        # Step 3: Try web search with DuckDuckGo
+        try:
+            search_url = f"https://duckduckgo.com/html/?q={question.replace(' ', '+')}"
+            response = requests.get(search_url, timeout=10)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.text, "html.parser")
+            snippets = [s.text.strip() for s in soup.find_all("div", class_="result__snippet")[:2]]
+            if snippets:
+                prompt = (
+                    f"Question: {question}\n"
+                    f"Search Results: {' '.join(snippets)[:500]}\n"
+                    "Provide a concise answer (e.g., a number or short phrase) based on the search results."
+                )
+                search_answer = self._query_llm(prompt)
+                answer_match = re.search(r"Answer: (.*?)(?:\nReasoning: (.*))?$", search_answer, re.DOTALL)
+                if answer_match:
+                    concise_answer = answer_match.group(1).strip()
+                    search_reasoning = answer_match.group(2).strip() if answer_match.group(2) else search_answer
+                else:
+                    concise_answer = self._extract_concise_answer(search_answer)
+                    search_reasoning = search_answer
+                reasoning.append(f"Web Search (DuckDuckGo): Searched '{question}'. Answer: {concise_answer}")
+                print(f"Agent returning concise answer (search): {concise_answer}")
+                return concise_answer, "\n".join(reasoning)
+            else:
+                reasoning.append("Web Search (DuckDuckGo): No relevant results found.")
+        except Exception as e:
+            reasoning.append(f"Web Search (DuckDuckGo) failed: {e}")
+
+        # Step 4: Fallback to LLM alone
         try:
-            # Prompt designed for concise answers and detailed reasoning
             prompt = (
                 f"Question: {question}\n"
                 "Please provide a concise answer (e.g., a number like '5' or a short phrase) "
                 "followed by a detailed explanation of your reasoning. "
                 "Format your response as: Answer: <concise answer>\nReasoning: <detailed reasoning>"
             )
-            payload = {
-                "inputs": prompt,
-                "parameters": {"max_new_tokens": 300, "return_full_text": False}
-            }
-            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=10)
-            response.raise_for_status()
-            full_response = response.json()[0]["generated_text"].strip()
-
-            # Extract concise answer and reasoning
+            full_response = self._query_llm(prompt)
             answer_match = re.search(r"Answer: (.*?)(?:\nReasoning: (.*))?$", full_response, re.DOTALL)
             if answer_match:
                 concise_answer = answer_match.group(1).strip()
-                reasoning = answer_match.group(2).strip() if answer_match.group(2) else "No reasoning provided by model."
+                llm_reasoning = answer_match.group(2).strip() if answer_match.group(2) else "No reasoning provided by model."
             else:
-                # Fallback: Try to extract a concise answer (e.g., a number or short phrase)
                 concise_answer = self._extract_concise_answer(full_response)
-                reasoning = full_response
-
-            print(f"Agent returning concise answer: {concise_answer}")
-            print(f"Reasoning (first 50 chars): {reasoning[:50]}...")
-            return concise_answer, reasoning
-        except requests.exceptions.RequestException as e:
+                llm_reasoning = full_response
+            reasoning.append(f"LLM (DistilBERT): {llm_reasoning}")
+            print(f"Agent returning concise answer (LLM): {concise_answer}")
+            return concise_answer, "\n".join(reasoning)
+        except Exception as e:
             print(f"Error querying Inference API: {e}")
             return f"Error: {e}", f"Error: Failed to get answer from model - {e}"
-        except Exception as e:
-            print(f"Unexpected error in agent: {e}")
-            return f"Error: {e}", f"Error: {e}"
+
+    def _query_llm(self, prompt: str) -> str:
+        try:
+            payload = {
+                "inputs": prompt,
+                "parameters": {"max_length": 100, "return_full_text": False}
+            }
+            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=10)
+            response.raise_for_status()
+            return response.json()[0]["generated_text"].strip()
+        except requests.exceptions.RequestException as e:
+            return f"Error: Failed to get answer from model - {e}"
 
     def _extract_concise_answer(self, response: str) -> str:
-        """Extracts a concise answer (e.g., number or short phrase) from the model's response."""
-        # Try to find a number (integer or float)
         number_match = re.search(r"\b\d+(\.\d+)?\b", response)
         if number_match:
             return number_match.group(0)
-        # Try to find a short phrase (up to 3 words)
         words = response.split()[:3]
         if len(words) <= 3 and len(" ".join(words)) <= 20:
             return " ".join(words)
-        # Fallback: Use first sentence or first 10 characters
         sentence_end = response.find(". ")
         if sentence_end != -1:
             return response[:sentence_end].strip()[:20]
@@ -214,7 +291,7 @@ with gr.Blocks() as demo:
         ---
         **Disclaimers:**
         Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a separate action or even to answer the questions in async.
         """
     )