Marco de Agentes SuperAGI

Despliega SuperAGI en Clore.ai — un marco de agentes autónomos orientado a desarrolladores con panel GUI, mercado de herramientas, agentes concurrentes y soporte opcional de LLM local en potentes servidores GPU en la nube.

Resumen

SuperAGI es un marco de agentes de IA autónomos de código abierto y orientado a desarrolladores con más de 15K estrellas en GitHub. A diferencia de los simples chatbots, SuperAGI ejecuta agentes autónomos — sistemas de IA que planifican de forma independiente, ejecutan tareas de varios pasos, usan herramientas e iteran hacia un objetivo sin entrada humana constante.

¿Por qué ejecutar SuperAGI en Clore.ai?

• GPU opcional con potente soporte para LLM locales — Ejecuta agentes respaldados por modelos locales (Llama, Mistral, etc.) en GPUs de Clore.ai para una IA autónoma totalmente privada y con control de costos.

• Ejecución concurrente de agentes — Ejecuta múltiples agentes en paralelo en el mismo servidor, cada uno trabajando en distintas tareas simultáneamente.

• Memoria persistente de agentes — Los agentes mantienen el contexto, aprenden de las salidas de las herramientas y almacenan memoria a largo plazo en bases de datos vectoriales entre ejecuciones.

• Mercado de herramientas — Integraciones preconstruidas para Google Search, GitHub, Email, Jira, Notion y más.

• Economía de Clore.ai — A ~0,20 $/h para una RTX 3090, puedes ejecutar agentes autónomos capaces a una fracción del costo de los servicios de IA en la nube.

Características clave

Función	Descripción
Provisionamiento de agentes	Crea, configura y despliega agentes vía GUI
Mercado de herramientas	Más de 30 herramientas integradas (búsqueda, código, archivos, APIs)
Soporte multmodelo	OpenAI, Anthropic, LLMs locales vía endpoint personalizado
Agentes concurrentes	Ejecuta múltiples agentes simultáneamente
Memoria del agente	Corto plazo (ventana de contexto) + largo plazo (BD vectorial)
Panel GUI	Interfaz web completa para la gestión de agentes
Gestor de recursos	Rastrea el uso de tokens y costos por agente
Plantillas de flujo de trabajo	Plantillas de agentes preconstruidas para tareas comunes

Arquitectura

┌────────────────────────────────────────────────────┐
│              Pila SuperAGI                         │
│                                                    │
│  ┌─────────────────────┐   ┌───────────────────┐   │
│  │  Frontend (Puerto 3000)│   │  API (Puerto 8001)  │   │
│  │   Interfaz Next.js    │   │  Backend FastAPI    │   │
│  └──────────┬──────────┘   └─────────┬─────────┘   │
│             └──────────┬─────────────┘             │
│                        ▼                           │
│  ┌─────────────────────────────────────────────┐   │
│  │              Ejecutor de Agentes            │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │   │
│  │  │ Agente 1 │  │ Agente 2 │  │ Agente N │  │   │
│  │  └──────────┘  └──────────┘  └──────────┘  │   │
│  └───────┬─────────────┬─────────────┬─────────┘   │
│          ▼             ▼             ▼             │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐      │
│  │ PostgreSQL │  │  Redis    │  │  Vector   │      │
│  │  (Estado)  │  │  (Cola)   │  │    DB     │      │
│  └───────────┘  └───────────┘  └───────────┘      │
└────────────────────────────────────────────────────┘
          │
    ┌─────┴──────┐
    ▼            ▼
 OpenAI      LLM local
 Anthropic   (Ollama/vLLM)

---

Requisitos

Especificaciones del servidor

Componente	Mínimo	Recomendado	Notas
GPU	Ninguno (modo API)	RTX 3090 (LLMs locales)	GPU necesaria para la inferencia de modelos locales
VRAM	—	24 GB	Para ejecutar modelos locales de 13B+
CPU	4 vCPU	8 vCPU	La ejecución de agentes es intensiva en CPU
RAM	8 GB	16 GB	Múltiples agentes concurrentes necesitan memoria
Almacenamiento	20 GB	Más de 100 GB	Registros de agentes, BD vectorial, almacenamiento de modelos

Referencia de precios de Clore.ai

