> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/autogpt.md).

# Agente autónomo AutoGPT

Despliega AutoGPT en Clore.ai: ejecuta la plataforma original de agente autónomo de IA con navegación web, ejecución de código y automatización de tareas de largo alcance.

## Descripción general

[AutoGPT](https://github.com/Significant-Gravitas/AutoGPT) es la plataforma pionera de agente de IA autónomo de código abierto, con **175 mil+ estrellas en GitHub** — uno de los repositorios con más estrellas en GitHub. Originalmente una herramienta CLI de Python que se volvió viral en 2023, AutoGPT ha evolucionado hasta convertirse en una plataforma completa con un frontend web, un generador visual de flujos de trabajo, orquestación multiagente y una suite de evaluación de agentes de auto-mejora.

La plataforma AutoGPT actual consta de:

* **Interfaz** — generador visual de agentes de Next.js (puerto 3000)
* **Backend / API** — servicio FastAPI que maneja la ejecución de agentes (puerto 8000)
* **Ejecutor de agentes** — workers de 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 los artefactos de los agentes

En **Clore.ai**, AutoGPT se ejecuta completamente en CPU (delegando las llamadas al LLM a APIs en la nube), lo que lo hace asequible a **$0.05–0.20/h**. Opcionalmente puedes integrar modelos locales mediante su compatibilidad con proveedores compatibles con OpenAI.

**Capacidades clave:**

* 🤖 **Agentes autónomos** — los agentes descomponen las tareas en subobjetivos y las ejecutan iterativamente
* 🌐 **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 de Python aislado para agentes de programación
* 📁 **Operaciones con archivos** — leer, escribir y administrar archivos como parte de la ejecución de tareas
* 🔗 **Multiagente** — crear subagentes especializados y orquestarlos jerárquicamente
* 🧠 **Memoria a largo plazo** — memoria respaldada por vectores que persiste entre sesiones
* 📈 **Evaluación comparativa de agentes** — suite integrada AgentBenchmark 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 (predeterminado) 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) | Ninguna / CPU | —     | 4 GB            | 20 GB  | ≈$0.05/h (CPU)                            |
| **Estándar**                 | Ninguna / CPU | —     | 8 GB            | 40 GB  | ≈$0.08/h                                  |
| **Recomendado**              | Ninguna / CPU | —     | 16 GB           | 60 GB  | ≈$0.12/h                                  |
| **+ LLM local (Ollama)**     | RTX 3090      | 24 GB | 16 GB           | 80 GB  | $0.07–0.21/h                              |
| **+ LLM local grande**       | A100 40 GB    | 40 GB | 32 GB           | 100 GB | [bare metal](https://clore.ai/bare-metal) |

> **Nota:** AutoGPT usa LLM basados en API de forma predeterminada (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 las siguientes:

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

***

## Inicio rápido

### 1. Alquila un servidor de 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 de backend) y **3000** (interfaz)
* Acceso SSH habilitado
* **20+ GB de espacio en disco**

### 2. Conéctate al servidor

```bash
ssh root@<clore-server-ip> -p <ssh-port>

# Actualiza los paquetes
apt-get update && apt-get upgrade -y

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

### 3. Clona y configura AutoGPT

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

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

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

### 4. Configura las 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 ESTAS) ───────────────────────────────────────────
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úrala con la IP de tu servidor Clore) ─────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api
```

### 5. Compila e inicia

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

# Observa el progreso de compilación e inicio
docker compose logs -f

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

### 6. Verifica que los servicios estén sanos

```bash
# Comprobar cada servicio
docker compose ps

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

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

### 7. Accede a AutoGPT

Abre tu navegador:

* **Interfaz:** `http://<clore-server-ip>:3000`
* **API del backend:** `http://<clore-server-ip>:8000`
* **Documentación de la API (Swagger):** `http://<clore-server-ip>:8000/docs`

Crea una cuenta en la interfaz, configura tu proveedor de LLM en Configuración y empieza a construir agentes.

***

## Configuración

### Referencia `.env` completa

```bash
# ── Aplicación ───────────────────────────────────────────────────────────────
ENVIRONMENT=production
APP_SECRET_KEY=<generar-con-openssl-rand-hex-32>
JWT_SECRET_KEY=<generar-con-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 mediante 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=<generar-con-openssl-rand-hex-32>
NEXTAUTH_URL=http://<clore-server-ip>:3000
```

### Personalización de 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

# Añadir Selenium a docker-compose para 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
```

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

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

# Supervisar los registros del ejecutor
docker compose logs -f executor
```

***

## Aceleración GPU

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

### Conéctate a Ollama en el mismo servidor

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

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

# Haz que Ollama sea accesible para 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`, apunta AutoGPT a Ollama:

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

> **Nota de rendimiento:** Los agentes autónomos realizan muchas llamadas secuenciales al LLM. Los modelos locales en RTX 3090 (\~30 tok/s) funcionan, pero 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 costes en Clore.ai

```bash
# El mayor coste de AutoGPT suele ser las llamadas a la API del 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

# Haz una 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 cambios más recientes
git pull origin master

cd autogpt_platform

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

# Ejecutar migraciones de la base de datos si es necesario
docker compose exec backend alembic upgrade head
```

### Supervisión de ejecuciones de agentes

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

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

# Ver el historial de ejecuciones del agente mediante la API
curl http://localhost:8000/api/v1/runs | python3 -m json.tool
```

### Refuerzo de seguridad

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

# Archivo Caddyfile:
# autogpt.tudominio.com {
#     reverse_proxy localhost:3000
# }
# api.autogpt.tudominio.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
```

### Optimización de los tiempos de compilación

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

# Pre-descarga las 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 un error de falta de memoria

```bash
# La compilación de Docker necesita suficiente memoria (4 GB+)
# 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
```

### El backend devuelve 500 / "Database not ready"

```bash
# Comprobar el estado de la base de datos
docker compose ps db
docker compose logs db

# Ejecutar migraciones de la base de datos manualmente
docker compose exec backend alembic upgrade head

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

### La interfaz muestra "Failed to connect to 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 hace esta solicitud)
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api

# Recompila la interfaz después de cambiar esta variable de entorno
docker compose up -d --build frontend
```

### El ejecutor de agentes falla / es terminado por falta de memoria

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

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

# O reduce las ejecuciones concurrentes de agentes
MAX_CONCURRENT_RUNS=2
```

### Conexión a Redis rechazada

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

# Probar la 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
```

### El agente se queda 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 mediante 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)
* [Ejecutar Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)
* [Ejecutar vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)
* [Comparación 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.