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

# Instalar Didit MCP: Claude, Cursor, VS Code, Windsurf

> Configura el MCP alojado de Didit en Claude, Cursor, VS Code, Windsurf, Zed u otro cliente MCP, o autoaloja el servidor abierto. Sin claves de API.

Elige tu cliente a continuación. El servidor **alojado** (`https://mcp.didit.me/mcp`) no necesita clave de API: en la primera conexión, tu cliente abre un navegador, seleccionas **[Iniciar sesión con Didit](https://docs.didit.me/es/integration/mcp/authentication.md)** y apruebas los permisos.

> [!TIP]
>
> **¿Usas Claude?** La página [Conectar Claude](https://docs.didit.me/es/integration/mcp/claude.md) tiene el enlace de conexión con un clic que abre el diálogo **Add custom connector** con el nombre y la URL ya rellenados, así que solo tienes que confirmar e iniciar sesión.

> [!NOTE]
>
> Los clientes que todavía no admiten MCP remoto/HTTP (Windsurf, Zed) se conectan a través del puente `mcp-remote`, que reenvía stdio a la URL alojada y gestiona por ti el proceso de autenticación de OAuth.

***

## Servidor alojado (recomendado)

> [tab] Claude Code
>
> Añade el servidor con la CLI y luego inicia sesión:
>
> ```bash theme={null}
> claude mcp add --transport http didit https://mcp.didit.me/mcp
> ```
>
> Inicia Claude Code y ejecuta `/mcp`: se abre el navegador para **Iniciar sesión con Didit**. Una vez que lo apruebas, las herramientas `didit` quedan disponibles.

> [tab] Claude web y Desktop
>
> Web: haz clic en [**Add Didit to Claude →**](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Didit\&connectorUrl=https://mcp.didit.me/mcp) y confirma el diálogo ya rellenado.
>
> Desktop: **Settings → Connectors → Add custom connector**, ponle el nombre `Didit` y configura la URL como:
>
> ```text theme={null}
> https://mcp.didit.me/mcp
> ```
>
> Haz clic en **Connect** y completa **Iniciar sesión con Didit** en el navegador. Las herramientas de Didit aparecerán entonces en el menú de herramientas del chat.

> [tab] Cursor
>
> Añade a `~/.cursor/mcp.json` (global) o a `.cursor/mcp.json` (por proyecto):
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> O usa **Settings → Tools & Integrations → New MCP Server**. Cursor se registra en Didit mediante Dynamic Client Registration y abre el navegador para iniciar sesión la primera vez que se usa.

> [tab] VS Code
>
> Con el modo agente de GitHub Copilot, añade `.vscode/mcp.json`:
>
> ```json theme={null}
> {
>   "servers": {
>     "didit": {
>       "type": "http",
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> O ejecuta **MCP: Add Server** desde la paleta de comandos y elige **HTTP**. Inicia sesión cuando se te solicite. Apunta VS Code a la URL completa `/mcp`: el servidor publica los metadatos de recurso OAuth para esa ruta.

> [tab] Windsurf
>
> Windsurf se conecta a través del puente `mcp-remote`. Añade a `~/.codeium/windsurf/mcp_config.json`:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "command": "npx",
>       "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"]
>     }
>   }
> }
> ```
>
> Abre **Settings → Cascade → MCP Servers → Manage** para confirmar que se ha cargado y luego inicia sesión desde el navegador.

> [tab] Zed
>
> Añade un servidor de contexto en el `settings.json` de Zed:
>
> ```json theme={null}
> {
>   "context_servers": {
>     "didit": {
>       "source": "custom",
>       "command": "npx",
>       "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"]
>     }
>   }
> }
> ```
>
> Zed inicia el puente y abre el navegador para **Iniciar sesión con Didit**.

> [tab] Cualquier otro cliente
>
> Cualquier cliente que implemente MCP sobre **Streamable HTTP** con **OAuth 2.1** puede conectarse directamente a `https://mcp.didit.me/mcp`. Descubre el servidor de autorización a partir de `https://mcp.didit.me/.well-known/oauth-protected-resource/mcp`, se registra mediante Dynamic Client Registration y ejecuta el flujo PKCE. El servidor solo acepta `POST` en `/mcp`; `GET` y `DELETE` responden `405`, porque no tiene estado y no mantiene ningún flujo iniciado por el servidor.
>
> Un cliente que solo admite stdio puede usar el mismo puente `mcp-remote` que Windsurf y Zed:
>
> ```bash theme={null}
> npx -y mcp-remote@latest https://mcp.didit.me/mcp
> ```
>
> Para probar el servidor sin un cliente, el [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) se conecta a la misma URL y te guía en el inicio de sesión.

> [!NOTE]
>
> **Sin clave de API en la configuración.** El servidor alojado te autentica en el navegador y actúa como **tú** en todas las organizaciones a las que perteneces, con los permisos de tu rol. Consulta [Autenticación](https://docs.didit.me/es/integration/mcp/authentication.md).

El servidor alojado responde a `GET https://mcp.didit.me/healthz` con su versión.

***

## Verifica tu conexión

Después de iniciar sesión, pregunta a tu cliente:

```text theme={null}
Use the Didit MCP server to call didit_context_get and list my organizations and applications.
```

El agente debería invocar `didit_context_get` y mostrar tus organizaciones con sus aplicaciones.
Si dice que no tiene herramientas de Didit, el servidor no se conectó o el inicio de sesión no terminó: consulta [Solución de problemas](https://docs.didit.me/es/integration/mcp/advanced.md#solución-de-problemas).

## Alojamiento propio

El servidor alojado se compila a partir del repositorio de código abierto [github.com/didit-protocol/mcp](https://github.com/didit-protocol/mcp) (MIT). Cada versión también se publica en npm como [`@didit-protocol/mcp-server`](https://www.npmjs.com/package/@didit-protocol/mcp-server), así que puedes ejecutar el servidor stdio directamente desde npm o compilar cualquiera de los dos puntos de entrada a partir de un clon. Un mismo código base incluye dos puntos de entrada:

| Punto de entrada | Modo | Transporte | Autenticación |
| - | - | - | - |
| `dist/http.js` | Alojado | Streamable HTTP en `MCP_PORT` (por defecto 3000), `POST /mcp`, `GET /healthz` | OAuth 2.1 Bearer, validado mediante introspección de tokens |
| `dist/index.js` | stdio (sin interfaz) | MCP stdio | Un token de acceso de usuario en `DIDIT_ACCESS_TOKEN` |

Ambos modos actúan como un **usuario** de Didit. No existe un modo con clave de API de aplicación.

**1. Clona y compila**

```bash theme={null}
git clone https://github.com/didit-protocol/mcp.git && cd mcp
npm install && npm run build
```

O compila el contenedor: `docker build -t didit-mcp .`. La imagen ejecuta `dist/http.js` como usuario sin privilegios de root, expone el puerto 3000 e incluye una comprobación de estado en `/healthz`.

**2. Ejecuta el servidor HTTP (OAuth)**

Copia `.env.example` en `.env` y completa los valores del modo alojado. Después:

```bash theme={null}
node dist/http.js
# or
docker run -p 3000:3000 --env-file .env didit-mcp
```

El servidor actúa únicamente como servidor de recursos OAuth. Necesita que `MCP_RESOURCE_URI` contenga la URL pública completa del transporte (por ejemplo, `https://mcp.example.com/mcp`, no solo el origen) y las credenciales con las que introspecciona tokens (`MCP_OAUTH_CLIENT_ID`, `MCP_OAUTH_CLIENT_SECRET`) frente al servidor de autorización de Didit. La lista completa de variables está en [Avanzado → alojamiento propio](https://docs.didit.me/es/integration/mcp/advanced.md#autoalojamiento).

**3. O ejecútalo por stdio (sin interfaz)**

Para un agente local que no puede completar un flujo OAuth, ejecuta el paquete publicado (no hace falta clonar el repositorio) y pasa un token de acceso de usuario en el entorno:

```bash theme={null}
DIDIT_ACCESS_TOKEN=<user-access-token> npx -y @didit-protocol/mcp-server
```

Desde un clon, `DIDIT_ACCESS_TOKEN=<user-access-token> node dist/index.js` hace lo mismo. Sin un token, el agente puede iniciar sesión con `didit_account_login`, seguido de `didit_account_verify_2fa` si la cuenta tiene activada la autenticación en dos pasos.

Las variables opcionales `MCP_DEFAULT_ORG` y `MCP_DEFAULT_APP` fijan el alcance en configuraciones de un único tenant. Regístralo en Claude Code con:

```bash theme={null}
claude mcp add didit-local -e DIDIT_ACCESS_TOKEN=<user-access-token> -- npx -y @didit-protocol/mcp-server
```

O en el archivo `mcp.json` de Cursor:

```json theme={null}
{
  "mcpServers": {
    "didit-local": {
      "command": "npx",
      "args": ["-y", "@didit-protocol/mcp-server"],
      "env": { "DIDIT_ACCESS_TOKEN": "<user-access-token>" }
    }
  }
}
```

El servidor stdio de código abierto no incluye las herramientas del servidor alojado para Travel Rule, marketplace, red antifraude y tokens del SDK de transacciones, ni sus herramientas de cumplimiento, salvo la de creación de flujos.
Añade `didit_org_top_up`, `didit_org_reveal_application_api_key` y cinco herramientas de configuración de cuenta (`didit_account_register`, `didit_account_verify_email`, `didit_account_resend_otp`, `didit_account_login`, `didit_account_verify_2fa`) que reciben credenciales como argumentos y, por lo tanto, nunca se incluyen en un conector remoto. Las herramientas que reciben archivos también aceptan argumentos `*_path` en stdio, ya que el servidor comparte tu sistema de archivos.

***

## Próximos pasos

> [card] [Autenticación](https://docs.didit.me/es/integration/mcp/authentication.md)
>
> Inicio de sesión, alcances y roles.

> [card] [Referencia de herramientas](https://docs.didit.me/es/integration/mcp/tools.md)
>
> Todo lo que el agente puede invocar.


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