first try

.gitignore

@@ -0,0 +1,8 @@
+.env
+.venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz

README_AGENT.md

@@ -0,0 +1,180 @@
+# 🤖 Advanced AI Agent with LlamaIndex
+
+Este es un agente de IA avanzado construido con LlamaIndex que incluye capacidades de CodeAct, búsqueda web y herramientas matemáticas.
+
+## 🚀 Características
+
+### 🧠 Capacidades del Agente
+
+- **Razonamiento Avanzado**: Utiliza LlamaIndex con modelos de Hugging Face
+- **CodeAct Agent**: Puede escribir y ejecutar código Python para resolver problemas complejos
+- **Herramientas Matemáticas**: Cálculos básicos y avanzados
+- **Búsqueda Web**: Integración con DuckDuckGo y Wikipedia
+- **Modo Fallback**: Funciona incluso sin configuración completa
+
+### 🛠 Herramientas Disponibles
+
+1. **Matemáticas**: suma, resta, multiplicación, división, potencias, porcentajes
+2. **Búsqueda DuckDuckGo**: Búsquedas web en tiempo real
+3. **Wikipedia**: Búsqueda de información factual
+4. **Peticiones Web**: Llamadas a APIs
+5. **Ejecución de Código**: Python con librerías como numpy, pandas, math
+
+## ⚙️ Configuración
+
+### 1. Instalar Dependencias
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Configurar Variables de Entorno
+
+Crea un archivo `.env` con:
+
+```bash
+# Token de Hugging Face (opcional pero recomendado)
+HUGGINGFACE_TOKEN=tu_token_aqui
+```
+
+Para obtener tu token:
+
+1. Ve a [Hugging Face Settings](https://huggingface.co/settings/tokens)
+2. Crea un nuevo token
+3. Copia el token en tu archivo `.env`
+
+### 3. Usar el Agente
+
+#### Desde Python:
+
+```python
+from agent import BasicAgent
+
+# Inicializar el agente
+agent = BasicAgent()
+
+# Hacer una pregunta
+result = agent("¿Cuál es la raíz cuadrada de 144?")
+print(result)
+```
+
+#### Desde la Interfaz Gradio:
+
+```bash
+python app.py
+```
+
+Luego ve a `http://127.0.0.1:7860`
+
+## 🎯 Formato de Respuestas
+
+El agente está configurado para dar respuestas en el formato:
+
+```
+[Explicación del razonamiento...]
+
+FINAL ANSWER: [RESPUESTA_FINAL]
+```
+
+### Reglas para FINAL ANSWER:
+
+- **Números**: Sin comas ni símbolos (ej: `42` no `42,000` o `$42`)
+- **Texto**: Sin artículos ni abreviaciones (ej: `New York` no `NYC`)
+- **Listas**: Separadas por comas siguiendo las reglas anteriores
+
+## 📝 Ejemplos de Uso
+
+### Matemáticas Básicas
+
+```python
+agent("¿Cuánto es 15 + 27?")
+# FINAL ANSWER: 42
+```
+
+### Cálculos Complejos
+
+```python
+agent("Calcula el 15% de 240 y súmale 50")
+# El agente escribirá código: (240 * 15 / 100) + 50
+# FINAL ANSWER: 86
+```
+
+### Búsqueda de Información
+
+```python
+agent("¿Cuál es la capital de Francia?")
+# Buscará en Wikipedia
+# FINAL ANSWER: Paris
+```
+
+### Problemas Complejos
+
+```python
+agent("Necesito calcular la suma de los primeros 10 números de Fibonacci")
+# El agente escribirá código para calcular Fibonacci
+# FINAL ANSWER: 143
+```
+
+## 🔧 Modos de Funcionamiento
+
+### 1. Modo Completo (con HUGGINGFACE_TOKEN)
+
+- Utiliza modelos de IA avanzados
+- CodeAct Agent completo
+- Todas las herramientas disponibles
+
+### 2. Modo Básico (sin token)
+
+- Procesamiento básico con expresiones regulares
+- Matemáticas simples
+- Respuestas limitadas pero funcionales
+
+## 🚨 Importante para Producción
+
+⚠️ **Seguridad**: El agente puede ejecutar código Python. En producción:
+
+- Usar sandboxing (Docker, contenedores)
+- Validar entradas del usuario
+- Limitar acceso a recursos del sistema
+
+## 🐛 Resolución de Problemas
+
+### Error: No se puede importar LlamaIndex
+
+```bash
+pip install --upgrade llama-index-core llama-index-llms-huggingface
+```
+
+### Error: Token inválido
+
+- Verifica que tu token de Hugging Face sea válido
+- Asegúrate que el archivo `.env` esté en el directorio correcto
+
+### Error: Modelo no encontrado
+
+- Algunos modelos requieren acceso especial
+- Prueba con modelos públicos como `microsoft/DialoGPT-medium`
+
+## 📚 Personalización
+
+### Cambiar el Modelo
+
+En `agent.py`, modifica:
+
+```python
+model_name="tu-modelo-preferido"
+```
+
+### Agregar Nuevas Herramientas
+
+1. Define tu función
+2. Crea un `FunctionTool.from_defaults(fn=tu_funcion)`
+3. Agrégala a `self.tools`
+
+### Personalizar el Prompt
+
+Modifica la variable `enhanced_prompt` en el método `__call__`
+
+---
+
+¡Tu agente de IA está listo para resolver problemas complejos! 🎉

agent.py

@@ -0,0 +1,390 @@
+"""
+Intelligent AI Agent using LlamaIndex with CodeAct capabilities
+This module contains the agent class with advanced tools and reasoning.
+"""
+
+import os
+import asyncio
+import io
+import contextlib
+import ast
+import traceback
+from typing import Any, Dict, Tuple, List
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    print("✅ .env file loaded successfully")
+except ImportError:
+    print("⚠️ python-dotenv not available, .env file not loaded")
+except Exception as e:
+    print(f"⚠️ Error loading .env file: {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,
+        AgentStream,
+    )
+    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.requests import RequestsToolSpec
+    LLAMA_INDEX_AVAILABLE = True
+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
+
+
+class BasicAgent:
+    """
+    Advanced AI Agent using LlamaIndex with CodeAct capabilities and multiple tools.
+    """
+    
+    def __init__(self):
+        """Initialize the agent with LLM, tools, and code executor."""
+        print("Initializing Advanced AI Agent with LlamaIndex...")
+        
+        # Get Hugging Face token
+        self.hf_token = os.getenv("HUGGINGFACE_TOKEN")
+        print(self.hf_token)
+        if not self.hf_token:
+            print("Warning: HUGGINGFACE_TOKEN not found. Using default model.")
+        
+        # Initialize LLM
+        self._initialize_llm()
+        
+        # Initialize tools
+        self._initialize_tools()
+        
+        # Initialize code executor
+        self._initialize_code_executor()
+        
+        # Initialize CodeAct Agent
+        self._initialize_agent()
+        
+        print("Advanced AI Agent initialized successfully.")
+        
+    def _initialize_llm(self):
+        """Initialize the Hugging Face LLM."""
+        if not LLAMA_INDEX_AVAILABLE:
+            print("LlamaIndex not available, using basic mode")
+            self.llm = None
+            return
+            
+        try:
+            # Using a capable model for reasoning and code generation
+            # Note: For production, consider using models like meta-llama/Llama-2-7b-chat-hf or similar
+            model_kwargs = {"temperature": 0.1, "max_length": 512}
+            generate_kwargs = {"temperature": 0.1, "do_sample": True}
+            
+            if self.hf_token:
+                # Use token if available
+                self.llm = HuggingFaceLLM(
+                    model_name=MODEL,
+                    tokenizer_name=MODEL,  # Explicitly use the same model for tokenizer
+                    model_kwargs=model_kwargs,
+                    generate_kwargs=generate_kwargs,
+                    tokenizer_kwargs={"token": self.hf_token},
+                )
+            else:
+                # Try without token for public models
+                self.llm = HuggingFaceLLM(
+                    model_name=MODEL,
+                    tokenizer_name=MODEL,  # Explicitly use the same model for tokenizer
+                    model_kwargs=model_kwargs,
+                    generate_kwargs=generate_kwargs,
+                )
+            print("✅ LLM initialized successfully")
+        except Exception as e:
+            print(f"Error initializing LLM: {e}")
+            # Fallback to a basic setup
+            self.llm = None
+            
+    def _initialize_tools(self):
+        """Initialize all available tools."""
+        self.tools = []
+        
+        # Store basic math functions for fallback mode
+        self.math_functions = {
+            'add': lambda a, b: a + b,
+            'subtract': lambda a, b: a - b,
+            'multiply': lambda a, b: a * b,
+            'divide': lambda a, b: a / b if b != 0 else "Error: Division by zero",
+            'power': lambda a, b: a ** b,
+            'percentage': lambda v, p: (v * p) / 100,
+        }
+        
+        if not LLAMA_INDEX_AVAILABLE:
+            print("Tools initialization skipped - LlamaIndex not available")
+            return
+        
+        # Mathematical tools
+        def add_numbers(a: float, b: float) -> float:
+            """Add two numbers together."""
+            return a + b
+            
+        def subtract_numbers(a: float, b: float) -> float:
+            """Subtract second number from first number."""
+            return a - b
+            
+        def multiply_numbers(a: float, b: float) -> float:
+            """Multiply two numbers."""
+            return a * b
+            
+        def divide_numbers(a: float, b: float) -> float:
+            """Divide first number by second number."""
+            if b == 0:
+                return "Error: Division by zero"
+            return a / b
+            
+        def power_numbers(a: float, b: float) -> float:
+            """Raise first number to the power of second number."""
+            return a ** b
+            
+        def calculate_percentage(value: float, percentage: float) -> float:
+            """Calculate percentage of a value."""
+            return (value * percentage) / 100
+            
+        # Create function tools
+        try:
+            math_tools = [
+                FunctionTool.from_defaults(fn=add_numbers),
+                FunctionTool.from_defaults(fn=subtract_numbers),
+                FunctionTool.from_defaults(fn=multiply_numbers),
+                FunctionTool.from_defaults(fn=divide_numbers),
+                FunctionTool.from_defaults(fn=power_numbers),
+                FunctionTool.from_defaults(fn=calculate_percentage),
+            ]
+            self.tools.extend(math_tools)
+            print("✅ Math tools initialized")
+        except Exception as e:
+            print(f"Warning: Could not initialize math tools: {e}")
+        
+        # Initialize search tools
+        try:
+            # DuckDuckGo search
+            ddg_spec = DuckDuckGoSearchToolSpec()
+            ddg_tools = ddg_spec.to_tool_list()
+            self.tools.extend(ddg_tools)
+            print("✅ DuckDuckGo search tool initialized")
+        except Exception as e:
+            print(f"Warning: Could not initialize DuckDuckGo tool: {e}")
+            
+        try:
+            # Wikipedia search
+            wiki_spec = WikipediaToolSpec()
+            wiki_tools = wiki_spec.to_tool_list()
+            self.tools.extend(wiki_tools)
+            print("✅ Wikipedia tool initialized")
+        except Exception as e:
+            print(f"Warning: Could not initialize Wikipedia tool: {e}")
+            
+        try:
+            # Web requests tool
+            requests_spec = RequestsToolSpec()
+            requests_tools = requests_spec.to_tool_list()
+            self.tools.extend(requests_tools)
+            print("✅ Web requests tool initialized")
+        except Exception as e:
+            print(f"Warning: Could not initialize requests tool: {e}")
+            
+        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)."""
+        if not self.llm:
+            print("Warning: No LLM available, using basic mode")
+            self.agent = None
+            self.context = None
+            return
+        
+        # Store initialization parameters for deferred initialization
+        self._agent_params = {
+            'code_execute_fn': self.code_executor.execute,
+            'llm': self.llm,
+            'tools': self.tools
+        }
+        self.agent = None
+        self.context = None
+        print("✅ CodeAct Agent parameters prepared (deferred initialization)")
+        
+    def _ensure_agent_initialized(self):
+        """Ensure the CodeAct agent is initialized when needed."""
+        if self.agent is None and hasattr(self, '_agent_params'):
+            try:
+                # Reset any existing context to avoid conflicts
+                if hasattr(self, 'context') and self.context:
+                    try:
+                        # Clean up existing context if possible
+                        self.context = None
+                    except:
+                        pass
+                
+                # Create the CodeAct Agent without assuming event loop state
+                self.agent = CodeActAgent(**self._agent_params)
+                print("✅ CodeAct Agent initialized (deferred)")
+                
+            except Exception as e:
+                print(f"Error in deferred agent initialization: {e}")
+                print("Continuing with fallback mode...")
+                return False
+        return self.agent is not None
+        
+    async def __call__(self, question: str) -> str:
+        """
+        Main method that processes a question and returns an answer.
+        """
+        print(f"Agent received question (first 100 chars): {question[:100]}...")
+        
+        # Ensure agent is initialized (for deferred initialization)
+        self._ensure_agent_initialized()
+        
+        # Enhanced prompt with specific formatting requirements
+        enhanced_prompt = f"""
+You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. 
+
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+
+Available tools and capabilities:
+- Mathematical calculations (addition, subtraction, multiplication, division, powers, percentages)
+- Web search using DuckDuckGo
+- Wikipedia search for factual information
+- Web requests for API calls
+- Code execution for complex calculations and data processing
+- Python libraries: math, datetime, json, re, numpy (if available), pandas (if available)
+
+Question: {question}
+
+Think step by step, use the available tools when necessary, and provide your final answer in the specified format.
+        """
+        
+        if self.agent:
+            try:
+                # Use the CodeAct agent for advanced reasoning
+                response = await self._async_agent_run(enhanced_prompt)
+                return response
+            except Exception as e:
+                print(f"Error with CodeAct agent: {e}")
+                return f"FINAL ANSWER: Error processing question - {str(e)}"
+        else:
+            return "FINAL ANSWER: Agent not properly initialized"
+    
+    
+    async def _async_agent_run(self, prompt: str) -> str:
+        """Run the agent asynchronously."""
+        try:
+            # Create a fresh context for this run to avoid loop conflicts
+            context = Context(self.agent)
+            handler = self.agent.run(prompt, ctx=context)
+            
+            async for event in handler.stream_events():
+                if isinstance(event, ToolCallResult):
+                    print(
+                        f"\n-----------\nCode execution result:\n{event.tool_output}"
+                    )
+                elif isinstance(event, ToolCall):
+                    print(f"\n-----------\nParsed code:\n{event.tool_kwargs['code']}")
+                elif isinstance(event, AgentStream):
+                    print(f"{event.delta}", end="", flush=True)
+
+            return await handler
+        except Exception as e:
+            print(f"Async agent error: {e}")
+            return f"FINAL ANSWER: Error in agent processing - {str(e)}"
+    
+   

app.py

@@ -3,23 +3,25 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from typing import Optional
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    print("✅ .env file loaded successfully")
+except ImportError:
+    print("⚠️ python-dotenv not available, .env file not loaded")
+except Exception as e:
+    print(f"⚠️ Error loading .env file: {e}")
+
+from agent import BasicAgent
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
-
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+async def run_and_submit_all(profile: Optional[gr.OAuthProfile]):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
@@ -73,6 +75,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
+    questions_data = questions_data[:1]
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
@@ -80,7 +83,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = await 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})
         except Exception as e:

requirements.txt

@@ -1,2 +1,19 @@
-gradio
-requests
+gradio[oauth]
+requests
+pandas
+python-dotenv
+# LlamaIndex core dependencies
+llama-index-core
+llama-index-llms-huggingface
+llama-index-workflows
+
+# LlamaIndex tools
+llama-index-tools-duckduckgo
+llama-index-tools-wikipedia
+llama-index-tools-requests
+
+# Additional dependencies for ML and data processing
+torch
+transformers
+numpy
+asyncio