Tipo de servidor	Costo aprox.	Caso de uso
CPU (8 vCPU, 16 GB)	≈0,10–0,20 $/h	SuperAGI + API externa (OpenAI/Anthropic)
RTX 3090 (24 GB)	~$0.20/h	SuperAGI + modelo local Ollama 13B
RTX 4090 (24 GB)	~$0.35/h	SuperAGI + Ollama, inferencia más rápida
2× RTX 3090	~0,40 USD/h	SuperAGI + modelo 70B (Q4 cuantizado)
A100 80 GB	~$1.10/h	SuperAGI + modelos grandes, alta concurrencia
H100 80 GB	≈2,50 $/h	Sistemas de agentes autónomos de nivel producción

💡 Consejo de coste: Para desarrollo y pruebas, use las APIs de OpenAI o Anthropic (no se necesita GPU). Cambie a una instancia con GPU solo cuando necesite inferencia de LLM local por motivos de privacidad o costo. Vea Guía de comparación de GPU.

Prerrequisitos

• Servidor Clore.ai con acceso SSH

• Docker + Docker Compose (preinstalado en Clore.ai)

• Git (preinstalado)

• 4+ vCPU, 8+ GB RAM (se recomiendan 16 GB para agentes concurrentes)

• Clave API de OpenAI o endpoint de LLM local (Ollama/vLLM)

---

Inicio rápido

Método 1: Docker Compose (Oficial — Recomendado)

El despliegue oficial de SuperAGI usa Docker Compose para gestionar todos los servicios.

Paso 1: Conéctate a tu servidor Clore.ai

ssh root@<tu-ip-servidor-clore> -p <puerto-ssh>

Paso 2: Clonar y configurar

git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI
cp config_template.yaml config.yaml

Paso 3: Editar config.yaml

nano config.yaml

Configuración mínima requerida:

# config.yaml
OPENAI_API_KEY: "sk-your-openai-key-here"

# Base de datos (dejar por defecto para Docker Compose)
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "password"

# Base de datos vectorial
VECTOR_STORE: "Redis"  # o "Pinecone", "Qdrant", "Weaviate"
REDIS_URL: "redis://super__agi-redis-1:6379/0"

# Configuración de la app
ENV: "PROD"
ALLOW_LISTS_CREATION: "true"

# Opcional: restringir el acceso
# AUTH_SECRET_KEY: "your-random-secret"

Paso 4: Inicia el stack

docker compose up -d --build

El proceso de compilación descarga dependencias y compila el frontend (~5–10 minutos en la primera ejecución).

Paso 5: Monitorizar el arranque

# Observa que todos los servicios se inicien
docker compose ps

# Seguir los logs
docker compose logs -f

# Espera a "Application startup complete" en los registros del backend
docker compose logs superagi-backend --tail 30

Paso 6: Acceder al panel

http://<tu-ip-servidor-clore>:3000

La API está disponible en:

http://<tu-ip-servidor-clore>:8001

Documentación de la API:

http://<tu-ip-servidor-clore>:8001/docs

---

Método 2: Inicio rápido con imágenes preconstruidas

Para un inicio más rápido usando imágenes preconstruidas (omite el paso de compilación):

git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI
cp config_template.yaml config.yaml

# Edita la configuración con tus claves API
nano config.yaml

# Usa imágenes preconstruidas si están disponibles
docker compose -f docker-compose.yaml pull
docker compose up -d

---

Método 3: Configuración mínima de un solo modelo

Una configuración simplificada para pruebas solo con OpenAI:

git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI

# Crea una configuración mínima
cat > config.yaml << 'EOF'
OPENAI_API_KEY: "sk-your-key-here"
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "superagi_password_123"
REDIS_URL: "redis://super__agi-redis-1:6379/0"
ENV: "PROD"
EOF

docker compose up -d --build

# Monitoriza el progreso de la compilación
docker compose logs superagi-frontend --tail 5 -f &
docker compose logs superagi-backend --tail 5 -f

---

Configuración

config.yaml Referencia

# ============================================================
# Proveedores LLM
# ============================================================
OPENAI_API_KEY: "sk-..."                    # Modelos OpenAI GPT
ANTHROPIC_API_KEY: "sk-ant-..."            # Modelos Claude

# Para modelos locales (Ollama o API compatible con OpenAI)
# Configurar en la UI: Settings → Models → Custom Model
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"  # Ollama en el mismo host
OPENAI_MODEL: "llama3.1:8b"

# ============================================================
# Base de datos
# ============================================================
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "your-strong-password"

