> ## 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 o MCP Didit: Claude, Cursor, VS Code, Windsurf

> Configure o servidor MCP da Didit no Claude, Cursor, VS Code, Windsurf, Zed ou noutro cliente MCP, ou aloje a versão open-source. Sem chaves de API.

Escolha o seu cliente abaixo. O servidor **alojado** (`https://mcp.didit.me/mcp`) não precisa de chave de API. Ao ligar pela primeira vez, o cliente abre um navegador, você **[inicia sessão com a Didit](https://docs.didit.me/pt/integration/mcp/authentication.md)** e aprova as permissões.

> [!TIP]
>
> **A usar o Claude?** A página [Ligar o Claude](https://docs.didit.me/pt/integration/mcp/claude.md) tem a ligação do conector de um clique, que abre a caixa de diálogo **Add custom connector** com o nome e o URL já preenchidos. Só tem de confirmar e iniciar sessão.

> [!NOTE]
>
> Os clientes que ainda não suportam MCP remoto/HTTP (Windsurf, Zed) ligam-se através da ponte `mcp-remote`, que encaminha stdio para o URL alojado e trata do handshake OAuth por si.

***

## Servidor alojado (recomendado)

> [tab] Claude Code
>
> Adicione o servidor com a CLI e, depois, inicie sessão:
>
> ```bash theme={null}
> claude mcp add --transport http didit https://mcp.didit.me/mcp
> ```
>
> Inicie o Claude Code e execute `/mcp`. Isto abre o navegador para **Iniciar sessão com a Didit**. Depois de aprovar, as ferramentas `didit` ficam disponíveis.

> [tab] Claude web e Desktop
>
> Web: clique em [**Add Didit to Claude →**](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Didit\&connectorUrl=https://mcp.didit.me/mcp) e confirme a caixa de diálogo com os campos previamente preenchidos.
>
> Desktop: **Settings → Connectors → Add custom connector**, dê-lhe o nome `Didit` e defina o URL como:
>
> ```text theme={null}
> https://mcp.didit.me/mcp
> ```
>
> Clique em **Ligar** e conclua o início de sessão com a Didit no navegador. As ferramentas da Didit passam a aparecer no menu de ferramentas do chat.

> [tab] Cursor
>
> Adicione ao ficheiro `~/.cursor/mcp.json` (global) ou `.cursor/mcp.json` (por projeto):
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> Ou use **Settings → Tools & Integrations → New MCP Server**. O Cursor regista-se com a Didit através de Dynamic Client Registration e abre o navegador para o início de sessão na primeira utilização.

> [tab] VS Code
>
> Com o modo de agente do GitHub Copilot, adicione o ficheiro `.vscode/mcp.json`:
>
> ```json theme={null}
> {
>   "servers": {
>     "didit": {
>       "type": "http",
>       "url": "https://mcp.didit.me/mcp"
>     }
>   }
> }
> ```
>
> Ou execute **MCP: Add Server** na paleta de comandos e escolha **HTTP**. Inicie sessão quando for solicitado. Aponte o VS Code para o URL completo do endpoint `/mcp`, porque o servidor publica os metadados do recurso OAuth para esse caminho.

> [tab] Windsurf
>
> O Windsurf liga-se através da ponte `mcp-remote`. Adicione ao ficheiro `~/.codeium/windsurf/mcp_config.json`:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "didit": {
>       "command": "npx",
>       "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"]
>     }
>   }
> }
> ```
>
> Abra **Settings → Cascade → MCP Servers → Manage** para confirmar que foi carregado e, depois, inicie sessão através do navegador.

> [tab] Zed
>
> Adicione um servidor de contexto ao ficheiro `settings.json` do Zed:
>
> ```json theme={null}
> {
>   "context_servers": {
>     "didit": {
>       "source": "custom",
>       "command": "npx",
>       "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"]
>     }
>   }
> }
> ```
>
> O Zed inicia a ponte e abre o navegador para **Iniciar sessão com a Didit**.

> [tab] Qualquer outro cliente
>
> Qualquer cliente que implemente MCP sobre **Streamable HTTP** com **OAuth 2.1** pode ligar-se diretamente a `https://mcp.didit.me/mcp`. Descobre o servidor de autorização a partir de `https://mcp.didit.me/.well-known/oauth-protected-resource/mcp`, regista-se com Dynamic Client Registration e executa o fluxo PKCE. O servidor aceita apenas `POST` em `/mcp`. `GET` e `DELETE` respondem com `405`, porque não tem estado e não mantém um fluxo iniciado pelo servidor.
>
> Um cliente que fale apenas stdio pode usar a mesma ponte `mcp-remote` que o Windsurf e o Zed:
>
> ```bash theme={null}
> npx -y mcp-remote@latest https://mcp.didit.me/mcp
> ```
>
> Para experimentar o servidor sem cliente, o [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) liga-se ao mesmo URL e orienta-o durante o início de sessão.

