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

# Toolsets de MCP de Didit y modo de solo lectura

> Carga solo las herramientas MCP de Didit que necesitas con toolsets, usa el modo solo lectura y accede al resto con búsqueda de herramientas.

Los toolsets permiten que una conexión MCP de Didit cargue una lista corta de herramientas en lugar de todo el catálogo, y el modo de solo lectura te da una conexión que nunca puede modificar datos. Ambos se configuran como un parámetro en la URL del servidor:

```text theme={null}
https://mcp.didit.me/mcp?toolsets=core
https://mcp.didit.me/mcp?read_only=true
```

Sin ningún parámetro, el servidor enumera todas las herramientas que tu rol puede usar, así que nada cambia en una conexión que ya tienes.

## Por qué cargar menos herramientas

Tu cliente envía la definición de cada herramienta listada al modelo antes de tu primera pregunta.
Para el catálogo completo de Didit, eso son decenas de miles de tokens en cada solicitud: entre 50 000 y 115 000, según el tokenizador del modelo.
Algunos clientes también limitan cuántas herramientas aceptan.

| Lo que carga la conexión | Herramientas listadas | Proporción de esos tokens |
| - | - | - |
| Todo (sin parámetro) | Cada herramienta que tu rol puede usar | Todas |
| La lista corta, `core` | Unas 30 | Alrededor de una décima parte |
| La lista corta, solo lectura | Unas 20 | Menos de una décima parte |

