# Chattee MCP-Server – Dokumentation

Der Chattee MCP-Server ist ein Remote-Server für das Model Context Protocol, über den KI-Assistenten wie Claude Code, Claude.ai, Cursor, Codex und ChatGPT komplette Web-Apps auf Chattee erstellen, ändern, deployen und veröffentlichen. Diese Seite zeigt dir, wie du jeden Client verbindest, wie Anmeldung und Scopes funktionieren, was die 35 Tools tun und an welche Limits du stoßen wirst.

## Was ist der Chattee MCP-Server?

Mit dem Chattee MCP-Server baut der KI-Assistent, den du schon nutzt, komplette Web-Apps auf [Chattee](/de): Er legt ein Projekt aus deiner Beschreibung an, reicht dir den Plan zur Freigabe weiter, verfolgt den Build und veröffentlicht die App auf einer Live-URL. Es ist ein Remote-Endpunkt, angemeldet per OAuth oder mit einem Personal Access Token.

Er spricht das Model Context Protocol (Revisionen 2025-11-25 und 2026-07-28) über Streamable HTTP, unter einer URL:

```text
https://chattee.ai/mcp/connect
```

Darüber kann dein Assistent ein Projekt aus einer Beschreibung anlegen, dir den Plan von Chattee und deine Antwort darauf weiterreichen, den Build beobachten, dir die Draft-Vorschau geben, auf eine Live-URL veröffentlichen, Projekte aus Vorlagen starten oder als Vorlage exportieren, Dateien lesen und schreiben, Umgebungsvariablen und Managed Resources verwalten, die Datenbank lesen und deine Credits prüfen. Chattee baut komplette Web-Apps: ein React-Frontend, ein Node-Backend, eine verwaltete Postgres-Datenbank, Login, Dateispeicher und E-Mail, deployt und gehostet auf chattee.ai.

Die eine Regel, die alles prägt: **Pläne und Geldentscheidungen bleiben bei dir.** Ein Plan wird dir vollständig gezeigt, und nur du gibst ihn frei; ein Lauf, der sein Budget erreicht, pausiert, und sein Rahmen steigt nur auf eine Summe, die du selbst nennst. Credits kaufst du im Builder, nie dein Assistent.

## Was kann ich meinen Assistenten mit Chattee machen lassen?

Frag in deinen eigenen Worten, so wie du einen Entwickler briefen würdest: Dein Assistent macht aus der Anfrage Aufrufe der Chattee-Tools und zeigt dir, was zurückkommt. Eine neue App läuft über einen Plan, den du freigibst; eine kleine Änderung geht direkt. Die Tabelle zeigt echte Anfragen und die Tools, die sie genutzt haben.

| Du fragst | Was passiert | Aufgerufene Tools |
|---|---|---|
| *Bau mir eine einseitige Website für meine Bäckerei „Sunrise Bakery“: einen Hero mit dem Namen und einer kurzen Zeile, drei Karten für unser Brot, unsere Kuchen und unseren Kaffee, unsere Öffnungszeiten und einen Kontaktbereich mit unserer Adresse (12 Baker Street, Springfield). Keine Anmeldung, kein Admin-Bereich. Veröffentliche sie, wenn sie fertig ist.* | Chattee plant eine einseitige Website ohne Backend und stellt zwei Fragen zum Aussehen; nach deinem Ja baut es die Seite und veröffentlicht sie. | `create_project`, `wait_for_run`, `answer_question`, `approve_plan`, `publish_project`, `get_release_status` |
| *Bau ein Schülerportal für meine Nachhilfeschule, Brightpath Tutoring. Schülerinnen und Schüler melden sich an und sehen ihre eigenen Noten und Anwesenheiten, und sie laden dort ihre Aufgaben hoch. Wenn jemand eine Aufgabe abgibt, möchte ich eine E-Mail darüber bekommen. Veröffentliche es, wenn es funktioniert.* | Chattee fragt, wie Schüler zu einem Konto kommen und wie das Portal aussehen soll, plant eine Full-Stack-App (Login, Datenbank, Dateispeicher, E-Mail) für dein Ja, baut sie, setzt den Lauf einmal nach seinem Zeitlimit fort und veröffentlicht sie. | `create_project`, `wait_for_run`, `answer_question`, `approve_plan`, `set_env_vars`, `get_project`, `get_run_logs`, `list_resources`, `get_release_status`, `continue_run`, `list_env_vars`, `publish_project` |
| *Bau mir eine App für unseren Sportverein, den TSV Grünwald. Mitglieder registrieren sich und melden sich an, sehen die Trainingszeiten und die nächsten Termine und können sich für einen Termin anmelden. Dafür bekommen sie eine Bestätigung per E-Mail. Der Vorstand lädt Dokumente wie Sitzungsprotokolle hoch, die alle Mitglieder lesen können. Veröffentliche die App, wenn sie fertig ist.* | Chattee fragt nach dem Aussehen und der Vereinsfarbe, plant die Mitglieder-App (Login, Datenbank, Dateispeicher, E-Mail) für dein Ja, baut sie, setzt den Lauf einmal nach seinem Zeitlimit fort und veröffentlicht sie. | `create_project`, `wait_for_run`, `answer_question`, `approve_plan`, `continue_run`, `publish_project`, `get_release_status` |
| *Warum ist das letzte Deploy fehlgeschlagen?* | Dein Assistent liest das Deploy-Log und erklärt den Fehler. | `get_run_logs` (`source`) |
| *Ändere die Überschrift auf der Startseite in „Jeden Morgen frisch“.* | Eine kleine, direkte Änderung ohne Plan; die Credits werden sofort verbraucht. | `send_message` (`mode`), `wait_for_run` |
| *Wie viele Leute haben sich auf Live registriert?* | Eine lesende Abfrage gegen die Live-Datenbank; Live-Abfragen werden protokolliert. | `query_database` (`env`, `sql`) |
| *Setz Live auf das Release von gestern zurück.* | Dein Assistent sucht das Release im Verlauf und stellt es auf Live wieder her. | `get_release_status`, `publish_project` (`restore_release_uid`) |
| *Speichere dieses Projekt als Vorlage.* | Eine private Vorlage mit eigener leerer Datenbank, aus der neue Projekte starten können. | `export_project_as_template` |

