</details>

<details>
<summary><b>Interacción del Agente</b> (haga clic para expandir)</summary>```mermaid
sequenceDiagram
    participant O as Orchestrator
    participant R as Researcher
    participant D as Developer
    participant E as Executor
    participant VS as Vector Store
    participant KB as Knowledge Base

    Note over O,KB: Flow Initialization
    O->>VS: Query similar tasks
    VS-->>O: Return experiences
    O->>KB: Load relevant knowledge
    KB-->>O: Return context

    Note over O,R: Research Phase
    O->>R: Analyze target
    R->>VS: Search similar cases
    VS-->>R: Return patterns
    R->>KB: Query vulnerabilities
    KB-->>R: Return known issues
    R->>VS: Store findings
    R-->>O: Research results

    Note over O,D: Planning Phase
    O->>D: Plan attack
    D->>VS: Query exploits
    VS-->>D: Return techniques
    D->>KB: Load tools info
    KB-->>D: Return capabilities
    D-->>O: Attack plan

    Note over O,E: Execution Phase
    O->>E: Execute plan
    E->>KB: Load tool guides
    KB-->>E: Return procedures
    E->>VS: Store results
    E-->>O: Execution status

</details>

<a id="advanced-agent-supervision"></a>
<details>
<summary><b>Supervisión Avanzada de Agentes</b> (haga clic para expandir)</summary>

PentAGI incluye mecanismos sofisticados de supervisión de agentes en múltiples capas para garantizar una ejecución eficiente de tareas, evitar bucles infinitos y proporcionar una recuperación inteligente de estados bloqueados:

### Monitoreo de Ejecución (Beta)
- **Intervención Automática del Mentor**: El agente asesor (mentor) se invoca automáticamente cuando los patrones de ejecución indican problemas potenciales.
- **Detección de Patrones**: Monitorea llamadas a herramientas idénticas (umbral: 5, configurable) y llamadas totales a herramientas (umbral: 10, configurable).
- **Análisis de Progreso**: Evalúa si el agente avanza hacia el objetivo de la subtarea, detecta bucles e ineficiencias.
- **Estrategias Alternativas**: Recomienda diferentes enfoques cuando la estrategia actual falla.
- **Guía de Recuperación de Información**: Sugiere buscar soluciones establecidas en lugar de reinventar.
- **Formato de Respuesta Mejorado**: Las respuestas de las herramientas incluyen secciones `<original_result>` y `<mentor_analysis>`.
- **Configurable**: Habilite mediante `EXECUTION_MONITOR_ENABLED` (predeterminado: falso), personalice umbrales con `EXECUTION_MONITOR_SAME_TOOL_LIMIT` y `EXECUTION_MONITOR_TOTAL_TOOL_LIMIT`.

**Mejor para**: Modelos más pequeños (< 32B parámetros), escenarios de ataque complejos que requieren orientación continua, evitar que los agentes se estanquen en un único enfoque.

**Impacto en el Rendimiento**: Aumento de 2 a 3 veces en el tiempo de ejecución y uso de tokens, pero ofrece una **mejora de 2x en la calidad de los resultados** según las pruebas con Qwen3.5-27B-FP8.

### Planificación Inteligente de Tareas (Beta)
- **Descomposición Automatizada**: El planificador (asesor en modo de planificación) genera de 3 a 7 pasos específicos y procesables antes de que los agentes especialistas comiencen a trabajar.
- **Planes Conscientes del Contexto**: Analiza el contexto completo de ejecución a través del agente enriquecedor para crear planes informados.
- **Asignación Estructurada**: La solicitud original se envuelve en una estructura `<task_assignment>` con el plan de ejecución y las instrucciones.
- **Gestión del Alcance**: Evita la expansión del alcance manteniendo a los agentes enfocados únicamente en la subtarea actual.
- **Instrucciones Enriquecidas**: Los planes destacan acciones críticas, posibles obstáculos y puntos de verificación.
- **Configurable**: Habilite mediante `AGENT_PLANNING_STEP_ENABLED` (predeterminado: falso).

**Mejor para**: Modelos < 32B parámetros, flujos de trabajo complejos de pruebas de penetración, mejora de las tasas de éxito en tareas sofisticadas.

**Configuración Mejorada del Asesor**: Funciona excepcionalmente bien cuando el agente asesor utiliza un modelo más potente o configuraciones mejoradas. Ejemplo: usar el mismo modelo base con el modo de razonamiento máximo para el asesor (consulte [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/HEAD/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml)) permite un análisis completo de tareas y una planificación estratégica desde una arquitectura de modelo idéntica.

**Impacto en el Rendimiento**: Agrega sobrecarga de planificación, pero mejora significativamente las tasas de finalización y reduce el trabajo redundante.

### Límites de Llamadas a Herramientas (Siempre Activo)
- **Límites Estrictos**: Evitan ejecuciones descontroladas independientemente del estado del modo de supervisión.
- **Diferenciados por Tipo de Agente**:
  - Agentes generales (Asistente, Agente Principal, Pentester, Programador, Instalador): `MAX_GENERAL_AGENT_TOOL_CALLS` (predeterminado: 100).
  - Agentes limitados (Buscador, Enriquecedor, Memorista, Generador, Reportero, Asesor, Reflexivo, Planificador): `MAX_LIMITED_AGENT_TOOL_CALLS` (predeterminado: 20).
- **Terminación Gradual**: El Reflexivo guía a los agentes hacia una finalización adecuada cuando se acercan a los límites.
- **Protección de Recursos**: Garantiza la estabilidad del sistema y evita el agotamiento de recursos.

### Integración del Reflexivo (Siempre Activo)
- **Corrección Automática**: Se invoca cuando el LLM no logra generar llamadas a herramientas después de 3 intentos.
- **Orientación Estratégica**: Analiza los fallos y guía a los agentes hacia un uso adecuado de las herramientas o herramientas de barrera (`done`, `ask`).
- **Mecanismo de Recuperación**: Proporciona orientación contextual basada en patrones de fallo específicos.
- **Aplicación de Límites**: Coordina la terminación gradual cuando se alcanzan los límites de llamadas a herramientas.

### Recomendaciones para Modelos de Código Abierto

**Imprescindible para Modelos < 32B Parámetros**:
Las pruebas con Qwen3.5-27B-FP8 demuestran que habilitar tanto el Monitoreo de Ejecución como la Planificación de Tareas es **esencial** para modelos de código abierto más pequeños:
- **Mejora de Calidad**: Resultados 2x mejores en comparación con la ejecución base sin supervisión.
- **Prevención de Bucles**: Reduce significativamente los bucles infinitos y el trabajo redundante.
- **Diversidad de Ataques**: Fomenta la exploración de múltiples vectores de ataque en lugar de fijarse en un solo enfoque.
- **Despliegues Aislados**: Permite pruebas de penetración autónomas de grado de producción en entornos de red cerrados con inferencia LLM local.

**Compensaciones**:
- Consumo de tokens: Aumento de 2 a 3 veces debido a las invocaciones del mentor/planificador.
- Tiempo de ejecución: 2 a 3 veces más largo debido a los pasos de análisis y planificación.
- Calidad de los resultados: Mejora de 2x en integridad, precisión y cobertura de ataque.
- Requisitos del modelo: Funciona mejor cuando el asesor utiliza una configuración mejorada (parámetros de razonamiento más altos, variante de modelo más potente o modelo diferente).

**Estrategia de Configuración**:
Para un rendimiento óptimo con modelos más pequeños, configure el agente asesor con ajustes mejorados:
- Utilice el mismo modelo con el modo de razonamiento máximo (ejemplo: [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/HEAD/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml)).
- O utilice un modelo más potente para el asesor mientras mantiene el modelo base para otros agentes.
- Ajuste los umbrales de monitoreo según la complejidad de la tarea y las capacidades del modelo.

</details>

La arquitectura de PentAGI está diseñada para ser modular, escalable y segura. Estos son los componentes clave:

1. **Servicios Principales**
   - Interfaz de Usuario Frontend: Interfaz web basada en React con TypeScript para seguridad de tipos.
   - API Backend: APIs REST y GraphQL basadas en Go con autenticación mediante token Bearer para acceso programático.
   - Almacén de Vectores: PostgreSQL con pgvector para búsqueda semántica y almacenamiento de memoria.
   - Cola de Tareas: Sistema de procesamiento de tareas asíncrono para un funcionamiento confiable.
   - Agente de IA: Sistema multiagente con roles especializados para pruebas eficientes.

2. **Grafo de Conocimiento**
   - Graphiti: API de grafo de conocimiento para seguimiento de relaciones semánticas y comprensión contextual.
   - Neo4j: Base de datos de grafos para almacenar y consultar relaciones entre entidades, acciones y resultados.
   - Captura automática de respuestas de agentes y ejecuciones de herramientas para construir una base de conocimiento integral.

3. **Pila de Monitoreo**
   - OpenTelemetry: Recolección y correlación unificada de datos de observabilidad.
   - Grafana: Paneles de visualización y alertas en tiempo real.
   - VictoriaMetrics: Almacenamiento de métricas de series temporales de alto rendimiento.
   - Jaeger: Trazado distribuido de extremo a extremo para depuración.
   - Loki: Agregación y análisis de registros escalable.

4. **Plataforma de Analítica**
   - Langfuse: Observabilidad avanzada de LLM y análisis de rendimiento.
   - ClickHouse: Almacén de datos analíticos orientado a columnas.
   - Redis: Caché de alta velocidad y limitación de velocidad.
   - MinIO: Almacenamiento de objetos compatible con S3 para artefactos.

5. **Herramientas de Seguridad**
   - Web Scraper: Entorno de navegador aislado para interacción web segura.
   - Herramientas de Pentesting: Conjunto completo de más de 20 herramientas de seguridad profesionales.
   - Ejecución en Entorno Aislado: Todas las operaciones se ejecutan en contenedores aislados.

6. **Sistemas de Memoria**
   - Memoria a Largo Plazo: Almacenamiento persistente de conocimiento y experiencias.
   - Memoria de Trabajo: Contexto activo y objetivos para operaciones actuales.
   - Memoria Episódica: Acciones históricas y patrones de éxito.
   - Base de Conocimiento: Experiencia de dominio estructurada y capacidades de herramientas.
   - Gestión de Contexto: Administra de forma inteligente las ventanas de contexto crecientes del LLM mediante resumen en cadena.

El sistema utiliza contenedores Docker para aislamiento y fácil implementación, con redes separadas para servicios principales, monitoreo y análisis para garantizar límites de seguridad adecuados. Cada componente está diseñado para escalar horizontalmente y puede configurarse para alta disponibilidad en entornos de producción.

## Inicio Rápido

### Requisitos del Sistema

- Docker y Docker Compose (o Podman - consulte [Configuración de Podman](#ejecutando-pentagi-con-podman)).
- Mínimo 2 vCPU.
- Mínimo 4 GB de RAM.
- 20 GB de espacio libre en disco.
- Acceso a Internet para descargar imágenes y actualizaciones.

### Usando el Instalador (Recomendado)

PentAGI proporciona un instalador interactivo con una interfaz de usuario basada en terminal para una configuración e implementación optimizadas. El instalador lo guía a través de verificaciones del sistema, configuración del proveedor de LLM, configuración del motor de búsqueda y endurecimiento de seguridad.

**Plataformas Compatibles:**
- **Linux**: amd64 [descargar](https://pentagi.com/downloads/linux/amd64/installer-latest.zip) | arm64 [descargar](https://pentagi.com/downloads/linux/arm64/installer-latest.zip)
- **Windows**: amd64 [descargar](https://pentagi.com/downloads/windows/amd64/installer-latest.zip)
- **macOS**: amd64 (Intel) [descargar](https://pentagi.com/downloads/darwin/amd64/installer-latest.zip) | arm64 (serie M) [descargar](https://pentagi.com/downloads/darwin/arm64/installer-latest.zip)

**Instalación Rápida (Linux amd64):**```bash
# Create installation directory
mkdir -p pentagi && cd pentagi

