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

# Instal·lar MCP Didit: Claude, Cursor, VS Code, Windsurf

> Configura el servidor MCP allotjat de Didit a Claude, Cursor, VS Code, Windsurf, Zed o qualsevol client MCP, o autoallotja'l. Sense claus d'API.

Tria el teu client a continuació. El servidor **allotjat** (`https://mcp.didit.me/mcp`) no necessita clau d'API: en connectar-te per primera vegada, el client obre un navegador, fas clic a **[Iniciar sessió amb Didit](https://docs.didit.me/ca/integration/mcp/authentication.md)** i aprovas els permisos.

> [!TIP]
>
> **Fas servir Claude?** La pàgina [Connecta Claude](https://docs.didit.me/ca/integration/mcp/claude.md) té l'enllaç del connector d'un sol clic, que obre el diàleg **Add custom connector** amb el nom i la URL ja omplerts, així que només has de confirmar i iniciar sessió.

> [!NOTE]
>
> Els clients que encara no admeten MCP remot/HTTP (Windsurf, Zed) es connecten mitjançant el pont `mcp-remote`, que redirigeix stdio cap a la URL allotjada i gestiona per tu l'intercanvi d'OAuth.

***

## Servidor allotjat (recomanat)

> [tab] Claude Code
>
> Afegeix el servidor amb la CLI i després activa l'inici de sessió:
>
> ```bash theme={null}
> claude mcp add --transport http didit https://mcp.didit.me/mcp
> ```
>
> Inicia Claude Code i executa `/mcp`: s'obrirà el navegador perquè iniciïs sessió amb Didit. Després d'aprovar-ho, les eines `didit` estaran disponibles.

> [tab] Claude web i Desktop
>
> Web: fes clic a [**Afegeix Didit a Claude →**](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Didit\&connectorUrl=https://mcp.didit.me/mcp) i confirma el diàleg amb els camps ja omplerts.
>
> Desktop: **Settings → Connectors → Add custom connector**, posa-li el nom `Didit` i estableix la URL a:
>
> ```text theme={null}
> https://mcp.didit.me/mcp
> ```
>
> Fes clic a **Connect** i completa el procés d'iniciar sessió amb Didit al navegador. Les eines de Didit apareixeran després al menú d'eines del xat.

> [tab] Cursor
>
> Afegeix a `~/.cursor/mcp.json` (global) o a `.cursor/mcp.json` (per projecte):
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> O bé fes servir **Settings → Tools & Integrations → New MCP Server**. Cursor es registra a Didit mitjançant Dynamic Client Registration i obre el navegador per iniciar sessió la primera vegada que l'utilitzes.

> [tab] VS Code
>
> Amb el mode agent de GitHub Copilot, afegeix `.vscode/mcp.json`:
>
> ```json theme={null}
> {
>   "servers": {
>     "didit": {
>       "type": "http",
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> O bé executa **MCP: Add Server** des de la paleta de comandaments i tria **HTTP**. Inicia sessió quan se't demani. Indica a VS Code la URL completa `/mcp`: el servidor publica les seves metadades del recurs OAuth per a aquesta ruta.

> [tab] Windsurf
>
> Windsurf es connecta mitjançant el pont `mcp-remote`. Afegeix a `~/.codeium/windsurf/mcp_config.json`:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "command": "npx",
>       "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"]
>     }
>   }
> }
> ```
>
> Obre **Settings → Cascade → MCP Servers → Manage** per confirmar que s'ha carregat i després inicia sessió des del navegador.

> [tab] Zed
>
> Afegeix un servidor de context al fitxer `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 pont i obre el navegador per a **Iniciar sessió amb Didit**.

> [tab] Qualsevol altre client
>
> Qualsevol client que implementi MCP sobre **Streamable HTTP** amb **OAuth 2.1** pot connectar-se directament a `https://mcp.didit.me/mcp`. Descobreix el servidor d'autorització a partir de `https://mcp.didit.me/.well-known/oauth-protected-resource/mcp`, es registra amb Dynamic Client Registration i executa el flux PKCE. El servidor només accepta `POST` a `/mcp`; `GET` i `DELETE` responen amb `405`, perquè no manté estat i no manté cap flux iniciat pel servidor.
>
> Un client que només parla stdio pot fer servir el mateix pont `mcp-remote` que Windsurf i Zed:
>
> ```bash theme={null}
> npx -y mcp-remote@latest https://mcp.didit.me/mcp
> ```
>
> Per provar el servidor sense client, el [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) es connecta a la mateixa URL i et guia durant l'inici de sessió.

> [!NOTE]
>
> **Sense clau d'API a la configuració.** El servidor allotjat t'autentica al navegador i actua en nom teu a totes les organitzacions de les quals ets membre, amb els permisos del teu rol. Consulta [Autenticació](https://docs.didit.me/ca/integration/mcp/authentication.md).

El servidor allotjat respon a `GET https://mcp.didit.me/healthz` amb la seva versió.

***

## Verifica la connexió

Després d'iniciar sessió, demana al teu client:

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

L'agent hauria de cridar `didit_context_get` i mostrar les teves organitzacions amb les seves aplicacions.
Si diu que no té eines de Didit, el servidor no s'ha connectat o l'inici de sessió no s'ha completat: consulta [Resolució de problemes](https://docs.didit.me/ca/integration/mcp/advanced.md#resolució-de-problemes).

## Autoallotjament

El servidor allotjat es compila a partir del repositori de codi obert [github.com/didit-protocol/mcp](https://github.com/didit-protocol/mcp) (MIT). Cada versió també es publica a npm com a [`@didit-protocol/mcp-server`](https://www.npmjs.com/package/@didit-protocol/mcp-server), de manera que pots executar el servidor stdio directament des de npm o compilar qualsevol dels dos punts d'entrada des d'un clon. Una mateixa base de codi conté dos punts d'entrada:

| Punt d'entrada | Mode | Transport | Autenticació |
| - | - | - | - |
| `dist/http.js` | Allotjat | HTTP en flux (Streamable HTTP) al `MCP_PORT` (per defecte 3000), `POST /mcp`, `GET /healthz` | Bearer OAuth 2.1, validat mitjançant introspecció de tokens |
| `dist/index.js` | stdio (sense interfície) | MCP stdio | Un token d'accés d'usuari a `DIDIT_ACCESS_TOKEN` |

Tots dos modes actuen com a **usuari** de Didit. No hi ha un mode de clau d'API d'aplicació.

**1. Clona i compila**

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

O crea el contenidor: `docker build -t didit-mcp .`. La imatge executa `dist/http.js` com a usuari no root, exposa el port 3000 i té una comprovació d'estat a `/healthz`.

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

Copia `.env.example` a `.env`, omple els valors del mode allotjat i, després, executa:

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

El servidor només és un servidor de recursos OAuth. Necessita que `MCP_RESOURCE_URI` estigui definit amb l'URL pública completa del transport (per exemple `https://mcp.example.com/mcp`, no només l'origen) i les credencials que utilitza per fer la introspecció de tokens (`MCP_OAUTH_CLIENT_ID`, `MCP_OAUTH_CLIENT_SECRET`) davant del servidor d'autorització de Didit. La llista completa de variables és a [Avançat → autoallotjament](https://docs.didit.me/ca/integration/mcp/advanced.md#autoallotjament).

**3. O executa-ho per stdio (sense interfície)**

Per a un agent local que no pot fer un flux OAuth, executa el paquet publicat (no cal clonar res) i passa un token d'accés d'usuari a l'entorn:

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

Des d'un clon, `DIDIT_ACCESS_TOKEN=<user-access-token> node dist/index.js` fa el mateix. Sense token, l'agent pot iniciar sessió amb `didit_account_login`, seguit de `didit_account_verify_2fa` quan el compte té l'autenticació de dos factors activada.

Les variables opcionals `MCP_DEFAULT_ORG` i `MCP_DEFAULT_APP` fixen l'àmbit per a configuracions d'un sol inquilí. Registra-ho a Claude Code amb:

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

O al fitxer `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 codi obert no inclou les eines de Travel Rule, del mercat, de la xarxa de frau ni les eines de tokens de l'SDK de transaccions del servidor allotjat, ni les seves eines de compliment, tret de les que permeten crear un flux de treball. Sí que afegeix `didit_org_top_up`, `didit_org_reveal_application_api_key` i cinc eines de configuració del compte (`didit_account_register`, `didit_account_verify_email`, `didit_account_resend_otp`, `didit_account_login`, `didit_account_verify_2fa`), que reben les credencials com a arguments i, per tant, mai no es distribueixen en un connector remot. Les eines que reben fitxers també accepten arguments `*_path` en stdio, perquè el servidor comparteix el sistema de fitxers.

***

## Següents passos

> [card] [Autenticació](https://docs.didit.me/ca/integration/mcp/authentication.md)
>
> Inici de sessió, àmbits i rols.

> [card] [Referència d'eines](https://docs.didit.me/ca/integration/mcp/tools.md)
>
> Tot el que l'agent pot cridar.


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