Über **MCP** (Model Context Protocol) greifen KI-Werkzeuge auf Munin zu. Die
Einrichtung dauert wenige Minuten.

## 1. Einen Key besorgen

Du brauchst einen eigenen API-Key für das Projekt. Wer im Projekt die Rolle
`admin` hat, legt ihn unter *Zugänge* an. Bitte um einen **eigenen Key je
Werkzeug**, zum Beispiel `anna-claude-code` und `anna-cline`. Dann steht im
Protokoll, welches Werkzeug was geschrieben hat.

Der Key wird nur ein einziges Mal angezeigt. Direkt darunter stehen die
fertigen Konfigurationsblöcke mit dem Key schon eingesetzt.

## 2. Das Werkzeug einrichten

Alle Werkzeuge sprechen denselben Endpunkt an:

```
{{SERVER}}/mcp
```

Der Key legt fest, welches Projekt du siehst. Weitere Angaben braucht es nicht.
Wer mit mehreren Projekten arbeitet, trägt mehrere Server ein, jeden mit
seinem eigenen Key.

> **Achtung:** Die drei Werkzeuge verwenden unterschiedliche Schreibweisen.
> Ein aus Claude Code kopierter Block funktioniert in Cline nicht.

| Werkzeug | Datei | Abschnitt | `type` |
|---|---|---|---|
| Claude Code | `.mcp.json` oder `~/.claude.json` | `mcpServers` | `http` |
| Cline | `cline_mcp_settings.json` | `mcpServers` | `streamableHttp` |
| OpenCode | `opencode.json` | `mcp` | `remote` |

### Claude Code

Am schnellsten auf der Kommandozeile:

```bash
claude mcp add --transport http munin-{{PROJEKT}} {{SERVER}}/mcp \
  --header "Authorization: Bearer wk_DEIN_KEY"
```

Mit `--scope user` gilt der Eintrag in allen Verzeichnissen, sonst nur im
aktuellen.

Soll die Einrichtung für das ganze Team ins Repository, dann als `.mcp.json`
**ohne** den Key im Klartext. Jede Person setzt die Umgebungsvariable
`MUNIN_KEY` auf ihren eigenen Key:

```json
{
  "mcpServers": {
    "munin-{{PROJEKT}}": {
      "type": "http",
      "url": "{{SERVER}}/mcp",
      "headers": { "Authorization": "Bearer ${MUNIN_KEY}" }
    }
  }
}
```

### Cline

In Cline: *MCP Servers* → *Configure* → *Configure MCP Servers*.

```json
{
  "mcpServers": {
    "munin-{{PROJEKT}}": {
      "type": "streamableHttp",
      "url": "{{SERVER}}/mcp",
      "headers": { "Authorization": "Bearer wk_DEIN_KEY" },
      "disabled": false,
      "autoApprove": ["recall", "get", "list", "related"]
    }
  }
}
```

`autoApprove` nennt die Werkzeuge, die ohne Rückfrage laufen dürfen. Die vier
lesenden gehören hinein, sonst muss jede Suche einzeln bestätigt werden.
`remember` und `forget` gehören **nicht** hinein, denn sie verändern das
gemeinsame Wissen.

### OpenCode

In `opencode.json` im Projektverzeichnis oder global unter
`~/.config/opencode/opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "munin-{{PROJEKT}}": {
      "type": "remote",
      "url": "{{SERVER}}/mcp",
      "enabled": true,
      "headers": { "Authorization": "Bearer {env:MUNIN_KEY}" }
    }
  }
}
```

`{env:MUNIN_KEY}` liest den Key aus der Umgebung.

## 3. Prüfen, ob es geht

Das Werkzeug sollte sechs Munin-Werkzeuge anbieten: `recall`, `get`, `list`,
`related`, `remember` und `forget`. Ein einfacher Test:

```
Rufe list auf und sag mir, welche Schlagworte es im Munin gibt.
```

## Wenn es nicht klappt

| Anzeichen | Wahrscheinliche Ursache |
|---|---|
| Fehler `401` | Key falsch, unvollständig kopiert oder zurückgezogen. Bei OpenCode: Die Umgebungsvariable ist nicht gesetzt, dann wird sie zu einem leeren Text. |
| Werkzeug zeigt keine Munin-Werkzeuge | Falscher `type` für dieses Werkzeug (siehe Tabelle oben) oder Tippfehler in der Adresse. |
| Schreiben schlägt fehl, Lesen geht | Der Key hat nur die Rolle `read`. |
| Meldung über ein erschöpftes Schreibbudget | Das Projekt hat seine Obergrenze an Schreibvorgängen je Stunde erreicht. Das deutet meist auf einen Agenten in einer Schleife hin. Siehe [Zugänge und Sicherheit](/hilfe/zugaenge). |

Wenn die Verbindung steht, geht es mit
[Mit Agenten arbeiten](/hilfe/mit-agenten-arbeiten) weiter. Ohne eine kurze
Anweisung in `AGENTS.md` oder `CLAUDE.md` benutzt ein Agent das Gedächtnis
selten von selbst.