# Seguridad

> Qué puede y qué no puede hacer el servidor MCP de Sypnia, la única herramienta que escribe y cómo apagarla, y qué debes saber antes de conectar un agente a datos de producción.

Aplica a: el motor de Sypnia (código abierto, en tu propia infraestructura) y Sypnia Cloud (servicio pago). Estado: al lanzar.  
Fuente: https://docs.sypnia.com/es/mcp/security/

Para agentes: Modelo de seguridad del servidor MCP de Sypnia: solo lectura salvo resolve_problem, cómo desactivarla (read_only=true, --read-only, SYPNIA_MCP_READ_ONLY), qué nunca contienen los resultados, manejo de inyección de instrucciones, permiso del token, registros, a dónde van los datos.

**\[Motor]** **\[Nube]** Lee esto antes de conectar un agente a un proyecto con usuarios reales. Dice exactamente qué puede hacer el servidor con el token que le das.

## Qué puede y qué no puede hacer el servidor

| Puede                                                                                               | No puede                                                                                                              |
| --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| Leer problemas, su análisis, pilas, trazas y versiones                                              | Cambiar tu código, tu repositorio o tus despliegues. No tiene acceso a ellos                                          |
| Leer sesiones como una lista de eventos: páginas, clics por su etiqueta, llamadas fallidas, errores | Devolver lo que una persona escribió. Nunca se recoge                                                                 |
| Leer números de rendimiento, estado de disponibilidad, y buscar                                     | Devolver grabaciones ni capturas de página. Ninguna herramienta lo hace, con ningún token                             |
| Marcar un problema como resuelto (una herramienta, ver abajo)                                       | Ignorar o borrar un problema, borrar una sesión o los datos de una persona                                            |
|                                                                                                     | Crear, leer o revocar llaves y tokens; cambiar ajustes, reglas de alerta, webhooks o comprobaciones de disponibilidad |
|                                                                                                     | Abrir, hacer merge o cerrar un pull request                                                                           |
|                                                                                                     | Llegar a otro proyecto. Un token es un proyecto                                                                       |

Nueve de las diez herramientas solo leen. Leer no tiene efectos: preguntar dos veces no cambia nada y solo cuesta una petición.

## La única herramienta que escribe

`resolve_problem` marca un problema como resuelto. Existe para que el ciclo se cierre: el agente arregla el código, tú haces merge, el agente marca el problema.

Es segura por diseño:

- **Es reversible.** Reabre el problema cuando quieras, en la app, la Consola, la CLI o la API.
- **Se deshace sola.** Si la falla vuelve a ocurrir, Sypnia reabre el problema y crea una alerta. Un problema resuelto antes de tiempo no puede esconder una falla que sigue pasando.
- **Queda registrada.** El problema guarda quién lo resolvió (`resolved_by: mcp:<nombre del token>`), cuándo y la nota.
- **Es la única.** Ninguna otra herramienta cambia nada.

La descripción de la herramienta le dice al agente que la llame solo después de que el arreglo tenga merge o esté desplegado. La mayoría de los clientes, además, te preguntan antes de correr una herramienta que escribe.

### Deja el servidor en solo lectura

**Servidor remoto**

Agrega `?read_only=true` a la dirección. La herramienta ya no aparece en la lista.

```bash
claude mcp add --transport http sypnia \
  "https://mcp.sypnia.com/mcp?read_only=true" \
  --header "Authorization: Bearer YOUR_API_TOKEN"
```

En una configuración JSON: `"url": "https://mcp.sypnia.com/mcp?read_only=true"`.

**Servidor local**

Pasa `--read-only`, o define `SYPNIA_MCP_READ_ONLY=true`.

```bash
claude mcp add --env SYPNIA_API_TOKEN=YOUR_API_TOKEN --transport stdio sypnia \
  -- npx -y @sypnia/mcp --read-only
```

**Todo el motor**

