agent file cleaned

agent.py

@@ -1,5 +1,5 @@
 """
-Intelligent AI Agent using LlamaIndex with CodeAct capabilities
+Intelligent AI Agent using LlamaIndex with websearch capabilities
 This module contains the agent class with advanced tools and reasoning.
 """
 
@@ -23,17 +23,14 @@ except Exception as e:
 
 # LlamaIndex imports
 try:
-    from llama_index.core.agent.workflow import CodeActAgent
-    from llama_index.core.workflow import Context
     from llama_index.core.agent.workflow import (
         ToolCall,
         ToolCallResult,
         FunctionAgent,
         AgentStream,
     )
-    from llama_index.llms.huggingface import HuggingFaceLLM
+    #from llama_index.llms.huggingface import HuggingFaceLLM
     from llama_index.core.tools import FunctionTool
-    from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
     from llama_index.tools.wikipedia import WikipediaToolSpec
     from llama_index.tools.tavily_research.base import TavilyToolSpec
     #from llama_index.llms.ollama import Ollama
@@ -44,59 +41,7 @@ except ImportError as e:
     print(f"LlamaIndex imports not available: {e}")
     LLAMA_INDEX_AVAILABLE = False
 
-MODEL = "microsoft/Phi-3.5-mini-instruct"
-
-class SimpleCodeExecutor:
-    """
-    A simple code executor that runs Python code with state persistence.
-    NOTE: not safe for production use! Use with caution.
-    """
-
-    def __init__(self, locals_dict: Dict[str, Any], globals_dict: Dict[str, Any]):
-        """Initialize the code executor."""
-        self.globals = globals_dict
-        self.locals = locals_dict
-
-    def execute(self, code: str) -> Tuple[bool, str, Any]:
-        """Execute Python code and capture output and return values."""
-        stdout = io.StringIO()
-        stderr = io.StringIO()
-
-        output = ""
-        return_value = None
-        try:
-            with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
-                try:
-                    tree = ast.parse(code)
-                    last_node = tree.body[-1] if tree.body else None
-
-                    if isinstance(last_node, ast.Expr):
-                        last_line = code.rstrip().split("\n")[-1]
-                        exec_code = (
-                            code[: -len(last_line)]
-                            + "\n__result__ = "
-                            + last_line
-                        )
-                        exec(exec_code, self.globals, self.locals)
-                        return_value = self.locals.get("__result__")
-                    else:
-                        exec(code, self.globals, self.locals)
-                except:
-                    exec(code, self.globals, self.locals)
-
-            output = stdout.getvalue()
-            if stderr.getvalue():
-                output += "\n" + stderr.getvalue()
-                
-        except Exception as e:
-            output = f"Error: {type(e).__name__}: {str(e)}\n"
-            output += traceback.format_exc()
-
-        if return_value is not None:
-            output += "\n\n" + str(return_value)
-        
-        return output
-
+#MODEL = "microsoft/Phi-3.5-mini-instruct"
 
 class BasicAgent:
     """
@@ -248,41 +193,6 @@ class BasicAgent:
             
         print(f"✅ Total {len(self.tools)} tools initialized")
         
-    def _initialize_code_executor(self):
-        """Initialize the code executor with necessary imports and functions."""
-        # Prepare locals with math functions
-        code_locals = {
-            "add_numbers": lambda a, b: a + b,
-            "subtract_numbers": lambda a, b: a - b,
-            "multiply_numbers": lambda a, b: a * b,
-            "divide_numbers": lambda a, b: a / b if b != 0 else "Error: Division by zero",
-            "power_numbers": lambda a, b: a ** b,
-            "calculate_percentage": lambda v, p: (v * p) / 100,
-        }
-        
-        # Prepare globals with common imports
-        code_globals = {
-            "__builtins__": __builtins__,
-            "math": __import__("math"),
-            "datetime": __import__("datetime"),
-            "json": __import__("json"),
-            "re": __import__("re"),
-        }
-        
-        try:
-            code_globals["numpy"] = __import__("numpy")
-            code_globals["np"] = code_globals["numpy"]
-        except ImportError:
-            pass
-            
-        try:
-            code_globals["pandas"] = __import__("pandas")
-            code_globals["pd"] = code_globals["pandas"]
-        except ImportError:
-            pass
-        
-        self.code_executor = SimpleCodeExecutor(code_locals, code_globals)
-        print("✅ Code executor initialized")
         
     def _initialize_agent(self):
         """Initialize the CodeAct Agent (deferred initialization)."""
@@ -354,7 +264,7 @@ class BasicAgent:
                 response = await self._async_agent_run(question)
                 return response
             except Exception as e:
-                print(f"Error with CodeAct agent: {e}")
+                print(f"Error with agent: {e}")
                 return f"FINAL ANSWER: Error processing question - {str(e)}"
         else:
             return "FINAL ANSWER: Agent not properly initialized"

app.py

@@ -162,6 +162,10 @@ 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.
+        
+        ---
+        My certificate of completion: [![Certificate](https://huggingface.co/datasets/agents-course/final-certificates/resolve/main/certificates/stiv14/2025-06-27.png)](https://huggingface.co/datasets/agents-course/final-certificates/resolve/main/certificates/stiv14/2025-06-27.png)
+        
         """
     )