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

# Didit MCP-Toolsets und Nur-Lese-Modus

> Laden Sie mit Didit MCP-Toolsets nur die benötigten Tools, verbinden Sie sich im Nur-Lese-Modus und erreichen Sie alle weiteren Tools per Tool-Suche.

Mit Toolsets lädt eine Didit-MCP-Verbindung eine kurze Liste von Tools statt des gesamten Katalogs, und der Nur-Lese-Modus liefert eine Verbindung, die niemals Daten ändern kann.
Beide werden als Parameter in der Server-URL festgelegt:

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

Ohne Parameter listet der Server jedes Tool auf, das Ihre Rolle verwenden darf. Für eine bestehende Verbindung ändert sich dadurch also nichts.

## Warum weniger Tools laden

Ihr Client sendet die Definition jedes aufgelisteten Tools an das Modell, bevor Sie Ihre erste Frage stellen.
Für den gesamten Didit-Katalog sind das Zehntausende Tokens bei jeder Anfrage, grob 50.000 bis 115.000, je nach Tokenizer des Modells.
Manche Clients begrenzen außerdem, wie viele Tools sie akzeptieren.

| Was die Verbindung lädt | Aufgelistete Tools | Anteil dieser Tokens |
| - | - | - |
| Alles (kein Parameter) | Jedes Tool, das Ihre Rolle nutzen darf | Alle davon |
| Die kurze Liste, `core` | Etwa 30 | Etwa ein Zehntel |
| Die kurze Liste, schreibgeschützt | Etwa 20 | Weniger als ein Zehntel |