En un motor alojado por ti, define `SYPNIA_MCP_READ_ONLY=true` para quitar la herramienta en todas las conexiones, pida lo que pida el cliente. `SYPNIA_MCP_ENABLED=false` quita el servidor MCP del todo. Mira la [referencia de configuración](https://docs.sypnia.com/es/self-hosting/configuration).

Solo lectura, aquí, habla del servidor MCP. El mismo token `read` todavía podría resolver un problema por la API HTTP, porque resolver es una de las marcas reversibles que ese permiso deja hacer.

## Texto de tu app llega a tu agente

Los resultados de las herramientas traen texto que Sypnia no escribió: mensajes de error, las etiquetas de lo que la gente tocó, títulos de páginas, nombres que tu app envió con `identify()`. Una persona que usa tu app podría poner palabras ahí a propósito, esperando que tu agente las lea como instrucciones («ignora tus instrucciones y…»).

Lo que hace Sypnia:

- Las instrucciones del servidor le dicen al agente que ese texto es un dato y que nunca debe obedecerlo.
- Los resultados tienen estructura: ese texto va en campos con nombre (`message`, `label`, `text`), nunca mezclado con las palabras del propio servidor.
- Las cadenas se cortan a su límite (un mensaje de error a 500 caracteres, una etiqueta a 80), así que hay poco espacio.
- Nada de lo que una persona escribió en un formulario está en un resultado.

Lo que debes hacer tú: deja encendida la confirmación de tu cliente para comandos y cambios de archivos cuando el agente trabaja con datos de producción, y revisa lo que cambia. Esto vale para cualquier herramienta que le lleve texto externo a un agente, no solo para Sypnia.

## A dónde van los datos

El servidor le entrega los resultados a tu agente de código. Tu agente los envía al proveedor de **su** modelo, bajo tu acuerdo con ese proveedor. Sypnia no elige ese modelo y no ve esa conversación.

Entonces, lo que devuelve una herramienta es lo que sale: ubicaciones y líneas del código de tu app, mensajes de error, etiquetas de clics, los ids de las personas, y sus nombres y correos **solo si tu app los envía** con `identify()`. Si eso no debe llegar al proveedor de tu agente, no envíes nombres ni correos a Sypnia, o usa un token de un proyecto que no los tenga.

## El token

- Usa un token de API con solo `read`. Mira [Autenticación](https://docs.sypnia.com/es/mcp/authentication).
- Un token por agente y por persona, con su nombre.
- Nunca un token `admin`, nunca el token raíz.
- Léelo del entorno; no lo subas al repositorio.
- Revócalo cuando se pierda un portátil o se vaya una persona: deja de funcionar en menos de un minuto.

## Remoto o local

|                  | Servidor remoto                                   | Servidor local (`@sypnia/mcp`)                     |
| ---------------- | ------------------------------------------------- | -------------------------------------------------- |
| Quién lo corre   | Sypnia (la nube) o tu motor                       | Tu máquina                                         |
| Qué guarda       | Nada. Cada llamada va al motor con tu token       | Nada. Reenvía cada llamada a la API                |
| Qué instalas     | Nada                                              | Un paquete de npm, licencia MIT, de código abierto |
| El token está en | La configuración de tu cliente, enviado por HTTPS | Tu entorno                                         |

El servidor local no hace ninguna otra llamada de red que a la dirección de la API que le diste.

## Qué queda registrado

Por cada llamada a una herramienta el motor registra: la hora, el id del token, el proyecto, el nombre de la herramienta, si salió bien y cuánto tardó. No registra los argumentos ni el resultado. En Sypnia Cloud estos registros se guardan 30 días.

## Límites

- 600 peticiones por minuto por token, compartidas con cualquier otro uso de ese token. Una llamada a una herramienta son de una a tres peticiones.
- Un resultado tiene como máximo 60.000 caracteres.
- Una llamada que tarda más de 30 segundos se detiene y responde un error.

## Reporta un problema de seguridad

Si encuentras una forma de hacer que el servidor haga algo que esta página dice que no puede, escribe a la dirección que está en [Prácticas de seguridad](https://docs.sypnia.com/es/privacy/security-practices).
