Update tools and CodeAgent

app.py

@@ -1,24 +1,113 @@
-import os
-import gradio as gr 
-import requests
-import pandas as pd 
 import json
+import faiss
+import numpy as np
+import requests
+from sentence_transformers import SentenceTransformer
+
+from smolagents import CodeAgent, tool, InferenceClientModel, DuckDuckGoSearchTool
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+GLOBAL_AGENT = None
+search_tool = DuckDuckGoSearchTool()
+
+
+# -----------------------
+# TOOL IMPLEMENTATIONS
+# -----------------------
+
+
+@tool
+def rag_search(query: str) -> str:
+    """
+    Retrieve relevant information from the local FAISS knowledge base.
+    """
+
+    agent = GLOBAL_AGENT
+
+    if agent.index is None:
+        return "Knowledge base empty."
+
+    query_embedding = agent.embed_model.encode([query])
+
+    distances, indices = agent.index.search(np.array(query_embedding), 3)
+
+    results = []
+
+    for idx in indices[0]:
+        item = agent.metadata[idx]
+
+        question = item.get("Question", "")
+        answer = item.get("Final answer", "")
+
+        results.append(f"Question: {question}\nAnswer: {answer}")
+
+    return "\n\n".join(results)
+
+
+@tool
+def calculator(expression: str) -> str:
+    """
+    Evaluate mathematical expressions.
+    Example: 5*23+12
+    """
+
+    try:
+        return str(eval(expression))
+    except Exception as e:
+        return f"CALCULATION_ERROR:{e}"
+
+
+@tool
+def web_search(query: str) -> str:
+    """
+    Search the web for up-to-date information.
+    """
+
+    try:
+        results = search_tool.run(query)
+        return str(results)[:1000]
+
+    except Exception as e:
+        return f"WEB_SEARCH_FAILED:{e}"
+
+
+@tool
+def image_reader(agent, image_path=None):
+    """Placeholder multimodal tool."""
+    return "IMAGE_ANALYSIS_NOT_IMPLEMENTED"
+
 
 class BasicAgent:
 
     def __init__(self, metadata_path="metadata.jsonl"):
         self.metadata = self._load_metadata(metadata_path)
         print("BasicAgent initialized with metadata")
-        
-        
+        global GLOBAL_AGENT
+        GLOBAL_AGENT = self
+        self.embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+        documents = [item.get("Question", "") for item in self.metadata]
+
+        if documents:
+            embeddings = self.embed_model.encode(documents)
+            dimension = len(embeddings[0])
+            self.index = faiss.IndexFlatL2(dimension)
+            self.index.add(np.array(embeddings))
+        else:
+            self.index = None
+
+        self.agent = CodeAgent(
+            tools=[rag_search, calculator, web_search, image_reader],
+            model=InferenceClientModel(),
+            max_steps=6,
+        )
+
     def _load_metadata(self, file_path):
         """Load metadata from a JSONL file, parsing each line as a JSON object."""
         data = []
         try:
-            with open(file_path, 'r', encoding='utf-8') as f:
+            with open(file_path, "r", encoding="utf-8") as f:
                 for line_number, line in enumerate(f, 1):
                     line = line.strip()
                     if not line:
@@ -34,7 +123,9 @@ class BasicAgent:
             print(f"Loaded metadata from '{file_path}' with {len(data)} entries")
             return data
         except FileNotFoundError:
-            print(f"Metadata file '{file_path}' not found. Proceeding without metadata.")
+            print(
+                f"Metadata file '{file_path}' not found. Proceeding without metadata."
+            )
             return []
         except Exception as e:
             print(f"Unexpected error loading metadata from '{file_path}': {e}")
@@ -81,55 +172,37 @@ class BasicAgent:
         return "No action executed"
 
     def __call__(self, question: str) -> str:
-        """
-            User Question
-                ↓
-            Planner
-                ↓
-            Reasoning Loop
-                ↓
-            Tool Selection
-                ↓
-            Tool Execution
-                ↓
-            Observation
-                ↓
-            Repeat until solved
-                ↓
-            Final Answer
-        """
-        
 
         print(f"Agent received question: {question}")
 
-        self.current_question = question
-        context = ""
-
-        for step in range(5):
+        try:
+            response = self.agent.run(
+                f"""
+                You are a reasoning agent solving benchmark questions.
 
-            thought = self.think(question, context)
-            print("Thought:", thought)
+                Use tools when needed:
+                - rag_search for local knowledge
+                - web_search for internet lookup
+                - calculator for math
 
-            action = self.decide_action(thought)
-            print("Action:", action)
+                Question: {question}
 
-            observation = self.run_action(action)
-            print("Observation:", observation)
+                Return only the final answer.
+                """
+            )
 
-            context += f"\nThought:{thought}\nObservation:{observation}"
+            return str(response)
 
-            if "FINAL_ANSWER:" in observation:
-                return observation.replace("FINAL_ANSWER:", "").strip()
+        except Exception as e:
+            return f"AGENT_ERROR:{e}"
 
-        return "unknown"
-    
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
-    space_id = os.getenv("SPACE_ID")  
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
         username = f"{profile.username}"
@@ -178,17 +251,35 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             continue
         try:
             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})
+            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:
             print(f"Error running agent on task {task_id}: {e}")
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            results_log.append(
+                {
+                    "Task ID": task_id,
+                    "Question": question_text,
+                    "Submitted Answer": f"AGENT ERROR: {e}",
+                }
+            )
 
     if not answers_payload:
         print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
@@ -233,6 +324,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
+
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
@@ -253,16 +345,15 @@ with gr.Blocks() as demo:
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    status_output = gr.Textbox(
+        label="Run Status / Submission Result", lines=5, interactive=False
+    )
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
     space_host_startup = os.getenv("SPACE_HOST")
     space_id_startup = os.getenv("SPACE_ID")
 
@@ -275,11 +366,15 @@ if __name__ == "__main__":
     if space_id_startup:
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+        print(
+            f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main"
+        )
     else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+        print(
+            "ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined."
+        )
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("-" * (60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)