> ## 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 do MCP da Didit e modo só de leitura

> Carregue só as ferramentas MCP da Didit de que precisa com toolsets, ligue-se em modo só de leitura e aceda às outras com pesquisa de ferramentas.

Os conjuntos de ferramentas permitem que uma ligação MCP da Didit carregue uma lista curta de ferramentas em vez de todo o catálogo, e o modo só de leitura oferece uma ligação que nunca pode alterar dados.
Ambos são definidos com um parâmetro no URL do servidor:

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

Sem parâmetro, o servidor lista todas as ferramentas que a sua função pode utilizar, pelo que nada muda numa ligação que já tenha.

## Por que carregar menos ferramentas

O seu cliente envia a definição de cada ferramenta listada ao modelo antes da sua primeira pergunta.
Para todo o catálogo da Didit, isso são dezenas de milhares de tokens em cada pedido: entre cerca de 50.000 e 115.000, consoante o tokenizer do modelo.
Alguns clientes também limitam o número de ferramentas que aceitam.

| O que a ligação carrega | Ferramentas listadas | Parte desses tokens |
| - | - | - |
| Tudo (sem parâmetro) | Todas as ferramentas que a sua função pode usar | Todas |
| A lista curta, `core` | Cerca de 30 | Cerca de um décimo |
| A lista curta, só leitura | Cerca de 20 | Menos de um décimo |

