---
title: "Einen MCP-Client verbinden"
description: "Binde den stdio-MCP-Server von verbatra in deinen Coding-Agenten oder einen anderen MCP-Client ein, ohne dass der Provider-Key in einer Datei im Repo landet."
type: "how-to"
---
# Einen MCP-Client verbinden

Binde den stdio-MCP-Server von verbatra in deinen Coding-Agenten oder einen anderen MCP-Client ein, ohne dass der Provider-Key in einer Datei im Repo landet.

Starte hier: Sobald `@verbatra/cli` im Projekt installiert ist, verbindet `npx @verbatra/cli init --agent` deinen Coding-Agenten, ohne Ausgaben zu erlauben.

Lass einen Coding-Agenten über den stdio-MCP-Server von verbatra den Übersetzungsstand lesen und Werte korrigieren. Registriere ihn einmal pro Client: Ein zweiter Eintrag startet einen zweiten Server. Du brauchst ein Projekt mit verbatra-Konfiguration ([`npx @verbatra/cli init`](https://verbatra.kreitz-webdev.de/de/docs/cli/init.md)) und Node.js `^22.18.0 || >=24`.

<AvailableFrom version="0.2.0" pkg="@verbatra/mcp" />

## Einen Startbefehl wählen [#einen-startbefehl-wählen]

| Befehl | Braucht | Liest `.env`-Dateien |
| --- | --- | --- |
| `npx -y @verbatra/mcp` | keine Installation | nein |
| `npx @verbatra/cli mcp` | `@verbatra/cli` und `@verbatra/mcp` als Dev-Abhängigkeiten | ja: `.env.local`, dann `.env` |

Meide `npx -y @verbatra/cli mcp`: Es endet mit `2`, weil die CLI `@verbatra/mcp` nie installiert. [Projektverzeichnis](https://verbatra.kreitz-webdev.de/de/docs/cli/mcp.md#projektverzeichnis) sagt, wo der Server die Konfiguration sucht.

### MCP Registry [#mcp-registry]

<AvailableFrom version="0.3.0" pkg="@verbatra/mcp" />

Der Server steht außerdem in der [offiziellen MCP Registry](https://registry.modelcontextprotocol.io) als `io.github.verbatra/verbatra`.

## Entscheiden, ob der Agent Geld ausgeben darf [#entscheiden-ob-der-agent-geld-ausgeben-darf]

Der Server startet nur mit Lese- und lokalen Bearbeitungstools: Kostenpflichtige Tools bleiben verborgen, und kein Tool liest einen Key.

<Accordions type="single">
<Accordion title="Regeln für Ausgaben und Keys">

Damit der Agent Geld ausgeben darf, ergänzt du beides:

- `--allow-spend` in den Argumenten oder `VERBATRA_MCP_ALLOW_SPEND=1` in der Umgebung ([Kostenpflichtige Tools](https://verbatra.kreitz-webdev.de/de/docs/cli/mcp.md#kostenpflichtige-tools));
- die Key-Variable deines Providers, etwa `ANTHROPIC_API_KEY` ([Provider](https://verbatra.kreitz-webdev.de/de/docs/providers.md)).

<Callout type="warn">
Schreib nie einen Key in eine committete Datei wie `.mcp.json`, `.codex/config.toml`, `.gemini/settings.json`, `.cursor/mcp.json` oder `.vscode/mcp.json`.
</Callout>

Sollen Übersetzungswerte nicht beim Modell des Agenten landen, ergänze `--redact-values`; siehe [Studio und MCP](https://verbatra.kreitz-webdev.de/de/docs/data-handling.md#studio-und-mcp).

</Accordion>
</Accordions>

### Erst schätzen [#erst-schätzen]

<AvailableFrom version="0.3.0" pkg="@verbatra/mcp" />

Der Server weist den Agenten trotzdem an, erst `translation.estimate` auszuführen und vor jeder Ausgabe auf dein Ja zu warten.

<Tabs items={["Claude Code", "Codex", "Gemini CLI", "Cursor", "VS Code", "Andere"]}>
<Tab value="Claude Code" forceMount>

## Claude Code [#claude-code]

### Von init schreiben lassen [#von-init-schreiben-lassen]

<AvailableFrom version="0.12.0" />

Empfohlen, im Projektstamm:

```bash
npx @verbatra/cli init --agent
```

[`init --agent`](https://verbatra.kreitz-webdev.de/de/docs/cli/init.md#coding-agenten-einrichten) schreibt die Anweisungsdatei für Agenten und, Ausgaben aus, diesen Eintrag in die committete `.mcp.json`, wenn es Claude Code (`CLAUDE.md`, `.claude/` oder `.mcp.json`) oder gar keinen Client findet; `--client claude` erzwingt ihn:

```json
{
  "mcpServers": {
    "verbatra": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@verbatra/mcp"]
    }
  }
}
```

Starte Claude Code neu und bestätige den Server `verbatra`; Claude Code reicht `CLAUDE_PROJECT_DIR` und deine Umgebung weiter. Um für eine Sitzung Geld auszugeben, exportierst du den Key und startest:

```bash
VERBATRA_MCP_ALLOW_SPEND=1 claude
```

`claude mcp list` prüft die Verbindung. Siehe die [MCP-Dokumentation von Claude Code](https://code.claude.com/docs/en/mcp).

### Andere Wege [#andere-wege]

#### Ohne die CLI [#ohne-die-cli]

```bash
claude mcp add --transport stdio --scope project verbatra -- npx -y @verbatra/mcp
```

Das schreibt denselben Eintrag. Ergänze hier nie `--env KEY=value`: Damit steht der Wert in `.mcp.json`.

#### Das verbatra-Plugin [#das-verbatra-plugin]

<AvailableFrom version="0.3.0" pkg="@verbatra/mcp" />

Statt `.mcp.json` bündelt das Plugin die [verbatra-Skills](https://verbatra.kreitz-webdev.de/de/docs/agent-recipes.md#das-skills-paket), diesen Server und einen Hook, der eine Locale-Datei prüft, nachdem Claude sie bearbeitet hat.

<Callout type="warn">
Kombinier das verbatra-Plugin nie mit einem `verbatra`-Eintrag in `.mcp.json`: Das Plugin bringt einen zweiten Server mit. `init --agent` überspringt den Eintrag, wenn das Plugin in `.claude/settings.json` oder `.claude/settings.local.json` aktiviert ist.
</Callout>

```bash
claude plugin marketplace add verbatra/skills
claude plugin install verbatra@verbatra --scope project
```

- **Server**: ein festgelegtes `@verbatra/mcp` mit `--cwd` auf dem offenen Projekt.
- **Ausgaben**: aus, bis du die Plugin-Option `allowSpend` einschaltest (`--config allowSpend=true` oder `/config`). Eine committete Datei kann sie nicht einschalten.
- **Key**: kommt aus der Umgebung, mit der du `claude` gestartet hast.
- **Hook**: führt das `verbatra check --file <path>` des Projekts aus (CLI 0.12.0 oder neuer) und meldet kaputte Platzhalter, Markup oder ICU, ohne einen Provider aufzurufen.

Siehe die [Plugin-Referenz von Claude Code](https://code.claude.com/docs/en/plugins-reference).

</Tab>

<Tab value="Codex" forceMount>

## Codex [#codex]

Empfohlen: `npx @verbatra/cli init --agent --client codex` (oder einfach `init --agent`, wenn `.codex/` existiert) hängt diese Tabelle an `.codex/config.toml` an, Ausgaben aus:

```toml title=".codex/config.toml"
[mcp_servers.verbatra]
command = "npx"
args = ["-y", "@verbatra/mcp"]
startup_timeout_sec = 60
```

Codex lädt sie erst, wenn du **Trust this folder?** bestätigst; das gilt für den Stamm des Repositorys. Aus einem Unterordner gestartet, richtet sich der Server nach der Konfiguration, die er findet. Siehe die [MCP-Dokumentation von Codex](https://learn.chatgpt.com/docs/extend/mcp?surface=cli).

### Codex-Benutzerkonfiguration [#codex-benutzerkonfiguration]

Für Ausgaben nimmst du stattdessen `~/.codex/config.toml`. `env_vars` reicht Variablen per Namen durch; eine `env`-Tabelle oder `codex mcp add --env` speichert den Wert:

```toml title="~/.codex/config.toml"
[mcp_servers.verbatra]
command = "npx"
args = ["-y", "@verbatra/mcp", "--allow-spend"]
cwd = "/path/to/your/project"
env_vars = ["ANTHROPIC_API_KEY"]
```

</Tab>

<Tab value="Gemini CLI" forceMount>

## Gemini CLI [#gemini-cli]

Empfohlen: `npx @verbatra/cli init --agent --client gemini` (oder einfach `init --agent`, wenn `.gemini/` oder `GEMINI.md` existiert) ergänzt diesen Eintrag in `.gemini/settings.json`, Ausgaben aus:

```json title=".gemini/settings.json"
{
  "mcpServers": {
    "verbatra": {
      "command": "npx",
      "args": ["-y", "@verbatra/mcp"]
    }
  }
}
```

Gemini CLI liest ihn nur aus dem Ordner, in dem es startet: Starte `gemini` im Projektstamm und vertrau ihm im Dialog oder mit `/permissions trust`. Lass `trust` ungesetzt; `/mcp` zeigt die Tools. Es liest `GEMINI.md`, nicht `AGENTS.md`: Ergänze `"context": { "fileName": ["AGENTS.md", "GEMINI.md"] }` in den Einstellungen oder `@AGENTS.md` in `GEMINI.md`. Siehe die [MCP-Dokumentation von Gemini CLI](https://geminicli.com/docs/tools/mcp-server/).

### Gemini-CLI-Benutzereinstellungen [#gemini-cli-benutzereinstellungen]

Für Ausgaben nimmst du deine Benutzereinstellungen mit absolutem `cwd`:

```json title="~/.gemini/settings.json"
{
  "mcpServers": {
    "verbatra": {
      "command": "npx",
      "args": ["-y", "@verbatra/mcp", "--allow-spend"],
      "cwd": "/path/to/your/project",
      "env": {
        "ANTHROPIC_API_KEY": "$ANTHROPIC_API_KEY"
      }
    }
  }
}
```

Gemini CLI verbirgt Key-Variablen vor Servern, also gibst du den Key über `env` weiter.

</Tab>

<Tab value="Cursor" forceMount>

## Cursor [#cursor]

`init --agent` schreibt Cursors `.cursor/mcp.json`, wenn es `.cursor/` oder `.cursorrules` findet, oder mit `--client cursor`:

```json title=".cursor/mcp.json"
{
  "mcpServers": {
    "verbatra": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@verbatra/mcp", "--cwd", "${workspaceFolder}"]
    }
  }
}
```

Für Ausgaben hängst du `"--allow-spend"` an `args` an und ergänzt `"env": { "ANTHROPIC_API_KEY": "${env:ANTHROPIC_API_KEY}" }`. Siehe die [MCP-Dokumentation von Cursor](https://cursor.com/docs/mcp).

</Tab>

<Tab value="VS Code" forceMount>

## VS Code [#vs-code]

VS Code (der Agent-Modus von GitHub Copilot) liest `.vscode/mcp.json` mit dem Schlüssel `servers`, die `init --agent --client vscode` schreibt. Ohne `--client` verbindet `init --agent` VS Code nur, wenn diese Datei schon existiert, und gibt für einen bloßen `.vscode/`-Ordner den Befehl aus. Es braucht kein `--cwd`:

```json title=".vscode/mcp.json"
{
  "servers": {
    "verbatra": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@verbatra/mcp"]
    }
  }
}
```

Für Ausgaben deklarierst du den Key als Input, den VS Code außerhalb der Datei speichert:

```json title=".vscode/mcp.json"
{
  "inputs": [
    {
      "type": "promptString",
      "id": "anthropic-key",
      "description": "Anthropic API key",
      "password": true
    }
  ],
  "servers": {
    "verbatra": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@verbatra/mcp", "--allow-spend"],
      "env": {
        "ANTHROPIC_API_KEY": "${input:anthropic-key}"
      }
    }
  }
}
```

[Zu VS Code hinzufügen](vscode:mcp/install?%7B%22name%22%3A%22verbatra%22%2C%22type%22%3A%22stdio%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40verbatra%2Fmcp%22%5D%7D)

Statt der Datei legt der Button oder dieser Befehl den Eintrag mit ausgeschalteten Ausgaben in deinem Benutzerprofil an; nutze einen der drei Wege, nie zwei:

```bash
code --add-mcp '{"name":"verbatra","command":"npx","args":["-y","@verbatra/mcp"]}'
```

Siehe die [MCP-Konfigurationsreferenz von VS Code](https://code.visualstudio.com/docs/agents/reference/mcp-configuration).

</Tab>

<Tab value="Andere" forceMount>

## GitHub Copilot [#github-copilot]

### Copilot Cloud Agent [#copilot-cloud-agent]

Eine Person mit Admin-Rechten fügt den Server unter **Settings**, **Copilot**, **MCP servers** hinzu. Der Cloud Agent ruft Tools ohne Rückfrage auf, also listest du nur Tools, die weder schreiben noch einen Provider aufrufen:

```json
{
  "mcpServers": {
    "verbatra": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "@verbatra/mcp"],
      "tools": [
        "project.snapshot",
        "project.doctor",
        "status.check",
        "status.diff",
        "glossary.get",
        "lock.state",
        "history.list",
        "key.integrity",
        "locale.integrity",
        "key.value",
        "key.context",
        "locale.values",
        "translation.estimate",
        "review.queue",
        "report.provenance",
        "usage.summary"
      ]
    }
  }
}
```

Nimm `translation.editEntry` und `glossary.write` nur auf, wenn der Agent in seinem Pull Request schreiben soll, und lass `review.approve` und `review.reject` draußen: Eine Review-Entscheidung braucht einen Menschen. Zum Prüfen öffnest du **View session** und klappst **Start MCP Servers** auf. Siehe [Extending the cloud agent with MCP](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/configure-mcp-servers).

### Copilot CLI [#copilot-cli]

```bash
copilot mcp add verbatra -- npx -y @verbatra/mcp --cwd /path/to/your/project
```

Das schreibt `~/.copilot/mcp-config.json`. Copilot CLI reicht einem Server nur `PATH` weiter, also gehört ein Key in das `env` dieses Eintrags, nie in eine Projektdatei. Siehe [Adding MCP servers to Copilot CLI](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers).

## Windsurf [#windsurf]

Windsurf liest eine einzige `mcp_config.json` für alle Projekte, also ist `--cwd` absolut:

```json title="mcp_config.json"
{
  "mcpServers": {
    "verbatra": {
      "command": "npx",
      "args": ["-y", "@verbatra/mcp", "--cwd", "/path/to/your/project"]
    }
  }
}
```

Für Ausgaben hängst du `"--allow-spend"` an und ergänzt `"env": { "ANTHROPIC_API_KEY": "${env:ANTHROPIC_API_KEY}" }`. Siehe die [MCP-Dokumentation von Cascade](https://docs.devin.ai/desktop/cascade/mcp).

## Zed [#zed]

Zed liest `context_servers` aus seinen Einstellungen; **Settings**, **AI**, **MCP Servers**, **Add Server** schreibt den Eintrag:

```json title="settings.json"
{
  "context_servers": {
    "verbatra": {
      "command": "npx",
      "args": ["-y", "@verbatra/mcp", "--cwd", "/path/to/your/project"],
      "env": {}
    }
  }
}
```

Ein Key in `env` ist ein wörtlicher Wert, also ergänzt du ihn und `--allow-spend` nur in deinen Benutzereinstellungen, nie in `.zed/settings.json`. Siehe die [MCP-Dokumentation von Zed](https://zed.dev/docs/ai/mcp).

## JetBrains AI Assistant [#jetbrains-ai-assistant]

Öffne **Settings**, **Tools**, **AI Assistant**, **Model Context Protocol (MCP)**, füge einen Server hinzu und füg ein:

```json
{
  "mcpServers": {
    "verbatra": {
      "command": "npx",
      "args": ["-y", "@verbatra/mcp"]
    }
  }
}
```

Setz **Working directory** auf den Projektstamm und lass diesen Eintrag ohne Ausgaben. Siehe die [MCP-Dokumentation von AI Assistant](https://www.jetbrains.com/help/ai-assistant/mcp.html).

## Claude Desktop [#claude-desktop]

**Settings**, **Developer**, **Edit Config** öffnet `claude_desktop_config.json`. Es gibt kein Projekt, also ist `--cwd` absolut:

```json title="claude_desktop_config.json"
{
  "mcpServers": {
    "verbatra": {
      "command": "npx",
      "args": ["-y", "@verbatra/mcp", "--cwd", "/path/to/your/project"]
    }
  }
}
```

Für Ausgaben hängst du `"--allow-spend"` an und ergänzt `"env": { "ANTHROPIC_API_KEY": "..." }` und startest Claude Desktop danach neu. Siehe [Connect to local MCP servers](https://modelcontextprotocol.io/docs/develop/connect-local-servers).

## Jeder andere stdio-Client [#jeder-andere-stdio-client]

Gib dem Client den Befehl `npx -y @verbatra/mcp`, dazu `--cwd /path/to/your/project`, außer er startet Server innerhalb des Projekts, und `--config <path>`, wenn die Konfiguration woanders liegt. `--allow-spend` und den Key ergänzt du nur über den eigenen Secret-Mechanismus des Clients.

</Tab>
</Tabs>

## Die Verbindung prüfen [#die-verbindung-prüfen]

<AvailableFrom version="0.3.0" pkg="@verbatra/mcp" />

Bitte den Agenten, `project.snapshot` aufzurufen. Es liefert Locales, Format und Provider, ohne den Provider aufzurufen.

- **`configured: false`**: Es wurde keine nutzbare Konfiguration gefunden. Lass `project.doctor` aufrufen und führ dann `npx @verbatra/cli init` aus oder korrigier `--cwd`. Siehe [Ohne Konfiguration](https://verbatra.kreitz-webdev.de/de/docs/cli/mcp.md#ohne-konfiguration).
- **Kostenpflichtige Tools fehlen**: Prüf den Ausgaben-Schalter und ob der Provider `none` ist.
- **Konfiguration geändert**: Kein Neustart nötig; siehe [Nach einer Konfigurationsänderung](https://verbatra.kreitz-webdev.de/de/docs/cli/mcp.md#nach-einer-konfigurationsänderung).

## Siehe auch [#siehe-auch]

- [`verbatra mcp`](https://verbatra.kreitz-webdev.de/de/docs/cli/mcp.md): Flags und jedes Tool.
- [verbatra mit JSON skripten](https://verbatra.kreitz-webdev.de/de/docs/agent-recipes.md#das-skills-paket): der Skill `verbatra-mcp-tools`.