# Download installer
wget -O installer.zip https://pentagi.com/downloads/linux/amd64/installer-latest.zip

# Extract
unzip installer.zip

# Run interactive installer
./installer

2. Copia `.env.example` a `.env` o descárgalo:```bash
curl -o .env https://raw.githubusercontent.com/vxcontrol/pentagi/master/.env.example

4. Complete las claves API requeridas en el archivo `.env`.```bash
# Required: At least one of these LLM providers
OPEN_AI_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GEMINI_API_KEY=your_gemini_key

# Optional: AWS Bedrock provider (enterprise-grade models)
BEDROCK_REGION=us-east-1
# Choose one authentication method:
BEDROCK_DEFAULT_AUTH=true                        # Option 1: Use AWS SDK default credential chain (recommended for EC2/ECS)
# BEDROCK_BEARER_TOKEN=your_bearer_token         # Option 2: Bearer token authentication
# BEDROCK_ACCESS_KEY_ID=your_aws_access_key      # Option 3: Static credentials
# BEDROCK_SECRET_ACCESS_KEY=your_aws_secret_key

# Optional: Ollama provider (local or cloud)
# OLLAMA_SERVER_URL=http://ollama-server:11434   # Local server
# OLLAMA_SERVER_URL=https://ollama.com           # Cloud service
# OLLAMA_SERVER_API_KEY=your_ollama_cloud_key    # Required for cloud, empty for local