A contrapartida é um passo extra.
Uma ferramenta fora da lista não se perde, mas o modelo tem de a encontrar com [pesquisa de ferramentas](#aceder-às-ferramentas-que-não-carregou) antes de a poder executar, e um modelo que vê todas as ferramentas escolhe a correta um pouco mais vezes do que um modelo que tem de pesquisar.
Carregue tudo quando uma conversa abrange muitas áreas e o custo de contexto não importa.
Carregue `core`, mais os conjuntos de ferramentas que mais usa, quando importa.

## Escolha os seus conjuntos de ferramentas

Adicione `toolsets` ao URL do servidor com uma lista separada por vírgulas:

```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` é a lista curta a partir da qual começa a maior parte do trabalho.
Abrange as suas organizações e aplicações, as sessões de verificação (criar, pesquisar, decidir, explicar, simular no sandbox e consultar as entregas de webhooks), a pesquisa de fluxos de verificação, as análises e o saldo, a chave de API e os webhooks da sua aplicação, a pesquisa de casos, utilizadores, empresas e transações, e a pesquisa na documentação.

* `core`: a lista curta acima.
* `account`: organizações, aplicações, chaves de API, membros e funções.
* `billing`: plano, saldo de créditos, métodos de pagamento, recibos e dados de faturação.
* `sessions`: sessões de verificação (criar, pesquisar, decidir, rever, partilhar, importar, PDFs e entregas de webhooks).
* `workflows`: fluxos de verificação e questionários (criar, editar, validar e publicar).
* `lists`: listas personalizadas, a lista de bloqueio e a lista de permissões.
* `vendors`: as pessoas e as empresas que verifica (utilizadores de fornecedores e empresas de fornecedores).
* `transactions`: monitorização de transações (transações, triagem de carteiras e regras com backtesting).
* `cases`: gestão de casos (criar, atribuir, escalar e resolver casos).
* `investigator`: o Investigator (a sua fila de revisão, relatórios, decisões, perguntas sobre políticas e desempenho).
* `webhooks`: destinos de webhooks e alertas.
* `reports`: análises, exportações e o registo de auditoria.
* `branding`: personalização de marca branca do fluxo de verificação.
* `verification`: APIs de verificação autónomas (documento de identidade, face, AML, comprovativo de morada, telefone, e-mail, verificações de base de dados e de empresas).
* `travel_rule`: Travel Rule (definições, o diretório de VASP, redes, endereços, transferências e mensagens).
* `marketplace`: o mercado de fornecedores (o catálogo, as suas ligações e os pedidos de integração).
* `networks`: redes de fraude (sessões, utilizadores e empresas ligados que partilham um dispositivo, documento ou contacto).
* `compliance`: o assistente de conformidade (o seu perfil regulamentar, os respetivos requisitos e os fluxos gerados a partir deles).
* `docs`: pesquisa na documentação da Didit.
* `all`: todas as ferramentas que a sua função pode utilizar. É a predefinição.

A [referência de ferramentas](https://docs.didit.me/pt/integration/mcp/tools.md) lista todas as ferramentas com o respetivo tipo e a permissão da função de que cada uma precisa.

Como se comporta a seleção:

* **Os conjuntos de ferramentas são opcionais.** Um URL sem `toolsets` lista tudo.
* **Indicar conjuntos lista apenas esses.** `?toolsets=cases` lista as ferramentas de casos, mais `didit_context_get`, que todas as ligações recebem. Acrescente `core` para manter também a lista curta.
* **Um conjunto de ferramentas define o que é listado, não o que pode executar.** Uma ferramenta fora da sua seleção continua a ser executada quando o modelo a chama pelo nome, com as mesmas permissões associadas à função de sempre.
* **Um nome que o servidor não conhece é ignorado.** A ligação continua a funcionar, e o servidor indica ao modelo qual o nome ignorado e quais são os válidos.
* **A sua função continua a aplicar-se.** Um conjunto de ferramentas nunca concede uma permissão: veja [funções e permissões](https://docs.didit.me/pt/integration/mcp/authentication.md#funções-e-permissões).

## Ligar em modo só de leitura

Adicione `read_only=true` ao URL do servidor:

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

Uma ligação só de leitura lista apenas as ferramentas que leem, e o servidor recusa cada chamada que criaria, alteraria ou eliminaria algo.
A recusa acontece no servidor em todas as chamadas, pelo que se mantém mesmo que o seu cliente se lembre de uma ferramenta de uma ligação anterior.
Use-a para relatórios, para explorar uma conta ou para um agente que não deve agir por iniciativa própria.

Para voltar a permitir alterações, ligue sem `read_only`.

## Aceder às ferramentas que não carregou

Quando uma ligação lista apenas parte do catálogo, o servidor acrescenta quatro ferramentas para que nenhuma fique inacessível:

* `didit_tool_search` (leitura): encontra ferramentas pelo que quer fazer ("exportar sessões para CSV") ou lista um único conjunto de ferramentas. Cada resultado indica o que a ferramenta faz, os seus parâmetros e se lê, escreve ou é destrutiva.
* `didit_tool_describe` (leitura): devolve a descrição completa e o esquema de entrada de até cinco ferramentas.
* `didit_tool_call_read` (leitura): executa uma ferramenta só de leitura que não está na lista. Recusa uma ferramenta que altera dados.
* `didit_tool_call_write` (destrutiva): executa uma ferramenta que cria, altera ou elimina dados e que não está na lista. Não é disponibilizada numa ligação só de leitura.

Uma chamada feita através de `didit_tool_call_read` ou `didit_tool_call_write` é verificada exatamente como uma chamada direta: as permissões da sua função, o modo só de leitura e cada exigência de `confirm: true` continuam a aplicar-se.
As duas são separadas para que o seu cliente lhe possa pedir confirmação antes de uma alteração e deixar passar uma consulta.

Com `core` carregado, um pedido como "convidar um novo colega para a minha organização" segue este percurso:

1. O modelo chama `didit_tool_search` com `invite a teammate` e obtém `didit_org_invite_member`, marcada como uma ferramenta de escrita.
2. Chama `didit_tool_call_write`, passando `didit_org_invite_member` como `name` juntamente com os próprios argumentos dessa ferramenta.
3. O seu cliente pede-lhe que aprove a chamada, tal como faz para qualquer ferramenta que altere dados.

Quando tudo está carregado não há nada por descobrir, por isso estas quatro ferramentas não aparecem na lista.

## Configurar no seu cliente

Use os mesmos passos do [guia de instalação](https://docs.didit.me/pt/integration/mcp/installation.md), mas com os parâmetros acrescentados ao URL.

> [tab] Claude Code
>
> ```bash theme={null}
> claude mcp add --transport http didit "https://mcp.didit.me/mcp?toolsets=core"
> ```
>
> Mantenha as aspas: caso contrário, a sua shell interpretaria o `?` e o `&`.

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

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

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

> [tab] Claude web e Desktop
>
> Abra **Settings**, depois **Connectors**, depois **Add custom connector**, e cole o URL com os respetivos parâmetros:
>
> ```text theme={null}
> https://mcp.didit.me/mcp?toolsets=core
> ```

> [tab] Servidor local
>
> O servidor local aceita opções (flags) ou variáveis de ambiente:
>
> ```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
> ```

Se o seu cliente permitir definir cabeçalhos, mas não editar o URL, envie em vez disso `X-MCP-Toolsets: core,workflows` e `X-MCP-Readonly: true`.
Para os toolsets, um valor no URL tem prioridade sobre o cabeçalho, e o modo só de leitura fica ativo sempre que um dos dois o pedir.

> [!NOTE]
>
> O plugin do ChatGPT usa um catálogo próprio, fixo e reduzido, em `https://mcp.didit.me/mcp/chatgpt`.
> Os toolsets e o modo só de leitura não se aplicam a ele.
> Consulte [Ligar o ChatGPT](https://docs.didit.me/pt/integration/mcp/chatgpt.md).

## Prompts, instruções e pesquisa na documentação

O servidor ajuda o modelo a começar pelo sítio certo:

* **Instruções.** Ao ligar-se, o servidor indica ao modelo que comece por `didit_context_get`, como `organization_id` e `application_id` são resolvidos, que crie numa aplicação sandbox e quais os conjuntos de ferramentas que esta ligação carregou.
* **Prompts.** Os clientes que suportam prompts MCP apresentam cinco pontos de partida: `integrate_didit`, `review_queue`, `explain_session`, `build_workflow` e `verification_report`. No Claude Code, aparecem como comandos de barra.
* **Pesquisa na documentação.** `didit_docs_search` pesquisa estas páginas da documentação e devolve as secções correspondentes com as respetivas ligações, para que as perguntas sobre o funcionamento da Didit sejam respondidas com base nas páginas atuais.

## Verificar o que uma ligação carregou

Pergunte ao seu cliente:

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

O modelo responde com base nas instruções do servidor.
Para confirmar que um servidor suporta conjuntos de ferramentas antes de depender deles, consulte o seu endpoint de estado:

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

A resposta lista `toolsets` e `read_only` em `features`.

## Próximos passos

> [card] [Instalação](https://docs.didit.me/pt/integration/mcp/installation.md)
>
> Ligue o Claude, o ChatGPT, o Cursor, o VS Code, o Codex ou qualquer cliente MCP.

> [card] [Referência das ferramentas](https://docs.didit.me/pt/integration/mcp/tools.md)
>
> Todas as ferramentas, o respetivo tipo e a permissão de função de que cada uma precisa.

> [card] [Autenticação](https://docs.didit.me/pt/integration/mcp/authentication.md)
>
> Inicie sessão com a Didit, os âmbitos e as permissões de função.

> [card] [Exemplos de instruções](https://docs.didit.me/pt/integration/mcp/examples.md)
>
> Instruções que funcionam desde o primeiro dia.


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