La contrapartida es un paso adicional.
Una herramienta fuera de la lista no se pierde, pero el modelo tiene que encontrarla con [búsqueda de herramientas](#acceder-a-las-herramientas-que-no-cargaste) antes de poder ejecutarla, y un modelo que ve todas las herramientas elige la correcta algo más a menudo que un modelo que tiene que buscarlas.
Carga todo cuando una conversación abarca muchas áreas y el coste de contexto no importa.
Carga `core`, junto con los conjuntos de herramientas que más usas, cuando sí importa.

## Elige tus conjuntos de herramientas

Añade `toolsets` a la URL del servidor con una lista separada por comas:

```text theme={null}
https://mcp.didit.me/mcp?toolsets=core
https://mcp.didit.me/mcp?toolsets=core,workflows
https://mcp.didit.me/mcp?toolsets=core,transactions,cases
```

`core` es la lista corta de la que parte la mayoría del trabajo.
Incluye tus organizaciones y aplicaciones, las sesiones de verificación (crear, buscar, decidir, explicar, simular en el sandbox y leer las entregas de webhook), la búsqueda de flujos de verificación (workflow), las analíticas y el saldo, la clave de API y los webhooks de tu aplicación, la búsqueda de casos, usuarios, empresas y transacciones, y la búsqueda en la documentación.

* `core`: la lista corta descrita arriba.
* `account`: organizaciones, aplicaciones, claves de API, miembros y roles.
* `billing`: plan, saldo de créditos, métodos de pago, recibos y datos de facturación.
* `sessions`: sesiones de verificación (crear, buscar, decidir, revisar, compartir, importar, PDF y entregas de webhook).
* `workflows`: flujos de verificación y cuestionarios (crear, editar, validar y publicar).
* `lists`: listas personalizadas, la lista de bloqueo y la lista de permitidos.
* `vendors`: las personas y empresas que verificas (usuarios y empresas de proveedores).
* `transactions`: monitorización de transacciones (transacciones, análisis de wallets y reglas con pruebas retrospectivas).
* `cases`: gestión de casos (crear, asignar, escalar y resolver casos).
* `investigator`: Investigator (su cola de revisión, informes, decisiones, preguntas sobre políticas y rendimiento).
* `webhooks`: destinos de webhook y alertas.
* `reports`: analíticas, exportaciones y registro de auditoría.
* `branding`: marca blanca del flujo de verificación.
* `verification`: APIs de verificación independientes (documento de identidad, rostro, AML, prueba de domicilio, teléfono, correo electrónico, validación de base de datos y verificaciones de empresas).
* `travel_rule`: Travel Rule (ajustes, el directorio de VASP, redes, direcciones de wallet, transferencias y mensajes).
* `marketplace`: el mercado de proveedores (el catálogo, tus conexiones y tus solicitudes de integración).
* `networks`: redes de fraude (sesiones vinculadas, usuarios y empresas que comparten un dispositivo, un documento o un contacto).
* `compliance`: el asistente de cumplimiento (tu perfil regulatorio, sus requisitos y los flujos generados a partir de ellos).
* `docs`: búsqueda en la documentación de Didit.
* `all`: todas las herramientas que tu rol puede usar. Es el valor predeterminado.

La [referencia de herramientas](https://docs.didit.me/es/integration/mcp/tools.md) enumera cada herramienta con su tipo y el permiso de rol que necesita.

Así se comporta la selección:

* **Los toolsets son opcionales.** Una URL sin `toolsets` lista todo.
* **Al indicar toolsets, se enumeran exactamente esos.** `?toolsets=cases` lista las herramientas de casos, además de `didit_context_get`, que se incluye en cada conexión. Añade `core` si quieres mantener también la lista corta.
* **Un toolset decide qué se lista, no qué puedes ejecutar.** Una herramienta fuera de tu selección sigue ejecutándose cuando el modelo la invoca por nombre, con los mismos permisos de rol de siempre.
* **Un nombre que el servidor no conoce se ignora.** La conexión sigue funcionando, y el servidor indica al modelo qué nombre ignoró y cuáles son válidos.
* **Tu rol sigue aplicando.** Un toolset nunca concede un permiso: consulta [roles y permisos](https://docs.didit.me/es/integration/mcp/authentication.md#roles-y-permisos).

## Conectar en modo de solo lectura

Añade `read_only=true` a la URL del servidor:

```text theme={null}
https://mcp.didit.me/mcp?read_only=true
https://mcp.didit.me/mcp?toolsets=core,reports&read_only=true
```

Una conexión de solo lectura solo muestra las herramientas que leen datos, y el servidor rechaza cada llamada que cree, modifique o elimine algo.
El rechazo se produce en el servidor en cada llamada, por lo que se mantiene aunque tu cliente recuerde una herramienta de una conexión anterior.
Úsala para generar informes, para explorar una cuenta o para un agente que no quieras que actúe por su cuenta.

Para volver a permitir cambios, conéctate sin `read_only`.

## Acceder a las herramientas que no cargaste

Cuando una conexión lista solo una parte del catálogo, el servidor añade cuatro herramientas para que ninguna quede fuera de alcance:

* `didit_tool_search` (lectura): encuentra herramientas según lo que quieres hacer ("exportar sesiones a CSV"), o lista un conjunto de herramientas. Cada coincidencia indica qué hace la herramienta, sus parámetros y si lee, escribe o es destructiva.
* `didit_tool_describe` (lectura): devuelve la descripción completa y el esquema de entrada de hasta cinco herramientas.
* `didit_tool_call_read` (lectura): ejecuta una herramienta de solo lectura que no está en la lista. Rechaza una herramienta que modifique datos.
* `didit_tool_call_write` (destructiva): ejecuta una herramienta que crea, modifica o elimina datos y que no está en la lista. No se ofrece en una conexión de solo lectura.

Una llamada a través de `didit_tool_call_read` o `didit_tool_call_write` se verifica exactamente igual que una llamada directa: siguen aplicando los permisos de tu rol, el modo de solo lectura y todos los requisitos de `confirm: true`.
Son dos herramientas separadas para que tu cliente pueda pedirte confirmación antes de un cambio y dejar pasar una consulta.

Con `core` cargado, una solicitud como "invitar a un nuevo miembro a mi organización" sigue este proceso:

1. El modelo llama a `didit_tool_search` con `invite a teammate` y obtiene `didit_org_invite_member`, marcada como de escritura.
2. Llama a `didit_tool_call_write`, pasando `didit_org_invite_member` como `name` junto con los argumentos propios de esa herramienta.
3. Tu cliente te pide que apruebes la llamada, como hace con cualquier herramienta que modifica datos.

Cuando todo está cargado no queda nada por descubrir, así que estas cuatro herramientas no aparecen en la lista.

## Configúralo en tu cliente

Sigue los mismos pasos que la [guía de instalación](https://docs.didit.me/es/integration/mcp/installation.md), pero añade los parámetros a la URL.

> [tab] Claude Code
>
> ```bash theme={null}
> claude mcp add --transport http didit "https://mcp.didit.me/mcp?toolsets=core"
> ```
>
> Mantén las comillas: de lo contrario, tu shell interpretaría el `?` y el `&` por su cuenta.

> [tab] Codex
>
> ```bash theme={null}
> codex mcp add didit --url "https://mcp.didit.me/mcp?toolsets=core"
> ```

> [tab] Cursor
>
> En `~/.cursor/mcp.json`:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "url": "https://mcp.didit.me/mcp?toolsets=core"
>     }
>   }
> }
> ```

> [tab] VS Code
>
> En `.vscode/mcp.json`:
>
> ```json theme={null}
> {
>   "servers": {
>     "didit": {
>       "type": "http",
>       "url": "https://mcp.didit.me/mcp?toolsets=core"
>     }
>   }
> }
> ```

> [tab] Claude web y Desktop
>
> Abre **Settings**, luego **Connectors**, luego **Add custom connector**, y pega la URL con sus parámetros:
>
> ```text theme={null}
> https://mcp.didit.me/mcp?toolsets=core
> ```

> [tab] Servidor local
>
> El servidor local acepta opciones de línea de comandos (flags) o variables de entorno:
>
> ```bash theme={null}
> npx -y @didit-protocol/mcp-server --toolsets=core,workflows --read-only
> ```
>
> ```bash theme={null}
> DIDIT_TOOLSETS=core,workflows DIDIT_READ_ONLY=true npx -y @didit-protocol/mcp-server
> ```

Si tu cliente te permite definir encabezados, pero no editar la URL, envía `X-MCP-Toolsets: core,workflows` y `X-MCP-Readonly: true` en su lugar.
Un valor en la URL tiene prioridad sobre el encabezado en lo que respecta a los conjuntos de herramientas, y el modo de solo lectura se activa si cualquiera de los dos lo solicita.

> [!NOTE]
>
> El plugin de ChatGPT usa su propio catálogo fijo y reducido, disponible en `https://mcp.didit.me/mcp/chatgpt`.
> Los conjuntos de herramientas y el modo de solo lectura no se aplican a él.
> Consulta [Conectar ChatGPT](https://docs.didit.me/es/integration/mcp/chatgpt.md).

## Instrucciones, prompts y búsqueda en la documentación

El servidor ayuda al modelo a empezar por el lugar correcto:

* **Instrucciones.** Al conectarse, el servidor indica al modelo que empiece con `didit_context_get`, explica cómo se resuelven `organization_id` y `application_id`, le pide que desarrolle dentro de una aplicación sandbox e indica qué conjuntos de herramientas ha cargado esta conexión.
* **Prompts.** Los clientes que admiten prompts de MCP muestran cinco puntos de partida: `integrate_didit`, `review_queue`, `explain_session`, `build_workflow` y `verification_report`. En Claude Code aparecen como comandos slash.
* **Búsqueda en la documentación.** `didit_docs_search` busca en estas páginas de documentación y devuelve las secciones coincidentes con sus enlaces, de modo que las preguntas sobre el funcionamiento de Didit se responden con las páginas actuales.

## Comprueba qué cargó una conexión

Pregúntale a tu cliente:

```text theme={null}
Which Didit toolsets does this connection load, and is it read-only?
```

El modelo responde a partir de las instrucciones del servidor.
Para comprobar que un servidor admite conjuntos de herramientas antes de depender de ellos, consulta su endpoint de estado:

```bash theme={null}
curl https://mcp.didit.me/healthz
```

La respuesta enumera `toolsets` y `read_only` en `features`.

## Próximos pasos

> [card] [Instalación](https://docs.didit.me/es/integration/mcp/installation.md)
>
> Conecta Claude, ChatGPT, Cursor, VS Code, Codex o cualquier cliente MCP.

> [card] [Referencia de herramientas](https://docs.didit.me/es/integration/mcp/tools.md)
>
> Cada herramienta, su tipo y el permiso del rol que necesita.

> [card] [Autenticación](https://docs.didit.me/es/integration/mcp/authentication.md)
>
> Inicia sesión con Didit y consulta los ámbitos y los permisos del rol.

> [card] [Indicaciones de ejemplo](https://docs.didit.me/es/integration/mcp/examples.md)
>
> Indicaciones que funcionan desde el primer día.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.