> [!NOTE]
>
> **Sem chave de API na configuração.** O servidor alojado autentica-o no navegador e atua em seu nome, em todas as organizações a que pertence, com as permissões da sua função. Veja [Autenticação](https://docs.didit.me/pt/integration/mcp/authentication.md).

O servidor alojado responde a `GET https://mcp.didit.me/healthz` com a sua versão.

***

## Verificar a ligação

Depois de iniciar sessão, pergunte ao seu cliente:

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

O agente deve chamar `didit_context_get` e mostrar as suas organizações com as respetivas aplicações.
Se disser que não tem ferramentas da Didit, o servidor não se ligou ou o início de sessão não foi concluído. Veja [Resolução de problemas](https://docs.didit.me/pt/integration/mcp/advanced.md#resolução-de-problemas).

## Alojamento próprio

O servidor alojado é criado a partir do repositório de código aberto [github.com/didit-protocol/mcp](https://github.com/didit-protocol/mcp) (MIT). Cada versão é também publicada no npm como [`@didit-protocol/mcp-server`](https://www.npmjs.com/package/@didit-protocol/mcp-server), por isso pode executar o servidor stdio diretamente a partir do npm ou compilar qualquer um dos pontos de entrada a partir de um clone. Uma única base de código inclui dois pontos de entrada:

| Ponto de entrada | Modo | Transporte | Autenticação |
| - | - | - | - |
| `dist/http.js` | Alojado | HTTP em transmissão contínua (Streamable HTTP) em `MCP_PORT` (predefinição 3000), `POST /mcp`, `GET /healthz` | OAuth 2.1 Bearer, validado por introspeção de token |
| `dist/index.js` | stdio (sem interface) | MCP stdio | Um token de acesso de utilizador em `DIDIT_ACCESS_TOKEN` |

Ambos os modos atuam como um **utilizador** da Didit. Não existe um modo de chave de API de aplicação.

**1. Clonar e compilar**

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

Ou crie o contentor: `docker build -t didit-mcp .`. A imagem executa `dist/http.js` com um utilizador sem privilégios de root, expõe a porta 3000 e tem uma verificação de estado em `/healthz`.

**2. Executar o servidor HTTP (OAuth)**

Copie `.env.example` para `.env`, preencha os valores do modo alojado e, em seguida, execute:

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

O servidor é apenas um servidor de recursos OAuth. Precisa de `MCP_RESOURCE_URI` definido com o URL público completo do transporte (por exemplo `https://mcp.example.com/mcp`, e não apenas a origem) e das credenciais que usa para validar tokens por introspeção (`MCP_OAUTH_CLIENT_ID`, `MCP_OAUTH_CLIENT_SECRET`) junto do servidor de autorização da Didit. A lista completa de variáveis está em [Avançado → alojamento próprio](https://docs.didit.me/pt/integration/mcp/advanced.md#auto-alojamento).

**3. Ou executar por stdio (sem interface)**

Para um agente local que não consegue executar um fluxo OAuth, execute o pacote publicado (não é necessário clonar) e passe um token de acesso de utilizador no ambiente:

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

A partir de um clone, `DIDIT_ACCESS_TOKEN=<user-access-token> node dist/index.js` faz o mesmo. Sem token, o agente pode iniciar sessão com `didit_account_login`, seguido de `didit_account_verify_2fa` quando a conta tiver autenticação de dois fatores.

As variáveis opcionais `MCP_DEFAULT_ORG` e `MCP_DEFAULT_APP` fixam o âmbito para configurações de um único inquilino. Registe-o no Claude Code com:

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

Ou no `mcp.json` do Cursor:

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

O servidor stdio de código aberto não inclui as ferramentas do servidor alojado para Travel Rule, marketplace, rede antifraude e tokens do SDK de transações, nem as suas ferramentas de conformidade além da criação de um fluxo.
Inclui `didit_org_top_up`, `didit_org_reveal_application_api_key` e cinco ferramentas de configuração de conta (`didit_account_register`, `didit_account_verify_email`, `didit_account_resend_otp`, `didit_account_login`, `didit_account_verify_2fa`), que recebem as credenciais como argumentos e, por isso, nunca são disponibilizadas num conector remoto. As ferramentas que recebem ficheiros também aceitam argumentos `*_path` em stdio, porque o servidor partilha o seu sistema de ficheiros.

***

## Próximos passos

> [card] [Autenticação](https://docs.didit.me/pt/integration/mcp/authentication.md)
>
> Início de sessão, âmbitos e funções.

> [card] [Referência de ferramentas](https://docs.didit.me/pt/integration/mcp/tools.md)
>
> Tudo o que o agente pode chamar.


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