# Agente autónomo AutoGPT

## Resumen

[AutoGPT](https://github.com/Significant-Gravitas/AutoGPT) es la plataforma pionera de agentes autónomos de IA de código abierto, con **175K+ estrellas en GitHub** — uno de los repositorios con más estrellas en GitHub. Originalmente una herramienta CLI en Python que se hizo viral en 2023, AutoGPT ha evolucionado hasta convertirse en una plataforma completa con una interfaz web, constructor visual de flujos de trabajo, orquestación multiagente y un conjunto de pruebas de referencia para agentes que se mejoran a sí mismos.

La plataforma AutoGPT actual consiste en:

* **Frontend** — Constructor visual de agentes Next.js (puerto 3000)
* **Backend / API** — Servicio FastAPI que maneja la ejecución de agentes (puerto 8000)
* **Ejecutor de agentes** — Workers en Python que ejecutan bucles de tareas autónomas
* **Postgres** — almacenamiento persistente para el estado y las ejecuciones de los agentes
* **Redis** — cola de trabajos y pub/sub
* **Minio** — almacenamiento de objetos compatible con S3 para artefactos de los agentes

En **Clore.ai**, AutoGPT funciona completamente en CPU (delegando las llamadas a LLM a APIs en la nube), lo que lo hace asequible a **$0.05–0.20/hora**. Opcionalmente puedes integrar modelos locales a través de su soporte de proveedores compatibles con OpenAI.

**Capacidades clave:**

* 🤖 **Agentes autónomos** — los agentes descomponen tareas en subobjetivos y las ejecutan de forma iterativa
* 🌐 **Navegación web** — los agentes pueden buscar en la web, extraer páginas y sintetizar información
* 💻 **Ejecución de código** — entorno de ejecución Python aislado para agentes de programación
* 📁 **Operaciones de archivos** — leer, escribir y gestionar archivos como parte de la ejecución de tareas
* 🔗 **Multiagente** — crear subagentes especializados y orquestarlos jerárquicamente
* 🧠 **Memoria a largo plazo** — memoria basada en vectores persistida entre sesiones
* 📈 **Evaluación de agentes** — suite AgentBenchmark integrada para evaluar el rendimiento de los agentes

***

## Requisitos

Los requisitos de cómputo de AutoGPT dependen de si usas APIs de LLM en la nube (por defecto) o modelos locales. La plataforma en sí es ligera.

| Configuración                | GPU                | VRAM  | RAM del sistema | Disco  | Precio de Clore.ai |
| ---------------------------- | ------------------ | ----- | --------------- | ------ | ------------------ |
| **Mínima** (APIs en la nube) | Ninguno / Solo CPU | —     | 4 GB            | 20 GB  | \~$0.05/hora (CPU) |
| **Estándar**                 | Ninguno / Solo CPU | —     | 8 GB            | 40 GB  | \~$0.08/hora       |
| **Recomendado**              | Ninguno / Solo CPU | —     | 16 GB           | 60 GB  | \~$0.12/hora       |
| **+ LLM local (Ollama)**     | RTX 3090           | 24 GB | 16 GB           | 80 GB  | \~$0.20/h          |
| **+ Gran LLM local**         | A100 40 GB         | 40 GB | 32 GB           | 100 GB | \~$0.80/h          |

> **Nota:** AutoGPT usa LLM basados en API por defecto (OpenAI GPT-4, Anthropic Claude, etc.). Una GPU solo es útil si configuras un endpoint de modelo local mediante Ollama u otro servidor compatible con OpenAI.

### Se requieren claves de API

Necesitarás al menos una de:

* **Clave de API de OpenAI** (se recomienda GPT-4o para el mejor rendimiento de los agentes)
* **Clave de API de Anthropic** (Claude 3.5 Sonnet es excelente para agentes)
* **Clave de Google AI** (se admiten modelos Gemini)

***

## Inicio rápido

### 1. Alquila un servidor Clore.ai

Inicia sesión en [clore.ai](https://clore.ai) y lanza un servidor con:

* **2+ núcleos de CPU, 8 GB de RAM** mínimo
* Puertos expuestos **8000** (API backend) y **3000** (frontend)
* Acceso SSH habilitado
* **20+ GB de espacio en disco**

### 2. Conéctate al servidor

```bash
ssh root@<ip-servidor-clore> -p <puerto-ssh>

# Actualizar paquetes
apt-get update && apt-get upgrade -y

# Verificar Docker y Compose
docker --version
docker compose version   # Debe ser v2.x
```

### 3. Clonar y configurar AutoGPT

```bash
# Clonar el repositorio
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform

# Copiar la plantilla de entorno
cp .env.example .env

# Editar el archivo de entorno
nano .env
```

### 4. Establecer variables de entorno requeridas

```bash
# Mínimo requerido en .env:

# ── Proveedor de LLM (elige al menos uno) ────────────────────────────────────────
OPENAI_API_KEY=sk-...
# ANTHROPIC_API_KEY=sk-ant-...

# ── Claves secretas (CAMBIA ESTO) ──────────────────────────────────────────────
APP_SECRET_KEY=$(openssl rand -hex 32)
JWT_SECRET_KEY=$(openssl rand -hex 32)

# ── Base de datos ─────────────────────────────────────────────────────────────────
DATABASE_URL=postgresql://postgres:password@db:5432/autogpt

# ── URL del backend (configúralo en la IP de tu servidor Clore) ───────────────────────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api
```

### 5. Construir y lanzar

```bash
# Construir imágenes e iniciar todos los servicios (la primera ejecución tarda 5-10 minutos)
docker compose up -d --build

# Vigilar el progreso de la construcción e inicio
docker compose logs -f

# Después del inicio, verifica que todos los contenedores estén en funcionamiento
docker compose ps
```

### 6. Verificar que los servicios estén saludables

```bash
# Comprobar cada servicio
docker compose ps

# Servicios en ejecución esperados:
# autogpt_platform-db-1        Up (healthy)
# autogpt_platform-redis-1     Up
# autogpt_platform-minio-1     Up
# autogpt_platform-backend-1   Up
# autogpt_platform-frontend-1  Up
# autogpt_platform-executor-1  Up

# Probar la API del backend
curl http://localhost:8000/api/health
# Esperado: {"status": "ok"}
```

### 7. Acceder a AutoGPT

Abre tu navegador:

* **Frontend:** `http://<clore-server-ip>:3000`
* **API Backend:** `http://<clore-server-ip>:8000`
* **Docs de la API (Swagger):** `http://<clore-server-ip>:8000/docs`

Crea una cuenta en el frontend, configura tu proveedor de LLM en Ajustes y comienza a crear agentes.

***

## Configuración

### Completo `.env` referencia

```bash
# ── Aplicación ──────────────────────────────────────────────────────────────
ENVIRONMENT=production
APP_SECRET_KEY=<generate-with-openssl-rand-hex-32>
JWT_SECRET_KEY=<generate-with-openssl-rand-hex-32>
ALLOWED_ORIGINS=http://<clore-server-ip>:3000

# ── Proveedores de LLM ────────────────────────────────────────────────────────────
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GROQ_API_KEY=gsk_...

# ── Compatible con OpenAI (para modelos locales vía Ollama/vLLM) ────────────────────
OPENAI_API_BASE=http://localhost:11434/v1   # Endpoint compatible con OpenAI de Ollama
OPENAI_API_KEY=ollama                        # Clave ficticia para Ollama

# ── Base de datos ─────────────────────────────────────────────────────────────────
DATABASE_URL=postgresql://postgres:password@db:5432/autogpt
POSTGRES_USER=postgres
POSTGRES_PASSWORD=password    # ¡Cámbialo en producción!
POSTGRES_DB=autogpt

# ── Redis (cola de trabajos) ────────────────────────────────────────────────────────
REDIS_URL=redis://redis:6379/0

# ── Minio (almacenamiento de objetos) ──────────────────────────────────────────────────
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=minioadmin   # ¡Cámbialo en producción!
MINIO_URL=http://minio:9000

# ── Frontend ─────────────────────────────────────────────────────────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api
NEXTAUTH_SECRET=<generate-with-openssl-rand-hex-32>
NEXTAUTH_URL=http://<clore-server-ip>:3000
```

### Personalizando las capacidades del agente

```bash
# Habilitar la capacidad de navegación web
WEB_BROWSER_ENABLED=true
SELENIUM_CHROME_DRIVER_URL=http://selenium:4444/wd/hub

# Agregar Selenium a docker-compose para la navegación web:
# services:
#   selenium:
#     image: selenium/standalone-chrome:latest
#     shm_size: 2gb
#     ports:
#       - "4444:4444"

# Acceso al sistema de archivos (espacio de trabajo del agente)
WORKSPACE_PATH=/workspace
RESTRICT_TO_WORKSPACE=true
```

### Administración de la escalabilidad del ejecutor de agentes

```bash
# Escalar workers del ejecutor para ejecuciones paralelas de agentes
docker compose up -d --scale executor=4

# Monitorizar los logs del ejecutor
docker compose logs -f executor
```

***

## Aceleración por GPU

AutoGPT delega toda la inferencia de LLM a proveedores externos por defecto. Para usar modelos locales acelerados por GPU:

### Conectar con Ollama en el mismo servidor

```bash
# Instalar Ollama en el servidor Clore
curl -fsSL https://ollama.com/install.sh | sh

# Descargar un modelo capaz (Llama 3 70B necesita A100, 8B funciona en RTX 3090)
ollama pull llama3:8b
# Para el mejor rendimiento de los agentes:
ollama pull llama3.1:70b   # Requiere A100 40GB+

# Hacer accesible Ollama a los contenedores Docker
OLLAMA_HOST=0.0.0.0 ollama serve &

# Probar el endpoint compatible con OpenAI
curl http://localhost:11434/v1/models
```

En `.env`, señala AutoGPT a Ollama:

```bash
OPENAI_API_BASE=http://host.docker.internal:11434/v1
OPENAI_API_KEY=ollama
OPENAI_DEFAULT_MODEL=llama3.1:70b
```

> **Nota sobre rendimiento:** Los agentes autónomos realizan muchas llamadas secuenciales a LLM. Los modelos locales en RTX 3090 (\~30 tok/s) funcionan, pero una A100 80GB permite iteraciones más rápidas. Ver [Comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md).

### Recomendaciones de modelos locales para agentes

| Modelo                | Calidad del agente | VRAM  | GPU de Clore |
| --------------------- | ------------------ | ----- | ------------ |
| Llama 3 8B            | Aceptable          | 8 GB  | RTX 3080     |
| Llama 3.1 8B Instruct | Bueno              | 8 GB  | RTX 3080     |
| Llama 3.1 70B         | Excelente          | 40 GB | A100 40GB    |
| Mixtral 8x7B          | Bueno              | 24 GB | RTX 3090     |
| Qwen 2.5 72B          | Excelente          | 40 GB | A100 40GB    |

***

## Consejos y mejores prácticas

### Gestión de costos en Clore.ai

```bash
# El mayor costo de AutoGPT suele ser las llamadas a las APIs de LLM, no el cómputo
# Establece límites de presupuesto de tokens en la configuración del agente:
# MAX_TOKENS_PER_RUN=100000
# MAX_COST_PER_RUN=1.00   # USD

# Hacer copia de seguridad del estado del agente antes de detener la instancia de Clore
docker exec autogpt_platform-db-1 \
  pg_dump -U postgres autogpt | gzip > autogpt-backup-$(date +%Y%m%d).sql.gz

# Copiar a la máquina local
scp -P <port> root@<ip>:autogpt-backup-*.sql.gz ./
```

### Actualizando AutoGPT

```bash
cd AutoGPT

# Obtener los últimos cambios
git pull origin master

cd autogpt_platform

# Reconstruir con el nuevo código
docker compose down
docker compose up -d --build

# Ejecutar migraciones de BD si es necesario
docker compose exec backend alembic upgrade head
```

### Monitorización de ejecuciones de agentes

```bash
# Vigilar los logs del backend para la actividad de los agentes
docker compose logs -f backend executor

# Monitorizar recursos del sistema durante las ejecuciones de agentes
htop
# o
docker stats

# Ver el historial de ejecuciones de agentes vía API
curl http://localhost:8000/api/v1/runs | python3 -m json.tool
```

### Endurecimiento de seguridad

```bash
# NUNCA expongas los puertos 8000/3000 directamente a Internet sin autenticación
# Usa Nginx o Caddy como proxy inverso con HTTPS:

# Archivo Caddy:
# autogpt.yourdomain.com {
#     reverse_proxy localhost:3000
# }
# api.autogpt.yourdomain.com {
#     reverse_proxy localhost:8000
# }

# Restringir el acceso al sistema de archivos del agente
RESTRICT_TO_WORKSPACE=true
WORKSPACE_PATH=/agent-workspace

# Deshabilitar el registro de usuarios después de la configuración inicial
ALLOW_SIGNUP=false
```

### Optimizando los tiempos de compilación

```bash
# La primera compilación es lenta (~10 min); las compilaciones posteriores usan caché
# Usa BuildKit para compilaciones más rápidas:
DOCKER_BUILDKIT=1 docker compose up -d --build

# Pre-descargar imágenes base para acelerar las compilaciones
docker pull python:3.11-slim
docker pull node:20-alpine
```

***

## Solución de problemas

### La compilación falla con error de memoria insuficiente

```bash
# La compilación de Docker necesita memoria suficiente (4GB+)
# Añade espacio de intercambio si es necesario:
fallocate -l 8G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

# Hacer permanente
echo '/swapfile none swap sw 0 0' >> /etc/fstab
```

### Backend devuelve 500 / "Base de datos no lista"

```bash
# Comprobar la salud de la BD
docker compose ps db
docker compose logs db

# Ejecutar migraciones de BD manualmente
docker compose exec backend alembic upgrade head

# Si las migraciones fallan, revisa DATABASE_URL en .env
docker compose exec backend printenv DATABASE_URL
```

### El frontend muestra "No se pudo conectar al backend"

```bash
# Verifica que NEXT_PUBLIC_AGPT_SERVER_URL esté configurado correctamente
grep NEXT_PUBLIC_AGPT_SERVER_URL .env

# Debe ser la IP pública, no localhost (el navegador realiza esta solicitud)
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api

# Reconstruir el frontend después de cambiar esta variable de entorno
docker compose up -d --build frontend
```

### El ejecutor de agentes se bloquea / es terminado por OOM

```bash
# Comprobar uso de memoria
docker stats autogpt_platform-executor-1

# Limitar la memoria del ejecutor y añadir política de reinicio
# En docker-compose.yaml:
#   executor:
#     mem_limit: 2g
#     restart: unless-stopped

# O reducir ejecuciones concurrentes de agentes
MAX_CONCURRENT_RUNS=2
```

### Conexión a Redis rechazada

```bash
# Comprobar que Redis esté en ejecución
docker compose ps redis
docker compose logs redis

# Probar conectividad desde el backend
docker compose exec backend redis-cli -h redis ping
# Esperado: PONG

# Si Redis requiere autenticación, establece:
REDIS_URL=redis://:password@redis:6379/0
```

### Agente atascado en un bucle

```bash
# Los agentes de AutoGPT a veces pueden entrar en bucles infinitos
# Establece un límite máximo de ciclos:
MAX_AGENT_CYCLES=50

# O interrumpe un agente en ejecución vía la API:
curl -X POST http://localhost:8000/api/v1/runs/<run-id>/stop
```

***

## Lecturas adicionales

* [Documentación oficial de AutoGPT](https://docs.agpt.co)
* [Repositorio de AutoGPT en GitHub](https://github.com/Significant-Gravitas/AutoGPT)
* [Guía de configuración de la plataforma AutoGPT](https://docs.agpt.co/platform/getting-started)
* [Ejecutando Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)
* [Ejecutando vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)
* [Comparativa de GPU de Clore.ai](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md)
* [Comunidad de AutoGPT en Discord](https://discord.gg/autogpt)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/autogpt.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.