# ============================================================
# Base de datos vectorial (memoria a largo plazo del agente)
# ============================================================
VECTOR_STORE: "Redis"       # Redis (predeterminado, integrado)
# O use externo:
# VECTOR_STORE: "Pinecone"
# PINECONE_API_KEY: "your-key"
# PINECONE_ENVIRONMENT: "us-east-1-aws"

# VECTOR_STORE: "Weaviate"
# WEAVIATE_URL: "http://weaviate:8080"

# ============================================================
# Claves API de herramientas (opcionales, para herramientas específicas)
# ============================================================
GOOGLE_API_KEY: "your-google-key"
GOOGLE_CUSTOM_SEARCH_ENGINE_ID: "your-cx-id"
GITHUB_TOKEN: "ghp_your-token"
JIRA_EMAIL: "[email protected]"
JIRA_API_TOKEN: "your-jira-token"
JIRA_SERVER_URL: "https://your-org.atlassian.net"

# ============================================================
# Almacenamiento
# ============================================================
STORAGE_TYPE: "File"        # Almacenamiento de archivos local
# STORAGE_TYPE: "S3"        # Compatible con S3 (MinIO, AWS)
# BUCKET_NAME: "superagi"
# AWS_ACCESS_KEY_ID: "..."
# AWS_SECRET_ACCESS_KEY: "..."

# ============================================================
# Seguridad
# ============================================================
JWT_SECRET_KEY: "your-random-secret-key"

Conectar SuperAGI a las herramientas

Las herramientas se configuran a través de la GUI en Settings → Toolkit. Cada herramienta puede activarse/desactivarse por agente.

Herramientas integradas:

Herramienta	Propósito	Se necesita clave API
Búsqueda en Google	Búsqueda web	Sí (API de Google)
DuckDuckGo	Búsqueda web	No
GitHub	Acceso a repositorios de código	Sí (token de GitHub)
Correo electrónico	Enviar/leer correo	Sí (configuración SMTP)
Escritor de código	Escribir y ejecutar código	No
Administrador de archivos	Leer/escribir archivos locales	No
Navegador	Navegación web sin cabeza	No
Jira	Seguimiento de incidencias	Sí
Notion	Base de conocimiento	Sí
Generación de imágenes	DALL-E 3, Stable Diffusion	Sí (clave de OpenAI)

Creando tu primer agente

Vía la GUI (Settings → Agents → Create Agent):

1. Nombre — Dale a tu agente un nombre descriptivo

2. Descripción — Qué hace este agente

3. Metas — Lista los objetivos (uno por línea)

4. Instrucciones — Prompt del sistema para el comportamiento

5. Modelo — Seleccionar LLM (GPT-4, Claude o local)

6. Herramientas — Habilita las herramientas relevantes

7. Máx. Iteraciones — Límite de seguridad (10–50 típico)

Vía la API REST:

# Crear un agente vía API
curl -X POST "http://localhost:8001/v1/agent" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Agente de Investigación",
    "description": "Investiga temas y escribe resúmenes",
    "goal": [
      "Investigar el tema proporcionado",
      "Escribir un resumen completo",
      "Guardar el resumen en un archivo"
    ],
    "agent_type": "Cola de Tareas",
    "constraints": [],
    "tools": ["DuckDuckGoSearch", "WriteFileTool", "ReadFileTool"],
    "exit_criterion": "Sin criterio de salida",
    "max_iterations": 25,
    "user_timezone": "UTC",
    "llm_model_config": {
      "model_name": "gpt-4o-mini",
      "temperature": 0.5,
      "max_new_tokens": 2000
    }
  }'

---

Aceleración por GPU

SuperAGI admite la inferencia de LLM local mediante cualquier endpoint compatible con OpenAI, lo que lo hace ideal para despliegues en Clore.ai con respaldo por GPU.

Configurando Ollama como backend LLM para agentes

Ver Guía de Ollama para la configuración completa de Ollama. Integración con SuperAGI:

Paso 1: Iniciar Ollama en el mismo servidor Clore.ai

docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_models:/root/.ollama \
  ollama/ollama

# Descarga un modelo capaz para uso de agentes (necesita buen razonamiento)
docker exec ollama ollama pull llama3.1:8b        # Rápido, buen razonamiento
docker exec ollama ollama pull mistral:7b-instruct  # Tareas de código
docker exec ollama ollama pull deepseek-coder:6.7b # Agentes centrados en código