Die ersten drei Zeilen sind echte Läufe aus dem MCP-Benchmark von Chattee: die Anfrage, wie der simulierte Nutzer sie geschrieben hat (übersetzt, wo der Lauf auf Englisch war), und die Tools, die der Assistent aufgerufen hat, in der Reihenfolge ihres ersten Aufrufs. Die übrigen sind einzelne Anfragen.

## Voraussetzungen

Du brauchst drei Dinge: ein Chattee-Konto, einen MCP-Client, der Streamable HTTP spricht, und einen Weg zur Anmeldung. Gehostete Clients melden sich per OAuth an und brauchen sonst nichts; Clients mit Header nutzen ein Personal Access Token. Dein Account-API-Key wird absichtlich abgelehnt, weil er weder Scopes hat noch widerrufbar ist.

- Ein Chattee-Konto ([kostenlos starten](/de/get-started?plan=free&source=docs_mcp)). Der kostenlose Plan enthält Credits.
- Ein MCP-Client: Claude Code, Claude.ai oder Claude Desktop, Cursor, Codex CLI, ChatGPT oder dein eigener Agent auf dem Claude Agent SDK.
- Entweder ein **Personal Access Token** (erstellt auf der [Seite KI-Assistenten](/app/ai-assistants) im Builder) oder ein Client, der sich per **OAuth** anmeldet. Dein Account-API-Key funktioniert hier nicht.

## Wie füge ich den Chattee MCP-Server in Claude Code hinzu?

Claude Code fügt den Chattee MCP-Server mit einem Befehl hinzu und meldet sich per OAuth an, ohne dass du irgendwo ein Token einfügst. Füge ihn für deinen Nutzer hinzu, damit er in jedem Projekt da ist; ein Team, das ein Repository teilt, committet stattdessen eine `.mcp.json`, die das Token jeder Person aus einer Umgebungsvariablen liest.

Füge den Server einmal hinzu und melde dich dann an:

```bash
claude mcp add --transport http chattee --scope user https://chattee.ai/mcp/connect
```

`--scope user` fügt Chattee für deinen Nutzer hinzu, so steht es dir in jedem Projekt zur Verfügung und nicht nur im aktuellen Ordner (das wäre der Standard von Claude Code). Melde dich dann in deiner Shell an:

```bash
claude mcp login chattee
```

In Claude Code geht dasselbe mit `/mcp`: Wähle dort Chattee. In beiden Fällen öffnet Claude Code die Freigabeseite von Chattee, du bestätigst, und die Tools erscheinen als `mcp__chattee__<tool>`. Wenn du statt OAuth ein Personal Access Token nutzen willst, gib es als Header mit:

```bash
claude mcp add --transport http chattee --scope user https://chattee.ai/mcp/connect --header "Authorization: Bearer chattee_pat_…"
```

Für eine projektweite Einrichtung, die ein Team teilt, gehört das in die `.mcp.json` im Repository. Die Datei enthält kein Token: Claude Code ersetzt `${CHATTEE_PAT}` durch die Umgebungsvariable `CHATTEE_PAT`, so nutzt jede Person im Team ihr eigenes Personal Access Token, und die Datei kann unverändert eingecheckt werden:

```json
{
  "mcpServers": {
    "chattee": {
      "type": "http",
      "url": "https://chattee.ai/mcp/connect",
      "headers": {
        "Authorization": "Bearer ${CHATTEE_PAT}"
      }
    }
  }
}
```

Setz die Variable, bevor du Claude Code startest, zum Beispiel in deinem Shell-Profil (`~/.zshrc` oder `~/.bashrc`): `export CHATTEE_PAT=chattee_pat_…`. Schreib das Token selbst nie in die `.mcp.json`, und checke es nirgends ein.

Dann bitte Claude Code zum Beispiel: *„Bau auf Chattee eine Buchungsseite für mein Yogastudio und zeig mir den Plan, bevor du ihn freigibst.“*

## Wie füge ich Chattee in Claude.ai und Claude Desktop als Connector hinzu?

Claude.ai, Claude Desktop und die mobilen Claude-Apps verbinden sich mit Chattee über einen eigenen Connector: Du fügst die Server-URL einmal ein, meldest dich bei Chattee an und bestätigst die Berechtigungen. Die Verbindung läuft über OAuth 2.1, geht in jedem Claude-Plan und erscheint dann in jedem Chat, in dem du den Connector einschaltest.

Eigene Connectors gibt es in jedem Plan (im kostenlosen Plan ist ein eigener Connector möglich). Die Menüpunkte stehen hier so, wie sie in der englischen Oberfläche heißen:

