# KI-Clients verbinden — Unity · AI Game Developer Wiki

Verbinde Claude Code, Cursor, Copilot, Codex, Gemini und weitere MCP-Clients über die ai-game.dev-Cloud oder einen lokalen Server mit Unity MCP.

Diese Seite wurde maschinell aus dem Englischen übersetzt. [Englisches Original lesen](https://ai-game.dev/docs/wiki/unity/connecting-ai-clients).

Diese Seite erklärt, wie ein KI-Client den Unity Editor erreicht, welchen Endpunkt und welche Anmeldung er verwendet und wie du jeden unterstützten Agenten im Fenster AI Game Developer, über `unity-mcp-cli` oder von Hand konfigurierst.

## Zwei Verbindungswege

Dein KI-Client spricht nie direkt mit Unity. Beide verbinden sich mit einem MCP-Server, und der Server leitet Tool-Aufrufe über eine SignalR-Verbindung an den Editor weiter.

|  | Cloud (Standard) | Benutzerdefiniert (lokal) |
| --- | --- | --- |
| Server | Der gehostete Endpunkt `https://ai-game.dev/mcp` | `gamedev-mcp-server`, vom Plugin heruntergeladen und gestartet |
| Editor-Verbindung | Das Plugin verbindet sich mit ai-game.dev | Das Plugin verbindet sich mit `http://localhost:<port>` |
| Client-Endpunkt | `https://ai-game.dev/mcp/p/<pin>` (gepinnt) oder `https://ai-game.dev/mcp` | `http://localhost:<port>` oder das Server-Binary über stdio |
| Anmeldung | ai-game.dev-Konto (OAuth Device Flow) | Keine, ai-game.dev OAuth oder ein gemeinsames Token |
| Funktioniert offline | Nein | Ja, mit `none`- oder `token`-Autorisierung |

Wähle den Modus mit dem Schalter **Connection** (**Custom** / **Cloud**) im Fenster AI Game Developer. [Konfiguration](https://ai-game.dev/de/docs/wiki/unity/configuration#connection-modes) behandelt die Einstellungen des lokalen Servers.

## Gepinnte URLs

Der Basis-Endpunkt `https://ai-game.dev/mcp` leitet per Fallback an einen deiner verbundenen Editoren weiter. Bei einem einzelnen geöffneten Projekt ist das in Ordnung, bei mehreren aber mehrdeutig.

Eine **gepinnte** URL, `https://ai-game.dev/mcp/p/<pin>`, leitet immer zum Editor eines Projekts weiter. Der Pin wird aus der Identität des Projekts abgeleitet. Die Schaltfläche **Configure** im Fenster und `unity-mcp-cli setup-mcp` schreiben standardmäßig die gepinnte URL; `setup-mcp --no-pin` schreibt stattdessen die Basis-URL. Beim stdio-Transport wird der Pin als Argument `project=<pin>` übergeben.

## Anmelden

Der Editor, die CLI und die Desktop-App teilen sich eine maschinenweite Anmeldung in `~/.ai-game-dev/credentials.json`. Melde dich einmal in einem davon an:

- Im Fenster: Cloud-Modus, dann **Authorize**, dann den Code im Browser bestätigen.
- In einem Terminal: `unity-mcp-cli login`.
- In der [AI Game Dev App](https://ai-game.dev/docs/app): **Sign in**.

Tokens werden im Hintergrund erneuert. **Revoke** im Fenster meldet alle AI Game Dev-Tools auf der Maschine ab (alle Engine-Plugins, die CLIs und die Desktop-App) und widerruft die Tokens auf dem Server.

Wie der KI-Client sich selbst authentifiziert, hängt von der geschriebenen Konfiguration ab:

- **Projektschlüssel (Standard für Cloud-HTTP, wenn du angemeldet bist).** Die Konfiguration enthält `Authorization: Bearer agd_pk_…`, einen nicht ablaufenden, widerrufbaren Schlüssel, der nur an dieses Projekt gebunden ist. Schlüssel werden in `~/.ai-game-dev/project-keys.json` aufbewahrt. **Regenerate key** im Fenster oder `setup-mcp --regenerate-key` ersetzt ihn und widerruft den alten.
- **OAuth (nur URL).** Keine Zugangsdaten in der Datei; der Client öffnet beim ersten Verbinden eine Browser-Anmeldung. Das erhältst du, wenn du nicht angemeldet bist, oder mit `setup-mcp --oauth`.
- **Personal Access Token.** Für CI oder Clients, die keinen Browser-Login durchführen können, erstelle ein Token in deinem ai-game.dev-Konto (siehe [Authentifizierung](https://ai-game.dev/docs/auth)) und übergib es mit `setup-mcp --token <token>`.

Behandle Projektschlüssel und Tokens wie Passwörter. Dateien wie `.mcp.json` liegen in deinem Projektordner, also prüfe deine `.gitignore`, bevor du sie committest. [Authentifizierung](https://ai-game.dev/docs/auth) erklärt die Kontoseite.

## Unterstützte KI-Agenten

Das Dropdown **AI agent** im Fenster listet diese Konfiguratoren auf. **Configure** schreibt die angezeigte Datei; **Remove** entfernt den Eintrag wieder.

| Agent | Geschriebene Konfigurationsdatei | CLI-ID |
| --- | --- | --- |
| Claude Code | `.mcp.json` (Projektstammverzeichnis) | `claude-code` |
| Claude Desktop | `claude_desktop_config.json` im App-Datenordner von Claude | `claude-desktop` |
| Cursor | `.cursor/mcp.json` | `cursor` |
| Visual Studio Code (Copilot) | `.vscode/mcp.json` | `vscode-copilot` |
| Visual Studio (Copilot) | `.vs/mcp.json` | `vs-copilot` |
| Rider (Junie) | `.junie/mcp/mcp.json` | `rider-junie` |
| GitHub Copilot CLI | `~/.copilot/mcp-config.json` | `github-copilot-cli` |
| Gemini | `.gemini/settings.json` | `gemini` |
| Antigravity | `~/.gemini/config/mcp_config.json` und `~/.gemini/antigravity/mcp_config.json` | `antigravity` |
| Cline | `cline_mcp_settings.json` im globalen Speicher von VS Code | `cline` |
| Open Code | `opencode.json` | `open-code` |
| Codex | `.codex/config.toml` | `codex` |
| Kilo Code | `.kilocode/mcp.json` | nur im Fenster |
| Zoo Code | `.roo/mcp.json` | nur im Fenster |
| Unity AI | `UserSettings/mcp.json` | `unity-ai` |
| Andere – Benutzerdefiniert | zeigt das zu kopierende JSON | `custom` |

Relative Pfade beziehen sich auf dein Unity-Projekt. Der Server-Eintrag heißt immer `ai-game-developer`. Führe `unity-mcp-cli setup-mcp --list` aus, um die IDs zu sehen, die deine CLI-Version unterstützt.

**Tipp**

Claude Desktop und Unity AI verwenden keine generierten Skills, und über den Eintrag Custom wählst du den Skills-Ordner. Bei den anderen Agenten aktiviere außerdem **Skills > Auto-generate** (oder führe `setup-skills` aus), damit der Agent RQL lernt.

## Mit unity-mcp-cli konfigurieren

`setup-mcp` schreibt dieselbe Ausgabe wie die Schaltfläche **Configure** im Fenster, ohne Unity zu öffnen:

```bash
unity-mcp-cli setup-mcp claude-code ./MyUnityProject
unity-mcp-cli setup-mcp cursor ./MyUnityProject --transport stdio
unity-mcp-cli setup-mcp claude-code ./MyUnityProject --no-pin
```

Der Standard-Transport ist `http`. Mit `--transport stdio` startet die Konfiguration stattdessen die lokale Server-Binary. Alle Flags findest du in der [CLI-Referenz](https://ai-game.dev/de/docs/wiki/unity/cli#setup-mcp).

## Manuell konfigurieren

Jeder MCP-Client, der HTTP unterstützt, kann den gehosteten Endpoint verwenden. Beispiel für Claude Code:

```bash
claude mcp add --transport http ai-game-developer https://ai-game.dev/mcp
```

Eine generische `mcpServers`-JSON-Konfiguration:

```json
{
  "mcpServers": {
    "ai-game-developer": {
      "url": "https://ai-game.dev/mcp"
    }
  }
}
```

Ersetze die URL durch die feste URL deines Projekts (angezeigt in den manuellen Konfigurationsschritten des Fensters), um ein bestimmtes Projekt anzusprechen. Die [MCP-Endpoint-Seite](https://ai-game.dev/de/mcp-endpoint-info) enthält Snippets für jeden Client, including das `servers`-Format von VS Code und einen PAT-Header.

### Lokaler Server über HTTP

Im Custom-Modus mit dem HTTP-Transport verweist du den Client auf den lokalen Server. Der Port ist der aus der **Server URL** im Fenster; die manuellen Konfigurationsschritte, die im Fenster für deinen Agenten angezeigt werden, enthalten die exakte URL einschließlich der Projekt-Pin:

```json
{
  "mcpServers": {
    "ai-game-developer": {
      "url": "http://localhost:<port>"
    }
  }
}
```

### Lokaler Server über stdio

Mit dem stdio-Transport startet der Client die Server-Binary selbst. Unter Windows:

```bash
claude mcp add ai-game-developer "<project>/Library/mcp-server/win-x64/gamedev-mcp-server.exe" port=<port> plugin-timeout=10000 client-transport=stdio
```

Verwende `osx-arm64`, `osx-x64`, `linux-x64`, `linux-arm64`, `win-x86` oder `win-arm64` für andere Plattformen (ohne `.exe` außerhalb von Windows). Ersetze `<project>` durch den vollständigen Projektpfad und `<port>` durch den Port aus dem Fenster. Es kann immer nur ein Agent einen stdio-Server verwenden, und die Start/Stop-Schaltfläche im Fenster ist deaktiviert, weil der Agent den Prozess besitzt. Bevorzuge HTTP, es sei denn, dein Client unterstützt kein HTTP.

## Nach der Konfiguration

Starte den KI-Client neu oder verbinde seinen MCP-Server erneut, damit er die neue Konfiguration liest. Folge dann [Erste Schritte](https://ai-game.dev/de/docs/wiki/unity/getting-started#verify), um die Verbindung zu prüfen. Wenn der Client keine Tools anzeigt, siehe [Fehlerbehebung](https://ai-game.dev/de/docs/wiki/unity/troubleshooting#no-tools).

---

Source (HTML): https://ai-game.dev/de/docs/wiki/unity/connecting-ai-clients

Machine-translated (de) from the English page: https://ai-game.dev/docs/wiki/unity/connecting-ai-clients