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

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

> Installa il server MCP Didit in Claude, Cursor, VS Code, Windsurf, Zed o altro client MCP. Open-source self-hosted disponibile. Senza chiavi API.

Scegli il client qui sotto. Il server **ospitato** (`https://mcp.didit.me/mcp`) non richiede alcuna chiave API: al primo collegamento il client apre un browser e tu [accedi con Didit](https://docs.didit.me/it/integration/mcp/authentication.md) e approvi le autorizzazioni.

> [!TIP]
>
> **Usi Claude?** La pagina [Connect Claude](https://docs.didit.me/it/integration/mcp/claude.md) contiene il link del connettore con un clic, che apre la finestra **Add custom connector** con nome e URL già compilati: ti basta confermare e accedere.

> [!NOTE]
>
> I client che non supportano ancora MCP remoto/HTTP (Windsurf, Zed) si collegano tramite il bridge `mcp-remote`, che inoltra lo stdio all'URL del server ospitato e gestisce per te l'handshake OAuth.

***

## Server ospitato (consigliato)

> [tab] Claude Code
>
> Aggiungi il server con la CLI, poi avvia l'accesso:
>
> ```bash theme={null}
> claude mcp add --transport http didit https://mcp.didit.me/mcp
> ```
>
> Avvia Claude Code ed esegui `/mcp`: si apre il browser per **accedere con Didit**. Dopo aver approvato, gli strumenti `didit` sono disponibili.

> [tab] Claude web e Desktop
>
> Web: fai clic su [**Add Didit to Claude →**](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Didit\&connectorUrl=https://mcp.didit.me/mcp) e conferma la finestra precompilata.
>
> Desktop: vai su **Settings → Connectors → Add custom connector**, assegna il nome `Didit` e imposta l'URL su:
>
> ```text theme={null}
> https://mcp.didit.me/mcp
> ```
>
> Fai clic su **Collega** e completa **Accedi con Didit** nel browser. Gli strumenti Didit compaiono poi nel menu degli strumenti della chat.

> [tab] Cursor
>
> Aggiungi a `~/.cursor/mcp.json` (globale) o a `.cursor/mcp.json` (per progetto):
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> Oppure usa **Settings → Tools & Integrations → New MCP Server**. Cursor si registra presso Didit tramite Dynamic Client Registration e, al primo utilizzo, apre il browser per l'accesso.

> [tab] VS Code
>
> Con la modalità agente di GitHub Copilot, aggiungi `.vscode/mcp.json`:
>
> ```json theme={null}
> {
>   "servers": {
>     "didit": {
>       "type": "http",
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> Oppure esegui **MCP: Add Server** dalla tavolozza dei comandi e scegli **HTTP**. Accedi quando richiesto. Indica a VS Code l'URL completo `/mcp`: il server pubblica i metadati della risorsa OAuth per quel percorso.

> [tab] Windsurf
>
> Windsurf si collega tramite il bridge `mcp-remote`. Aggiungi a `~/.codeium/windsurf/mcp_config.json`:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "command": "npx",
>       "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"]
>     }
>   }
> }
> ```
>
> Apri **Settings → Cascade → MCP Servers → Manage** per verificare che sia stato caricato, poi accedi tramite il browser.

> [tab] Zed
>
> Aggiungi un server di contesto nel file `settings.json` di Zed:
>
> ```json theme={null}
> {
>   "context_servers": {
>     "didit": {
>       "source": "custom",
>       "command": "npx",
>       "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"]
>     }
>   }
> }
> ```
>
> Zed avvia il bridge e apre il browser per **Accedi con Didit**.

> [tab] Qualsiasi altro client
>
> Qualsiasi client che implementa MCP su **Streamable HTTP** con **OAuth 2.1** può collegarsi direttamente a `https://mcp.didit.me/mcp`. Individua il server di autorizzazione tramite `https://mcp.didit.me/.well-known/oauth-protected-resource/mcp`, si registra con Dynamic Client Registration ed esegue il flusso PKCE. Il server accetta solo `POST` su `/mcp`; `GET` e `DELETE` restituiscono `405`, perché è senza stato e non mantiene alcun flusso avviato dal server.
>
> Un client che supporta solo stdio può usare lo stesso bridge `mcp-remote` di Windsurf e Zed:
>
> ```bash theme={null}
> npx -y mcp-remote@latest https://mcp.didit.me/mcp
> ```
>
> Per provare il server senza un client, [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) si collega allo stesso URL e ti guida nell'accesso.

> [!NOTE]
>
> **Nessuna chiave API nella configurazione.** Il server ospitato ti autentica nel browser e agisce in tua vece in tutte le organizzazioni di cui fai parte, con le autorizzazioni del tuo ruolo. Vedi [Authentication](https://docs.didit.me/it/integration/mcp/authentication.md).

Il server ospitato risponde a `GET https://mcp.didit.me/healthz` con la sua versione.

***

## Verifica la connessione

Dopo aver effettuato l'accesso, chiedi al tuo client:

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

L'agente dovrebbe chiamare `didit_context_get` e mostrare le tue organizzazioni con le rispettive applicazioni.
Se risponde che non ha strumenti Didit, il server non si è collegato oppure l'accesso non è stato completato: vedi [Troubleshooting](https://docs.didit.me/it/integration/mcp/advanced.md#risoluzione-dei-problemi).

## Self-hosting

Il server ospitato è costruito dal repository open source [github.com/didit-protocol/mcp](https://github.com/didit-protocol/mcp) (MIT). Ogni release è anche pubblicata su npm come [`@didit-protocol/mcp-server`](https://www.npmjs.com/package/@didit-protocol/mcp-server), quindi puoi eseguire il server stdio direttamente da npm oppure compilare uno dei due punti di ingresso da un clone. Un'unica base di codice include due punti di ingresso:

| Punto di ingresso | Modalità | Trasporto | Autenticazione |
| - | - | - | - |
| `dist/http.js` | Ospitata | Streamable HTTP su `MCP_PORT` (predefinita 3000), `POST /mcp`, `GET /healthz` | OAuth 2.1 Bearer, validata tramite introspezione dei token |
| `dist/index.js` | stdio (headless) | MCP stdio | Un token di accesso utente in `DIDIT_ACCESS_TOKEN` |

Entrambe le modalità agiscono come **utente** Didit. Non esiste una modalità con chiave API dell'applicazione.

**1. Clona e compila**

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

Oppure compila il container: `docker build -t didit-mcp .`. L'immagine esegue `dist/http.js` come utente non root, espone la porta 3000 e ha un controllo dello stato su `/healthz`.

**2. Avvia il server HTTP (OAuth)**

Copia `.env.example` in `.env`, compila i valori della modalità ospitata, quindi:

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

Il server è esclusivamente un server delle risorse OAuth. Richiede che `MCP_RESOURCE_URI` sia impostato sull'URL pubblico completo del trasporto (ad esempio `https://mcp.example.com/mcp`, non la sola origine) e le credenziali che usa per eseguire l'introspezione dei token (`MCP_OAUTH_CLIENT_ID`, `MCP_OAUTH_CLIENT_SECRET`) presso il server di autorizzazione Didit. L'elenco completo delle variabili è in [Avanzate → hosting autonomo](https://docs.didit.me/it/integration/mcp/advanced.md#self-hosting).

**3. Oppure eseguilo tramite stdio (headless)**

Per un agente locale che non può eseguire un flusso OAuth, esegui il pacchetto pubblicato (non serve un clone) e passa un token di accesso utente nell'ambiente:

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

Da un clone, `DIDIT_ACCESS_TOKEN=<user-access-token> node dist/index.js` fa lo stesso. Senza token, l'agente può accedere con `didit_account_login`, seguito da `didit_account_verify_2fa` quando l'account ha l'autenticazione a due fattori.

Le variabili facoltative `MCP_DEFAULT_ORG` e `MCP_DEFAULT_APP` fissano l'ambito per configurazioni a tenant singolo. Registralo in Claude Code con:

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

Oppure nel file `mcp.json` di Cursor:

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

Il server stdio open source non include gli strumenti del server ospitato per Travel Rule, marketplace, rete antifrode e token dell'SDK delle transazioni, né gli strumenti di conformità, ad eccezione della creazione di workflow.
Aggiunge `didit_org_top_up`, `didit_org_reveal_application_api_key` e cinque strumenti di configurazione dell'account (`didit_account_register`, `didit_account_verify_email`, `didit_account_resend_otp`, `didit_account_login`, `didit_account_verify_2fa`) che ricevono le credenziali come argomenti e pertanto non vengono mai distribuiti su un connettore remoto. Anche gli strumenti che accettano file prevedono argomenti `*_path` su stdio, poiché il server condivide il tuo filesystem.

***

## Prossimi passi

> [card] [Autenticazione](https://docs.didit.me/it/integration/mcp/authentication.md)
>
> Accesso, scope e ruoli.

> [card] [Riferimento agli strumenti](https://docs.didit.me/it/integration/mcp/tools.md)
>
> Tutto ciò che l'agente può chiamare.


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