# MCP-Server

> Verbinde Claude Code, Cursor und andere KI-Tools über den Remote-MCP-Server mit deinem intoCHAT-Konto: Endpunkt, API-Schlüssel und Scopes, Einrichtung für jeden Client, die Tools und die Grenzen.

intoCHAT hat einen Remote-MCP-Server. MCP (Model Context Protocol) ist der Standard, über den KI-Tools wie Claude Code und Cursor sich mit anderen Diensten verbinden. Hast du dein Tool verbunden, kannst du es in normalen Worten bitten, deine Agenten aufzulisten, ihre Gespräche und Leads zu lesen, Textbausteine und Q&A-Paare hinzuzufügen, Quellen zu löschen oder einem Agenten eine Testnachricht zu senden, und es ruft intoCHAT für dich auf.

Der MCP-Server nutzt dieselben API-Schlüssel, Scopes, Pläne und dasselbe Ratenlimit wie die [REST-API](/de/docs/rest-api), und seine Tools tun genau das, was die passenden REST-Endpunkte tun.

## Endpunkt

```text
https://www.intochat.ai/api/mcp
```

Der Server nutzt den Transport Streamable HTTP. Jede Anfrage braucht deinen API-Schlüssel im Header `Authorization`:

```text
Authorization: Bearer ic_live_YOUR_KEY
```

Nutze die Adresse mit `www`, wie oben.

