---
title: "MCP-Server - KI-Agenten benachrichtigen Sie oder rufen an"
sidebarTitle: MCP-Server
description: "Verbinden Sie Claude Code, Codex, Cursor, ChatGPT und andere KI-Agenten mit dem MCP-Server von Echobell – für Push-Benachrichtigungen oder Anrufe."
---

# MCP-Server für KI-Agenten

Echobell betreibt einen offiziellen Server für das [Model Context Protocol](https://modelcontextprotocol.io) (MCP). Verbinden Sie ihn mit Ihrem KI-Agenten – Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude, ChatGPT oder jedem anderen MCP-Client –, und der Agent erhält ein Werkzeug namens `notify`, mit dem er über einen Ihrer Echobell-Kanäle eine Benachrichtigung verschickt.

Starten Sie ein großes Refactoring, einen Testlauf oder ein Deployment, gehen Sie weg und bitten Sie den Agenten, Ihnen Bescheid zu geben, wenn er fertig ist. Ihr Telefon vibriert, sobald die Arbeit erledigt ist, zeigt eine zeitkritische Warnung, wenn der Agent Sie braucht, oder klingelt wie ein Telefonanruf, wenn etwas gründlich schiefgeht.

## So funktioniert es

- Es ist ein **entfernter** MCP-Server unter `https://mcp.echobell.one/mcp`, der den Transport Streamable HTTP verwendet. Es gibt nichts zu installieren: kein npm-Paket, kein `npx`, keinen lokalen Prozess.
- Jede MCP-URL gehört zu **einem Kanal**. Wenn der Agent `notify` aufruft, erhalten alle Abonnenten dieses Kanals die Benachrichtigung, jeweils mit dem [Benachrichtigungstyp](/docs/notification), den sie gewählt haben.
- Die Zugangsdaten sind das **Trigger-Token** des Kanals – dasselbe Token, mit dem die Webhook-URL des Kanals endet. Der MCP-Server funktioniert wie der [Webhook](/docs/webhook) des Kanals, nur mit einem Werkzeug, das der Agent aufzurufen weiß.

<Callout type="info">
  Legen Sie für Ihre Agenten einen eigenen Kanal an, zum Beispiel „KI-Agenten“,
  und abonnieren Sie ihn mit dem Typ **Anruf**. Ihre Agenten können dann jede
  Stufe bis hin zu einem Anruf wählen, und Sie können den Kanal mit
  Teammitgliedern teilen, die dieselben Alarme erhalten möchten.
</Callout>

## Ihre MCP-URL abrufen

### In der App

1. Öffnen Sie die Echobell-App und tippen Sie auf den Kanal, den Ihr Agent verwenden soll.
2. Suchen Sie in den Kanaldetails den Abschnitt **KI-Agent verbinden**.
3. Kopieren Sie die **MCP-Server-URL** oder das fertige Einrichtungs-Snippet für Ihren Agenten.

### Aus der Webhook-URL

Die MCP-URL verwendet dasselbe Token wie die Webhook-URL des Kanals. Nehmen Sie das Token vom Ende der Webhook-URL und setzen Sie es hinter `https://mcp.echobell.one/mcp/`:

```
Webhook URL: https://hook.echobell.one/t/<channel-token>
MCP URL:     https://mcp.echobell.one/mcp/<channel-token>
```

<Callout type="warn">
  Die MCP-URL enthält das Trigger-Token Ihres Kanals. Wer sie hat, kann den
  Abonnenten des Kanals Benachrichtigungen schicken. Behandeln Sie sie daher so
  vertraulich wie ein Passwort. Siehe [Sicherheit](#sicherheit).
</Callout>

## Agent einrichten

Alle folgenden Snippets verwenden die URL-Variante. Ersetzen Sie `<channel-token>` durch das Trigger-Token Ihres Kanals, oder fügen Sie das Snippet aus der App ein, in dem es bereits eingetragen ist.

### Claude Code

```bash
claude mcp add --transport http echobell https://mcp.echobell.one/mcp/<channel-token>
```

Fügen Sie `--scope user` hinzu, damit der Server in jedem Projekt verfügbar ist und nicht nur im aktuellen.

### Codex

Fügen Sie Folgendes in `~/.codex/config.toml` ein:

```toml
[mcp_servers.echobell]
url = "https://mcp.echobell.one/mcp/<channel-token>"
```

### Cursor

Fügen Sie Folgendes in `~/.cursor/mcp.json` ein, oder in `.cursor/mcp.json` innerhalb eines Projekts:

```json
{
  "mcpServers": {
    "echobell": {
      "url": "https://mcp.echobell.one/mcp/<channel-token>"
    }
  }
}
```

### VS Code (GitHub Copilot)

Fügen Sie Folgendes in `.vscode/mcp.json` in Ihrem Workspace ein und verwenden Sie das Werkzeug dann im Agent-Modus von Copilot Chat:

```json
{
  "servers": {
    "echobell": {
      "type": "http",
      "url": "https://mcp.echobell.one/mcp/<channel-token>"
    }
  }
}
```

Wenn `.vscode/mcp.json` in Ihr Repository eingecheckt wird, verwenden Sie stattdessen die [Header-Variante mit Eingabeaufforderung](#header-variante), damit das Token nicht in der Datei steht.

### Windsurf

Fügen Sie Folgendes in `~/.codeium/windsurf/mcp_config.json` ein:

```json
{
  "mcpServers": {
    "echobell": {
      "serverUrl": "https://mcp.echobell.one/mcp/<channel-token>"
    }
  }
}
```

### Gemini CLI

Fügen Sie Folgendes in `~/.gemini/settings.json` ein:

```json
{
  "mcpServers": {
    "echobell": {
      "httpUrl": "https://mcp.echobell.one/mcp/<channel-token>"
    }
  }
}
```

### Claude Desktop und claude.ai

1. Öffnen Sie **Einstellungen → Konnektoren**.
2. Wählen Sie **Benutzerdefinierten Konnektor hinzufügen**.
3. Geben Sie den Namen `Echobell` und die URL `https://mcp.echobell.one/mcp/<channel-token>` ein und fügen Sie den Konnektor hinzu.

Der Konnektor steht dann in Claude im Web und in der Desktop-App zur Verfügung.

### ChatGPT

1. Aktivieren Sie in den Einstellungen von ChatGPT den Entwicklermodus.
2. Öffnen Sie **Einstellungen → Konnektoren** und wählen Sie **Erstellen**.
3. Geben Sie die URL `https://mcp.echobell.one/mcp/<channel-token>` ein und stellen Sie die Authentifizierung auf **Keine Authentifizierung** – das Token in der URL ist die Zugangsberechtigung.

### Andere MCP-Clients

Jeder Client, der den Transport Streamable HTTP unterstützt, funktioniert. Geben Sie ihm die URL `https://mcp.echobell.one/mcp/<channel-token>` oder verwenden Sie die Header-Variante unten.

### Header-Variante

Statt das Token in die URL zu schreiben, können Sie es in einem `Authorization`-Header senden. Beide Varianten sind gleichwertig.

```
URL:            https://mcp.echobell.one/mcp
Authorization:  Bearer <channel-token>
```

Mit Claude Code:

```bash
claude mcp add --transport http echobell https://mcp.echobell.one/mcp \
  --header "Authorization: Bearer <channel-token>"
```

In VS Code hält eine Eingabeaufforderung das Token aus `.vscode/mcp.json` heraus, sodass Sie die Datei bedenkenlos einchecken können. VS Code fragt beim ersten Start des Servers nach dem Token und speichert es sicher:

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "echobell-token",
      "description": "Echobell channel trigger token",
      "password": true
    }
  ],
  "servers": {
    "echobell": {
      "type": "http",
      "url": "https://mcp.echobell.one/mcp",
      "headers": {
        "Authorization": "Bearer ${input:echobell-token}"
      }
    }
  }
}
```

## Das Werkzeug `notify`

Der Server stellt ein einziges Werkzeug bereit: `notify`. Ihr Agent entscheidet anhand Ihres Prompts, wie er es ausfüllt.

| Argument | Typ | Erforderlich | Beschreibung |
|---|---|---|---|
| `title` | string | Ja | Titel der Benachrichtigung. |
| `body` | string | Nein | Text der Benachrichtigung. |
| `link` | string (URL) | Nein | Ein Link, der geöffnet wird, wenn Sie auf die Benachrichtigung tippen, etwa ein Pull Request, ein Build-Log oder ein Dashboard. |
| `urgency` | string | Nein | `normal`, `time-sensitive` oder `calling`. Weglassen, um die eigene Stufe jedes Abonnenten zu verwenden. Siehe [Dringlichkeit](#dringlichkeit). |

## Dringlichkeit

Jeder, der einen Kanal abonniert, wählt dafür in der App einen Benachrichtigungstyp: Normal, Zeitkritisch oder Anruf. Diese Wahl ist die **höchste** Stufe, mit der der Kanal ihn erreichen kann.

- Lässt der Agent `urgency` weg, erhält jeder Abonnent die Stufe, die er gewählt hat.
- Sendet der Agent `urgency`, kann er die Stufe eines Abonnenten nur **senken**, niemals anheben. Haben Sie mit dem Typ Anruf abonniert, kommt `"urgency": "normal"` als normale Benachrichtigung an. Haben Sie mit Normal abonniert, kommt auch `"urgency": "calling"` nur als normale Benachrichtigung an.

So deckt ein einziger Kanal alles ab. Abonnieren Sie ihn mit dem Typ Anruf und sagen Sie dem Agenten, dass er Routinemeldungen als `normal` schicken und `calling` nur verwenden soll, wenn etwas kaputt ist.

Anders als `notificationType` bei Webhook-Anfragen wirkt `urgency` auch bei Kanälen mit eigener Vorlage.

### Anrufe erfordern Echobell Premium

Anruf-Benachrichtigungen sind eine Funktion von Echobell Premium. Fordert der Agent `calling` an, erhält ein Abonnent ohne Premium stattdessen eine **zeitkritische** Benachrichtigung – genau wie bei der App und bei Webhooks.

### Ein Anruf pro Minute und Kanal

Ein Kanal ruft jeden Abonnenten höchstens einmal pro Minute an. Fordert der Agent innerhalb dieser Minute einen weiteren Anruf an – etwa weil er in einer Wiederholungsschleife feststeckt –, erhält der Abonnent stattdessen eine **zeitkritische** Benachrichtigung, die Fokusmodi trotzdem durchbricht. Webhook- und E-Mail-Auslöser folgen derselben Regel.

Der Agent erfährt von beiden Fällen. Das Ergebnis des Werkzeugs listet jede Herabstufung auf, sodass der Agent weiß, dass das Telefon nicht geklingelt hat, und Ihnen das sagen kann, statt anzunehmen, dass Sie angerufen wurden.

## Was der Agent zurückbekommt

Jeder Aufruf von `notify` liefert dem Agenten eine kurze Textzusammenfassung sowie strukturierte Daten:

```json
{
  "notificationTriggered": true,
  "reason": null,
  "requestedUrgency": "calling",
  "recipients": 1,
  "deliveredUrgency": { "normal": 0, "time-sensitive": 1, "calling": 0 },
  "fallbacks": [
    {
      "from": "calling",
      "to": "time-sensitive",
      "reason": "premium-required",
      "recipients": 1
    }
  ]
}
```

| Feld | Bedeutung |
|---|---|
| `notificationTriggered` | `true`, wenn eine Benachrichtigung verschickt wurde. |
| `reason` | Warum nichts verschickt wurde: `conditions-not-met` (die [Bedingungen](/docs/conditions) des Kanals trafen nicht zu) oder `no-subscribers` (niemand hat den Kanal abonniert). `null`, wenn eine Benachrichtigung verschickt wurde. |
| `requestedUrgency` | Die vom Agenten angeforderte `urgency`, oder `null`, wenn er sie weggelassen hat. |
| `recipients` | Wie viele Abonnenten benachrichtigt wurden. |
| `deliveredUrgency` | Wie viele Abonnenten welche Stufe erhalten haben. |
| `fallbacks` | Abonnenten, die eine niedrigere Stufe als angefordert erhalten haben, und warum: `premium-required` (Anrufe erfordern Premium), `subscriber-setting` (die eigene Stufe des Abonnenten für den Kanal ist niedriger) oder `call-cooldown` (der Kanal hat diesen Abonnenten innerhalb der letzten Minute bereits angerufen). |

## Kanäle mit und ohne eigene Vorlage

Der MCP-Server funktioniert mit beiden Arten von Kanälen:

- **Kanäle ohne Vorlage** (der Standard) zeigen `title` und `body` genau so an, wie der Agent sie sendet.
- **Kanäle mit Vorlage** (mit aktivierter Option **Eigene Vorlage** unter **Erweiterte Einstellungen**) erstellen die Benachrichtigung aus Ihren [Vorlagen](/docs/template). `title`, `body`, `link`, `externalLink` und `urgency` stehen als Vorlagenvariablen zur Verfügung, und die [Bedingungen](/docs/conditions) des Kanals gelten weiterhin. Treffen die Bedingungen nicht zu, wird nichts verschickt, und der Agent erhält `reason: "conditions-not-met"`.

## Beispiel-Prompts

Sobald der Server verbunden ist, bitten Sie in normaler Sprache um Benachrichtigungen:

- „Führe die komplette Testsuite aus und benachrichtige mich mit Echobell, wenn du fertig bist.“
- „Refaktoriere das Zahlungsmodul. Schick mir eine zeitkritische Echobell-Warnung, wenn du eine Entscheidung von mir brauchst.“
- „Deploye auf Staging. Ruf mich an, wenn das Deployment fehlschlägt, sonst schick eine normale Benachrichtigung mit der URL.“
- „Wenn die Migration fertig ist, benachrichtige mich mit einer Zusammenfassung und einem Link zum Pull Request.“

Damit es zur Gewohnheit wird, ergänzen Sie die Anweisungsdatei Ihres Agenten (`CLAUDE.md`, `AGENTS.md`, `.cursorrules` usw.) um eine Zeile wie diese:

```
When a task takes longer than a few minutes, call the Echobell notify tool when it finishes.
Use urgency "calling" only when something is broken and needs me right away.
```

## Sicherheit

- **Das Token ist die Zugangsberechtigung.** Wer die MCP-URL (oder das Token) hat, kann den Abonnenten des Kanals Benachrichtigungen schicken. Damit lässt sich nichts lesen und nichts an Ihrem Konto ändern – das Einzige, was damit möglich ist, ist eine Benachrichtigung.
- **Halten Sie es aus geteilten Dateien heraus.** Checken Sie keine Konfigurationsdatei ein, die die URL-Variante enthält. Verwenden Sie für Projektkonfigurationen die [Header-Variante](#header-variante) mit einer Eingabeaufforderung oder einer Umgebungsvariablen.
- **Entziehen Sie den Zugriff, indem Sie das Trigger-Token zurücksetzen.** Öffnen Sie den Kanal in der App und setzen Sie sein Trigger-Token zurück. Die alte MCP-URL funktioniert sofort nicht mehr (Anfragen erhalten `401 Unauthorized`), ebenso die alte Webhook-URL. Aktualisieren Sie Ihre Agenten und Webhook-Aufrufer mit dem neuen Token.

## Limits und Fehler

- **Ratenbegrenzung**: Jedes Token nimmt bis zu 120 MCP-Anfragen pro Minute an. MCP-Anfragen haben ein eigenes Kontingent, getrennt von den Webhook-Anfragen des Kanals.
- **401 Unauthorized**: Das Token fehlt, ist falsch oder wurde zurückgesetzt.

## Verwandte Themen

- [Webhooks](/docs/webhook) – denselben Kanal aus Skripten, CI und anderen Diensten auslösen
- [Benachrichtigungstypen](/docs/notification) – wie sich Normal, Zeitkritisch und Anruf unterscheiden
- [Vorlagen](/docs/template) und [Bedingungen](/docs/conditions) – Benachrichtigungen gestalten und filtern