# Optional: Chinese AI providers
# DEEPSEEK_API_KEY=your_deepseek_key             # DeepSeek (strong reasoning)
# GLM_API_KEY=your_glm_key                       # GLM (Zhipu AI)
# KIMI_API_KEY=your_kimi_key                     # Kimi (Moonshot AI, ultra-long context)
# QWEN_API_KEY=your_qwen_key                     # Qwen (Alibaba Cloud, multimodal)

# Optional: Local LLM provider (zero-cost inference)
OLLAMA_SERVER_URL=http://localhost:11434
OLLAMA_SERVER_MODEL=your_model_name

# Optional: Additional search capabilities
DUCKDUCKGO_ENABLED=true
DUCKDUCKGO_REGION=us-en
DUCKDUCKGO_SAFESEARCH=
DUCKDUCKGO_TIME_RANGE=
SPLOITUS_ENABLED=true
GOOGLE_API_KEY=your_google_key
GOOGLE_CX_KEY=your_google_cx
TAVILY_API_KEY=your_tavily_key
TRAVERSAAL_API_KEY=your_traversaal_key
PERPLEXITY_API_KEY=your_perplexity_key
PERPLEXITY_MODEL=sonar-pro
PERPLEXITY_CONTEXT_SIZE=medium

# Searxng meta search engine (aggregates results from multiple sources)
SEARXNG_URL=http://your-searxng-instance:8080
SEARXNG_CATEGORIES=general
SEARXNG_LANGUAGE=
SEARXNG_SAFESEARCH=0
SEARXNG_TIME_RANGE=
SEARXNG_TIMEOUT=

## Graphiti knowledge graph settings
GRAPHITI_ENABLED=true
GRAPHITI_TIMEOUT=30
GRAPHITI_URL=http://graphiti:8000
GRAPHITI_MODEL_NAME=gpt-5-mini

# Neo4j settings (used by Graphiti stack)
NEO4J_USER=neo4j
NEO4J_DATABASE=neo4j
NEO4J_PASSWORD=devpassword
NEO4J_URI=bolt://neo4j:7687

# Assistant configuration
ASSISTANT_USE_AGENTS=false         # Default value for agent usage when creating new assistants

7. Ejecute el stack PentAGI:```bash
curl -O https://raw.githubusercontent.com/vxcontrol/pentagi/master/docker-compose.yml
docker compose up -d

> [!IMPORTANT]
> - Reemplaza `192.168.1.100` con la dirección IP real de tu servidor
> - NO uses `0.0.0.0` en `PUBLIC_URL` o `CORS_ORIGINS` - usa la dirección IP real
> - Incluye tanto localhost como la IP de tu servidor en `CORS_ORIGINS` para mayor flexibilidad

2. **Recrea los contenedores** para aplicar los cambios:```bash
docker compose down
docker compose up -d --force-recreate

Deberías ver `0.0.0.0:8443->8443/tcp` o `:::8443->8443/tcp`.

Si ves `127.0.0.1:8443->8443/tcp`, la variable de entorno no se ha aplicado. En ese caso, edita directamente la línea 31 de `docker-compose.yml`:```yaml
ports:
  - "0.0.0.0:8443:8443"

5. **Acceder a PentAGI:**

- **Acceso local:** `https://localhost:8443`
- **Acceso por red:** `https://your-server-ip:8443`

> [!NOTE]
> Necesitarás aceptar la advertencia del certificado SSL autofirmado en tu navegador al acceder mediante dirección IP.

---

### Ejecutar PentAGI con Podman

PentAGI es totalmente compatible con Podman como alternativa a Docker. Sin embargo, cuando se usa **Podman en modo rootless**, el servicio scraper requiere una configuración especial porque los contenedores rootless no pueden enlazar puertos privilegiados (puertos por debajo de 1024).

#### Configuración de Podman sin root

La configuración predeterminada del scraper usa el puerto 443 (HTTPS), que es un puerto privilegiado. Para Podman rootless, reconfigura el scraper para que use un puerto no privilegiado:

**1. Edita `docker-compose.yml`** - modifica el servicio `scraper` (alrededor de la línea 199):```yaml
scraper:
  image: vxcontrol/scraper:latest
  restart: unless-stopped
  container_name: scraper
  hostname: scraper
  expose:
    - 3000/tcp  # Changed from 443 to 3000
  ports:
    - "${SCRAPER_LISTEN_IP:-127.0.0.1}:${SCRAPER_LISTEN_PORT:-9443}:3000"  # Map to port 3000
  environment:
    - MAX_CONCURRENT_SESSIONS=${LOCAL_SCRAPER_MAX_CONCURRENT_SESSIONS:-10}
    - USERNAME=${LOCAL_SCRAPER_USERNAME:-someuser}
    - PASSWORD=${LOCAL_SCRAPER_PASSWORD:-somepass}
  logging:
    options:
      max-size: 50m
      max-file: "7"
  volumes:
    - scraper-ssl:/usr/src/app/ssl
  networks:
    - pentagi-network
  shm_size: 2g

> [!IMPORTANT]
> Cambios clave para Podman:
> - Usar **HTTP** en lugar de HTTPS para `SCRAPER_PRIVATE_URL`
> - Usar el puerto **3000** en lugar de 443
> - Cambiar el `expose` interno a `3000/tcp`
> - Actualizar el mapeo de puertos para apuntar a `3000` en lugar de `443`

**3. Recrear contenedores:**```bash
podman-compose down
podman-compose up -d --force-recreate

Si ves HTML de salida, el scraper está funcionando correctamente.

#### Modo Rootful de Podman

Si estás ejecutando Podman en modo rootful (con sudo), puedes usar la configuración predeterminada sin modificaciones. El scraper funcionará en el puerto 443 según lo previsto.

#### Compatibilidad con Docker

Todas las configuraciones de Podman son totalmente compatibles con Docker. El enfoque de puerto no privilegiado funciona de manera idéntica en ambos entornos de ejecución de contenedores.

### Configuración del Asistente

PentAGI te permite configurar el comportamiento predeterminado de los asistentes:

| Variable              | Por defecto | Descripción                                                           |
| --------------------- | ----------- | --------------------------------------------------------------------- |
| `ASSISTANT_USE_AGENTS`| `false`     | Controla el valor predeterminado para el uso de agentes al crear nuevos asistentes |

La configuración `ASSISTANT_USE_AGENTS` afecta el estado inicial del interruptor "Usar Agentes" al crear un nuevo asistente en la interfaz de usuario:
- `false` (predeterminado): Los nuevos asistentes se crean con la delegación de agentes deshabilitada por defecto.
- `true`: Los nuevos asistentes se crean con la delegación de agentes habilitada por defecto.