> Die Anmeldung mit OAuth wird noch nicht unterstützt. Clients, die sich nur über OAuth verbinden können, etwa eigene Connectors in Claude.ai und in der Claude-Desktop-App oder Connectors in ChatGPT, können den Server vorerst nicht nutzen. Clients, in denen du einen Header setzen kannst, funktionieren: Claude Code, Cursor, der MCP Inspector und die Claude-Desktop-App über eine lokale Bridge (siehe [Andere Clients](#andere-clients)).

## Bevor du loslegst

Der MCP-Server ist wie die REST-API in **Starter**, **Pro** und **Enterprise** enthalten. Im Plan **Free** kannst du keine API-Schlüssel erstellen, und ein Konto, das zurück zu Free wechselt, bekommt bei jeder Anfrage einen Fehler, bis es wieder im Plan Starter oder höher ist.

Du brauchst einen API-Schlüssel. Nur der Owner des Kontos und Admins können einen erstellen.

## API-Schlüssel erstellen

1. Klicke in der Seitenleiste unter **Settings** auf **API keys**.
2. Gib dem Schlüssel unter **Create a key** einen **Name**, zum Beispiel `Claude Code`.
3. Wähle unter **Access**, was das KI-Tool darf. **Every scope, including ones added later** erlaubt jedes Tool. Soll es nur lesen dürfen, wähle **Only the scopes I choose** und hake nur die `:read`-Scopes an. Welchen Scope jedes Tool braucht, steht unter [Tools](#tools).
4. Klicke auf **Create key**, dann auf **Copy**, und klicke auf **I've saved it**. Der Schlüssel wird nur einmal angezeigt.

Ein Schlüssel funktioniert für jeden Agenten im Konto. Behandle ihn wie ein Passwort: Halte ihn aus Dateien heraus, die du committest oder teilst, und widerrufe ihn auf der Seite **API keys**, wenn jemand anderes ihn haben könnte. Mehr dazu unter [API-Schlüssel erstellen](/de/docs/rest-api#api-schlussel-erstellen) in der Dokumentation der REST-API.

## Claude Code verbinden

Führe das in einem Terminal aus, mit deinem Schlüssel statt `ic_live_YOUR_KEY`:

```bash
claude mcp add --transport http intochat https://www.intochat.ai/api/mcp \
  --header "Authorization: Bearer ic_live_YOUR_KEY"
```

Damit fügst du den Server für das aktuelle Projekt hinzu, nur auf deinem Computer. Um ihn in jedem Projekt zu nutzen, füge `--scope user` vor `--transport` ein.

Um die Einrichtung in der `.mcp.json` des Projekts mit deinem Team zu teilen, ohne den Schlüssel selbst, lies den Schlüssel aus einer Umgebungsvariablen:

```json
{
  "mcpServers": {
    "intochat": {
      "type": "http",
      "url": "https://www.intochat.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer ${INTOCHAT_API_KEY}"
      }
    }
  }
}
```

Tippe dann in Claude Code `/mcp`, um zu prüfen, ob **intochat** verbunden ist, und frag zum Beispiel: „Liste meine intoCHAT-Agenten auf.“

## Cursor verbinden

Öffne in den Einstellungen von Cursor den Bereich MCP und füge einen Server hinzu, oder bearbeite `~/.cursor/mcp.json` (alle Projekte) oder `.cursor/mcp.json` in einem Projekt:

```json
{
  "mcpServers": {
    "intochat": {
      "url": "https://www.intochat.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer ic_live_YOUR_KEY"
      }
    }
  }
}
```

Die intoCHAT-Tools erscheinen dann in der Liste der MCP-Tools, und der Agent von Cursor kann sie nutzen.

## Andere Clients

Jeder MCP-Client, der den Transport Streamable HTTP unterstützt und in dem du einen Header hinzufügen kannst, kann sich verbinden. Gib ihm den [Endpunkt](#endpunkt) und den Header `Authorization`.

**Claude-Desktop-App.** Ihre Einstellungen unter **Connectors** brauchen OAuth, was noch nicht unterstützt wird. Füge den Server stattdessen über die Open-Source-Bridge `mcp-remote` in `claude_desktop_config.json` hinzu. Dafür brauchst du Node.js auf deinem Computer:

```json
{
  "mcpServers": {
    "intochat": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://www.intochat.ai/api/mcp", "--header", "Authorization:${INTOCHAT_AUTH}"],
      "env": {
        "INTOCHAT_AUTH": "Bearer ic_live_YOUR_KEY"
      }
    }
  }
}
```

**MCP Inspector.** Führe `npx @modelcontextprotocol/inspector` aus, wähle **Streamable HTTP**, gib den Endpunkt ein und füge den Header `Authorization` hinzu. Verbinde dich über den Proxy des Inspectors: Der Server lehnt Anfragen ab, die direkt von einer Webseite auf einer anderen Website kommen.

**Test mit curl.** Jede Anfrage ist eine JSON-RPC-Nachricht in einem POST:

```bash
curl https://www.intochat.ai/api/mcp \
  -H "Authorization: Bearer ic_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2025-11-25" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}'
```

Der Server spricht die MCP-Versionen `2026-07-28` und `2025-03-26` bis `2025-11-25`, beantwortet jede Anfrage mit JSON und hält zwischen Anfragen keine Sitzung.

## Tools

| Tool | Scope | Was es tut |
| --- | --- | --- |
| `list_agents` | `agents:read` | Listet die Agenten des Kontos mit ihren IDs, ihrem Trainingsstatus und ihren Zahlen auf. |
| `get_agent` | `agents:read` | Ruft einen Agenten ab. |
| `chat_with_agent` | `chat` | Sendet eine Nachricht an einen Agenten und liefert seine Antwort. Jede Antwort zählt als eine Nachricht deines Plans. |
| `list_conversations` | `conversations:read` | Listet die Gespräche eines Agenten auf, die neuesten zuerst, ohne Verläufe. |
| `get_conversation` | `conversations:read` | Ruft ein Gespräch mit seinem Verlauf ab. |
| `list_leads` | `leads:read` | Listet die Leads auf, die ein Agent erfasst hat, die neuesten zuerst. |
| `list_contacts` | `leads:read` | Listet die [Kontakte](/de/docs/contacts) eines Agenten auf, die neuesten zuerst, oder sucht einen anhand von `email` oder `external_id`. |
| `upsert_contact` | `contacts:write` | Legt einen Kontakt anhand von `external_id`, sonst `email` an oder aktualisiert ihn, mit `phone`, `name` und `attributes` (ein Objekt; `null` entfernt ein Attribut). |
| `list_sources` | `sources:read` | Listet die Wissensquellen eines Agenten, seinen Trainingsfortschritt und die belegten Zeichen auf. |
| `add_text_source` | `sources:write` | Fügt einen Textbaustein mit Titel hinzu und startet das Training. |
| `add_qa_pair` | `sources:write` | Fügt eine Frage mit Antwort hinzu und startet das Training. Hat der Agent dieselbe Frage schon, wird ihre Antwort ersetzt. |
| `delete_source` | `sources:write` | Löscht eine Quelle und das, was der Agent daraus gelernt hat. Das lässt sich nicht rückgängig machen. |

Jedes Tool liefert dieselben Daten wie sein REST-Endpunkt, als JSON. `list_conversations`, `list_leads` und `list_contacts` nehmen optional `limit` (1 bis 100), `cursor` und `since` an, wie unter [Paginierung](/de/docs/rest-api#paginierung) beschrieben.

Die Tools sind als nur lesend oder nicht gekennzeichnet, und `delete_source`, `add_qa_pair` und `upsert_contact` zusätzlich als Tools, die Bestehendes ändern können, damit dein KI-Tool dich fragen kann, bevor es sie nutzt. Viele KI-Tools fragen ohnehin nach deiner Bestätigung, bevor sie ein Tool ausführen.

Fehlt dem Schlüssel der Scope, den ein Tool braucht, antwortet das Tool mit einem Fehler, der den Scope nennt, und es passiert nichts. Ein Agent, ein Gespräch oder eine Quelle aus einem anderen Konto ist „nicht gefunden“, genau wie etwas, das es nicht gibt.

Tools zum Erstellen von Agenten oder zum Ändern ihrer Einstellungen oder Anweisungen gibt es nicht. Das machst du im Dashboard.

## Mit einem Agenten chatten

`chat_with_agent` sendet eine echte Nachricht, beantwortet mit demselben Code wie im Chat-Widget, aus dem Wissen, den Anweisungen und den Aktionen des Agenten. Nutze es, um zu testen, wie ein Agent antwortet.

- Jede Antwort zählt als eine Nachricht deines Plans und auf das [monatliche Nachrichtenlimit](/de/docs/limits-and-access#monatliches-nachrichtenlimit) des Agenten, falls du eines festgelegt hast. Siehe [Was als Nachricht zählt](/de/docs/plans-and-limits#was-als-nachricht-zahlt).
- Lass `conversationId` weg, um ein neues Gespräch zu beginnen. Um eines fortzusetzen, übergib die `conversationId` der früheren Antwort.
- Die Gespräche erscheinen im Tab **Conversations** des Agenten wie alle anderen.
- Ein privater Agent ist auf diesem Weg nicht erreichbar. Siehe [Private Agenten](/de/docs/allowed-domains#private-agenten).

Bitte dein KI-Tool, nicht viele Nachrichten hintereinander zu senden, wenn du das nicht willst: Jede verbraucht Nachrichten deines Plans.

## Grenzen

- **Plan:** Starter, Pro oder Enterprise. Im Plan Free werden Anfragen abgelehnt.
- **Ratenlimit:** 60 Anfragen pro Minute und Schlüssel, geteilt mit der REST-API. Das Verbinden braucht ein paar Anfragen, ebenso jeder Tool-Aufruf. Über dem Limit werden Anfragen für den Rest der Minute abgelehnt. Ein eigener Schlüssel für dein KI-Tool verhindert, dass es die Anfragen deines Servers verbraucht.
- **Nachrichten:** Jede Antwort von `chat_with_agent` zählt als eine Nachricht deines Plans. Eine Antwort muss innerhalb von 55 Sekunden fertig sein.
- **Anmeldung:** nur API-Schlüssel. OAuth wird noch nicht unterstützt, Clients, die es brauchen, können sich also nicht verbinden.
- **Quellen:** nur Textbausteine und Q&A-Paare. Website-Seiten, Dateien und Notion-Seiten fügst du im Dashboard hinzu.
- **Keine Live-Updates:** Der Server beantwortet jede Anfrage und schickt keine Benachrichtigungen von sich aus.

Kann sich dein Client nicht verbinden, prüfe den Fehler, den er zeigt: Ein ungültiger oder widerrufener Schlüssel wird mit `401` abgelehnt, ein Konto im Plan Free mit `403` und zu viele Anfragen mit `429`.

## Wie es weitergeht

- intoCHAT aus deinem eigenen Code aufrufen: [REST-API](/de/docs/rest-api).
- Lass dir Leads und Übergaben an deinen Server schicken, sobald sie passieren: [Webhooks](/de/docs/webhooks).
- Schreib gute Textbausteine und Q&A-Paare: [Text und Q&A](/de/docs/text-and-qa).
