> 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/superagi.md).

# Framework de agentes SuperAGI

Despliega SuperAGI en Clore.ai: un framework de agentes de IA autónomos centrado en desarrolladores con panel GUI, mercado de herramientas, agentes concurrentes y soporte opcional para LLM local en potentes servidores de nube GPU.

## Descripción general

[SuperAGI](https://github.com/TransformerOptimus/SuperAGI) es un framework de agentes de IA autónomos, de código abierto y orientado primero a desarrolladores, con más de 15K estrellas en GitHub. A diferencia de los chatbots simples, 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 intervención humana constante.

**¿Por qué ejecutar SuperAGI en Clore.ai?**

* **Sin necesidad de GPU, con potente compatibilidad con LLM locales** — Ejecuta agentes respaldados por modelos locales (Llama, Mistral, etc.) en las GPU de Clore.ai para una IA autónoma totalmente privada y con costos controlados.
* **Ejecución concurrente de agentes** — Ejecuta varios agentes en paralelo en el mismo servidor, cada uno trabajando simultáneamente en tareas diferentes.
* **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.07–0.21/h para una RTX 3090, puedes ejecutar agentes autónomos capaces por una fracción del costo de los servicios de IA en la nube.

### Características clave

| Función                              | Descripción                                                          |
| ------------------------------------ | -------------------------------------------------------------------- |
| Aprovisionamiento de agentes         | Crear, configurar e implementar agentes mediante GUI                 |
| Mercado de herramientas              | Más de 30 herramientas integradas (búsqueda, código, archivos, APIs) |
| Compatibilidad con múltiples modelos | OpenAI, Anthropic, LLM locales mediante endpoint personalizado       |
| Agentes concurrentes                 | Ejecuta varios agentes simultáneamente                               |
| Memoria del agente                   | Corto plazo (ventana de contexto) + largo plazo (BD vectorial)       |
| Panel de control GUI                 | Interfaz web completa para la gestión de agentes                     |
| Gestor de recursos                   | Seguimiento del uso de tokens y costos por agente                    |
| Plantillas de flujo de trabajo       | Plantillas de agentes preconstruidas para tareas comunes             |

### Arquitectura

```
┌────────────────────────────────────────────────────┐
│              Pila de SuperAGI                      │
│                                                    │
│  ┌─────────────────────┐   ┌───────────────────┐   │
│  │  Frontend (Puerto 3000)│   │  API (Puerto 8001)  │   │
│  │   Interfaz de 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) | Se necesita GPU 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 requiere muchos recursos de CPU       |
| **RAM**            | 8 GB               | 16 GB                   | Varios agentes concurrentes necesitan memoria                 |
| **Almacenamiento** | 20 GB              | 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.07–0.21/h                              | SuperAGI + modelo local Ollama 13B                   |
| RTX 4090 (24 GB)    | $0.14–0.42/h                              | SuperAGI + Ollama, inferencia más rápida             |
| 2× RTX 3090         | $0.14–0.42/h                              | SuperAGI + modelo 70B (cuantizado Q4)                |
| A100 80 GB          | [bare metal](https://clore.ai/bare-metal) | SuperAGI + modelos grandes, alta concurrencia        |
| H100 80 GB          | \~$1.04/h                                 | Sistemas de agentes autónomos de nivel de producción |

> 💡 **Consejo de costo:** Para desarrollo y pruebas, usa las API de OpenAI o Anthropic (no se necesita GPU). Cambia a una instancia con GPU solo cuando necesites inferencia local de LLM por motivos de privacidad o costo. Ver [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md).

### Requisitos previos

* Servidor de Clore.ai con acceso SSH
* Docker + Docker Compose (preinstalados en Clore.ai)
* Git (preinstalado)
* 4+ vCPU, 8+ GB de RAM (se recomiendan 16 GB para agentes concurrentes)
* Clave de API de OpenAI **o** endpoint local de LLM (Ollama/vLLM)

***

## Inicio rápido

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

La implementación oficial de SuperAGI usa Docker Compose para gestionar todos los servicios.

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

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

**Paso 2: Clonar y configurar**

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

**Paso 3: Editar `config.yaml`**

```bash
nano config.yaml
```

Configuración mínima requerida:

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

# Base de datos (dejar como predeterminado 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: Iniciar la pila**

```bash
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: Supervisar el inicio**

```bash
# Ver cómo arrancan todos los servicios
docker compose ps

# Seguir los registros
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://<your-clore-server-ip>:3000
```

La API está disponible en:

```
http://<your-clore-server-ip>:8001
```

Documentación de la API:

```
http://<your-clore-server-ip>: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):

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

# Edita la configuración con tus claves de 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:

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

# Crear 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

# Supervisar 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

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

# Para modelos locales (Ollama o API compatible con OpenAI)
# Establécelo en la interfaz: Configuración → Modelos → Modelo personalizado
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 usa una externa:
# VECTOR_STORE: "Pinecone"
# PINECONE_API_KEY: "your-key"
# PINECONE_ENVIRONMENT: "us-east-1-aws"

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

# ============================================================
# Claves de API de herramientas (opcional, 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: "your@email.com"
JIRA_API_TOKEN: "your-jira-token"
JIRA_SERVER_URL: "https://your-org.atlassian.net"

# ============================================================
# Almacenamiento
# ============================================================
STORAGE_TYPE: "File"        # Almacenamiento local de archivos
# 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 herramientas

Las herramientas se configuran a través de la GUI en **Configuración → Toolkit**. Cada herramienta puede habilitarse o deshabilitarse por agente.

**Herramientas integradas:**

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

### Creación de tu primer agente

A través de la GUI (Configuración → Agentes → Crear agente):

1. **Nombre** — Dale a tu agente un nombre descriptivo
2. **Descripción** — Qué hace este agente
3. **Objetivos** — Enumera los objetivos (uno por línea)
4. **Instrucciones** — Prompt del sistema para el comportamiento
5. **Modelo** — Selecciona el LLM (GPT-4, Claude o local)
6. **Herramientas** — Habilita las herramientas relevantes
7. **Máximo de iteraciones** — Límite de seguridad (normalmente 10–50)

A través de la API REST:

```bash
# Crear un agente mediante la API
curl -X POST "http://localhost:8001/v1/agent" \
  -H "Content-Type: application/json" \\
  -d '{
    "name": "Research Agent",
    "description": "Investiga temas y escribe resúmenes",
    "goal": [
      "Investiga el tema proporcionado",
      "Escribe un resumen completo",
      "Guarda el resumen en un archivo"
    ],
    "agent_type": "Task Queue",
    "constraints": [],
    "tools": ["DuckDuckGoSearch", "WriteFileTool", "ReadFileTool"],
    "exit_criterion": "No exit criterion",
    "max_iterations": 25,
    "user_timezone": "UTC",
    "llm_model_config": {
      "model_name": "gpt-4o-mini",
      "temperature": 0.5,
      "max_new_tokens": 2000
    }
  }'