Der Kompromiss ist ein zusätzlicher Schritt.
Ein Tool außerhalb der Liste geht nicht verloren, aber das Modell muss es erst mit der [Tool-Suche](#auf-tools-zugreifen-die-sie-nicht-geladen-haben) finden, bevor es das Tool ausführen kann. Ein Modell, das alle Tools sieht, wählt das richtige etwas häufiger aus als ein Modell, das suchen muss.
Laden Sie alle Tools, wenn eine Unterhaltung viele Bereiche umfasst und die Kosten für den Kontext keine Rolle spielen.
Laden Sie `core` plus die Toolsets, die Sie am häufigsten nutzen, wenn die Kontextkosten eine Rolle spielen.

## Toolsets wählen

Fügen Sie `toolsets` mit einer durch Kommas getrennten Liste an die Server-URL an:

```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` ist die kurze Liste, mit der die meisten Arbeiten beginnen.
Sie umfasst Ihre Organisationen und Anwendungen, Verifizierungssitzungen (erstellen, suchen, entscheiden, erklären, in der Sandbox simulieren und Webhook-Zustellungen abrufen), das Suchen von Workflows, Analysen und Guthaben, den API-Schlüssel Ihrer Anwendung und Webhooks, das Suchen von Fällen, Benutzern, Unternehmen und Transaktionen sowie die Suche in der Dokumentation.

* `core`: die oben beschriebene kurze Liste.
* `account`: Organisationen, Anwendungen, API-Schlüssel, Mitglieder und Rollen.
* `billing`: Tarif, Guthaben, Zahlungsmethoden, Belege und Rechnungsdaten.
* `sessions`: Verifizierungssitzungen (erstellen, suchen, entscheiden, prüfen, teilen, importieren, PDFs und Webhook-Zustellungen).
* `workflows`: Verifizierungs-Workflows und Fragebögen (erstellen, bearbeiten, validieren und veröffentlichen).
* `lists`: benutzerdefinierte Listen, die Sperrliste und die Zulassungsliste.
* `vendors`: die Personen und Unternehmen, die Sie verifizieren (Anbieterbenutzer und Anbieterunternehmen).
* `transactions`: Transaktionsüberwachung (Transaktionen, Wallet-Screening und Regeln mit Backtesting).
* `cases`: Fallmanagement (Fälle erstellen, zuweisen, eskalieren und abschließen).
* `investigator`: der Investigator (seine Prüfwarteschlange, Berichte, Entscheidungen, Richtlinienfragen und Leistung).
* `webhooks`: Webhook-Ziele und Alerts.
* `reports`: Analysen, Exporte und das Audit-Log.
* `branding`: White-Label-Branding des Verifizierungsablaufs.
* `verification`: eigenständige Verifizierungs-APIs (Ausweisdokument, Gesicht, AML, Adressnachweis, Telefon, E-Mail, Datenbankvalidierung und Unternehmensprüfungen).
* `travel_rule`: Travel Rule (Einstellungen, das VASP-Verzeichnis, Netzwerke, Wallet-Adressen, Transfers und Nachrichten).
* `marketplace`: der Anbieter-Marktplatz (der Katalog, Ihre Verbindungen und Integrationsanfragen).
* `networks`: Betrugsnetzwerke (verknüpfte Sitzungen, Benutzer und Unternehmen, die ein Gerät, ein Dokument oder einen Kontakt teilen).
* `compliance`: der Compliance-Assistent (Ihr regulatorisches Profil, dessen Anforderungen und die daraus erzeugten Workflows).
* `docs`: Suche in der Didit-Dokumentation.
* `all`: jedes Tool, das Ihre Rolle verwenden darf. Dies ist der Standard.

Die [Tool-Referenz](https://docs.didit.me/de/integration/mcp/tools.md) listet jedes Tool mit seinem Typ und der Rollenberechtigung auf, die es benötigt.

So verhält sich die Auswahl:

* **Toolsets müssen ausdrücklich aktiviert werden.** Eine URL ohne `toolsets` listet alles auf.
* **Wenn Sie Toolsets benennen, werden genau diese aufgelistet.** `?toolsets=cases` listet die Fall-Tools sowie `didit_context_get`, das jede Verbindung erhält. Fügen Sie `core` hinzu, um auch die kurze Liste zu behalten.
* **Ein Toolset bestimmt, was aufgelistet wird, nicht, was Sie ausführen dürfen.** Ein Tool außerhalb Ihrer Auswahl wird weiterhin ausgeführt, wenn das Modell es namentlich aufruft, mit denselben Rollenberechtigungen wie immer.
* **Ein Name, den der Server nicht kennt, wird ignoriert.** Die Verbindung funktioniert trotzdem, und der Server teilt dem Modell mit, welcher Name ignoriert wurde und welche Namen gültig sind.
* **Ihre Rolle gilt weiterhin.** Ein Toolset gewährt niemals eine Berechtigung: Siehe [Rollen und Berechtigungen](https://docs.didit.me/de/integration/mcp/authentication.md#rollen-und-berechtigungen).

## Im Nur-Lese-Modus verbinden

Fügen Sie `read_only=true` zur Server-URL hinzu:

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

Eine Verbindung im Nur-Lese-Modus listet nur Tools auf, die Daten lesen, und der Server lehnt jeden Aufruf ab, der etwas erstellen, ändern oder löschen würde.
Die Ablehnung erfolgt bei jedem Aufruf auf dem Server. Sie gilt daher auch dann, wenn sich Ihr Client ein Tool aus einer früheren Verbindung merkt.
Nutzen Sie diesen Modus für Reporting, zum Erkunden eines Kontos oder für einen Agenten, der nicht selbstständig handeln soll.

Um Änderungen wieder zu erlauben, verbinden Sie sich ohne `read_only`.

## Auf Tools zugreifen, die Sie nicht geladen haben

Wenn eine Verbindung nur einen Teil des Katalogs auflistet, fügt der Server vier Tools hinzu, damit alles erreichbar bleibt:

* `didit_tool_search` (Lesezugriff): findet Tools anhand dessen, was Sie tun möchten („Sitzungen als CSV exportieren“), oder listet ein Toolset auf. Jeder Treffer beschreibt, was das Tool tut, welche Parameter es hat und ob es liest, schreibt oder destruktiv ist.
* `didit_tool_describe` (Lesezugriff): gibt die vollständige Beschreibung und das Eingabeschema von bis zu fünf Tools zurück.
* `didit_tool_call_read` (Lesezugriff): führt ein reines Lese-Tool aus, das nicht in der Liste steht. Ein Tool, das Daten ändert, wird abgelehnt.
* `didit_tool_call_write` (destruktiv): führt ein Tool aus, das Daten erstellt, ändert oder löscht und nicht in der Liste steht. Auf einer Verbindung im Nur-Lese-Modus nicht verfügbar.

Ein Aufruf über `didit_tool_call_read` oder `didit_tool_call_write` wird genauso geprüft wie ein direkter Aufruf: Ihre Rollenberechtigungen, der Nur-Lese-Modus und alle Anforderungen `confirm: true` gelten weiterhin.
Die beiden sind getrennt, damit Ihr Client vor einer Änderung bei Ihnen nachfragen, eine Abfrage aber ohne Rückfrage durchlassen kann.

Bei geladenem `core` läuft eine Anfrage wie „ein neues Teammitglied in meine Organisation einladen“ so ab:

1. Das Modell ruft `didit_tool_search` mit `invite a teammate` auf und erhält `didit_org_invite_member`, markiert als Schreibzugriff.
2. Es ruft `didit_tool_call_write` auf und übergibt `didit_org_invite_member` als `name` zusammen mit den eigenen Argumenten dieses Tools.
3. Ihr Client fordert Sie auf, den Aufruf zu bestätigen, wie bei jedem Tool, das Daten ändert.

Wenn alles geladen ist, gibt es nichts mehr zu entdecken, und diese vier Tools werden nicht aufgelistet.

## In Ihrem Client einrichten

Verwenden Sie dieselben Schritte wie in der [Installationsanleitung](https://docs.didit.me/de/integration/mcp/installation.md), ergänzt um die Parameter in der URL.

> [tab] Claude Code
>
> ```bash theme={null}
> claude mcp add --transport http didit "https://mcp.didit.me/mcp?toolsets=core"
> ```
>
> Behalten Sie die Anführungszeichen bei: Ihre Shell würde sonst das `?` und das `&` selbst interpretieren.

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

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

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

> [tab] Claude Web und Desktop
>
> Öffnen Sie **Settings**, dann **Connectors**, dann **Add custom connector**, und fügen Sie die URL mit ihren Parametern ein:
>
> ```text theme={null}
> https://mcp.didit.me/mcp?toolsets=core
> ```

> [tab] Lokaler Server
>
> Der lokale Server akzeptiert Flags oder Umgebungsvariablen:
>
> ```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
> ```

Wenn Ihr Client Header setzen, die URL aber nicht bearbeiten lässt, senden Sie stattdessen `X-MCP-Toolsets: core,workflows` und `X-MCP-Readonly: true`.
Für Toolsets hat ein Wert in der URL Vorrang vor dem Header. Der Nur-Lese-Modus ist aktiv, sobald einer der beiden ihn anfordert.

> [!NOTE]
>
> Das ChatGPT-Plugin verwendet einen eigenen, festen und reduzierten Katalog unter `https://mcp.didit.me/mcp/chatgpt`.
> Toolsets und der Nur-Lese-Modus gelten dafür nicht.
> Siehe [ChatGPT verbinden](https://docs.didit.me/de/integration/mcp/chatgpt.md).

## Prompts, Anweisungen und Dokumentationssuche

Der Server hilft dem Modell, an der richtigen Stelle zu beginnen:

* **Anweisungen.** Beim Verbinden weist der Server das Modell an, mit `didit_context_get` zu beginnen, erklärt, wie `organization_id` und `application_id` aufgelöst werden, weist es an, in einer Sandbox-Anwendung zu entwickeln, und nennt, welche Toolsets diese Verbindung geladen hat.
* **Prompts.** Clients, die MCP-Prompts unterstützen, zeigen fünf Einstiegspunkte: `integrate_didit`, `review_queue`, `explain_session`, `build_workflow` und `verification_report`. In Claude Code erscheinen sie als Slash-Befehle.
* **Dokumentationssuche.** `didit_docs_search` durchsucht diese Dokumentation und gibt die passenden Abschnitte mit ihren Links zurück, sodass Fragen zur Funktionsweise von Didit anhand der aktuellen Seiten beantwortet werden.

## Prüfen, was eine Verbindung geladen hat

Fragen Sie Ihren Client:

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

Das Modell antwortet auf Basis der Serverinstruktionen.
Um vor dem Einsatz zu prüfen, ob ein Server Toolsets unterstützt, rufen Sie seinen Status-Endpoint auf:

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

Die Antwort listet `toolsets` und `read_only` unter `features` auf.

## Nächste Schritte

> [card] [Installation](https://docs.didit.me/de/integration/mcp/installation.md)
>
> Verbinden Sie Claude, ChatGPT, Cursor, VS Code, Codex oder einen beliebigen MCP-Client.

> [card] [Referenz der Tools](https://docs.didit.me/de/integration/mcp/tools.md)
>
> Alle Tools, ihre Typen und die jeweils benötigte Rollenberechtigung.

> [card] [Authentifizierung](https://docs.didit.me/de/integration/mcp/authentication.md)
>
> Anmeldung bei Didit, Scopes und Rollenberechtigungen.

> [card] [Beispiel-Prompts](https://docs.didit.me/de/integration/mcp/examples.md)
>
> Prompts, die vom ersten Tag an funktionieren.


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