# Framework de agentes SuperAGI

## Resumen

[SuperAGI](https://github.com/TransformerOptimus/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](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md).

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

```bash
ssh root@<tu-ip-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 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**

```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: Monitorizar el arranque**

```bash
# 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):

```bash
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:

```bash
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

```yaml
# ============================================================
# 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: "your@email.com"
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:

```bash
# 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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) para la configuración completa de Ollama. Integración con SuperAGI:

**Paso 1: Iniciar Ollama en el mismo servidor 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 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`:

```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](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)):

```bash
# 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

```bash
# 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:

```bash
# 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

```bash
# 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

```bash
# 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

```bash
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`

```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 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

```bash
# 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)

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

```bash
# 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

```bash
# 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

```bash
# 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](https://superagi.com/docs) — guías oficiales, referencia de la API
* [SuperAGI en GitHub](https://github.com/TransformerOptimus/SuperAGI) — código fuente, issues, comunidad
* [Ejecutando Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend de LLM local para agentes
* [Ejecutando 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 correcto 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 discusiones 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: 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/superagi.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.