Ten en cuenta que los usuarios siempre pueden sobrescribir esta configuración activando o desactivando el botón "Usar Agentes" en la interfaz al crear o editar un asistente. Esta variable de entorno solo controla el estado predeterminado inicial.

## Cómo usar PentAGI después de iniciar sesión

Una vez que la pila esté funcionando y puedas iniciar sesión en la interfaz web, la forma más rápida de comenzar es a través del flujo de trabajo **Flows**.

### 1. Crea tu primer flujo

1. Abre **Flows** en la barra lateral.
2. Haz clic en **New Flow**.
3. Elige el modo que se adapte a tu objetivo:
   - **Automation**: Ejecución completamente autónoma para un objetivo de prueba que deseas que PentAGI realice de principio a fin.
   - **Assistant**: Ayuda interactiva de ida y vuelta cuando deseas dirigir la investigación paso a paso. En este modo también puedes habilitar el interruptor **Use Agents** para que PentAGI delegue subtareas a subagentes especializados para investigaciones más complejas.
4. Selecciona el proveedor de LLM que deseas usar para este flujo.
5. Describe el objetivo y la meta en lenguaje natural en el cuadro de mensaje.

Los buenos primeros prompts generalmente incluyen:

- el sistema o URL objetivo
- el tipo de evaluación que deseas
- cualquier limitación de alcance o reglas de participación
- el resultado que esperas, como un informe de vulnerabilidad o la validación de una hipótesis

Ejemplo:```text
Assess https://target.example for common web application vulnerabilities. Focus on authentication, file handling, and injection issues. Stay within the provided target only and summarize confirmed findings with reproduction steps.

### Exploración y Pruebas de API

PentAGI proporciona documentación interactiva para explorar y probar endpoints de API:

#### GraphQL Playground

Acceda al GraphQL Playground en `https://your-pentagi-instance:8443/api/v1/graphql/playground`

1. Haga clic en la pestaña **HTTP Headers** en la parte inferior
2. Agregue su encabezado de autorización:   ```json
   {
     "Authorization": "Bearer YOUR_API_TOKEN"
   }

**Configuración del Nivel de Pago (Múltiples Modelos con Configuración Preconstruida)**

Para los niveles de pago que admiten múltiples modelos concurrentes, utilice la configuración preconstruida de Ollama Cloud:```bash
# Using pre-built Ollama Cloud configuration (included in Docker image)
OLLAMA_SERVER_URL=https://ollama.com
OLLAMA_SERVER_API_KEY=your_ollama_cloud_api_key
OLLAMA_SERVER_CONFIG_PATH=/opt/pentagi/conf/ollama-cloud.provider.yml

La variable de entorno `PENTAGI_OLLAMA_SERVER_CONFIG_PATH` asigna tu archivo de configuración del host a `/opt/pentagi/conf/ollama.provider.yml` dentro del contenedor.

**Ejemplo de configuración personalizada** (`my-ollama-config.yml`):```yaml
primary_agent:
  model: "qwen3-coder-next:cloud"
  temperature: 1.0
  top_p: 0.9
  max_tokens: 32768
  reasoning:
    effort: high

coder:
  model: "qwen3-coder:32b"
  temperature: 1.0
  max_tokens: 20480

**Consideraciones de rendimiento:**

- **Descubrimiento de modelos** (`OLLAMA_SERVER_LOAD_MODELS_ENABLED=true`): Añade 1-2s de latencia al inicio consultando la API de Ollama
- **Auto-pull** (`OLLAMA_SERVER_PULL_MODELS_ENABLED=true`): El primer inicio puede tardar varios minutos descargando modelos
- **Tiempo de espera de extracción** (`OLLAMA_SERVER_PULL_MODELS_TIMEOUT=900`): 15 minutos en segundos
- **Configuración estática**: Desactiva ambas banderas y especifica los modelos en el archivo de configuración para el inicio más rápido

#### Creación de modelos Ollama personalizados con contexto extendido

PentAGI requiere modelos con ventanas de contexto más grandes que las configuraciones predeterminadas de Ollama. Necesitas crear modelos personalizados con el parámetro `num_ctx` aumentado a través de Modelfiles. Mientras que los flujos de trabajo típicos de agentes consumen alrededor de 64K tokens, PentAGI utiliza un tamaño de contexto de 110K para margen de seguridad y manejo de escenarios complejos de pruebas de penetración.

**Importante**: El parámetro `num_ctx` solo se puede establecer durante la creación del modelo a través de Modelfile; no se puede cambiar después de la creación del modelo ni anularse en tiempo de ejecución.

##### Ejemplo: Qwen3 32B FP16 con contexto extendido

Crea un Modelfile llamado `Modelfile_qwen3_32b_fp16_tc`:```dockerfile
FROM qwen3:32b-fp16
PARAMETER num_ctx 110000
PARAMETER temperature 0.3
PARAMETER top_p 0.8
PARAMETER min_p 0.0
PARAMETER top_k 20
PARAMETER repeat_penalty 1.1

##### Ejemplo: QwQ 32B FP16 con Contexto Extendido

Crea un Modelfile llamado `Modelfile_qwq_32b_fp16_tc`:```dockerfile
FROM qwq:32b-fp16
PARAMETER num_ctx 110000
PARAMETER temperature 0.2
PARAMETER top_p 0.7
PARAMETER min_p 0.0
PARAMETER top_k 40
PARAMETER repeat_penalty 1.2

> **Nota**: El modelo QwQ 32B FP16 requiere aproximadamente **71.3 GB VRAM** para inferencia. Asegúrese de que su sistema tenga suficiente memoria GPU antes de intentar usar este modelo.

Estos modelos personalizados se referencian en los archivos de configuración del proveedor preconstruidos (`ollama-qwen332b-fp16-tc.provider.yml` y `ollama-qwq32b-fp16-tc.provider.yml`) que están incluidos en la imagen Docker en `/opt/pentagi/conf/`.

### Configuración del Proveedor OpenAI

PentAGI se integra con la amplia gama de modelos de OpenAI, que ofrece capacidades avanzadas de razonamiento con cadena de pensamiento extendida, modelos agentivos con integración mejorada de herramientas y modelos de código especializados para ingeniería de seguridad.

#### Variables de Configuración

| Variable             | Predeterminado              | Descripción                 |
| -------------------- | --------------------------- | --------------------------- |
| `OPEN_AI_KEY`        |                             | Clave API para servicios de OpenAI |
| `OPEN_AI_SERVER_URL` | `https://api.openai.com/v1` | Punto de conexión de la API de OpenAI |

#### Ejemplos de Configuración```bash
# Basic OpenAI setup
OPEN_AI_KEY=your_openai_api_key
OPEN_AI_SERVER_URL=https://api.openai.com/v1

