---
title: "Serveur MCP - Vos agents IA vous notifient ou vous appellent"
sidebarTitle: Serveur MCP
description: "Connectez Claude Code, Codex, Cursor, ChatGPT et d'autres agents IA au serveur MCP d'Echobell pour recevoir une notification push ou un appel."
---

# Serveur MCP pour les agents IA

Echobell propose un serveur officiel pour le [Model Context Protocol](https://modelcontextprotocol.io) (MCP). Connectez-le à votre agent IA — Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude, ChatGPT ou tout autre client MCP — et l'agent dispose d'un outil, `notify`, qui envoie une notification via l'un de vos canaux Echobell.

Lancez un gros refactoring, une suite de tests ou un déploiement, éloignez-vous et demandez à l'agent de vous prévenir quand il a terminé. Votre téléphone vibre quand le travail est fini, affiche une alerte urgente quand l'agent a besoin de vous, ou sonne comme un appel quand quelque chose tourne vraiment mal.

## Fonctionnement

- C'est un serveur MCP **distant**, à l'adresse `https://mcp.echobell.one/mcp`, qui utilise le transport Streamable HTTP. Il n'y a rien à installer : pas de paquet npm, pas de `npx`, pas de processus local.
- Chaque URL MCP appartient à **un canal**. Quand l'agent appelle `notify`, tous les abonnés de ce canal reçoivent la notification, chacun avec le [type de notification](/docs/notification) qu'il a choisi.
- L'identifiant est le **jeton de déclenchement** du canal — le même jeton qui termine l'URL webhook du canal. Le serveur MCP fonctionne comme le [webhook](/docs/webhook) du canal, avec en plus un outil que l'agent sait appeler.

<Callout type="info">
  Créez un canal dédié à vos agents, par exemple « Agents IA », et
  abonnez-vous-y en **Appel**. Vos agents peuvent alors choisir n'importe quel
  niveau jusqu'à l'appel, et vous pouvez partager le canal avec les membres de
  votre équipe qui veulent recevoir les mêmes alertes.
</Callout>

## Obtenir votre URL MCP

### Depuis l'app

1. Ouvrez l'app Echobell et touchez le canal que votre agent doit utiliser.
2. Dans le détail du canal, repérez la section **Connecter un agent IA**.
3. Copiez l'**URL du serveur MCP**, ou l'extrait de configuration prêt à l'emploi pour votre agent.

### À partir de l'URL webhook

L'URL MCP utilise le même jeton que l'URL webhook du canal. Prenez le jeton à la fin de l'URL webhook et placez-le après `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">
  L'URL MCP contient le jeton de déclenchement de votre canal. Quiconque la
  possède peut envoyer des notifications aux abonnés du canal : gardez-la aussi
  confidentielle qu'un mot de passe. Voir [Sécurité](#sécurité).
</Callout>

## Configurer votre agent

Tous les extraits ci-dessous utilisent la forme URL. Remplacez `<channel-token>` par le jeton de déclenchement de votre canal, ou collez l'extrait fourni par l'app, qui le contient déjà.

### Claude Code

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

Ajoutez `--scope user` pour rendre le serveur disponible dans tous vos projets, et pas seulement dans le projet actuel.

### Codex

Ajoutez ceci à `~/.codex/config.toml` :

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

### Cursor

Ajoutez ceci à `~/.cursor/mcp.json`, ou à `.cursor/mcp.json` dans un projet :

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

### VS Code (GitHub Copilot)

Ajoutez ceci à `.vscode/mcp.json` dans votre espace de travail, puis utilisez l'outil depuis Copilot Chat en mode agent :

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

Si `.vscode/mcp.json` est versionné dans votre dépôt, utilisez plutôt l'[authentification par en-tête avec une invite de saisie](#authentification-par-en-tête), afin que le jeton ne figure pas dans le fichier.

### Windsurf

Ajoutez ceci à `~/.codeium/windsurf/mcp_config.json` :

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

### Gemini CLI

Ajoutez ceci à `~/.gemini/settings.json` :

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

### Claude Desktop et claude.ai

1. Ouvrez **Paramètres → Connecteurs**.
2. Choisissez **Ajouter un connecteur personnalisé**.
3. Saisissez le nom `Echobell` et l'URL `https://mcp.echobell.one/mcp/<channel-token>`, puis ajoutez-le.

Le connecteur est disponible dans Claude sur le web et dans l'application de bureau.

### ChatGPT

1. Activez le mode développeur dans les paramètres de ChatGPT.
2. Ouvrez **Paramètres → Connecteurs** et choisissez **Créer**.
3. Saisissez l'URL `https://mcp.echobell.one/mcp/<channel-token>` et réglez l'authentification sur **Aucune authentification** — le jeton contenu dans l'URL sert d'identifiant.

### Autres clients MCP

Tout client compatible avec le transport Streamable HTTP fonctionne. Donnez-lui l'URL `https://mcp.echobell.one/mcp/<channel-token>`, ou utilisez l'authentification par en-tête ci-dessous.

### Authentification par en-tête

Au lieu de mettre le jeton dans l'URL, vous pouvez l'envoyer dans un en-tête `Authorization`. Les deux formes sont équivalentes.

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

Avec Claude Code :

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

Dans VS Code, une invite de saisie garde le jeton hors de `.vscode/mcp.json`, ce qui permet de versionner le fichier sans risque. VS Code demande le jeton au premier démarrage du serveur et le stocke de manière sécurisée :

```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}"
      }
    }
  }
}
```

## L'outil `notify`

Le serveur expose un seul outil, `notify`. Votre agent décide comment le remplir à partir de votre prompt.

| Argument | Type | Obligatoire | Description |
|---|---|---|---|
| `title` | string | Oui | Titre de la notification. |
| `body` | string | Non | Corps de la notification. |
| `link` | string (URL) | Non | Un lien ouvert quand vous touchez la notification, par exemple une pull request, un journal de build ou un tableau de bord. |
| `urgency` | string | Non | `normal`, `time-sensitive` ou `calling`. Omettez-le pour utiliser le niveau choisi par chaque abonné. Voir [Urgence](#urgence). |

## Urgence

Chaque personne qui s'abonne à un canal choisit pour lui un type de notification dans l'app : Normal, Urgent ou Appel. Ce choix est le niveau **le plus élevé** auquel le canal peut la joindre.

- Quand l'agent omet `urgency`, chaque abonné reçoit le niveau qu'il a choisi.
- Quand l'agent envoie `urgency`, il ne peut qu'**abaisser** le niveau d'un abonné, jamais le relever. Si vous êtes abonné en Appel, `"urgency": "normal"` arrive comme une notification normale. Si vous êtes abonné en Normal, `"urgency": "calling"` arrive tout de même comme une notification normale.

Un seul canal suffit ainsi pour tout. Abonnez-vous en Appel, puis demandez à l'agent d'envoyer les nouvelles de routine en `normal` et de n'utiliser `calling` que lorsque quelque chose est cassé.

Contrairement à `notificationType` dans les requêtes webhook, `urgency` fonctionne aussi sur les canaux avec un modèle personnalisé.

### L'appel nécessite Echobell Premium

Les notifications par appel sont une fonctionnalité d'Echobell Premium. Quand l'agent demande `calling`, un abonné sans Premium reçoit à la place une notification **urgente** — exactement comme avec l'app et les webhooks.

### Un appel par minute et par canal

Un canal appelle chaque abonné au plus une fois par minute. Si l'agent demande un autre appel dans cette minute — par exemple parce qu'il est bloqué dans une boucle de nouvelles tentatives —, l'abonné reçoit à la place une notification **urgente**, qui passe tout de même outre les modes de concentration. Les webhooks et les déclencheurs email suivent la même règle.

L'agent est informé dans les deux cas. Le résultat de l'outil liste chaque repli, si bien que l'agent sait que le téléphone n'a pas sonné et peut vous le dire au lieu de supposer que vous avez été appelé.

## Ce que l'agent reçoit en retour

Chaque appel à `notify` renvoie à l'agent un court résumé textuel ainsi que des données structurées :

```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
    }
  ]
}
```

| Champ | Signification |
|---|---|
| `notificationTriggered` | `true` quand une notification a été envoyée. |
| `reason` | Pourquoi rien n'a été envoyé : `conditions-not-met` (les [conditions](/docs/conditions) du canal n'étaient pas remplies) ou `no-subscribers` (personne n'est abonné au canal). `null` quand une notification a été envoyée. |
| `requestedUrgency` | L'`urgency` demandée par l'agent, ou `null` s'il l'a omise. |
| `recipients` | Le nombre d'abonnés notifiés. |
| `deliveredUrgency` | Le nombre d'abonnés ayant reçu chaque niveau. |
| `fallbacks` | Les abonnés qui ont reçu un niveau inférieur à celui demandé, et pourquoi : `premium-required` (l'appel nécessite Premium), `subscriber-setting` (le niveau choisi par l'abonné pour ce canal est plus bas) ou `call-cooldown` (le canal a déjà appelé cet abonné au cours de la dernière minute). |

## Canaux sans modèle et canaux avec modèle

Le serveur MCP fonctionne avec les deux types de canaux :

- Les **canaux sans modèle** (par défaut) affichent le `title` et le `body` exactement tels que l'agent les envoie.
- Les **canaux avec modèle** (option **Modèle personnalisé** activée dans les **Paramètres avancés**) construisent la notification à partir de vos [modèles](/docs/template). `title`, `body`, `link`, `externalLink` et `urgency` sont disponibles comme variables de modèle, et les [conditions](/docs/conditions) du canal s'appliquent toujours. Si les conditions ne sont pas remplies, rien n'est envoyé et l'agent reçoit `reason: "conditions-not-met"`.

## Exemples de prompts

Une fois le serveur connecté, demandez des notifications en langage courant :

- « Lance toute la suite de tests et préviens-moi avec Echobell quand tu as fini. »
- « Refactorise le module de paiement. Envoie-moi une alerte Echobell urgente si tu as besoin que je prenne une décision. »
- « Déploie en staging. Appelle-moi si le déploiement échoue, sinon envoie une notification normale avec l'URL. »
- « Quand la migration est terminée, préviens-moi avec un résumé et un lien vers la pull request. »

Pour en faire une habitude, ajoutez une ligne comme celle-ci au fichier d'instructions de votre agent (`CLAUDE.md`, `AGENTS.md`, `.cursorrules`, etc.) :

```
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.
```

## Sécurité

- **Le jeton est l'identifiant.** Quiconque possède l'URL MCP (ou le jeton) peut envoyer des notifications aux abonnés du canal. Il ne permet ni de lire quoi que ce soit ni de modifier votre compte — la seule chose qu'il permet, c'est de notifier.
- **Tenez-le à l'écart des fichiers partagés.** Ne versionnez pas un fichier de configuration qui contient la forme URL. Pour une configuration de projet, utilisez l'[authentification par en-tête](#authentification-par-en-tête) avec une invite de saisie ou une variable d'environnement.
- **Révoquez l'accès en réinitialisant le jeton de déclenchement.** Ouvrez le canal dans l'app et réinitialisez son jeton de déclenchement. L'ancienne URL MCP cesse immédiatement de fonctionner (les requêtes reçoivent `401 Unauthorized`), tout comme l'ancienne URL webhook. Mettez à jour vos agents et vos appels webhook avec le nouveau jeton.

## Limites et erreurs

- **Limite de débit** : chaque jeton accepte jusqu'à 120 requêtes MCP par minute. Les requêtes MCP disposent de leur propre quota, distinct de celui des requêtes webhook du canal.
- **401 Unauthorized** : le jeton est absent, incorrect ou a été réinitialisé.

## Pour aller plus loin

- [Webhooks](/docs/webhook) — déclencher le même canal depuis des scripts, une CI et d'autres services
- [Types de notification](/docs/notification) — les différences entre Normal, Urgent et Appel
- [Modèles](/docs/template) et [Conditions](/docs/conditions) — mettre en forme et filtrer les notifications