Paso 2: Configurar SuperAGI para usar Ollama

En config.yaml:

# Apunta a Ollama (ejecutándose en el host Docker)
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"

O configurar en la UI de SuperAGI:

• Settings → Models → Add Custom Model

• Proveedor: compatible con OpenAI

• URL base: http://172.17.0.1:11434/v1

• Clave API: ollama (cualquier cadena)

• Nombre del modelo: llama3.1:8b

Configurando vLLM para agentes de alto rendimiento

Para despliegues de producción con muchos agentes concurrentes (ver Guía de vLLM):

# Iniciar vLLM en el servidor con GPU
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your-token \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --served-model-name mistral-7b \
  --max-model-len 8192 \
  --enable-prefix-caching

# En config.yaml:
# OPENAI_API_BASE: "http://172.17.0.1:8000/v1"

Dimensionamiento de GPU para cargas de trabajo de agentes

Caso de uso	Modelo	GPU	VRAM	Agentes concurrentes
Pruebas	GPT-4o-mini (API)	Ninguna	—	Ilimitado (limitado por tasa)
Agentes ligeros	Llama 3.1 8B	RTX 3090	8 GB	2–4
Tareas de razonamiento	Mistral 7B Instruct	RTX 3090	6 GB	3–5
Agentes complejos	Llama 3.1 70B Q4	2× RTX 3090	48 GB	1–2
Producción	Llama 3.1 70B FP16	A100 80GB	80 GB	3–6

---

Consejos y mejores prácticas

Diseño de agentes

• Sé específico con las metas — Metas vagas como "hacer investigación" hacen que los agentes entren en bucle. Usa "Investigar X y escribir un resumen de 500 palabras en el archivo output.txt."

• Establece límites de iteración — Siempre establece max_iterations (20–50). Los agentes ilimitados pueden consumir tokens rápidamente.

• Usa el modo de cola de tareas — Para pipelines de múltiples pasos, los agentes "Task Queue" son más fiables que el modo "Don't Limit".

• Prueba primero con modelos baratos — Valida la lógica del agente con GPT-4o-mini o un modelo local de 7B antes de usar modelos caros.

Gestión de costos en Clore.ai

# Monitoriza el uso de tokens en tiempo real desde el panel de SuperAGI
# Settings → Resources → Token Usage

# Establece límites a nivel de organización en config.yaml
MAX_BUDGET_TOKENS: 100000  # Límite blando por sesión

Dado que Clore.ai cobra por hora:

# Guarda las configuraciones de agentes antes de detener la instancia
docker compose exec superagi-backend \
  python -c "import json; from superagi.models import Agent; ..."

# Hacer copia de seguridad de la base de datos PostgreSQL
docker compose exec super__agi-db-1 \
  pg_dump -U super_agi super_agi | gzip > superagi-db-$(date +%Y%m%d).sql.gz

# Copiar la copia de seguridad fuera del servidor
scp -P <ssh-port> root@<server-ip>:~/SuperAGI/superagi-db-*.sql.gz ./

Asegurando SuperAGI

# Habilitar autenticación en config.yaml
AUTH_SECRET_KEY: "your-strong-random-secret"

# Restringir la API a localhost (usar túneles SSH)
# Modificar docker-compose.yml para eliminar el enlace de puerto externo:
# ports:
#   - "127.0.0.1:8001:8001"  # API solo local
#   - "127.0.0.1:3000:3000"  # UI solo local

# Luego acceder vía túnel SSH:
# ssh -L 3000:localhost:3000 -L 8001:localhost:8001 root@<server-ip> -p <port>

Almacenamiento persistente entre sesiones de Clore.ai

# Crear script de copia de seguridad completo
cat > /root/backup-superagi.sh << 'EOF'
#!/bin/bash
cd ~/SuperAGI

# Copia de seguridad de la base de datos
docker compose exec -T super__agi-db-1 \
  pg_dump -U super_agi super_agi | \
  gzip > ~/backups/superagi-db-$(date +%Y%m%d-%H%M).sql.gz

# Copia de seguridad de la configuración y áreas de trabajo
tar -czf ~/backups/superagi-files-$(date +%Y%m%d-%H%M).tar.gz \
  config.yaml \
  workspace/ \
  .env 2>/dev/null || true

echo "Copia de seguridad completada: $(ls -lh ~/backups/ | tail -2)"
EOF