# Using with proxy for enhanced security
OPEN_AI_KEY=your_openai_api_key
PROXY_URL=http://your-proxy:8080

> [!NOTE]
> **Google Vertex AI para modelos Claude**
>
> PentAGI no expone actualmente una ruta de configuración dedicada de Google Vertex AI para Anthropic Claude en `.env`. No hay un campo separado de clave API de Vertex AI en este momento, y las variables existentes de Anthropic (`ANTHROPIC_API_KEY`, `ANTHROPIC_SERVER_URL`) apuntan a la API directa de Anthropic. Las rutas compatibles para Claude son:
>
> - **API directa de Anthropic**: `ANTHROPIC_API_KEY` y `ANTHROPIC_SERVER_URL` (ver arriba).
> - **AWS Bedrock**: Variables `BEDROCK_*` (ver [Configuración del proveedor AWS Bedrock](#aws-bedrock-provider-configuration)).
>
> Si necesita usar Vertex AI hoy, la solución alternativa compatible más segura es exponer Vertex AI a través de un proxy o puerta de enlace compatible con OpenAI que traduzca las llamadas de Vertex AI al formato Chat Completions mientras preserva el comportamiento de chat y llamada a herramientas del que depende PentAGI, luego apunte el proveedor LLM personalizado a esa puerta de enlace mediante `LLM_SERVER_URL`, `LLM_SERVER_KEY` y `LLM_SERVER_MODEL`. Esta ruta es tan confiable como la puerta de enlace que elija.

#### Modelos Compatibles

PentAGI soporta 10 modelos Claude con llamada a herramientas, streaming, pensamiento extendido, pensamiento adaptativo y almacenamiento en caché de indicaciones. Los modelos marcados con `*` se utilizan en la configuración predeterminada.

**Serie Claude 4 - Modelos Más Recientes (2025-2026)**

| ID del Modelo          | Pensamiento | Fecha de Publicación | Precio (Entrada/Salida/Caché L/E) | Caso de Uso                                      |
| ---------------------- | ----------- | -------------------- | --------------------------------- | ------------------------------------------------ |
| `claude-opus-4-6`*     | ✅          | Mayo 2025            | $5.00/$25.00/$0.50/$6.25          | Modelo más inteligente para agentes autónomos y codificación. Pensamiento extendido + adaptativo para desarrollo complejo de exploits, simulación de ataques en múltiples etapas |
| `claude-sonnet-4-6`*   | ✅          | Ago 2025             | $3.00/$15.00/$0.30/$3.75          | Mejor equilibrio velocidad/inteligencia con pensamiento adaptativo. Evaluaciones de seguridad multifase, análisis inteligente de vulnerabilidades, caza de amenazas en tiempo real |
| `claude-haiku-4-5`*    | ✅          | Oct 2025             | $1.00/$5.00/$0.10/$1.25           | Modelo más rápido con inteligencia casi de frontera. Escaneo de alta frecuencia, monitoreo en tiempo real, pruebas automatizadas masivas |

**Modelos Heredados - Aún Compatibles**

| ID del Modelo          | Pensamiento | Fecha de Publicación | Precio (Entrada/Salida/Caché L/E) | Caso de Uso                                      |
| ---------------------- | ----------- | -------------------- | --------------------------------- | ------------------------------------------------ |
| `claude-sonnet-4-5`    | ✅          | Sep 2025             | $3.00/$15.00/$0.30/$3.75          | Razonamiento de última generación (superado por 4-6). Pruebas de penetración sofisticadas, análisis avanzado de amenazas |
| `claude-opus-4-5`      | ✅          | Nov 2025             | $5.00/$25.00/$0.50/$6.25          | Razonamiento definitivo (superado por opus-4-6). Investigación crítica de seguridad, descubrimiento de vulnerabilidades de día cero, operaciones de equipo rojo |
| `claude-opus-4-1`      | ✅          | Ago 2025             | $15.00/$75.00/$1.50/$18.75        | Razonamiento avanzado (superado). Pruebas de penetración complejas, modelado de amenazas sofisticado |
| `claude-sonnet-4-0`    | ✅          | Mayo 2025            | $3.00/$15.00/$0.30/$3.75          | Razonamiento de alto rendimiento (superado). Modelado de amenazas complejo, coordinación de múltiples herramientas |
| `claude-opus-4-0`      | ✅          | Mayo 2025            | $15.00/$75.00/$1.50/$18.75        | Primera generación Opus (superado). Desarrollo de exploits en múltiples pasos, flujos de trabajo autónomos de pentesting |

**Modelos Obsoletos - Migrar a Modelos Actuales**

| ID del Modelo                 | Pensamiento | Fecha de Publicación | Precio (Entrada/Salida/Caché L/E) | Notas                                        |
| ----------------------------- | ----------- | -------------------- | --------------------------------- | -------------------------------------------- |
| `claude-3-haiku-20240307`     | ❌          | Mar 2024             | $0.25/$1.25/$0.03/$0.30          | Será retirado el 19 de abril de 2026. Migrar a claude-haiku-4-5 |

**Precios**: Por 1M de tokens. El precio de caché incluye costos tanto de Lectura como de Escritura.

**Configuración de Pensamiento Extendido**:
- **Max Tokens 4096**: Generador (claude-opus-4-6) para máxima profundidad de razonamiento en desarrollo complejo de exploits
- **Max Tokens 2048**: Codificador (claude-sonnet-4-6) para análisis equilibrado de código e investigación de vulnerabilidades
- **Max Tokens 1024**: Agente principal, asistente, refinador, asesor, reflector, buscador, instalador, probador de penetración para razonamiento enfocado en tareas específicas
- **Pensamiento Extendido**: Todos los modelos Claude 4.5+ y 4.6 soportan pensamiento extendido configurable para tareas de razonamiento profundo

**Características Clave**:
- **Pensamiento Extendido**: Todos los modelos Claude 4.5+ y 4.6 con profundidades de razonamiento de cadena de pensamiento configurables para análisis de seguridad complejo
- **Pensamiento Adaptativo**: La serie Claude 4.6 (Opus/Sonnet) ajusta dinámicamente la profundidad de razonamiento según la complejidad de la tarea para un rendimiento óptimo
- **Almacenamiento en Caché de Indicaciones**: Reducción significativa de costos con precios separados de lectura/escritura (10% lectura, 125% escritura de la entrada)
- **Ventana de Contexto Extendida**: 200K tokens estándar, hasta 1M tokens (beta) para Claude Opus/Sonnet 4.6 para análisis exhaustivo de bases de código
- **Llamada a Herramientas**: Llamadas a funciones robustas con precisión excepcional para orquestación de herramientas de seguridad
- **Streaming**: Transmisión de respuestas en tiempo real para flujos de trabajo interactivos de pruebas de penetración
- **Diseño Centrado en la Seguridad**: Mecanismos de seguridad integrados que garantizan prácticas de pruebas de seguridad responsables
- **Soporte Multimodal**: Capacidades de visión en los modelos más recientes para análisis de capturas de pantalla y evaluación de seguridad de interfaces de usuario
- **IA Constitucional**: Entrenamiento de seguridad avanzado que brinda orientación de seguridad confiable y ética

### Configuración del Proveedor Google AI (Gemini)

PentAGI se integra con los modelos Gemini de Google a través de la API de Google AI, ofreciendo capacidades de razonamiento multimodal de última generación con pensamiento extendido y almacenamiento en caché de contexto.

#### Variables de Configuración

| Variable            | Valor Predeterminado                          | Descripción                      |
| ------------------- | --------------------------------------------- | -------------------------------- |
| `GEMINI_API_KEY`    |                                               | Clave API para servicios de Google AI |
| `GEMINI_SERVER_URL` | `https://generativelanguage.googleapis.com`   | Punto final de la API de Google AI |

#### Ejemplos de Configuración```bash
# Basic Gemini setup
GEMINI_API_KEY=your_gemini_api_key
GEMINI_SERVER_URL=https://generativelanguage.googleapis.com

# Using with proxy
GEMINI_API_KEY=your_gemini_api_key
PROXY_URL=http://your-proxy:8080

#### Modelos compatibles

PentAGI es compatible con 21 modelos de AWS Bedrock con capacidades de llamada a herramientas, streaming y multimodales. Los modelos marcados con `*` se utilizan en la configuración predeterminada.

| ID del modelo                                    | Proveedor       | Razonamiento | Multimodal | Precio (Entrada/Salida) | Caso de uso                              |
| ------------------------------------------------ | --------------- | ------------ | ---------- | ----------------------- | ---------------------------------------- |
| `us.amazon.nova-2-lite-v1:0`                     | Amazon Nova     | ❌            | ✅          | $0.33/$2.75             | Razonamiento adaptativo, pensamiento eficiente |
| `us.amazon.nova-premier-v1:0`                    | Amazon Nova     | ❌            | ✅          | $2.50/$12.50            | Razonamiento complejo, análisis avanzado |
| `us.amazon.nova-pro-v1:0`                        | Amazon Nova     | ❌            | ✅          | $0.80/$3.20             | Precisión, velocidad y costo equilibrados |
| `us.amazon.nova-lite-v1:0`                       | Amazon Nova     | ❌            | ✅          | $0.06/$0.24             | Procesamiento rápido, operaciones de alto volumen |
| `us.amazon.nova-micro-v1:0`                      | Amazon Nova     | ❌            | ❌          | $0.035/$0.14            | Latencia ultra baja, monitoreo en tiempo real |
| `us.anthropic.claude-opus-4-6-v1`*               | Anthropic       | ✅            | ✅          | $5.00/$25.00            | Codificación de primer nivel, agentes empresariales |
| `us.anthropic.claude-sonnet-4-6`                 | Anthropic       | ✅            | ✅          | $3.00/$15.00            | Inteligencia fronteriza, escala empresarial |
| `us.anthropic.claude-opus-4-5-20251101-v1:0`     | Anthropic       | ✅            | ✅          | $5.00/$25.00            | Desarrollo de software de varios días    |
| `us.anthropic.claude-haiku-4-5-20251001-v1:0`*   | Anthropic       | ✅            | ✅          | $1.00/$5.00             | Rendimiento casi fronterizo, alta velocidad |
| `us.anthropic.claude-sonnet-4-5-20250929-v1:0`*  | Anthropic       | ✅            | ✅          | $3.00/$15.00            | Agentes del mundo real, excelencia en codificación |
| `us.anthropic.claude-sonnet-4-20250514-v1:0`     | Anthropic       | ✅            | ✅          | $3.00/$15.00            | Rendimiento equilibrado, listo para producción |
| `us.anthropic.claude-3-5-haiku-20241022-v1:0`    | Anthropic       | ❌            | ❌          | $0.80/$4.00             | Modelo más rápido, escaneo rentable       |
| `cohere.command-r-plus-v1:0`                     | Cohere          | ❌            | ❌          | $3.00/$15.00            | Operaciones a gran escala, RAG superior  |
| `deepseek.v3.2`                                  | DeepSeek        | ❌            | ❌          | $0.58/$1.68             | Razonamiento de contexto largo, eficiencia |
| `openai.gpt-oss-120b-1:0`*                       | OpenAI (OSS)    | ✅            | ❌          | $0.15/$0.60             | Razonamiento sólido, análisis científico |
| `openai.gpt-oss-20b-1:0`                         | OpenAI (OSS)    | ✅            | ❌          | $0.07/$0.30             | Codificación eficiente, desarrollo de software |
| `qwen.qwen3-next-80b-a3b`                        | Qwen            | ❌            | ❌          | $0.15/$1.20             | Contexto ultra largo, razonamiento insignia |
| `qwen.qwen3-32b-v1:0`                            | Qwen            | ❌            | ❌          | $0.15/$0.60             | Razonamiento equilibrado, casos de uso de investigación |
| `qwen.qwen3-coder-30b-a3b-v1:0`                  | Qwen            | ❌            | ❌          | $0.15/$0.60             | Codificación por vibración, primero en lenguaje natural |
| `qwen.qwen3-coder-next`                          | Qwen            | ❌            | ❌          | $0.45/$1.80             | Uso de herramientas, llamada a funciones optimizada |
| `mistral.mistral-large-3-675b-instruct`          | Mistral         | ❌            | ✅          | $4.00/$12.00            | Multimodal avanzado, contexto largo     |
| `moonshotai.kimi-k2.5`                           | Moonshot        | ❌            | ✅          | $0.60/$3.00             | Visión, lenguaje, código en un solo modelo |

**Precios**: Por 1M de tokens. Los modelos con soporte de razonamiento/pensamiento tienen costos de cómputo adicionales durante la fase de razonamiento.

#### Modelos probados pero incompatibles

Algunos modelos de AWS Bedrock fueron probados pero **no son compatibles** debido a limitaciones técnicas:

| Familia del modelo         | Razón de la incompatibilidad                                                               |
| -------------------------- | ------------------------------------------------------------------------------------------ |
| **GLM (Z.AI)**            | El formato de llamada a herramientas es incompatible con la API Converse (espera cadena en lugar de JSON) |
| **AI21 Jamba**            | Límites de velocidad severos (1-2 solicitudes/min) impiden pruebas confiables y uso en producción |
| **Meta Llama 3.3/3.1**    | Procesamiento inestable de resultados de llamadas a herramientas, causa fallos inesperados en flujos de varios turnos |
| **Mistral Magistral**     | La llamada a herramientas no es compatible con el modelo                                   |
| **Moonshot K2-Thinking**  | Comportamiento de streaming inestable con llamadas a herramientas, poco confiable en producción |
| **Qwen3-VL**              | Streaming inestable con llamada a herramientas, la combinación multimodal + herramientas falla intermitentemente |

> [!IMPORTANT]
> **Límites de velocidad y gestión de cuotas**
>
> Las cuotas predeterminadas de AWS Bedrock para los modelos Claude son **extremadamente restrictivas** (2-20 solicitudes/minuto para cuentas nuevas). Para pruebas de penetración en producción:
>
> 1. **Solicite aumentos de cuota** a través de la consola de AWS Service Quotas para los modelos que planea usar
> 2. **Use modelos Amazon Nova**: cuotas predeterminadas más altas y excelente rendimiento
> 3. **Habilite el rendimiento aprovisionado** para pruebas consistentes de alto volumen
> 4. **Monitoree el uso**: AWS limita agresivamente en los límites de cuota
>
> Sin aumentos de cuota, espere retrasos frecuentes e interrupciones en el flujo de trabajo.

> [!WARNING]
> **Requisitos de la API Converse**
>
> PentAGI utiliza la **API Converse** de Amazon Bedrock para el acceso unificado a modelos. Todos los modelos compatibles requieren:
>
> - ✅ Soporte de API Converse/ConverseStream
> - ✅ Uso de herramientas (llamada a funciones) para flujos de trabajo de pruebas de penetración
> - ✅ Uso de herramientas de streaming para retroalimentación en tiempo real
>
> Verifique las capacidades del modelo en: [Características de modelos de AWS Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html)

**Características clave**:
- **Caché automática de prompts**: Reducción de costos del 40-70% en contexto repetido (modelos Claude 4.x)
- **Razonamiento extendido**: Razonamiento paso a paso para análisis de seguridad complejos (Claude, DeepSeek R1, OpenAI GPT)
- **Análisis multimodal**: Procese capturas de pantalla, diagramas, videos para pruebas completas (Nova, Claude, Mistral, Kimi)
- **Llamada a herramientas**: Integración perfecta con más de 20 herramientas de pentesting mediante llamada a funciones
- **Streaming**: Streaming de respuestas en tiempo real para flujos de trabajo de evaluación de seguridad interactivos

### Configuración del proveedor DeepSeek

PentAGI se integra con DeepSeek, proporcionando acceso a modelos de IA avanzados con fuertes capacidades de razonamiento, codificación y almacenamiento en caché de contexto a precios competitivos.

#### Variables de configuración

| Variable              | Valor predeterminado         | Descripción                                        |
| --------------------- | ---------------------------- | -------------------------------------------------- |
| `DEEPSEEK_API_KEY`    |                              | Clave API de DeepSeek para autenticación           |
| `DEEPSEEK_SERVER_URL` | `https://api.deepseek.com`  | URL del endpoint de la API de DeepSeek             |
| `DEEPSEEK_PROVIDER`   |                              | Prefijo del proveedor para la integración con LiteLLM (opcional) |

#### Ejemplos de configuración```bash
# Direct API usage
DEEPSEEK_API_KEY=your_deepseek_api_key
DEEPSEEK_SERVER_URL=https://api.deepseek.com

# With LiteLLM proxy
DEEPSEEK_API_KEY=your_litellm_key
DEEPSEEK_SERVER_URL=http://litellm-proxy:4000
DEEPSEEK_PROVIDER=deepseek  # Adds prefix to model names (deepseek/deepseek-v4-flash) for LiteLLM

#### Modelos Soportados

PentAGI admite 13 modelos GLM con llamada a herramientas, streaming, modos de pensamiento híbrido y almacenamiento en caché de indicaciones. Los modelos marcados con `*` se utilizan en la configuración predeterminada. El pensamiento se controla mediante `extra_body.thinking.type` ("enabled"/"disabled"); a diferencia de Kimi, GLM es permisivo con la temperatura en cualquier modo.

**Serie GLM-5.x - Última Generación (contexto de 200K, salida máxima de 128K)**

| ID del Modelo  | Pensamiento | Contexto | Salida Máx. | Precio (Entrada/Salida/Caché) | Caso de Uso                                                                                          |
| -------------- | ----------- | -------- | ----------- | ------------------------------ | ---------------------------------------------------------------------------------------------------- |
| `glm-5.1`*     | ✅ Híbrido  | 200K     | 128K        | $1.40/$4.40/$0.26              | Nuevo buque insignia: ejecución autónoma sostenida de 8h, alineado con Claude Opus 4.6 (generador/refinador/asesor/codificador/pentester por defecto) |
| `glm-5`        | ✅ Híbrido  | 200K     | 128K        | $1.00/$3.20/$0.20              | Base para Ingeniería Agentica, MoE 744B/40B activos, codificación a nivel de Claude Opus 4.5        |
| `glm-5-turbo`* | ✅ Híbrido  | 200K     | 128K        | $1.20/$4.00/$0.24              | Nativo de OpenClaw: optimizado para invocación de herramientas, tareas persistentes, ejecución de cadena larga (agente_principal/asistente por defecto) |

**Serie GLM-4.7 - Premium con Pensamiento Intercalado**

| ID del Modelo     | Pensamiento | Contexto | Salida Máx. | Precio (Entrada/Salida/Caché) | Caso de Uso                                              |
| ----------------- | ----------- | -------- | ----------- | ------------------------------ | --------------------------------------------------------- |
| `glm-4.7`         | ✅ Híbrido  | 200K     | 128K        | $0.60/$2.20/$0.11              | Programación mejorada, razonamiento multi-paso estable   |
| `glm-4.7-flashx`  | ✅ Híbrido  | 200K     | 128K        | $0.07/$0.40/$0.01              | Ultraeconómico con GPU prioritaria, pero límites RPM más bajos (evitar para uso de alta frecuencia) |
| `glm-4.7-flash`   | ✅ Híbrido  | 200K     | 128K        | Gratis/Gratis/Gratis           | Modelo SOTA ~30B gratuito, 1 solicitud concurrente       |

**Serie GLM-4.6 - Equilibrada con Pensamiento Automático**

| ID del Modelo | Pensamiento | Contexto | Salida Máx. | Precio (Entrada/Salida/Caché) | Caso de Uso                                          |
| ------------- | ----------- | -------- | ----------- | ------------------------------ | ----------------------------------------------------- |
| `glm-4.6`     | ✅ Automático | 200K    | 128K        | $0.60/$2.20/$0.11              | Equilibrado, llamadas a herramientas en streaming, eficiente en tokens |

**Serie GLM-4.5 - Razonamiento/Codificación/Agentes Unificados**

| ID del Modelo        | Pensamiento | Contexto | Salida Máx. | Precio (Entrada/Salida/Caché) | Caso de Uso                                          |
| -------------------- | ----------- | -------- | ----------- | ------------------------------ | ----------------------------------------------------- |
| `glm-4.5`            | ✅ Automático | 128K    | 96K         | $0.60/$2.20/$0.11              | Unificado, MoE 355B/32B activos                      |
| `glm-4.5-x`          | ✅ Automático | 128K    | 96K         | $2.20/$8.90/$0.45              | Premium ultrarrápido, latencia más baja               |
| `glm-4.5-air`*       | ✅ Automático | 128K    | 96K         | $0.20/$1.10/$0.03              | MoE rentable 106B/12B (simple/simple_json/reflector/buscador/enriquecedor/instalador por defecto) |
| `glm-4.5-airx`       | ✅ Automático | 128K    | 96K         | $1.10/$4.50/$0.22              | Air acelerado con GPU prioritaria                     |
| `glm-4.5-flash`      | ✅ Automático | 128K    | 96K         | Gratis/Gratis/Gratis           | Gratuito con soporte para razonamiento/codificación/agentes |

**GLM-4 Heredado - Arquitectura Densa**

| ID del Modelo              | Pensamiento | Contexto | Salida Máx. | Precio (Entrada/Salida) | Caso de Uso                                              |
| ------------------------- | ----------- | -------- | ----------- | ----------------------- | --------------------------------------------------------- |
| `glm-4-32b-0414-128k`     | ❌          | 128K     | 16K         | $0.10/$0.10             | Denso 32B ultraeconómico, análisis sin razonamiento       |

**Precios**: Por 1M de tokens. El precio de caché es para acierto de caché de indicaciones; el almacenamiento en caché es actualmente gratuito según la promoción de Z.AI. GLM-4-32B no tiene soporte de caché.

**Configuración del Agente por Defecto**:

Estrategia: `glm-5.1` (nuevo buque insignia, $1.40 entrada) para razonamiento crítico, `glm-5-turbo` (nativo de OpenClaw, optimizado para agentes) para orquestación, `glm-4.5-air` (MoE barato con pensamiento híbrido y RPM confiable) para todos los agentes de utilidad/instalador. Se evita `glm-4.7-flashx` como predeterminado debido a límites RPM más bajos que causan frecuentes errores 429 a alta frecuencia.

| Rol del Agente                | Modelo Predeterminado | Pensamiento | Temperatura | Top P | Salida Máx. |
| ----------------------------- | --------------------- | ----------- | ----------- | ----- | ----------- |
| Generador / Refinador         | `glm-5.1`             | Habilitado  | 1.0         | 0.95  | 32768       |
| Codificador                   | `glm-5.1`             | Habilitado  | 1.0         | 0.95  | 20480       |
| Asesor / Pentester            | `glm-5.1`             | Habilitado  | 1.0         | 0.95  | 16384       |
| Agente Principal / Asistente  | `glm-5-turbo`         | Habilitado  | 1.0         | 0.95  | 16384       |
| Instalador                    | `glm-4.5-air`         | Habilitado  | 1.0         | 0.95  | 16384       |
| Simple / Reflector            | `glm-4.5-air`         | Deshabilitado | 0.6       | 0.9   | 8192        |
| Buscador / Enriquecedor / JSON Simple | `glm-4.5-air` | Deshabilitado | 0.6 | 0.9 | 4096 |

> **Nota sobre la temperatura**: GLM acepta tanto `1.0` como `0.6` en modo de pensamiento o sin pensamiento (según la documentación de Z.AI). La función `IsReasoningModel` de langchaingo coincide con los prefijos `glm-4.5*`/`glm-4.6*`/`glm-4.7*` y fuerza la temperatura a 1.0 en `createChatRequest` — esto es inofensivo para GLM (a diferencia de Kimi) pero significa que los valores de temperatura para esos modelos en YAML son solo indicativos. `glm-5`/`glm-5.1`/`glm-5-turbo` no coinciden, por lo que los valores explícitos pasan sin cambios.

**Modos de Pensamiento**:
- **Híbrido** (GLM-5.x, GLM-4.7): Alternancia explícita mediante `extra_body.thinking.type`
- **Automático** (serie GLM-4.6, GLM-4.5): El modelo determina automáticamente cuándo se necesita razonamiento
- **Pensamiento Preservado** (Capacidad de Codificación Z.AI): todos los agentes con pensamiento habilitado en PentAGI también pasan `extra_body.thinking.clear_thinking: false` para que `reasoning_content` de turnos anteriores del asistente se conserve a lo largo de la conversación. Esto es necesario en el endpoint estándar de la API (`/api/paas/v4`) — en el endpoint del Plan de Codificación estaría habilitado por defecto. Mejora la continuidad del razonamiento y las tasas de acierto de caché en cadenas de llamadas a herramientas de múltiples turnos.
- Todos los agentes con pensamiento habilitado también pasan `extra_body.tool_choice: auto` de forma defensiva

**Características Clave**:
- **Tareas de Largo Plazo**: GLM-5.1 admite ejecución autónoma sostenida de 8 horas, ideal para flujos de trabajo agenticos complejos de múltiples etapas
- **Orquestación Nativa de OpenClaw**: GLM-5-Turbo está específicamente optimizado para invocación de herramientas, seguimiento de instrucciones y ejecución de cadena larga
- **Almacenamiento en Caché de Indicaciones**: Reducción significativa de costos en contexto repetido (se muestra el precio de entrada en caché)
- **Contexto Ultra Largo**: 200K tokens para las series GLM-5.x/4.7/4.6
- **Arquitectura MoE**: Eficiente 744B/40B activos (GLM-5/5.1), 355B/32B (GLM-4.5), 106B/12B (GLM-4.5-Air)
- **Llamada a Herramientas**: Integración perfecta con más de 20 herramientas de pentesting mediante llamadas a funciones
- **Streaming**: Streaming en tiempo real con soporte de llamadas a herramientas en streaming (GLM-4.6+)
- **Multilingüe**: Capacidades excepcionales de PNL en chino e inglés
- **Opciones Gratuitas**: GLM-4.7-Flash y GLM-4.5-Flash para prototipado y experimentación

**Integración LiteLLM**: Establezca `GLM_PROVIDER=zai` para habilitar el prefijo de nombre del modelo al usar configuraciones predeterminadas de PentAGI con el proxy LiteLLM. Déjelo vacío para uso directo de la API.

### Configuración del Proveedor Kimi

PentAGI se integra con Kimi de Moonshot AI, proporcionando modelos de contexto ultra largo con capacidades multimodales perfectos para analizar bases de código y documentación extensas.

#### Variables de Configuración

---

[Read more](https://github.com/vxcontrol/pentagi)