1. Öffne **[Customize → Connectors](https://claude.ai/customize/connectors)** (Team- und Enterprise-Owner: **Organization settings → Connectors**, dann **Add → Custom → Web**).
2. Klick auf **+**, wähle **Add custom connector**, füge `https://chattee.ai/mcp/connect` als URL ein und klick auf **Add**.
3. Verbinde den Connector: Claude öffnet die Freigabeseite von Chattee. Melde dich an, prüfe die Berechtigungen und bestätige.

Chattee erscheint dann als Connector, den du pro Chat einschalten kannst, im Web, in Claude Desktop und in den mobilen Apps. In Claude wird kein Token eingefügt.

## Wie füge ich den Chattee MCP-Server in Cursor hinzu?

Cursor installiert den Chattee MCP-Server mit einem Klick oder aus ein paar Zeilen in der `mcp.json` und meldet sich dann per OAuth auf der Freigabeseite von Chattee an. Weil Cursor konfigurierte Header ignoriert, sobald ein Server OAuth anbietet, ist die Anmeldung hier der einzige Weg; ein Token in der Datei bewirkt nichts.

[Zu Cursor hinzufügen](cursor://anysphere.cursor-deeplink/mcp/install?name=chattee&config=eyJ1cmwiOiJodHRwczovL2NoYXR0ZWUuYWkvbWNwL2Nvbm5lY3QifQ==)

Oder trag den Server selbst in `~/.cursor/mcp.json` ein (oder in die `.cursor/mcp.json` des Projekts):

```json
{
  "mcpServers": {
    "chattee": {
      "url": "https://chattee.ai/mcp/connect"
    }
  }
}
```

Cursor erkennt, dass der Server OAuth anbietet, und bittet dich um die Anmeldung; bestätige auf der Freigabeseite von Chattee.

## Wie füge ich den Chattee MCP-Server in Codex CLI hinzu?

Codex CLI verbindet sich mit Chattee über ein Personal Access Token, das es aus einer Umgebungsvariablen liest, damit das Token nie in einer Konfigurationsdatei steht. Füge den Server mit einem Befehl oder drei Zeilen TOML hinzu und behalte das Standard-Warten: Codex beendet jeden Tool-Aufruf nach 60 Sekunden.

Lege ein Personal Access Token in der Umgebungsvariable `CHATTEE_PAT` ab und füge dann den Server hinzu:

```bash
codex mcp add chattee --url https://chattee.ai/mcp/connect --bearer-token-env-var CHATTEE_PAT
```

Oder schreib dasselbe in `~/.codex/config.toml`:

```toml
[mcp_servers.chattee]
url = "https://chattee.ai/mcp/connect"
bearer_token_env_var = "CHATTEE_PAT"
```

Codex beendet einen Tool-Aufruf nach 60 Sekunden. Behalte deshalb den Standard von 45 Sekunden für `wait_for_run`; das Tool kehrt vorher zurück, und Codex ruft es einfach erneut auf.

## Wie verbinde ich den Chattee MCP-Server mit ChatGPT?

ChatGPT verbindet MCP-Server im Developer mode, auf der Seite, die es heute Plugins nennt (früher Connectors), in den bezahlten Plänen von OpenAI und nur im Web. Chattee verbindet sich ausschließlich über OAuth: Du fügst die Server-URL ein, bestätigst auf der Freigabeseite von Chattee und wählst Chattee dann in einer Unterhaltung aus.

OpenAI bietet den Developer mode in den bezahlten Plänen (Plus, Pro, Business, Enterprise und Edu) und nur im Web an; in einem Business-, Enterprise- oder Edu-Workspace muss ihn eventuell erst ein Admin erlauben. Die Menüpunkte stehen hier so, wie sie in der englischen Oberfläche heißen:

1. Öffne **Settings → Security and login** und schalte **Developer mode** ein.
2. Geh zu **[ChatGPT Plugins](https://chatgpt.com/plugins)**, klick auf **+**, gib einen Namen (Chattee) und eine kurze Beschreibung ein und füge `https://chattee.ai/mcp/connect` als Server-URL der Verbindung ein. Leg sie an.
3. ChatGPT schickt dich zur Freigabeseite von Chattee; melde dich an und bestätige.
4. Wähl in einer neuen Unterhaltung im **+**-Menü **Developer mode** und dann Chattee aus.

Personal Access Tokens nimmt ChatGPT nicht an, und das ist in Ordnung: Der OAuth-Ablauf vergibt dieselben Scopes, und die Verbindung widerrufst du in Chattee auf der [Seite KI-Assistenten](/app/ai-assistants).

## Wie nutze ich den Chattee MCP-Server aus dem Claude Agent SDK?

Ein Agent, den du mit dem Claude Agent SDK baust, erreicht Chattee über denselben Remote-Server: Übergib ihn in den Optionen von `query()`, mit einem Personal Access Token aus der Umgebung. Der Server setzt Scopes durch, aber nicht deine Freigabe-Policy, also entscheidet dein Agent, wann ein Plan freigegeben wird; behalte dort einen Menschen in der Schleife.

Übergib den Server in den Optionen von `query()`, mit einem Personal Access Token als Bearer, gelesen aus der Umgebungsvariable `CHATTEE_PAT`, damit das Token nie in deinem Code steht:

```js
mcpServers: {
  chattee: {
    type: "http",
    url: "https://chattee.ai/mcp/connect",
    headers: { Authorization: "Bearer " + process.env.CHATTEE_PAT },
  },
}
```

Erlaube die Tools mit `allowedTools: ["mcp__chattee"]` und behalte bei `approve_plan` einen Menschen in der Schleife – der Server lehnt hier nichts ab, also entscheidet die Policy deines Agenten darüber, dass kein Plan ungesehen freigegeben wird.

## Der Chattee-Skill und tools.json

Der Chattee-Skill bringt einem Agenten bei, wie er mit Chattee arbeitet: den Build-Ablauf, die Regel zur Freigabe, was jedes Ergebnis bedeutet und jedes Tool. Er ist eine Markdown-Datei, dazu ein Zip für Claude.ai. `tools.json` listet dieselben Tools als Daten. Ein Plugin, sobald es gelistet ist, installiert Verbindung und Skill zusammen.

- **Agent-Skill:** [`skill.md`](/docs/mcp/skill.md) bringt einem Agenten den Build-Ablauf, die Regel zur Freigabe und jedes Tool bei, für jeden Client, der Agent Skills liest (Claude Code, Cursor, Codex, das Claude Agent SDK). Der Skill ist auf Englisch, weil Agenten ihn lesen. Claude.ai nimmt denselben Skill als [`chattee-skill.zip`](/docs/mcp/chattee-skill.zip): Lade ihn unter **Customize → Skills** hoch.
- **Tools als JSON:** [`tools.json`](/docs/mcp/tools.json) listet jedes Tool mit Gruppe, Scope, Zugriff und Eingaben, für Agenten und Verzeichnisse, die Daten statt Text wollen.

## Anmeldung: OAuth oder Personal Access Tokens

Es gibt zwei Wege zur Anmeldung und einen Satz Scopes. Gehostete Clients nutzen OAuth 2.1 und schicken dich zur Freigabeseite von Chattee; Clients mit Header senden ein Personal Access Token. In beiden Fällen entscheiden die Scopes, die du vergibst, welche Tools funktionieren, und widerrufen kannst du eine Verbindung oder ein Token auf der [Seite KI-Assistenten](/app/ai-assistants).

- **OAuth 2.1** nutzen die gehosteten Clients (Claude.ai, ChatGPT, Cursor, die `/mcp`-Anmeldung in Claude Code). Der Client weist sich mit einem Client-ID-Metadata-Dokument oder per dynamischer Registrierung aus, belegt den Besitz mit PKCE (S256) und schickt dich zur Freigabeseite von Chattee. Die Seite zeigt den Namen des Clients mit seiner geprüften Domain oder markiert einen Client, der sich selbst registriert hat, als ungeprüft und zeigt, wohin dich die Freigabe zurückschickt. Access Tokens gelten 1 Stunde, Refresh Tokens 30 Tage; ein Refresh rotiert das Token, und ein wiederverwendetes widerruft die ganze Freigabe.
- **Personal Access Tokens** (`chattee_pat_…`) sind für Clients mit Header: Claude Code mit `--header`, Codex, das Agent SDK, Skripte. Erstelle sie auf der **[Seite KI-Assistenten](/app/ai-assistants)**, mit den Scopes, die du willst, und optional einem Ablaufdatum. Das Token wird einmal gezeigt und gehasht gespeichert. Widerrufen kannst du es auf derselben Seite.

| Scope | Was er erlaubt | Tools |
|---|---|---|
| `projects:read` | Workspaces, Projekte, Chats, Läufe, Logs, Dateien, Vorlagen und Release-Status lesen | `list_workspaces`, `list_projects`, `get_project`, `list_chats`, `get_chat`, `wait_for_run`, `get_run_logs`, `get_release_status`, `list_templates`, `get_template`, `list_files`, `read_file`; außerdem: `create_project`, `send_message` und `refine_plan` mit Anhängen |
| `projects:write` | Projekte und Chats anlegen, Nachrichten senden, Pläne freigeben und überarbeiten, Fragen beantworten, Läufe stoppen, fortsetzen und wiederholen | `create_project`, `create_chat`, `send_message`, `approve_plan`, `refine_plan`, `answer_question`, `stop_run`, `continue_run`, `retry_run`; außerdem: `wait_for_run`, wenn dein Client die Frage des Agenten als Formular zeigt |
| `projects:delete` | Projekte und Chats löschen (ein Projekt braucht seinen exakten Namen als Bestätigung) | `delete_project`, `delete_chat` |
| `publish` | auf Live veröffentlichen, ein Release wiederherstellen, Umgebungsvariablen auf Live anwenden | `publish_project`; außerdem: `set_env_vars` mit `env: live` |
| `templates` | ein Projekt als Vorlage exportieren; eigene Vorlagen umbenennen, beschreiben, taggen, veröffentlichen und löschen | `export_project_as_template`, `update_template`, `delete_template` |
| `files:write` | Dateien im Draft eines Projekts schreiben und löschen | `write_file`, `delete_file` |
| `config` | Umgebungsvariablen, Managed Resources, Provisionierung, lesende Datenbankabfragen | `list_env_vars`, `set_env_vars`, `list_resources`, `provision_resource`, `query_database` |
| `usage:read` | der Credit-Stand | `get_credits` |

**Möglichst wenig Rechte:** Ein Token mit nur `projects:read` und `usage:read` kann alles ansehen und nichts ändern; nimm `projects:write` zum Bauen dazu und `publish` nur, wenn dein Assistent Änderungen live stellen soll.

Ein Tool, das ohne seinen Scope aufgerufen wird, antwortet mit einem `insufficient_scope`-Ergebnis, das den Scope nennt und wo du ihn vergibst; geändert wird nichts. Verbundene Apps und Tokens siehst und widerrufst du auf der [Seite KI-Assistenten](/app/ai-assistants).

## MCP-Tools im Überblick

Der Chattee MCP-Server hat 35 Tools in acht Gruppen, unten aufgeführt mit dem Scope, den jedes braucht, und dem, was es mit deinen Daten tun darf. Jedes Ergebnis ist Markdown für den Assistenten plus strukturierte Daten, und jeder Link darin (Builder-Chat, Draft-Vorschau, Live-URL) ist absolut, damit dein Assistent ihn dir weiterreichen kann.

### Konto und Workspaces

Als wer du baust: deine Workspaces und die Credits, aus denen ein Build schöpft.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `list_workspaces` | Listet die Workspaces, zu denen du gehörst; der alphabetisch erste ist der Standard. | `projects:read` | Nur lesen |
| `get_credits` | Zeigt den Credit-Stand, aus dem der nächste Build schöpft, und das Credit-Limit pro Lauf. | `usage:read` | Nur lesen |

### Projekte

Ein Projekt ist eine Web-App mit eigener Draft-Vorschau und eigener Live-URL.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `list_projects` | Listet die Projekte eines Workspace mit Deploy-Status und Links; `query` sucht nach Namen. | `projects:read` | Nur lesen |
| `get_project` | Zeigt Module, Draft- und Live-Status, unveröffentlichte Änderungen, den Chat mit dem laufenden Lauf und Links. | `projects:read` | Nur lesen |
| `create_project` | Legt ein Projekt aus einer Beschreibung an (die Planung startet sofort) oder aus einer Vorlage. | `projects:write`¹ | Ändert Daten |
| `delete_project` | Löscht ein Projekt endgültig; verlangt seinen exakten Namen als Bestätigung. | `projects:delete` | Überschreibt oder löscht |

¹ Mit Anhängen brauchen `create_project`, `send_message` und `refine_plan` zusätzlich `projects:read`.

### Chats

Jeder Chat ist ein Gespräch mit dem Agenten; ein Projekt macht immer nur eine Sache zur Zeit.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `list_chats` | Listet die Chats eines Projekts nach letzter Aktivität. | `projects:read` | Nur lesen |
| `create_chat` | Öffnet einen neuen Chat oder gibt den leeren zurück; gibt nie den belegten Chat heraus. | `projects:write` | Ändert Daten |
| `get_chat` | Liest das Transkript als typisierte Zeilen (Text, Plan, Frage, Abschlusszusammenfassung) plus den Stand des Laufs; blättert mit `before` zurück. | `projects:read` | Nur lesen |
| `delete_chat` | Löscht einen Chat; abgelehnt, solange er einen offenen Lauf hat. | `projects:delete` | Überschreibt oder löscht |

### Build-Läufe

Einen Lauf starten, auf seine Entscheidungspunkte warten und deine Entscheidungen zum Plan und zu den Fragen des Agenten weitergeben.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `send_message` | Startet einen Lauf (`mode: plan` oder `edit`) oder reicht Feedback in den laufenden hinein; ein großer Chat, der länger ruhte, geht in einem neuen weiter. | `projects:write`¹ | Ändert Daten |
| `wait_for_run` | Wartet bis zu einem Entscheidungspunkt (Plan, Frage, Pause, Abschluss, Fehler) oder bis zum Timeout und streamt den Fortschritt. | `projects:read` | Ändert Daten² |
| `approve_plan` | Reicht dein Ja zum Plan weiter; deployt und startet den Build. | `projects:write` | Ändert Daten |
| `refine_plan` | Reicht dein Feedback zum Plan weiter; der Agent überarbeitet ihn. | `projects:write`¹ | Ändert Daten |
| `answer_question` | Reicht deine Antwort auf eine Frage des Agenten weiter; nie eine Vermutung. | `projects:write` | Ändert Daten |
| `stop_run` | Stoppt den Lauf oder beendet einen, der an seinem Credit-Limit pausiert. | `projects:write` | Überschreibt oder löscht³ |
| `continue_run` | Setzt einen pausierten Lauf fort; erhöht sein Budget nur auf eine Summe, die du selbst nennst. | `projects:write` | Ändert Daten |
| `retry_run` | Lässt einen gestoppten oder fehlgeschlagenen Lauf auf derselben Konversation erneut laufen. | `projects:write` | Ändert Daten |
| `get_run_logs` | Liest die Tool-Aufrufe des Laufs, das Deploy-Log oder das Log eines Containers; sagt, wenn eine Antwort gekürzt wurde. | `projects:read` | Nur lesen |

¹ Mit Anhängen brauchen `create_project`, `send_message` und `refine_plan` zusätzlich `projects:read`.

² `wait_for_run` sendet nur die Antwort, die du gibst, wenn dein Client die Frage des Agenten als Formular zeigt.

³ `stop_run` beendet den laufenden Lauf oder einen, der an seinem Credit-Limit pausiert; schon erledigte Arbeit bleibt im Draft.

### Veröffentlichen

Den Draft nach Live bringen, das Release verfolgen oder zu einem früheren zurückkehren.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `get_release_status` | Draft gegen Live, das Release hinter Live, Verlauf und Blocker; wartet mit `wait_seconds` auf ein Release. | `projects:read` | Nur lesen |
| `publish_project` | Veröffentlicht den Draft auf Live oder stellt ein früheres Release wieder her. | `publish` | Überschreibt oder löscht |

### Vorlagen

Ein Projekt aus einer Vorlage starten oder ein deploytes Projekt zur Vorlage machen.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `list_templates` | Listet die Vorlagen, aus denen du starten kannst: deine, veröffentlichte oder beide. | `projects:read` | Nur lesen |
| `get_template` | Zeigt Beschreibung, Tags, Module und Vorschau einer Vorlage. | `projects:read` | Nur lesen |
| `export_project_as_template` | Friert ein deploytes Projekt als private Vorlage mit eigener leerer Datenbank ein. | `templates` | Ändert Daten |
| `update_template` | Benennt eine Vorlage um, beschreibt, taggt, veröffentlicht sie oder zieht sie zurück. | `templates` | Ändert Daten |
| `delete_template` | Löscht eine Vorlage endgültig; zieh sie vorher zurück. | `templates` | Überschreibt oder löscht |

### Dateien

Den Code lesen oder eine kleine, eindeutige Änderung machen; für alles Größere eine Bearbeitung schicken, damit der Agent baut und prüft.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `list_files` | Zeigt einen Dateibaum oder sucht in Namen und Inhalten. | `projects:read` | Nur lesen |
| `read_file` | Liest einen Ausschnitt einer Textdatei, höchstens 200.000 Zeichen pro Aufruf. | `projects:read` | Nur lesen |
| `write_file` | Schreibt eine ganze Datei im Draft und legt sie an, wenn sie fehlt; zählt als unveröffentlichte Änderung. | `files:write` | Überschreibt oder löscht |
| `delete_file` | Löscht eine Datei im Draft. | `files:write` | Überschreibt oder löscht |

### Konfiguration und Daten

Die Einstellungen der App, ihre Managed Resources und lesende Datenbankabfragen.

| Tool | Was es tut | Scope | Zugriff |
|---|---|---|---|
| `list_env_vars` | Listet Variablen pro Modul; der Wert eines Secrets kommt als `null` zurück. | `config` | Nur lesen |
| `set_env_vars` | Führt Variablen zusammen; entfernt eine nur mit `remove: true`; `apply` erstellt die Container neu. | `config`⁴ | Überschreibt oder löscht |
| `list_resources` | Listet die verwaltete Datenbank, Dateispeicher, Auth und E-Mail mit ihrem Zustand. | `config` | Nur lesen |
| `provision_resource` | Fügt eine Managed Resource außerhalb eines Plans hinzu. | `config` | Ändert Daten |
| `query_database` | Zeigt das Schema oder führt eine lesende Abfrage gegen Draft oder Live aus (`env` ist Pflicht; Live-Abfragen werden protokolliert). | `config` | Nur lesen |

⁴ Mit `env: live` braucht `set_env_vars` zusätzlich `publish`.

## Der Build-Ablauf und die Freigabe durch dich

Jeder Build folgt demselben Ablauf: ein Planungslauf, deine Freigabe, der Build und eine Veröffentlichung, wenn du sie willst. Dein Assistent steuert ihn mit einer Handvoll Tools und wartet dazwischen, denn ein Build dauert 5–90 Minuten. Zwei Entscheidungen bleiben immer bei dir: einen Plan freigeben und mehr ausgeben als das Budget eines Laufs.

1. `create_project` (oder `send_message` in einen bestehenden Chat mit `mode: plan`) startet einen Planungslauf.
2. `wait_for_run` kehrt zurück, wenn der Plan fertig ist. Dein Assistent zeigt dir den **vollständigen Plan** und den Link in den Builder.
3. Du sagst Ja – `approve_plan` – oder gibst Feedback – `refine_plan`. Die Freigabe deployt die Container und startet die Umsetzung.
4. `wait_for_run`, wiederholt, bis der Lauf abgeschlossen ist. Ein Lauf dauert 5–90 Minuten; jedes Warten endet nach höchstens 240 Sekunden mit dem bisherigen Fortschritt, und ein `timed_out_waiting` heißt nur „ruf es noch einmal auf“.
5. Wenn der Agent etwas fragt (`awaiting_input`), reicht dein Assistent die Frage weiter, und deine Antwort geht über `answer_question` zurück. Clients, die MCP-Elicitation unterstützen, bekommen die Frage stattdessen als Formular.
6. Ist der Lauf abgeschlossen, kommen die Abschlusszusammenfassung und der Link zur Draft-Vorschau zurück. `publish_project`, wenn du es willst; die Live-URL kommt auf demselben Weg.

Budget-Pausen, eine abgelaufene Karte oder fehlende Credits beenden ein Warten mit dem Ergebnis `escalate` und Links in den Builder. Das Budget eines pausierten Laufs steigt nur auf eine Summe, die du selbst nennst: Dein Assistent gibt deine Zahl mit `continue_run` weiter und speichert sie nur dann als deinen Standard, wenn du das extra sagst. Ein Lauf, der an seinem Limit pausiert, endet nach 30 Minuten von selbst, wenn niemand entscheidet, und `stop_run` beendet ihn sofort; seine Arbeit bleibt erhalten, und deine nächste Nachricht setzt sie als neuen Lauf mit frischem Credit-Limit fort. Credits kaufst du im Builder; nichts an diesem Endpunkt kauft sie.

## Limits und Rate Limits

Jedes Limit unten setzt der Server durch und nennt es in seiner Antwort, wenn du es erreichst, damit dein Assistent warten oder den Aufruf eingrenzen kann, statt zu raten. Wartevorgänge sind begrenzt, damit kein Client einen Aufruf verliert, Aufrufe pro Nutzer gedrosselt, und lange Inhalte kommen in Ausschnitten, durch die du blätterst.

- `wait_for_run` wartet standardmäßig 45 Sekunden; `get_release_status` wartet standardmäßig 0 Sekunden, antwortet also sofort, wenn du kein `wait_seconds` angibst. Beide warten höchstens 240 Sekunden pro Aufruf. Länger bringt nichts: Claude Code bricht einen HTTP-Tool-Aufruf nach fünf Minuten ohne Fortschritt ab.
- 120 Aufrufe pro Minute und Nutzer, über alle deine Tokens und verbundenen Apps; darüber kommt ein `rate_limited`-Ergebnis mit `retry_after_seconds`. Ein laufendes Warten hält den Lauf am Leben.
- 20 gleichzeitige Wartevorgänge pro Nutzer, ein Lauf pro Projekt zur Zeit, und das Projektlimit deines Plans.
- Anhänge: bis zu 10 pro Nachricht, Text bis 256 KB und Binärdateien bis 5 MB je Datei, insgesamt höchstens 20 MB pro Nachricht.
- `read_file` liefert höchstens 200.000 Zeichen pro Aufruf. Ein längerer Ausschnitt kommt mit `truncated: true` und `next_offset_line` zurück, und das Ergebnis sagt, wie du mit `offset_line` und `limit_lines` weiterliest.
- `get_chat` kürzt lange Nachrichten (`truncated: true`) und liefert ältere über `before`: Übergib das `next_before` aus dem Ergebnis, um die Seite davor zu lesen.
- `get_run_logs` begrenzt jede Antwort und sagt, wenn es eine gekürzt hat; grenze es mit `tail` oder `source` ein.
- Idempotency Keys auf schreibenden Tools werden 24 Stunden gemerkt; ein Neustart des Dienstes vergisst sie.

## Sicherheit

Der Endpunkt ist die einzige öffentliche Fläche des Chattee MCP-Servers; die Token-Prüfung und jeder Aufruf in Chattee laufen dahinter auf demselben Host. Tokens werden gehasht gespeichert, Scopes bei jedem Aufruf geprüft, Inhalte durchlaufen die Guardrails des Builders, und jeder Tool-Aufruf landet in einem Audit-Log.

- Der Endpunkt ist die einzige öffentliche Fläche. Die Token-Prüfung und jeder Aufruf der Chattee-Steuerung laufen auf dem Loopback desselben Hosts.
- Tokens werden gehasht gespeichert. OAuth nutzt PKCE S256, exakte Redirect-URIs (Loopback-Ports ausgenommen, nach RFC 8252), einmal gültige Codes und rotierende Refresh Tokens; die Freigabeseite zeigt die geprüfte Domain eines Clients und markiert einen selbst registrierten Client als ungeprüft, damit ein Client, der sich als ein anderer ausgibt, sichtbar ist.
- Scopes werden bei jedem Aufruf durchgesetzt; der Endpunkt lehnt den Account-API-Key ab.
- Inhalte durchlaufen dieselben Guardrails wie im Builder. Eine Sperre durch die Guardrails widerruft jedes Token und jede verbundene App des Kontos.
- Jeder Tool-Aufruf landet in einem Audit-Log, das 30 Tage aufbewahrt wird. Im Builder-Chat ist eine Nachricht, die dein Assistent gesendet hat, mit dem Client gekennzeichnet, der sie gesendet hat, zum Beispiel „über Claude Code“.
- Ein Token oder eine verbundene App widerrufst du jederzeit auf der [Seite KI-Assistenten](/app/ai-assistants).

## Fehlersuche

Die meisten Fehler nennen ihre Lösung selbst: Das Ergebnis enthält einen Code, einen Satz zum Geschehenen und oft einen Link in den Builder. Unten stehen die Codes, die dir am ehesten begegnen, jeweils mit dem, was du tun kannst. Schlägt ein Aufruf ohne Code fehl, melde ihn uns mit der Uhrzeit des Aufrufs.

- **401 `invalid_token`** – das Token wurde widerrufen, ist abgelaufen oder ist der Account-API-Key. Erstelle ein Personal Access Token, oder verbinde neu, damit der Client sich erneut anmeldet.
- **`token_inactive`** – die Zugangsdaten haben während des Aufrufs aufgehört zu funktionieren: widerrufen oder abgelaufen. Eine verbundene App meldet sich bei der nächsten Anfrage neu an (verbinde sie neu, falls nicht); ein Personal Access Token lässt sich nicht retten, also erstelle auf der [Seite KI-Assistenten](/app/ai-assistants) ein neues und nutze es stattdessen.
- **`email_unconfirmed`** – die E-Mail-Adresse deines Chattee-Kontos ist noch nicht bestätigt. Bestätige sie mit dem Link aus der E-Mail, die Chattee dir geschickt hat (der Builder schickt sie dir auch erneut), und versuch es dann noch einmal.
- **`account_blocked`** – dein Chattee-Konto ist gesperrt, und bis es wieder freigegeben ist, funktioniert an diesem Endpunkt nichts. [Schreib uns](/de/p/contact).
- **`internal_error`** – in Chattee ist etwas schiefgegangen. Versuch den Aufruf noch einmal; schlägt er wieder fehl, [melde ihn uns](/de/p/contact) mit der Uhrzeit des Aufrufs.
- **`insufficient_scope`** – das Ergebnis nennt den fehlenden Scope. Vergib ihn am Token, oder verbinde die App neu und akzeptiere die Berechtigung.
- **`rate_limited`** – warte die `retry_after_seconds` ab; nichts ist verloren, der Lauf geht weiter.
- **`conflict_busy`** – ein anderer Chat des Projekts hält den Workspace; das Ergebnis nennt ihn. Warte dort, oder stoppe diesen Lauf.
- **`attachment_invalid`** – das `base64` eines Anhangs ist kein gültiges Base64. Kodiere die Datei neu, oder schick eine Textdatei als `text`.
- **`too_many_tasks`** – für dein Konto sind zu viele lang laufende Tasks auf dem Server offen (bei Clients, die MCP-Tasks nutzen). Lass einige zu Ende laufen oder brich sie ab und versuch es dann erneut; die Läufe selbst sind davon nicht betroffen.
- **Cursor fragt immer wieder nach der Anmeldung** – Cursor ignoriert `Authorization`-Header, wenn ein Server OAuth anbietet. Entferne den Header und melde dich an.
- **Codex meldet ein Timeout** – Codex beendet Tool-Aufrufe nach 60 Sekunden. Behalte das Standard-Warten; gib `timeout_seconds` nicht über 50 an.
- **503 `introspection_unavailable`** – Chattee konnte Tokens einen Moment lang nicht prüfen. Versuch es nach ein paar Sekunden erneut; der Client behält sein Token.

## Änderungen

- **2026-10-15** – Die Doku und die Landingpage gibt es jetzt auch auf Spanisch, Französisch und Portugiesisch, neben Englisch und Deutsch: `/es/docs/mcp`, `/fr/docs/mcp` und `/pt/docs/mcp`, jeweils mit ihrer Markdown-Fassung. Der Agent-Skill und `tools.json` bleiben auf Englisch.
- **2026-10-02** – Ein Lauf, der an seinem Credit-Limit pausiert, endet nach 30 Minuten von selbst, wenn niemand entscheidet, und `stop_run` beendet ihn sofort (Ergebnis `ended`); `get_credits` nennt das Limit, mit dem ein Lauf startet, und wie weit es höchstens steigen darf; `create_project` nimmt das Limit des ersten Laufs und `approve_plan` den eigenen Rahmen des Builds, jeweils nur als Zahl, die du selbst nennst.
- **2026-10-01** – Die Tools stehen in einer Tabelle pro Gruppe, mit dem Scope jedes Tools und dem, was es mit deinen Daten tun darf; Beispiel-Prompts aus echten Läufen; der Chattee-Skill (`skill.md` und ein Zip für Claude.ai) und `tools.json`; ein Assistent erhöht das Budget eines pausierten Laufs nur auf eine Summe, die du selbst nennst. Claude Code: Der Einrichtungsbefehl fügt Chattee für deinen Nutzer hinzu (`--scope user`), und `claude mcp login chattee` meldet dich in der Shell an. Die Schritte für Claude.ai und ChatGPT folgen den aktuellen Menüs beider Apps.
- **2026-09-26** – Erste Version: 35 Tools, OAuth 2.1 mit PKCE und Personal Access Tokens, beide Protokollrevisionen, MCP-Elicitation und Tasks für Clients, die sie unterstützen, eine Abschlusszusammenfassung am Ende jedes Builds.

## FAQ

### Was kann der Chattee MCP-Server?

Er lässt deinen KI-Assistenten aus einer Beschreibung eine komplette Web-App auf Chattee bauen: das Projekt anlegen, dir den Plan zur Freigabe weiterreichen, den Build verfolgen, dir die Draft-Vorschau geben und auf eine Live-URL veröffentlichen. Außerdem kann er Dateien lesen und ändern, Umgebungsvariablen und Managed Resources verwalten, die Datenbank lesend abfragen und aus Vorlagen starten.

### Wie fange ich mit dem Chattee MCP-Server an?

Leg ein kostenloses Chattee-Konto an, füge https://chattee.ai/mcp/connect in deinem Assistenten hinzu (ein Befehl in Claude Code, ein eigener Connector in Claude.ai, ein JSON-Eintrag in Cursor), melde dich per OAuth oder mit einem Personal Access Token an und bitte deinen Assistenten, etwas zu bauen. Die Einrichtung für jeden Client steht auf dieser Seite.

### Welche KI-Assistenten funktionieren mit dem Chattee MCP-Server?

Claude Code, Claude.ai, Claude Desktop und die mobilen Claude-Apps, Cursor, Codex CLI, ChatGPT im Developer mode und Agenten auf dem Claude Agent SDK. Jeder andere MCP-Client, der Streamable HTTP spricht, funktioniert auch; mcp-remote verbindet einen Client, der nur stdio spricht.

### Ist der Chattee MCP-Server kostenlos?

Die Verbindung ist kostenlos. Das Bauen verbraucht die Credits deines Chattee-Plans, genau wie im Browser, und der kostenlose Plan enthält Credits zum Start. Ein Lauf, der sein Budget erreicht, pausiert; sein Rahmen steigt nur auf eine Summe, die du selbst nennst, und Credits kaufst du im Builder.

### Deployt und hostet Chattee die App?

Ja. Jedes Projekt bekommt eine Draft-Vorschau, und das Veröffentlichen bringt es auf eine Live-URL auf chattee.ai oder deiner eigenen Domain, mit verwalteter Postgres-Datenbank, Login, Dateispeicher und E-Mail, wenn die App sie braucht. Dein Assistent hat nie mit Servern, Containern oder Deploy-Skripten zu tun.

### Kann mein Assistent einen Plan selbst freigeben?

Nein. Jeder Plan wird dir vollständig gezeigt, und nur du gibst ihn frei, im Chat oder im Builder. Die Tool-Beschreibungen verbieten die Selbstfreigabe, und ein Token lässt sich auf Lese-Scopes beschränken, wenn du sichergehen willst.

### Kann mein Assistent das Budget eines Laufs erhöhen?

Nur auf eine Summe, die du selbst nennst. Ein Lauf, der sein Budget erreicht, pausiert, und dein Assistent gibt dir den Link in den Builder. Nennst du ihm selbst eine neue Summe, setzt er den Lauf mit genau diesem Rahmen fort und speichert ihn nur nach einem eigenen Ja als deinen Standard. Entscheidet niemand, endet der pausierte Lauf nach 30 Minuten von selbst und behält seine Arbeit; deine nächste Nachricht setzt sie als neuen Lauf fort. Credits kauft dein Assistent nie: Pläne und Credits kaufst du im Builder.

### Was ist anders, als einen Coding-Agenten die App selbst bauen zu lassen?

Ein Coding-Agent allein schreibt Code auf deinem Rechner, und Hosting, Datenbank, Login, E-Mail und Deploys musst du selbst zusammenstellen. Über Chattee gibt dein Assistent die Beschreibung an einen Builder, der die ganze App plant, baut, deployt und hostet, während du den Plan freigibst und entscheidest, wann sie live geht.

### Welche MCP-Protokollversionen werden unterstützt?

Beide aktuellen Revisionen: 2025-11-25, die sessionbasierte, die heute jeder verbreitete Client spricht, und 2026-07-28, die zustandslose mit Tasks und Input-Required-Ergebnissen. Transport ist Streamable HTTP. Ein stdio-Paket gibt es nicht; mcp-remote überbrückt einen Client, der eines braucht.

### Kann ich meinen Account-API-Key statt eines Tokens nutzen?

Nein. Der Endpunkt lehnt den Account-Key bewusst ab: Ein Personal Access Token hat Scopes und lässt sich widerrufen, der Account-Key beides nicht. Erstelle ein Token auf der Seite KI-Assistenten oder lass den Client sich per OAuth anmelden.

### Wie lange dauert ein Build?

Eine komplette App braucht 5–90 Minuten, eine kleine Änderung ein paar. wait_for_run kehrt an jedem Entscheidungspunkt zurück und sonst nach höchstens 240 Sekunden, dein Assistent fragt also weiter nach, bis der Lauf dich braucht.

### Was passiert, wenn mein Assistent während eines Builds die Verbindung verliert?

Auf Chattee-Seite nichts: Läufe leben im Backend, nicht in der Verbindung. Verbinde dich neu und rufe wait_for_run erneut auf, oder öffne den Chat im Builder, wo derselbe Lauf weitergeht.

### Gibt es diese Dokumentation auch in anderen Sprachen?

Ja: auf Englisch unter /docs/mcp, auf Spanisch unter /es/docs/mcp, auf Französisch unter /fr/docs/mcp und auf Portugiesisch unter /pt/docs/mcp, die Landingpage jeweils unter demselben Präfix (/mcp, /es/mcp und so weiter). Der Agent-Skill und tools.json sind nur auf Englisch, weil Agenten sie lesen.