Migración completa a Google Gemini - Agente GAIA con OAuth y validaciones

.env.example

@@ -0,0 +1,7 @@
+# Google Gemini API Key
+# Obtén tu API key gratis en: https://aistudio.google.com/apikey
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# Opcional: HuggingFace Space info (se autoconfiguran en el Space)
+# SPACE_ID=tu-usuario/nombre-del-space
+# SPACE_HOST=nombre-del-space-tu-usuario.hf.space

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.env filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environment variables
+.env
+.env.local
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Virtual environment (no subir a HF Spaces)
+.venv/
+venv/
+.gradio

DEPLOY.md

@@ -0,0 +1,179 @@
+# 🚀 Guía de Despliegue en HuggingFace Spaces
+
+Esta guía te ayudará a desplegar tu agente GAIA con Gemini en HuggingFace Spaces.
+
+## 📋 Pre-requisitos
+
+1. **Cuenta de HuggingFace**
+   - Crea una gratis en: https://huggingface.co/join
+
+2. **API Key de Google Gemini**
+   - Obtén una gratis en: https://aistudio.google.com/apikey
+   - No requiere tarjeta de crédito
+   - Límite generoso de requests gratuitos
+
+## 🎯 Pasos de Despliegue
+
+### 1. Crear el Space
+
+1. Ve a: https://huggingface.co/new-space
+2. Configura:
+   - **Owner**: Tu usuario
+   - **Space name**: `gaia-agent-gemini` (o el nombre que prefieras)
+   - **License**: MIT
+   - **SDK**: Gradio
+   - **Hardware**: CPU (gratuito) - suficiente para este proyecto
+   - **Visibility**: Public (para el curso)
+
+3. Clic en **Create Space**
+
+### 2. Subir el Código
+
+**Opción A: Git (Recomendado)**
+
+```bash
+# Clona tu nuevo Space
+git clone https://huggingface.co/spaces/TU-USUARIO/gaia-agent-gemini
+cd gaia-agent-gemini
+
+# Copia todos los archivos del proyecto
+cp -r /ruta/a/tu/proyecto/* .
+
+# Sube a HuggingFace
+git add .
+git commit -m "Initial commit - GAIA agent with Gemini"
+git push
+```
+
+**Opción B: Web UI**
+
+1. Abre tu Space en HuggingFace
+2. Clic en **Files** → **Add file** → **Upload files**
+3. Arrastra y suelta todos los archivos:
+   - `app.py`
+   - `agents.py`
+   - `model.py`
+   - `tools.py`
+   - `tool.py`
+   - `final_answer.py`
+   - `api.py`
+   - `requirements.txt`
+   - `README.md`
+
+### 3. Configurar la API Key
+
+1. Ve a **Settings** (arriba a la derecha)
+2. Scroll hasta **Repository secrets**
+3. Clic en **New secret**
+4. Agrega:
+   - **Name**: `GEMINI_API_KEY`
+   - **Value**: Tu API key de Google (ej: `AIzaSy...`)
+5. Clic en **Add**
+
+### 4. Verificar el Despliegue
+
+El Space se construirá automáticamente. Espera 2-3 minutos.
+
+Verás:
+- ⚙️ **Building** → Instalando dependencias
+- 🟢 **Running** → ¡Listo para usar!
+
+Si hay errores, revisa los **Logs** en la pestaña **Logs**.
+
+### 5. Probar el Agente
+
+1. Abre tu Space (URL: `https://huggingface.co/spaces/TU-USUARIO/gaia-agent-gemini`)
+2. Clic en **Sign in with Hugging Face**
+3. Autoriza el acceso
+4. Clic en **▶️ Ejecutar Evaluación**
+5. Observa los resultados en la tabla
+
+## 🔧 Configuración Avanzada
+
+### Cambiar el Modelo Gemini
+
+Edita `app.py` línea 15:
+
+```python
+# Opciones disponibles:
+MODEL_ID = "gemini/gemini-2.0-flash-exp"      # Rápido (recomendado)
+MODEL_ID = "gemini/gemini-1.5-flash"          # Estable
+MODEL_ID = "gemini/gemini-1.5-pro"            # Más potente (más lento)
+```
+
+### Limitar Número de Preguntas (Testing)
+
+Edita `app.py`, descomenta la línea ~71:
+
+```python
+# questions_data = questions_data[:5]  # Solo 5 preguntas para testing
+```
+
+### Habilitar Debug Verbose
+
+Edita `agents.py`, cambia línea ~83:
+
+```python
+agent = create_agent(model_id=MODEL_ID, verbose=True)  # Ya está activado
+```
+
+## 🐛 Solución de Problemas
+
+### Error: "GEMINI_API_KEY no configurada"
+
+**Solución**: Verifica que agregaste el secret correctamente en Settings → Repository secrets.
+
+### Error: "Import gradio could not be resolved"
+
+**Solución**: El Space se está construyendo. Espera hasta que termine (estado "Running").
+
+### Error: "Rate limit exceeded"
+
+**Solución**: Gemini tiene límites gratuitos (60 requests/min). El código ya incluye retry logic. Si falla, espera 1 minuto y vuelve a intentar.
+
+### Error: "SPACE_ID no configurado"
+
+**Solución**: Este error solo ocurre en ejecución local. En HuggingFace Spaces, esta variable se configura automáticamente.
+
+## 📊 Evaluar Resultados
+
+Después de ejecutar, verás:
+
+- **Puntuación**: % de respuestas correctas
+- **Correctas**: N de M preguntas
+- **Tabla**: Todas las preguntas y respuestas
+
+Compara tu puntuación en el [leaderboard del curso](https://huggingface.co/spaces/agents-course-unit4-scoring).
+
+## 🔄 Actualizar el Código
+
+Si haces cambios localmente:
+
+```bash
+cd gaia-agent-gemini
+# Edita archivos...
+git add .
+git commit -m "Descripción del cambio"
+git push
+```
+
+El Space se reconstruirá automáticamente.
+
+## 🎓 Recursos
+
+- [Documentación de Spaces](https://huggingface.co/docs/hub/spaces)
+- [Gradio OAuth Docs](https://www.gradio.app/guides/sharing-your-app#o-auth-login-via-hugging-face)
+- [Google Gemini Docs](https://ai.google.dev/gemini-api/docs)
+- [LiteLLM Gemini Guide](https://docs.litellm.ai/docs/providers/gemini)
+
+## 💬 Soporte
+
+Si tienes problemas:
+
+1. Revisa los **Logs** en tu Space
+2. Consulta este README.md y DEPLOY.md
+3. Pregunta en el [foro del curso](https://huggingface.co/learn/agents-course)
+
+---
+
+¡Buena suerte con tu agente! 🚀

README.md

@@ -1,14 +1,76 @@
 ---
-title: Hf Gaia Agents Course MN
-emoji: 📊
-colorFrom: green
-colorTo: purple
+title: GAIA Agent - Gemini
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 license: mit
-short_description: 'Agente AI para responder preguntas del benchmark GAIA Level '
+short_description: Agente AI usando Google Gemini para GAIA Level 1 (HF Course Unit 4)
+hf_oauth: true
+hf_oauth_expiration_minutes: 480
+---
+
+# 🤖 Agente GAIA con Google Gemini
+
+Agente AI que usa **Google Gemini** para resolver tareas del benchmark GAIA Level 1.
+
+Proyecto para el [Curso de Agentes de HuggingFace - Unit 4 Hands-on](https://huggingface.co/learn/agents-course/unit4/hands-on).
+
+## 🚀 Características
+
+- ✅ **Google Gemini 2.0 Flash** - Rápido y gratuito
+- ✅ **OAuth de HuggingFace** - Autenticación segura
+- ✅ **OCR con Tesseract** - Procesamiento de imágenes
+- ✅ **Validación GAIA** - Formato estricto de respuestas
+- ✅ **Retry Logic** - Manejo robusto de rate limits
+
+## 📦 Configuración
+
+1. **Clona este Space**
+2. **Configura la API key** en Settings → Repository secrets:
+   - Nombre: `GEMINI_API_KEY`
+   - Obtén una gratis en: https://aistudio.google.com/apikey
+3. **Inicia sesión** con tu cuenta de HuggingFace
+4. **Ejecuta** la evaluación
+
+## 🏗️ Arquitectura
+
+```
+app.py          → Interfaz Gradio con OAuth
+agents.py       → Clase Agent principal
+model.py        → Wrapper de Gemini con LiteLLM
+tools.py        → OCR y procesamiento de archivos
+tool.py         → Registro de herramientas
+final_answer.py → Validaciones de formato GAIA
+api.py          → Cliente HTTP para API del curso
+```
+
+## 🎯 Flujo de Trabajo
+
+1. Usuario inicia sesión con OAuth
+2. Sistema obtiene preguntas desde la API del curso
+3. Agente procesa cada pregunta con Gemini
+4. Sistema valida formato de respuestas (GAIA strict)
+5. Respuestas se envían a la API para evaluación
+6. Resultados se muestran en tabla Gradio
+
+## 💡 ¿Por qué Gemini?
+
+- **Gratis** con límites generosos (gratuity API tier)
+- **Rápido** - Gemini Flash optimizado para baja latencia
+- **Multimodal** - Procesa texto e imágenes
+- **Sin tarjeta** - No requiere método de pago
+
+## 📚 Recursos
+
+- [Curso de Agentes HF](https://huggingface.co/learn/agents-course)
+- [GAIA Benchmark](https://huggingface.co/gaia-benchmark)
+- [Google AI Studio](https://aistudio.google.com/apikey)
+- [LiteLLM Docs](https://docs.litellm.ai/)
+
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

RESUMEN_IMPLEMENTACION.md

@@ -0,0 +1,292 @@
+# 📝 Resumen de Implementación - Agente GAIA con Gemini
+
+## 🎯 Objetivo
+
+Crear un agente AI que resuelva tareas del benchmark GAIA Level 1 usando **Google Gemini** en lugar de OpenAI, para el curso de Agentes de HuggingFace (Unit 4 Hands-on).
+
+## 🏗️ Arquitectura del Sistema
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      app.py (Gradio UI)                     │
+│  - OAuth Login                                              │
+│  - Botón ejecutar evaluación                                │
+│  - Tabla de resultados                                      │
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+                      ▼
+┌─────────────────────────────────────────────────────────────┐
+│                  agents.py (Agent Class)                    │
+│  - System prompt optimizado para GAIA                       │
+│  - Construcción de contexto (pregunta + archivos)           │
+│  - Limpieza de respuestas (extracción de FINAL ANSWER)      │
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+        ┌─────────────┼─────────────┐
+        ▼             ▼             ▼
+┌──────────────┐ ┌──────────┐ ┌──────────────────┐
+│  model.py    │ │ tool.py  │ │ final_answer.py  │
+│              │ │          │ │                  │
+│ GeminiModel  │ │ Tools    │ │ Validaciones     │
+│ - LiteLLM    │ │ Registry │ │ GAIA             │
+│ - Retry      │ │          │ │ - Números        │
+│ - Rate Limit │ │ get_     │ │ - Strings        │
+│   Handling   │ │ tools()  │ │ - Listas         │
+└──────┬───────┘ └─────┬────┘ └──────────────────┘
+       │               │
+       └───────┬───────┘
+               ▼
+    ┌───────────────────────┐
+    │     tools.py          │
+    │                       │
+    │ - read_image_text()   │
+    │   (OCR con Tesseract) │
+    │ - BytesIO handling    │
+    └───────────────────────┘
+               │
+               ▼
+    ┌───────────────────────┐
+    │      api.py           │
+    │                       │
+    │ - get_questions()     │
+    │ - submit_answers()    │
+    └───────────────────────┘
+```
+
+## 📦 Componentes Creados
+
+### 1. `model.py` - Wrapper de Gemini
+
+**Propósito**: Abstracción para llamar a Google Gemini con manejo robusto de errores.
+
+**Características**:
+- Usa **LiteLLM** para interfaz unificada
+- Retry logic con backoff exponencial
+- Extrae tiempo de espera de mensajes de error de rate limit
+- Cache con `@lru_cache` para la instancia del modelo
+
+**Modelo usado**: `gemini/gemini-2.0-flash-exp`
+- Rápido (baja latencia)
+- Gratuito con límites generosos
+- Última versión experimental
+
+### 2. `agents.py` - Clase Agent Principal
+
+**Propósito**: Orquesta la resolución de preguntas GAIA.
+
+**System Prompt**:
+- Optimizado para benchmark GAIA
+- Énfasis en precisión y formato estricto
+- Instrucciones de "FINAL ANSWER:" obligatorio
+
+**Métodos clave**:
+- `_build_context()`: Construye el prompt con pregunta y archivos
+- `_clean_answer()`: Extrae respuesta final con regex
+- `_is_reversed_text()`: Detecta texto al revés (common GAIA trick)
+
+### 3. `tools.py` - Procesamiento de Archivos
+
+**Propósito**: OCR de imágenes y manejo de archivos.
+
+**Fix aplicado**:
+```python
+from io import BytesIO  # Faltaba esta importación
+```
+
+**Función principal**:
+- `read_image_text(url)`: Descarga imagen y extrae texto con Tesseract
+
+### 4. `tool.py` - Registro de Herramientas
+
+**Propósito**: Proporcionar herramientas disponibles al agente.
+
+**Herramientas**:
+1. `file_from_url`: Descarga archivos
+2. `read_text_file`: Lee archivos de texto
+3. `read_image_text`: OCR de imágenes (via tools.py)
+
+### 5. `final_answer.py` - Validaciones GAIA
+
+**Propósito**: Asegurar formato correcto según reglas GAIA.
+
+**Validaciones**:
+- `validate_number_format()`: Sin comas, sin unidades
+- `validate_string_format()`: Sin artículos ("the", "a")
+- `validate_list_format()`: Sin corchetes, comas como separadores
+- `clean_answer()`: Remueve prefijos comunes
+
+### 6. `app.py` - Interfaz Gradio
+
+**Propósito**: UI web con OAuth y evaluación automática.
+
+**Características**:
+- **OAuth de HuggingFace**: Login obligatorio
+- **Flujo completo**:
+  1. Login usuario
+  2. Obtener preguntas desde API
+  3. Procesar con agente Gemini
+  4. Enviar respuestas
+  5. Mostrar resultados
+- **Manejo de errores**: Try-except en cada paso
+- **Logging**: Prints informativos para debugging
+
+### 7. `requirements.txt` - Dependencias
+
+```
+gradio>=5.0.0              # Web UI
+litellm>=1.0.0             # Wrapper LLM unificado
+google-generativeai>=0.8.0 # Gemini SDK
+pandas>=2.0.0              # DataFrames
+requests>=2.31.0           # HTTP
+pillow>=10.0.0             # Imágenes
+pytesseract>=0.3.10        # OCR
+python-dotenv>=1.0.0       # .env files
+```
+
+### 8. `README.md` - Documentación
+
+**Metadatos importantes**:
+```yaml
+hf_oauth: true                    # Habilita OAuth
+hf_oauth_expiration_minutes: 480  # 8 horas
+sdk: gradio
+sdk_version: 5.49.1
+```
+
+## 🔑 Cambios Clave vs OpenAI
+
+| Aspecto | OpenAI (antes) | Gemini (ahora) |
+|---------|---------------|----------------|
+| **Modelo** | `gpt-4o-mini` | `gemini-2.0-flash-exp` |
+| **SDK** | `openai` | `litellm` + `google-generativeai` |
+| **API Key** | `OPENAI_API_KEY` | `GEMINI_API_KEY` |
+| **Costo** | Pago ($) | Gratis (con límites) |
+| **Inicialización** | `OpenAI(api_key=...)` | `litellm.completion(model="gemini/...")` |
+| **Rate Limits** | Más altos (pago) | 60 req/min (gratis) |
+
+## 🚀 Flujo de Ejecución
+
+1. **Usuario accede al Space**
+   - Ve interfaz Gradio
+   - Login con HuggingFace OAuth
+
+2. **Usuario ejecuta evaluación**
+   - Clic en botón "Ejecutar"
+   - `run_and_submit_all()` se ejecuta
+
+3. **Sistema obtiene preguntas**
+   - GET request a API del curso
+   - Recibe lista de preguntas GAIA Level 1
+
+4. **Sistema procesa cada pregunta**
+   - `process_question()` para cada una
+   - Agent construye prompt
+   - Gemini genera respuesta
+   - Validaciones GAIA aplicadas
+   - Extracción de "FINAL ANSWER:"
+
+5. **Sistema envía respuestas**
+   - POST request a API del curso
+   - Payload: username, agent_code, answers
+
+6. **Sistema muestra resultados**
+   - Score, correctas/total
+   - Tabla con todas las preguntas y respuestas
+
+## 🛡️ Manejo de Errores
+
+### Rate Limits
+```python
+if "quota exceeded" in error_msg or "rate limit" in error_msg:
+    # Extrae tiempo de espera del mensaje
+    match = re.search(r'try again in (\d+)s', error_msg)
+    wait_seconds = int(match.group(1)) if match else 60
+    time.sleep(wait_seconds + 1)
+    # Reintenta...
+```
+
+### Errores de Red
+- Timeout de 30s en requests
+- Try-except en cada llamada HTTP
+- Mensajes de error informativos al usuario
+
+### Errores de Gemini
+- Retry automático hasta 3 veces
+- Backoff exponencial (2^attempt segundos)
+- Logging de errores para debugging
+
+## 📊 Formato GAIA
+
+El agente cumple con las **reglas estrictas de GAIA**:
+
+- **Números**: Sin comas, sin unidades
+  - ❌ `1,234 meters`
+  - ✅ `1234`
+
+- **Strings**: Sin artículos
+  - ❌ `The Eiffel Tower`
+  - ✅ `Eiffel Tower`
+
+- **Listas**: Comas sin espacios, sin corchetes
+  - ❌ `[apple, banana]`
+  - ✅ `apple,banana`
+
+## 🔧 Configuración Requerida
+
+### En HuggingFace Spaces
+
+1. **Settings → Repository secrets**:
+   - `GEMINI_API_KEY`: Tu API key de Google
+
+2. **README.md** (metadata):
+   - `hf_oauth: true`
+   - `sdk: gradio`
+
+### Variables de Entorno Automáticas
+
+HF Spaces configura automáticamente:
+- `SPACE_ID`: `usuario/nombre-space`
+- `SPACE_HOST`: `nombre-space-usuario.hf.space`
+
+Usadas para construir el link del código del agente.
+
+## ✅ Testing Local
+
+```bash
+# 1. Instalar dependencias
+pip install -r requirements.txt
+
+# 2. Configurar API key
+export GEMINI_API_KEY="tu_api_key_aqui"
+
+# 3. Ejecutar app
+python app.py
+
+# 4. Abrir navegador
+# http://localhost:7860
+```
+
+**Nota**: OAuth solo funciona en HF Spaces. En local, el perfil será `None`.
+
+## 📈 Próximas Mejoras
+
+- [ ] Soporte para GAIA Level 2 y 3
+- [ ] Cache de respuestas procesadas
+- [ ] Métricas de tiempo de respuesta
+- [ ] Soporte para más LLMs (Claude, Mistral, etc.)
+- [ ] Logs persistentes en archivo
+- [ ] Tests unitarios
+
+## 🎓 Referencias
+
+- [GAIA Benchmark](https://huggingface.co/gaia-benchmark)
+- [Curso de Agentes HF](https://huggingface.co/learn/agents-course/unit4/hands-on)
+- [Google Gemini Docs](https://ai.google.dev/gemini-api/docs)
+- [LiteLLM Docs](https://docs.litellm.ai/)
+- [Gradio OAuth](https://www.gradio.app/guides/sharing-your-app#o-auth-login-via-hugging-face)
+
+---
+
+**Implementado**: Diciembre 2024  
+**Stack**: Python 3.10+, Gradio 5.x, Google Gemini, LiteLLM  
+**Licencia**: MIT

agents.py

@@ -0,0 +1,246 @@
+"""
+Agent class para resolver tareas GAIA usando Gemini.
+"""
+
+import re
+from typing import Optional, List, Any
+from model import GeminiModel
+
+
+class Agent:
+    """
+    Agente para resolver tareas del benchmark GAIA usando Google Gemini.
+    """
+    
+    def __init__(
+        self,
+        model: GeminiModel,
+        tools: Optional[List[Any]] = None,
+        verbose: bool = False
+    ):
+        """
+        Inicializa el agente.
+        
+        Args:
+            model: Modelo Gemini a usar
+            tools: Lista de herramientas disponibles (opcional)
+            verbose: Si True, imprime información de debug
+        """
+        self.model = model
+        self.tools = tools or []
+        self.verbose = verbose
+        
+        # Prompt optimizado para GAIA benchmark
+        self.system_prompt = """You are an expert AI assistant specialized in solving GAIA benchmark tasks with precision.
+
+CRITICAL FORMATTING RULES (EXACT MATCHING REQUIRED):
+
+1. NUMBERS:
+   - Write as plain digits: 42 (not 42.0 or 42,000)
+   - NO commas in numbers: 1000000 (not 1,000,000)
+   - NO units unless explicitly requested: 42 (not $42 or 42%)
+   - Use Arabic numerals: 9 (not nine)
+
+2. STRINGS:
+   - Lowercase preferred: paris (not Paris)
+   - NO articles: paris (not "the paris" or "a paris")
+   - NO abbreviations: san francisco (not SF or S.F.)
+   - Write digits in plain text unless specified
+
+3. LISTS:
+   - Comma-separated: apple,orange,banana
+   - NO brackets: apple,orange (not [apple,orange])
+   - NO quotes: apple,orange (not "apple","orange")
+
+4. CURRENCY (only if explicitly requested):
+   - Use symbol: $40.00
+   - Follow requested format exactly
+
+5. DATES:
+   - Follow exact format requested in question
+
+YOUR RESPONSE STRUCTURE:
+1. Analyze the question carefully
+2. If files/images are mentioned, describe what you observe
+3. Think step by step
+4. Provide reasoning
+5. End with: FINAL ANSWER: [exact answer only]
+
+IMPORTANT: Only text after "FINAL ANSWER:" is submitted. Be EXACT - GAIA uses strict string matching!"""
+    
+    def __call__(self, question: str, files: Optional[List[str]] = None) -> str:
+        """
+        Interfaz principal para resolver una pregunta.
+        
+        Args:
+            question: La pregunta a responder
+            files: Lista opcional de rutas de archivos asociados
+            
+        Returns:
+            str: La respuesta limpia y formateada
+        """
+        if self.verbose:
+            print(f"\n{'='*60}")
+            print(f"📋 Pregunta: {question[:100]}...")
+            if files:
+                print(f"📎 Archivos: {files}")
+        
+        answer = self.answer_question(question, files)
+        
+        if self.verbose:
+            print(f"✅ Respuesta: {answer}")
+            print(f"{'='*60}\n")
+        
+        return answer
+    
+    def answer_question(self, question: str, files: Optional[List[str]] = None) -> str:
+        """
+        Procesa la pregunta y genera una respuesta.
+        
+        Args:
+            question: La pregunta a responder
+            files: Lista opcional de archivos
+            
+        Returns:
+            str: Respuesta limpia
+        """
+        try:
+            # Construir contexto
+            context = self._build_context(question, files)
+            
+            # Construir prompt completo
+            full_prompt = f"{self.system_prompt}\n\n{context}"
+            
+            if self.verbose:
+                print(f"🤖 Llamando a Gemini...")
+            
+            # Llamar al modelo con temperatura baja para precisión
+            response = self.model.generate_simple(
+                full_prompt, 
+                temperature=0.1,
+                max_tokens=1000
+            )
+            
+            # Limpiar y formatear respuesta
+            clean = self._clean_answer(response)
+            
+            return clean
+            
+        except Exception as e:
+            error_msg = f"ERROR: {str(e)}"
+            print(f"❌ {error_msg}")
+            return error_msg
+    
+    def _build_context(self, question: str, files: Optional[List[str]] = None) -> str:
+        """
+        Construye el contexto para el prompt.
+        
+        Args:
+            question: La pregunta
+            files: Lista opcional de archivos
+            
+        Returns:
+            str: Contexto formateado
+        """
+        context_parts = [f"TASK: {question}"]
+        
+        # Añadir información sobre archivos si existen
+        if files:
+            context_parts.append("\nFILES PROVIDED:")
+            for file_path in files:
+                context_parts.append(f"- {file_path}")
+            context_parts.append("\nAnalyze these files if relevant to answering the question.")
+        
+        # Detectar texto invertido (reversed text) - común en GAIA
+        if self._is_reversed_text(question):
+            reversed_q = question[::-1]
+            context_parts.append(f"\n⚠️  REVERSED TEXT DETECTED!")
+            context_parts.append(f"Original text: {question}")
+            context_parts.append(f"Actual question: {reversed_q}")
+            context_parts.append("Answer the reversed version in NORMAL text.")
+        
+        return "\n".join(context_parts)
+    
+    def _is_reversed_text(self, text: str) -> bool:
+        """
+        Detecta si el texto está invertido.
+        
+        Args:
+            text: Texto a analizar
+            
+        Returns:
+            bool: True si parece estar invertido
+        """
+        # Heurística: texto invertido suele empezar con "." o contener patrones invertidos
+        indicators = [
+            text.strip().startswith("."),
+            "?rewsna" in text.lower(),
+            "?noitseuq" in text.lower(),
+            ".rewsna eht sa" in text.lower()
+        ]
+        return any(indicators)
+    
+    def _clean_answer(self, response: str) -> str:
+        """
+        Limpia y formatea la respuesta según reglas GAIA.
+        
+        Args:
+            response: Respuesta cruda del modelo
+            
+        Returns:
+            str: Respuesta limpia
+        """
+        # Extraer respuesta final si hay marcador "FINAL ANSWER:"
+        if "FINAL ANSWER:" in response.upper():
+            # Buscar case-insensitive
+            parts = re.split(r'FINAL ANSWER:', response, flags=re.IGNORECASE)
+            if len(parts) > 1:
+                response = parts[-1].strip()
+        
+        # Remover prefijos comunes
+        prefixes = [
+            "The answer is:", "Answer:", "Final Answer:", 
+            "The final answer is:", "=>", "Result:",
+            "Output:", "Solution:"
+        ]
+        for prefix in prefixes:
+            if response.lower().startswith(prefix.lower()):
+                response = response[len(prefix):].strip()
+        
+        # Limpiar comillas y espacios
+        response = response.strip(" '\"")
+        
+        # Remover punto final si no es parte de la respuesta
+        # (solo si la respuesta es larga o contiene espacios)
+        if response.endswith("."):
+            # No remover si parece un decimal o número con punto
+            if not response.replace(".", "").replace(",", "").replace(" ", "").isdigit():
+                # Solo remover si hay espacios o es muy larga
+                if " " in response or len(response) > 20:
+                    response = response.rstrip(".")
+        
+        # Manejar respuestas invertidas - invertir de vuelta
+        if self._is_reversed_text(response):
+            response = response[::-1]
+        
+        # Remover corchetes de listas si existen
+        response = response.strip("[]")
+        
+        return response.strip()
+
+
+def create_agent(model_id: str = "gemini/gemini-2.0-flash-exp", verbose: bool = False, **kwargs) -> Agent:
+    """
+    Factory function para crear un agente con Gemini.
+    
+    Args:
+        model_id: ID del modelo Gemini a usar
+        verbose: Si True, imprime información de debug
+        **kwargs: Argumentos adicionales para el modelo
+        
+    Returns:
+        Agent: Instancia del agente configurado
+    """
+    from model import get_model
+    model = get_model(model_id, **kwargs)
+    return Agent(model=model, verbose=verbose)

api.py

@@ -0,0 +1,24 @@
+import requests
+
+BASE_URL = "https://huggingface.co/learn/agents-course/unit4/api"
+
+def get_random_question():
+    res = requests.get(f"{BASE_URL}/random-question")
+    res.raise_for_status()
+    return res.json()
+
+def get_question_files(task_id):
+    res = requests.get(f"{BASE_URL}/files/{task_id}")
+    res.raise_for_status()
+    return res.json()
+
+def submit_answers(username, space_url, answers):
+    res = requests.post(
+        f"{BASE_URL}/submit",
+        json={
+            "username": username,
+            "space_link": space_url,
+            "submissions": answers
+        }
+    )
+    return res.json()

app.py

@@ -1,7 +1,270 @@
+"""
+Gradio Space para agente GAIA usando Google Gemini.
+Integración con API del curso y OAuth de HuggingFace.
+"""
+
+import os
 import gradio as gr
+import requests
+import pandas as pd
+from typing import List, Dict
+
+# Imports del proyecto
+from agents import create_agent
+from api import get_random_question, submit_answers
+
+# Constantes
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+MODEL_ID = "gemini/gemini-2.0-flash-exp"  # Gemini Flash - rápido y gratis
+
+
+def process_question(agent, question: str, task_id: str, files: List[str] = None) -> Dict:
+    """Procesa una pregunta individual."""
+    try:
+        answer = agent(question, files)
+        return {
+            "submission": {"task_id": task_id, "submitted_answer": answer},
+            "log": {
+                "Task ID": task_id, 
+                "Question": question[:100] + "...", 
+                "Submitted Answer": answer
+            }
+        }
+    except Exception as e:
+        error_msg = f"ERROR: {str(e)}"
+        return {
+            "submission": {"task_id": task_id, "submitted_answer": error_msg},
+            "log": {
+                "Task ID": task_id, 
+                "Question": question[:100] + "...", 
+                "Submitted Answer": error_msg
+            }
+        }
+
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Obtiene preguntas, ejecuta el agente y envía respuestas.
+    """
+    # Verificar login
+    if not profile:
+        return "⚠️ Por favor inicia sesión con Hugging Face usando el botón de arriba.", None
+    
+    username = profile.username
+    print(f"✅ Usuario logueado: {username}")
+    
+    # Obtener SPACE_ID para el link al código
+    space_id = os.getenv("SPACE_ID")
+    if not space_id:
+        return "⚠️ SPACE_ID no configurado. Debe desplegarse en HuggingFace Space.", None
+    
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"📦 Código: {agent_code}")
+    
+    # URLs de la API
+    questions_url = f"{DEFAULT_API_URL}/questions"
+    submit_url = f"{DEFAULT_API_URL}/submit"
+    
+    # 1. Crear agente con Gemini
+    try:
+        print("🤖 Inicializando agente Gemini...")
+        agent = create_agent(model_id=MODEL_ID, verbose=True)
+    except Exception as e:
+        error_msg = f"❌ Error al inicializar agente: {str(e)}\n"
+        error_msg += "Asegúrate de configurar GEMINI_API_KEY en Settings → Repository secrets"
+        print(error_msg)
+        return error_msg, None
+    
+    # 2. Obtener preguntas
+    try:
+        print(f"📥 Obteniendo preguntas desde: {questions_url}")
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        
+        if not questions_data:
+            return "⚠️ No se recibieron preguntas del servidor.", None
+        
+        print(f"✅ Recibidas {len(questions_data)} preguntas")
+        
+        # Para testing, descomentar para limitar a 5 preguntas:
+        # questions_data = questions_data[:5]
+        
+    except Exception as e:
+        error_msg = f"❌ Error al obtener preguntas: {str(e)}"
+        print(error_msg)
+        return error_msg, None
+    
+    # 3. Procesar preguntas
+    print(f"🔄 Procesando {len(questions_data)} preguntas...")
+    submissions = []
+    logs = []
+    
+    for i, q_data in enumerate(questions_data, 1):
+        print(f"\n{'='*60}")
+        print(f"Pregunta {i}/{len(questions_data)}")
+        print(f"{'='*60}")
+        
+        task_id = q_data.get("task_id", f"unknown_{i}")
+        question = q_data.get("question", "")
+        files = q_data.get("files", [])
+        
+        result = process_question(agent, question, task_id, files)
+        submissions.append(result["submission"])
+        logs.append(result["log"])
+    
+    if not submissions:
+        return "⚠️ No se generaron respuestas.", pd.DataFrame(logs)
+    
+    # 4. Enviar respuestas
+    print(f"\n{'='*60}")
+    print(f"📤 Enviando {len(submissions)} respuestas...")
+    print(f"{'='*60}")
+    
+    submission_data = {
+        "username": username,
+        "agent_code": agent_code,
+        "answers": submissions
+    }
+    
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        
+        # Formatear resultado
+        status_message = (
+            f"✅ ¡Respuestas enviadas exitosamente!\n\n"
+            f"👤 Usuario: {result_data.get('username')}\n"
+            f"📊 Puntuación: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correctas)\n"
+            f"💬 Mensaje: {result_data.get('message', 'Sin mensaje')}"
+        )
+        
+        print("✅ Envío exitoso")
+        print(status_message)
+        
+        results_df = pd.DataFrame(logs)
+        return status_message, results_df
+    
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"El servidor respondió con código {e.response.status_code}"
+        try:
+            error_json = e.response.json()
+            error_detail += f"\nDetalle: {error_json.get('detail', e.response.text)}"
+        except:
+            error_detail += f"\nRespuesta: {e.response.text[:500]}"
+        
+        error_msg = f"❌ Error al enviar respuestas: {error_detail}"
+        print(error_msg)
+        results_df = pd.DataFrame(logs)
+        return error_msg, results_df
+    
+    except Exception as e:
+        error_msg = f"❌ Error inesperado: {str(e)}"
+        print(error_msg)
+        results_df = pd.DataFrame(logs)
+        return error_msg, results_df
+
+
+# Interfaz Gradio
+with gr.Blocks(title="Agente GAIA - Gemini", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🤖 Agente GAIA - Google Gemini
+    
+    Este Space usa **Google Gemini** para resolver tareas GAIA Level 1.
+    
+    ## 📋 Instrucciones
+    
+    1. **Clona este Space** y personalízalo
+    2. **Inicia sesión** con tu cuenta de HuggingFace
+    3. **Configura** `GEMINI_API_KEY` en Settings → Repository secrets
+       - Obtén tu API key gratis en: https://aistudio.google.com/apikey
+    4. **Ejecuta** la evaluación
+    
+    ---
+    """)
+    
+    # Botón de login OAuth
+    gr.LoginButton()
+    
+    gr.Markdown("### 🚀 Ejecutar Evaluación")
+    
+    run_button = gr.Button(
+        "▶️ Ejecutar Evaluación y Enviar Respuestas",
+        variant="primary",
+        size="lg"
+    )
+    
+    status_output = gr.Textbox(
+        label="📊 Estado / Resultado",
+        lines=8,
+        interactive=False
+    )
+    
+    results_table = gr.DataFrame(
+        label="📝 Preguntas y Respuestas del Agente",
+        wrap=True
+    )
+    
+    # Conectar botón
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+    
+    gr.Markdown("""
+    ---
+    
+    ### 📚 Recursos
+    
+    - [Curso de Agentes HuggingFace](https://huggingface.co/learn/agents-course)
+    - [Unit 4 Hands-on](https://huggingface.co/learn/agents-course/unit4/hands-on)
+    - [Google AI Studio](https://aistudio.google.com/apikey) - Obtén tu API key
+    
+    ### 💡 Ventajas de Gemini
+    
+    - ✅ **Gratis** con límites generosos
+    - ✅ **Rápido** (Gemini Flash)
+    - ✅ **Multimodal** (texto e imágenes)
+    - ✅ Sin necesidad de tarjeta de crédito
+    
+    ### 🔧 Modelo Usado
+    
+    - **Gemini 2.0 Flash Experimental** - Última versión, muy rápida
+    - Configurable en `app.py` línea 15
+    """)
 
-def greet(name):
-    return "Hello " + name + "!!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+if __name__ == "__main__":
+    print("\n" + "="*60)
+    print(" 🚀 Iniciando Agente GAIA con Gemini")
+    print("="*60)
+    
+    # Verificar variables de entorno
+    space_host = os.getenv("SPACE_HOST")
+    space_id = os.getenv("SPACE_ID")
+    
+    if space_host:
+        print(f"✅ SPACE_HOST: {space_host}")
+        print(f"   URL: https://{space_host}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST no encontrado (¿local?)")
+    
+    if space_id:
+        print(f"✅ SPACE_ID: {space_id}")
+        print(f"   Repo: https://huggingface.co/spaces/{space_id}")
+    else:
+        print("ℹ️  SPACE_ID no encontrado (¿local?)")
+    
+    if not os.getenv("GEMINI_API_KEY"):
+        print("⚠️  GEMINI_API_KEY no configurada")
+        print("   Obtén una gratis en: https://aistudio.google.com/apikey")
+    else:
+        print("✅ GEMINI_API_KEY configurada")
+    
+    print("="*60 + "\n")
+    print("🌐 Lanzando interfaz Gradio...")
+    
+    # En HF Spaces, Gradio maneja el hosting automáticamente
+    demo.launch()

final_answer.py

@@ -0,0 +1,123 @@
+"""
+Validaciones de formato para respuestas GAIA.
+"""
+
+import re
+
+
+def validate_number_format(answer: str) -> tuple[bool, str]:
+    """Valida formato de respuesta numérica según reglas GAIA."""
+    if not any(char.isdigit() for char in answer):
+        return True, "No es un número"
+    
+    issues = []
+    
+    # Verificar comas en números
+    if "," in answer and any(c.isdigit() for c in answer):
+        issues.append("Números no deben contener comas")
+    
+    # Verificar símbolos de moneda no solicitados
+    if any(sym in answer for sym in ["$", "€", "£", "¥"]):
+        issues.append("Símbolo de moneda - verificar si fue solicitado")
+    
+    # Verificar porcentaje
+    if "%" in answer:
+        issues.append("Símbolo % - verificar si fue solicitado")
+    
+    return (len(issues) == 0, "; ".join(issues) if issues else "OK")
+
+
+def validate_string_format(answer: str) -> tuple[bool, str]:
+    """Valida formato de respuesta de texto según reglas GAIA."""
+    issues = []
+    
+    # Verificar artículos al inicio
+    if answer.lower().startswith(("the ", "a ", "an ")):
+        issues.append("No debe comenzar con artículos")
+    
+    # Verificar mayúsculas innecesarias
+    if answer.isupper() and len(answer) > 3:
+        issues.append("Evitar mayúsculas excesivas")
+    
+    return (len(issues) == 0, "; ".join(issues) if issues else "OK")
+
+
+def validate_list_format(answer: str) -> tuple[bool, str]:
+    """Valida formato de lista según reglas GAIA."""
+    issues = []
+    
+    if "[" in answer or "]" in answer:
+        issues.append("Listas no deben incluir corchetes []")
+    
+    if "(" in answer or ")" in answer:
+        issues.append("Listas no deben incluir paréntesis ()")
+    
+    return (len(issues) == 0, "; ".join(issues) if issues else "OK")
+
+
+def clean_answer(answer: str) -> str:
+    """
+    Limpia la respuesta aplicando reglas GAIA.
+    
+    Args:
+        answer: Respuesta a limpiar
+        
+    Returns:
+        str: Respuesta limpia
+    """
+    # Remover prefijos comunes
+    prefixes = [
+        "Final Answer:", "Answer:", "The answer is:",
+        "Result:", "=>", "Output:"
+    ]
+    for prefix in prefixes:
+        if answer.startswith(prefix):
+            answer = answer[len(prefix):].strip()
+    
+    # Remover comillas
+    answer = answer.strip("\"'")
+    
+    # Remover corchetes de listas
+    answer = answer.strip("[]")
+    
+    # Remover espacios extras
+    answer = " ".join(answer.split())
+    
+    return answer
+
+
+def validate_answer_format(answer: str, question: str = "") -> dict:
+    """
+    Validación completa de formato de respuesta.
+    
+    Returns:
+        dict: {valid: bool, issues: list, warnings: list}
+    """
+    issues = []
+    warnings = []
+    
+    if not answer or answer.strip() == "":
+        issues.append("Respuesta vacía")
+        return {"valid": False, "issues": issues, "warnings": warnings}
+    
+    if len(answer) > 500:
+        warnings.append("Respuesta muy larga")
+    
+    # Validaciones específicas
+    num_valid, num_msg = validate_number_format(answer)
+    if not num_valid:
+        issues.append(num_msg)
+    
+    str_valid, str_msg = validate_string_format(answer)
+    if not str_valid:
+        warnings.append(str_msg)
+    
+    list_valid, list_msg = validate_list_format(answer)
+    if not list_valid:
+        issues.append(list_msg)
+    
+    return {
+        "valid": len(issues) == 0,
+        "issues": issues,
+        "warnings": warnings
+    }

model.py

@@ -0,0 +1,125 @@
+"""
+Model wrapper para usar Google Gemini via LiteLLM.
+Similar a chiarapaglioni/GAIA-agents pero simplificado.
+"""
+
+import os
+import time
+import re
+from typing import Any, Optional
+from functools import lru_cache
+
+try:
+    from litellm import completion, RateLimitError
+    LITELLM_AVAILABLE = True
+except ImportError:
+    LITELLM_AVAILABLE = False
+    print("⚠️  LiteLLM no instalado. Instala con: pip install litellm")
+
+
+class GeminiModel:
+    """Wrapper para Gemini usando LiteLLM con manejo de rate limits."""
+    
+    def __init__(self, model_id: str = "gemini/gemini-2.0-flash-exp", api_key: Optional[str] = None, max_retries: int = 5):
+        """
+        Inicializa el modelo Gemini.
+        
+        Args:
+            model_id: ID del modelo Gemini (con prefijo gemini/)
+            api_key: API key de Google (GEMINI_API_KEY del env si no se proporciona)
+            max_retries: Número máximo de reintentos en caso de rate limit
+        """
+        if not LITELLM_AVAILABLE:
+            raise ImportError("LiteLLM es requerido. Instala con: pip install litellm")
+        
+        self.model_id = model_id
+        self.api_key = api_key or os.getenv("GEMINI_API_KEY")
+        self.max_retries = max_retries
+        
+        if not self.api_key:
+            raise ValueError("GEMINI_API_KEY no encontrada en variables de entorno")
+    
+    def __call__(self, messages, **kwargs):
+        """
+        Llama al modelo con manejo de rate limits.
+        
+        Args:
+            messages: Lista de mensajes en formato OpenAI/LiteLLM
+            **kwargs: Argumentos adicionales (temperature, max_tokens, etc.)
+            
+        Returns:
+            str: Respuesta del modelo
+        """
+        for attempt in range(self.max_retries):
+            try:
+                response = completion(
+                    model=self.model_id,
+                    messages=messages,
+                    api_key=self.api_key,
+                    **kwargs
+                )
+                return response.choices[0].message.content
+            
+            except RateLimitError as e:
+                error_str = str(e)
+                print(f"⚠️  RateLimitError (intento {attempt + 1}/{self.max_retries})")
+                
+                # Intentar extraer tiempo de espera del error
+                match = re.search(r'"retryDelay": ?"(\d+)s"', error_str)
+                retry_seconds = int(match.group(1)) if match else 50
+                
+                print(f"💤 Esperando {retry_seconds} segundos antes de reintentar...")
+                time.sleep(retry_seconds)
+            
+            except Exception as e:
+                if attempt == self.max_retries - 1:
+                    print(f"❌ Error después de {self.max_retries} intentos: {e}")
+                    raise
+                
+                print(f"⚠️  Error en intento {attempt + 1}/{self.max_retries}: {e}")
+                time.sleep(5)
+        
+        raise RateLimitError(f"Rate limit excedido después de {self.max_retries} reintentos.")
+    
+    def generate_simple(self, prompt: str, **kwargs) -> str:
+        """
+        Helper para generar respuesta desde un prompt simple.
+        
+        Args:
+            prompt: Texto del prompt
+            **kwargs: Argumentos adicionales
+            
+        Returns:
+            str: Respuesta generada
+        """
+        messages = [{"role": "user", "content": prompt}]
+        return self(messages, **kwargs)
+
+
+@lru_cache(maxsize=1)
+def get_gemini_model(model_id: str = "gemini/gemini-2.0-flash-exp", **kwargs) -> GeminiModel:
+    """
+    Factory function con cache para obtener instancia del modelo Gemini.
+    
+    Args:
+        model_id: ID del modelo Gemini
+        **kwargs: Argumentos adicionales
+        
+    Returns:
+        GeminiModel: Instancia del modelo con cache
+    """
+    return GeminiModel(model_id=model_id, **kwargs)
+
+
+def get_model(model_id: str = "gemini/gemini-2.0-flash-exp", **kwargs) -> GeminiModel:
+    """
+    Función principal para obtener modelo.
+    
+    Args:
+        model_id: ID del modelo (por defecto Gemini Flash)
+        **kwargs: Argumentos adicionales
+        
+    Returns:
+        GeminiModel: Instancia del modelo
+    """
+    return get_gemini_model(model_id, **kwargs)

requirements.txt

@@ -0,0 +1,18 @@
+# Framework web
+gradio>=5.0.0
+
+# LLM - Google Gemini via LiteLLM
+litellm>=1.0.0
+google-generativeai>=0.8.0
+
+# Procesamiento de datos
+pandas>=2.0.0
+requests>=2.31.0
+
+# Procesamiento de imágenes (OCR)
+pillow>=10.0.0
+pytesseract>=0.3.10
+
+# Variables de entorno
+python-dotenv>=1.0.0
+

tool.py

@@ -0,0 +1,80 @@
+"""
+Registro de herramientas disponibles para el agente GAIA.
+"""
+
+import requests
+from tools import read_image_text
+from io import BytesIO
+from PIL import Image
+
+
+def file_from_url(url: str) -> bytes:
+    """
+    Descarga un archivo desde una URL y retorna su contenido como bytes.
+    
+    Args:
+        url: URL del archivo a descargar
+        
+    Returns:
+        Contenido del archivo en bytes
+    """
+    try:
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        return response.content
+    except Exception as e:
+        print(f"Error descargando archivo desde {url}: {e}")
+        return b""
+
+
+def read_text_file(url: str) -> str:
+    """
+    Lee el contenido de un archivo de texto desde una URL.
+    
+    Args:
+        url: URL del archivo de texto
+        
+    Returns:
+        Contenido del archivo como string
+    """
+    try:
+        content = file_from_url(url)
+        if content:
+            # Intentar decodificar con diferentes encodings
+            for encoding in ['utf-8', 'latin-1', 'cp1252']:
+                try:
+                    return content.decode(encoding)
+                except UnicodeDecodeError:
+                    continue
+            # Si ninguno funciona, retornar con errores ignorados
+            return content.decode('utf-8', errors='ignore')
+        return ""
+    except Exception as e:
+        print(f"Error leyendo archivo de texto desde {url}: {e}")
+        return ""
+
+
+def get_tools():
+    """
+    Retorna la lista de herramientas disponibles para el agente.
+    
+    Returns:
+        Lista de diccionarios con información de cada herramienta
+    """
+    return [
+        {
+            "name": "file_from_url",
+            "description": "Descarga un archivo desde una URL",
+            "function": file_from_url
+        },
+        {
+            "name": "read_text_file",
+            "description": "Lee el contenido de un archivo de texto desde una URL",
+            "function": read_text_file
+        },
+        {
+            "name": "read_image_text",
+            "description": "Extrae texto de una imagen usando OCR (Tesseract)",
+            "function": read_image_text
+        }
+    ]

tools.py

@@ -0,0 +1,25 @@
+from PIL import Image
+import pytesseract
+import requests
+from io import BytesIO
+import os
+
+# Configurar Tesseract en Windows si es necesario
+# Descomenta y ajusta la ruta si Tesseract no está en PATH:
+# pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'
+
+def read_image_text(url: str):
+    """Extrae texto de una imagen con OCR."""
+    try:
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        img = Image.open(BytesIO(response.content))
+        text = pytesseract.image_to_string(img)
+        return text.strip()
+    except Exception as e:
+        print(f"❌ Error al leer imagen {url}: {e}")
+        return ""
+
+def web_search(query: str):
+    """Simula búsqueda web (puedes mejorarla con Wikipedia API)."""
+    return f"(Simulación de búsqueda web para '{query}')"