```

***

## Aceleración GPU

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

### Configuración de Ollama como backend LLM del agente

Ver [Guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) para la configuración completa de Ollama. Integración con SuperAGI:

**Paso 1: Inicia Ollama en el mismo servidor de Clore.ai**

```bash
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 del agente (requiere 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 con mucha carga de código
```

**Paso 2: Configura SuperAGI para usar Ollama**

En `config.yaml`:

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

O configúralo en la interfaz de SuperAGI:

* **Configuración → Modelos → Añadir modelo personalizado**
* Proveedor: compatible con OpenAI
* URL base: `http://172.17.0.1:11434/v1`
* Clave API: `ollama` (cualquier cadena)
* Nombre del modelo: `llama3.1:8b`

### Configuración de vLLM para agentes de alto rendimiento

Para despliegues de producción con muchos agentes concurrentes (ver [Guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)):

```bash
# Inicia vLLM en el servidor 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)   | Ninguno     | —     | Ilimitados (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 los objetivos** — Objetivos vagos como "hacer investigación" hacen que los agentes entren en bucle. Usa "Investiga X y escribe un resumen de 500 palabras en el archivo output.txt."
* **Establece límites de iteración** — Establece siempre `max_iterations` (20–50). Los agentes sin límite pueden consumir tokens rápidamente.
* **Usa el modo cola de tareas** — Para flujos de trabajo de varios pasos, los agentes de "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 costes en Clore.ai

```bash
# Supervisa el uso de tokens en tiempo real desde el panel de SuperAGI
# Configuración → Recursos → Uso de tokens

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

Dado que Clore.ai cobra por hora:

```bash
# Guarda las configuraciones del agente 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 ./
```

### Protección de SuperAGI

```bash
# Habilita la autenticación en config.yaml
AUTH_SECRET_KEY: "your-strong-random-secret"

# Restringe la API a localhost (usa túneles SSH)
# Modifica docker-compose.yml para quitar el enlace de puerto externo:
# puertos:
#   - "127.0.0.1:8001:8001"  # API solo local
#   - "127.0.0.1:3000:3000"  # Solo UI local

# Luego accede mediante el túnel SSH:
# ssh -L 3000:localhost:3000 -L 8001:localhost:8001 root@<server-ip> -p <port>
```

### Almacenamiento persistente entre sesiones de Clore.ai

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

# Copiar 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

# Copiar configuración y espacios 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 completa: $(ls -lh ~/backups/ | tail -2)"
EOF

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

### Actualizando SuperAGI

```bash
cd ~/SuperAGI

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

# Obtener los cambios más recientes
git pull origin main

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

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

***

## Solución de problemas

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

```bash
# 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 falla la compilación de npm para el frontend
docker compose build superagi-frontend --no-cache

# Comprobar 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 se bloquea al iniciar

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

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

# 2. La base de datos no está lista
docker compose restart superagi-backend  # Espera primero a que la BD inicie

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

### El frontend no carga (puerto 3000)

```bash
# 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 de la API es accesible desde el frontend
docker compose exec superagi-frontend \
  curl -s http://superagi-backend:8001/health
```

### Los agentes entran en bucle indefinidamente

```bash
# Revisa los registros del agente en la interfaz de SuperAGI:
# Panel → Agente → Ver registros

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

# O detener todos los agentes mediante la 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 con Redis

```bash
# Comprobar el estado de Redis
docker compose ps super__agi-redis-1
docker compose logs super__agi-redis-1

# Probar la conexión con 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 es accesible desde el contenedor de SuperAGI

```bash
# Encontrar la IP del puente de 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 red del host
docker run -d --network host ...  # No es compatible fácilmente con docker compose

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

### Se agotó el grupo de conexiones de la base de datos

```bash
# Aumentar las conexiones máximas de PostgreSQL en docker-compose.yml
# Debajo del 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](https://superagi.com/docs) — guías oficiales, referencia de la API
* [GitHub de SuperAGI](https://github.com/TransformerOptimus/SuperAGI) — código fuente, incidencias, comunidad
* [Ejecutar Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend de LLM local para agentes
* [Ejecutar vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — inferencia de alto rendimiento para agentes concurrentes
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — elegir el nivel adecuado de Clore.ai
* [Mercado de herramientas de SuperAGI](https://superagi.com/marketplace/) — herramientas para agentes creadas por la comunidad
* [Discord de SuperAGI](https://discord.gg/dXbRe5BHJC) — soporte y debates de la comunidad
* [Documentación de FastAPI (API de SuperAGI)](http://localhost:8001/docs) — documentación interactiva de la API en tu instancia


---

# 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/superagi.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.