> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mnemom.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Inicio rápido de Mnemom Gateway

> Gobernanza completa de agentes — verificación, análisis de integridad y aplicación de políticas — en 5 minutos sin cambios de código

# Mnemom Gateway

Mnemom Gateway es una pasarela de IA transparente que se sitúa entre tu aplicación y cualquier proveedor LLM. Proporciona la stack de confianza completa de Mnemom desde el primer momento:

* AP-Traces verificables
* Comprobaciones de integridad AIP por turno
* Aplicación de políticas a partir de las secciones `capabilities` y `enforcement` de la tarjeta de alineamiento
* Protección Safe House configurada mediante la tarjeta de protección
* Verificación frente a la tarjeta de alineamiento del agente

Tus prompts y respuestas pasan sin cambios. Tus claves API nunca salen de tu máquina.

<Steps>
  <Step title="Instalar la CLI">
    ```bash theme={null}
    npm install -g @mnemom/mnemom
    ```
  </Step>

  <Step title="Autenticarse">
    Inicia sesión en tu cuenta de Mnemom:

    ```bash theme={null}
    mnemom login
    ```

    Esto abre un flujo de inicio de sesión en el navegador y almacena tu token de autenticación en `~/.mnemom/auth.json`.

    <Note>
      Tus claves API del proveedor **no** se envían a Mnemom. Solo se usan hashes SHA-256 para identificar tu agente. El hash no puede revertirse para recuperar tu clave.
    </Note>
  </Step>

  <Step title="Realizar una llamada API">
    Usa la URL de la pasarela en lugar de la URL directa del proveedor. Incluye el encabezado `x-mnemom-agent` para nombrar tu agente — se creará automáticamente en la primera llamada en el Sandbox de Mnemom sin propietario. Antes de que los comandos de lectura (`mnemom status`, `logs`, `integrity`, `card show`) puedan resolverlo, debes reclamar el agente en tu cuenta (paso siguiente). Usa `-i` para imprimir los encabezados de respuesta y capturar el id `X-Mnemom-Agent` que necesitarás para la reclamación.

    ```bash theme={null}
    # En lugar de https://api.anthropic.com/v1/messages
    curl -i https://gateway.mnemom.ai/anthropic/v1/messages \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "x-mnemom-agent: my-agent" \
      -H "anthropic-version: 2023-06-01" \
      -H "content-type: application/json" \
      -d '{
        "model": "claude-sonnet-4-6",
        "max_tokens": 1024,
        "messages": [{"role": "user", "content": "Hello"}]
      }'
    ```

    La pasarela admite los tres proveedores en sus rutas estándar:

    | Proveedor | Ruta de la pasarela             | Equivalente directo                   |
    | --------- | ------------------------------- | ------------------------------------- |
    | Anthropic | `gateway.mnemom.ai/anthropic/*` | `api.anthropic.com/*`                 |
    | OpenAI    | `gateway.mnemom.ai/openai/*`    | `api.openai.com/*`                    |
    | Gemini    | `gateway.mnemom.ai/gemini/*`    | `generativelanguage.googleapis.com/*` |

    <Tip>
      La mayoría de los SDK y frameworks te permiten anular la URL base. Configúrala con la ruta de la pasarela para tu proveedor y todo lo demás funciona sin cambios.
    </Tip>
  </Step>

  <Step title="Lo que querrás leer de vuelta">
    La pasarela agrega encabezados de respuesta que llevan el veredicto de Safe House, metadatos de correlación de soporte y entradas de avisos. Una integración conforme debe analizar y observar estos encabezados — al menos mostrarlos cuando algo va mal.

    | Encabezado            | Cuándo se emite                                         | Qué hacer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
    | --------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `X-Mnemom-Request-Id` | Siempre                                                 | UUIDv4 por solicitud. **Siempre regístralo.** Pégalo en un ticket de soporte y podremos recuperar cada línea de log de la solicitud.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
    | `X-Mnemom-Verdict`    | Siempre (gateway)                                       | Estructurado `front=…; autonomy=…; integrity=…; back=…` con cada valor en `{pass \| observed \| nudged \| enforced \| unverified}`. Analízalo; el estado de cuatro puntos de control te indica qué observó Safe House (front+back), qué hizo CLPI en las llamadas a herramientas (autonomy) y qué hizo AIP en el razonamiento (integrity). `unverified` es exclusivo de integrity: el analizador falló, así que no existe un veredicto confiable — `enforce` retiene la respuesta (fail-closed, sigue siendo 2xx), `observe`/`nudge` la reenvían y registran el estado unverified. Nunca se reporta como `pass`. |
    | `X-Mnemom-Advisory`   | Cuando la pasarela tiene avisos                         | JSON compacto `[{source, text, severity?, id?}, …]`. Muestra las entradas en tu UI de operador / logs. Se omite por completo cuando está vacío.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
    | `X-Mnemom-Agent`      | Cuando la solicitud está vinculada a un agente nombrado | El identificador del agente que la pasarela resolvió para tu solicitud (p. ej., `mnm-a1b2c3d4…`). Útil para cruzar referencias con filas del panel de control.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
    | `X-Mnemom-Session`    | En sesiones multi-turno                                 | Token de correlación de sesión estable. Devuélvelo en el siguiente turno para mantener la continuidad de la sesión.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
    | `Retry-After`         | En `429` y algunos `503`                                | Segundos a esperar antes de reintentar. **Respétalo.**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |

    Análisis rápido:

    ```typescript theme={null}
    const v = response.headers.get('X-Mnemom-Verdict')!;
    const checkpoints = Object.fromEntries(v.split(';').map(s => s.trim().split('=')));
    // checkpoints.front, checkpoints.autonomy, checkpoints.integrity, checkpoints.back

    if (checkpoints.integrity === 'enforced') {
      // Ocurrió un reemplazo AIP en el mismo turno — muéstralo en tu UI.
    }
    if (checkpoints.integrity === 'unverified') {
      // El analizador falló — no hay veredicto confiable. En enforce esta
      // respuesta ya fue retenida/reemplazada; en observe/nudge fue reenviada.
    }
    ```

    Consulta la referencia de encabezados para el conjunto canónico completo + parsers por lenguaje, y la referencia de errores para el mapeo veredicto-a-estado (cuando `enforced` se convierte en cuarentena 422 o bloqueo 403).
  </Step>

  <Step title="Reclamar tu agente">
    La pasarela creó tu agente en el Sandbox compartido de Mnemom (sin propietario). Reclamarlo demuestra que posees la clave del proveedor y lo mueve a tu cuenta para que todos los comandos de lectura puedan resolverlo.

    Copia el valor `X-Mnemom-Agent` de los encabezados de respuesta anteriores y ejecuta:

    ```bash theme={null}
    mnemom agents claim mnm-550e8400-e29b-41d4-a716-446655440000 --name my-agent --key $ANTHROPIC_API_KEY
    ```

    Reemplaza `mnm-550e8400-e29b-41d4-a716-446655440000` con el id real de tu encabezado `X-Mnemom-Agent`.

    * Pasa `--name` que coincida con el valor `x-mnemom-agent` que enviaste en la llamada a la pasarela (omite `--name` si hiciste esa llamada sin el encabezado). Si el id, `--name` o `--key` no resuelven a un agente real, la reclamación devuelve `404` — verifica el id `X-Mnemom-Agent` y que `--name`/`--key` coincidan con la llamada a la pasarela.
    * La clave se hashea localmente (SHA-256) y nunca se envía a Mnemom.
    * El agente llega a tu organización personal por defecto; pasa `--org <slug>` para reclamarlo en una organización compartida.
    * La operación es idempotente — seguro ejecutarlo más de una vez.

    <Note>
      Una respuesta `503` significa que tu organización personal aún está siendo aprovisionada. Espera unos segundos y vuelve a intentarlo. Para errores `403` de inquilino cruzado o no-miembro, consulta la guía del flujo de reclamación de agentes.
    </Note>
  </Step>

  <Step title="Verificar el estado">
    Verifica que la pasarela sea accesible y que tu agente esté conectado:

    ```bash theme={null}
    mnemom status --agent my-agent
    ```

    ```text Salida theme={null}
    Agent:    my-agent (mnm-550e8400-e29b-41d4-a716-446655440000)
    Gateway:  https://gateway.mnemom.ai (healthy)
    Status:   Connected
    Providers: anthropic, openai
    Last seen: just now
    ```
  </Step>

  <Step title="Ver las trazas">
    Después de realizar llamadas API a través de la pasarela, consulta lo que se rastreó:

    ```bash theme={null}
    mnemom logs --agent my-agent
    ```

    ```text Salida theme={null}
    2026-02-17T10:30:00Z  tr-abc123  recommend  bounded   verified  0.82
    2026-02-17T10:30:05Z  tr-abc124  search     bounded   verified  0.76
    2026-02-17T10:30:12Z  tr-abc125  respond    bounded   verified  0.91
    ```

    Usa `mnemom logs --agent my-agent -l 20` para mostrar más entradas.
  </Step>

  <Step title="Comprobar la integridad">
    Consulta las puntuaciones de integridad AIP para la actividad reciente de tu agente:

    ```bash theme={null}
    mnemom integrity --agent my-agent
    ```

    ```text Salida theme={null}
    Agent: mnm-550e8400-e29b-41d4-a716-446655440000
    Checkpoints: 12
    Verdicts:
      clear: 11
      review_needed: 1
      boundary_violation: 0
    Integrity score: 0.94
    Drift: none detected
    ```
  </Step>

  <Step title="Ver tu tarjeta de alineamiento">
    Consulta la tarjeta de alineamiento asignada a tu agente:

    ```bash theme={null}
    mnemom card show --agent my-agent
    ```

    Personalízala publicando tu propia tarjeta:

    ```bash theme={null}
    mnemom card publish my-card.yaml --agent my-agent
    ```
  </Step>

  <Step title="Explorar el panel de control">
    Los datos de tu agente están disponibles en [mnemom.ai/dashboard](https://mnemom.ai/dashboard) una vez que hayas iniciado sesión. El panel de control muestra:

    * **Línea de tiempo de conciencia** -- Una vista cronológica de cada traza, punto de control de integridad y acción de aplicación
    * **Tarjeta de alineamiento** -- Los valores y límites declarados de tu agente
    * **Puntuaciones de integridad** -- Historial de veredictos AIP y análisis de tendencias
    * **Alertas de deriva** -- Notificaciones cuando el comportamiento diverge del alineamiento declarado
    * **Registro de aplicación** -- Registros de nudges y bloqueos (si la aplicación está habilitada)
  </Step>
</Steps>

## Agentes nombrados

Si ejecutas múltiples agentes detrás de la misma clave API, usa el encabezado `x-mnemom-agent` para dar a cada uno una identidad distinta. La ruta del proveedor permanece sin cambios — la pasarela deriva un ID de agente único mediante `SHA256(apiKey + '|' + agentName)`. Consulta Identidad del agente para la derivación completa del ID, las rutas de creación automática vs registro programático y cómo la rotación de claves interactúa con la identidad del agente.

```bash theme={null}
curl https://gateway.mnemom.ai/anthropic/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "x-mnemom-agent: my-coder" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello"}]
  }'
```

Cada agente nombrado obtiene su propio historial de trazas, puntuaciones de integridad y detección de deriva — aunque compartan una clave API. Los agentes se crean automáticamente en la primera llamada API; reclama una vez (consulta el paso de reclamación anterior) para vincular el agente a tu cuenta.

<Tip>
  También puedes crear agentes de forma programática mediante la API CRUD de agentes si quieres pre-crearlos con metadatos antes de su primera solicitud.
</Tip>

## Proveedores compatibles

| Proveedor | Modelos                                | Soporte Thinking / AIP                                    | Encabezado de autenticación |
| --------- | -------------------------------------- | --------------------------------------------------------- | --------------------------- |
| Anthropic | Claude Opus 4.7, Sonnet 4.6, Haiku 4.5 | Completo (bloques de pensamiento analizados directamente) | `x-api-key`                 |
| OpenAI    | GPT-5.2, GPT-5.2 Pro, GPT-5            | Mediante resúmenes de razonamiento (confianza reducida)   | `Authorization: Bearer`     |
| Gemini    | Gemini 2.5 Pro, Gemini 3 Pro           | Completo (partes de pensamiento analizadas directamente)  | `x-goog-api-key`            |

### Compatibilidad AIP

| Proveedor / Modelo                               | Soporte AIP   | Método                                         |
| ------------------------------------------------ | ------------- | ---------------------------------------------- |
| Modelos de razonamiento Anthropic (Opus, Sonnet) | Completo      | Bloques de pensamiento analizados directamente |
| Serie GPT-5 Thinking de OpenAI                   | Parcial       | Resúmenes de razonamiento (confianza reducida) |
| Gemini 2.5/3 con thinking                        | Completo      | Partes de pensamiento analizadas directamente  |
| Modelos sin razonamiento                         | Solo rastreo  | Veredicto clear sintético                      |
| OpenAI legacy (o3/o4-mini)                       | No compatible | Razonamiento cifrado                           |

<Note>
  **Elementos thinking en respuestas proxiadas.** Safe House / AIP habilita el thinking extendido para analizar el razonamiento del agente por turno. Las respuestas proxiadas incluyen por lo tanto un elemento de contenido `thinking` en el array `content` junto al bloque `text` estándar. Los clientes que asumen arrays de contenido de solo texto deben actualizarse para manejar o ignorar los bloques thinking. Los tokens de salida thinking se facturan como tokens de salida estándar — este comportamiento es intencional y no puede desactivarse.
</Note>

## Qué se rastrea

Mnemom Gateway construye [AP-Traces](https://github.com/mnemom/aap) que registran:

* **Acción** -- Lo que hizo el agente (tipo, nombre, categoría)
* **Decisión** -- Qué alternativas se consideraron y por qué se seleccionó una
* **Escalada** -- Si el agente escaló a un humano y por qué
* **Verificación** -- Si la traza es coherente con la tarjeta de alineamiento declarada del agente
* **Integridad** -- Análisis AIP por turno de los bloques de pensamiento, con veredicto (`clear` / `review_needed` / `boundary_violation`)

## Qué NO se almacena

<Warning>
  Tus **prompts**, **respuestas** y **claves API** nunca son almacenados por Mnemom. La pasarela procesa las solicitudes en memoria y las reenvía al proveedor. Solo se persisten los metadatos de traza estructurados (acciones, decisiones, veredictos) y los resultados del análisis de bloques de pensamiento.
</Warning>

## Modos de aplicación

Mnemom Gateway admite tres modos de aplicación cuando se detecta una violación de integridad:

| Modo      | Comportamiento                                                                                                                                                                                                                   |
| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `observe` | Detecta violaciones, las registra, no actúa (predeterminado)                                                                                                                                                                     |
| `nudge`   | Detecta violaciones, inyecta retroalimentación en la siguiente solicitud del agente mediante el prompt del sistema. El agente lo ve y puede auto-corregirse.                                                                     |
| `enforce` | Aplica el veredicto en el mismo turno tanto para solicitudes con streaming como sin streaming (HTTP 403 para las solicitudes sin streaming); en streaming esto añade latencia porque la respuesta se evalúa antes de entregarse. |

Establece el modo de aplicación actualizando la tarjeta de alineamiento del agente. `integrity_mode` y `autonomy_mode` son campos de nivel superior en la tarjeta de alineamiento; el endpoint legacy `/v1/agents/{id}/enforcement` fue retirado el 2026-05-14.

Tres caminos, elige el que se adapte a tu flujo de trabajo:

* **Panel de control:** abre `https://mnemom.ai/dashboard/agents/{your-agent-id}/card`, activa `integrity_mode`, guarda. El camino más sencillo.
* **CLI:** `mnemom card edit` abre el YAML de la tarjeta de alineamiento actual en `$EDITOR`; cambia `integrity_mode: nudge`, guarda, la CLI publica y recompone.
* **Programático:** `PUT /v1/alignment/agent/{agent_id}` con la tarjeta canónica completa. Consulta la guía de gestión de tarjetas para el flujo leer-modificar-escribir y el esquema de tarjeta de alineamiento para los requisitos de campos.

## Próximos pasos

* Ver la descripción general del protocolo para entender cómo funcionan juntos AAP, AIP y CLPI
* Configurar la aplicación de políticas para definir reglas de gobernanza para el uso de herramientas de tu agente
* Explorar conceptos para entender las tarjetas de alineamiento, las trazas y la integridad
* Descripción general de CLPI para entender la capa de gobernanza (aplicación de políticas, recuperación de confianza, anclaje on-chain)
* Leer sobre la aplicación para documentación detallada de los modos de aplicación
* [Auto-alojar](/es/quickstart/self-hosted) si necesitas control completo de residencia de datos