chmod +x /root/backup-superagi.sh
mkdir -p ~/backups

Actualizando SuperAGI

cd ~/SuperAGI

# Guardar la configuración actual
cp config.yaml config.yaml.backup

# Obtener los últimos cambios
git pull origin main

# Reconstruir y reiniciar
docker compose down
docker compose up -d --build

# Verificar que todos los servicios estén saludables
docker compose ps
docker compose logs superagi-backend --tail 20

---

Solución de problemas

La compilación falla durante docker compose up --build

# Revisar los registros de compilación en detalle
docker compose build superagi-backend --no-cache 2>&1 | tail -50

# Solución común: liberar espacio en disco
docker system prune -f
df -h  # Asegúrate de tener al menos 10 GB libres

# Si la compilación npm falla para el frontend
docker compose build superagi-frontend --no-cache

# Verificar la memoria de Node.js durante la compilación
docker compose build superagi-frontend \
  --build-arg NODE_OPTIONS="--max-old-space-size=4096"

El backend falla al arrancar

# Revisar los registros del backend
docker compose logs superagi-backend --tail 50

# Causas comunes:
# 1. Sintaxis inválida en config.yaml
python3 -c "import yaml; yaml.safe_load(open('config.yaml'))" && echo "YAML OK"

# 2. Base de datos no lista
docker compose restart superagi-backend  # Espera a que la BD arranque primero

# 3. Falta la clave API
grep OPENAI_API_KEY config.yaml  # Asegúrate de que esté configurada y no vacía

El frontend no carga (puerto 3000)

# Revisar el contenedor del frontend
docker compose ps superagi-frontend
docker compose logs superagi-frontend --tail 30

# Verificar el mapeo de puertos
ss -tlnp | grep 3000

# Comprobar si el backend API es accesible desde el frontend
docker compose exec superagi-frontend \
  curl -s http://superagi-backend:8001/health

Los agentes entran en bucle indefinidamente

# Revisar los registros del agente en la UI de SuperAGI:
# Dashboard → Agent → View Logs

# Forzar la detención de un agente en ejecución vía API
curl -X POST "http://localhost:8001/v1/agent/<agent-id>/stop" \
  -H "Content-Type: application/json"

# O detener todos los agentes vía BD
docker compose exec super__agi-db-1 \
  psql -U super_agi -c "UPDATE agent_executions SET status='COMPLETED' WHERE status='RUNNING';"

Errores de conexión a Redis

# Revisar el estado de Redis
docker compose ps super__agi-redis-1
docker compose logs super__agi-redis-1

# Probar la conexión a Redis
docker compose exec superagi-backend \
  python3 -c "import redis; r=redis.from_url('redis://super__agi-redis-1:6379/0'); print(r.ping())"

# Reiniciar Redis
docker compose restart super__agi-redis-1

Ollama no accesible desde el contenedor de SuperAGI

# Encontrar la IP del puente Docker
docker network inspect bridge | grep Gateway

# Probar desde el contenedor del backend
docker compose exec superagi-backend \
  curl -s http://172.17.0.1:11434/v1/models

# Si usas host networking
docker run -d --network host ...  # No es compatible fácilmente con docker compose

# Alternativa: agregar Ollama a la misma red de compose
# Añadir a los servicios de docker-compose.yml:
# ollama:
#   image: ollama/ollama
#   deploy:
#     resources:
#       reservations:
#         devices:
#           - driver: nvidia
#             count: all
#             capabilities: [gpu]

Pool de conexiones de la base de datos agotado

# Aumentar max connections de PostgreSQL en docker-compose.yml
# Bajo el servicio db:
command: postgres -c max_connections=200

# Reiniciar la base de datos
docker compose restart super__agi-db-1
docker compose restart superagi-backend

---

Lecturas adicionales

• Documentación de SuperAGI — guías oficiales, referencia de la API

• SuperAGI en GitHub — código fuente, issues, comunidad

• Ejecutando Ollama en Clore.ai — backend de LLM local para agentes

• Ejecutando vLLM en Clore.ai — inferencia de alto rendimiento para agentes concurrentes

• Guía de comparación de GPU — elegir el nivel correcto de Clore.ai

• Mercado de herramientas de SuperAGI — herramientas para agentes creadas por la comunidad

• Discord de SuperAGI — soporte y discusiones de la comunidad

• Documentación de FastAPI (API de SuperAGI) — documentación interactiva de la API en tu instancia