# MCP pour la messagerie : comment les agents IA peuvent envoyer des SMS et WhatsApp en toute sécurité

> Un serveur MCP transforme une API de messagerie en outils pour un agent IA. C'est puissant mais risqué : un agent peut contacter de vrais clients. Découvrez le fonctionnement du MCP pour SMS et WhatsApp, la connexion au serveur BroadNet et les garde-fous à instaurer.

- URL canonique: https://www.broadnet.me/fr/blog/mcp-server-sms-whatsapp-ai-agents
- Langue: fr
- Dernière mise à jour: 2026-09-26
- Éditeur: BroadNet (https://www.broadnet.me)

- Publié le: 2026-09-26
- Auteur: BroadNet Engineering

Un serveur de messagerie MCP expose une API de messagerie sous forme d'outils qu'un agent d'IA peut découvrir et appeler via le Model Context Protocol, afin qu'un assistant puisse envoyer un SMS ou un message WhatsApp sur demande. BroadNet en exécute un à https://mcp.broadnet.me/mcp, en utilisant le transport Streamable HTTP et un jeton Bearer, sur le même API qui dessert WhatsApp, SMS, RCS, Telegram, Push, Email, Messenger et Instagram. Ce guide explique son fonctionnement et, plus important encore, comment empêcher un agent d'envoyer des messages aux mauvaises personnes.

## Points clés

- MCP est un protocole ouvert, basé sur JSON-RPC 2.0, qui permet aux applications d'IA de découvrir et d'appeler des outils externes. Un serveur de MCP de messagerie transforme les points de terminaison d'envoi, de modèle et de rapport en outils.
- Les serveurs distants utilisent le transport Streamable HTTP : un point de terminaison HTTPS, chaque message client étant un POST HTTP. Les serveurs locaux utilisent généralement stdio.
- Le serveur MCP BroadNet se trouve à https://mcp.broadnet.me/mcp et refuse toute requête sans un en-tête Authorization: Bearer.
- Un jeton est un identifiant d'accès d'envoi. L'agent agit avec ses permissions, exactement comme le ferait votre propre code.
- La spécification MCP stipule qu'il DEVRAIT toujours y avoir un humain dans la boucle capable de refuser des appels d'outils, et que les serveurs DOIVENT limiter le débit des invocations d'outils. Construisez le consentement, les plages de non-sollicitation, les plafonds et les approbations autour de chaque outil d'envoi.

## Qu'est-ce que le Model Context Protocol ?

La [spécification MCP](https://modelcontextprotocol.io/specification/latest) décrit MCP comme "un protocole ouvert qui permet une intégration transparente entre les applications LLM et les sources de données et outils externes". Elle utilise des messages JSON-RPC 2.0 entre trois rôles : les hôtes (l'application d'IA), les clients (les connecteurs à l'intérieur de l'hôte) et les serveurs (les services qui fournissent des outils, des ressources et des invites). Au 26 septembre 2026, la dernière révision de la spécification est datée du 2026-07-28.

Les outils sont la partie qui importe pour la messagerie. Un client les liste avec tools/list, le modèle en choisit un, et le client l'invoque avec tools/call. La spécification qualifie les outils de "contrôlés par le modèle" : le modèle décide quand les utiliser. C'est précisément pourquoi un outil d'envoi nécessite des garde-fous que le modèle ne peut pas contourner par le discours.

## Comment fonctionne un serveur MCP pour SMS et WhatsApp ?

Le chemin de la requête comporte cinq sauts. Le point de conception est que le serveur MCP n'ajoute aucune nouvelle puissance d'envoi ; il expose l'API que vous possédez déjà, sous le même jeton et les mêmes contrôles.

1. Un utilisateur demande à l'hôte IA, par exemple : "envoyer la mise à jour de la livraison à ce client sur WhatsApp".
2. Le modèle choisit un outil dans la liste que le client MCP a récupérée, tel qu'un outil d'envoi WhatsApp, et remplit ses arguments.
3. Le client MCP envoie une requête tools/call sous la forme d'un POST HTTP vers https://mcp.broadnet.me/mcp avec le jeton Bearer.
4. Le serveur MCP BroadNet valide le jeton et appelle le point de terminaison API BroadNet correspondant.
5. L'API achemine le message vers WhatsApp ou vers le réseau mobile et renvoie un résultat, qui retourne au modèle en tant que résultat de l'outil.

Dans l'enregistrement de la démo de l'équipe produit, le client liste 380 outils BroadNet, parmi lesquels send_message, post_sms_send, post_whatsapp_message_send, get_whatsapp_template_list, post_whatsapp_template_send, post_rcs_message_send et get_report_delivery. La liste exacte dépend de la version du serveur et de votre compte ; consultez la [documentation du serveur MCP](https://www.broadnet.me/developers/mcp).

## Streamable HTTP ou stdio : quel transport ?

La spécification définit deux transports standards. Celui que vous utilisez dépend de l'endroit où le serveur s'exécute, et cela décide de la manière dont vous vous authentifiez.

|  | stdio | Streamable HTTP |
|---|---|---|
| Où le serveur s'exécute | En tant que sous-processus lancé par le client, sur la même machine | En tant que service indépendant, il a atteint plus de HTTPS |
| Comment les messages circulent | JSON-RPC délimités par des sauts de ligne via l'entrée et la sortie standard | Chaque message client est un POST HTTP vers un point de terminaison MCP unique ; les réponses reviennent sous forme de JSON ou d'un flux d'événements envoyés par le serveur |
| Comment fonctionnent les identifiants d'accès | La spécification indique que les serveurs stdio devraient lire les identifiants d'accès à partir de l'environnement | Un en-tête Authorization: Bearer sur chaque requête ; les jetons ne doivent jamais figurer dans la chaîne de requête |
| Utilisation typique | Outils de développement locaux | Services hébergés partagés par de nombreux clients, tels qu'un API de messagerie |
| BroadNet | Non proposé | https://mcp.broadnet.me/mcp |

Pour HTTP serveurs, la révision du 2025-06-18 de la spécification exige également que les serveurs valident l'en-tête Origin et recommande qu'ils authentifient chaque connexion. La dernière révision (2026-07-28) rend chaque requête autonome, transportant la version du protocole et les capacités du client dans ses propres métadonnées ; les révisions précédentes ouvraient une session avec un handshake d'initialisation, et les clients détectent quelle révision un serveur utilise et effectuent un repli.

## Comment connecter un agent d'IA au serveur MCP de BroadNet ?

1. Obtenez un jeton à partir de votre compte BroadNet. Dans le portail BroadAdmin, Integrations, puis MCP Integration, une clé temporaire est générée ; une clé permanente provient de l'administrateur de votre compte ou du compte maître.
2. Ajoutez le serveur à votre client MCP. La plupart des clients utilisent une configuration JSON comme celle ci-dessous. Les noms des champs varient légèrement d'un client à l'autre, vous devriez donc consulter la documentation de votre client.
3. Gardez le jeton hors des fichiers que vous validez. Utilisez le support des variables d'environnement de votre client, comme le fait la configuration ci-dessous.
4. Ouvrez la liste des outils et désactivez chaque outil dont l'agent n'a pas besoin.
5. Effectuez un test avec un seul message vers un numéro qui vous appartient avant de laisser l'agent accéder aux données client.

```
{
  "mcpServers": {
    "broadnet": {
      "type": "http",
      "url": "https://mcp.broadnet.me/mcp",
      "headers": {
        "Authorization": "Bearer ${BROADNET_TOKEN}"
      }
    }
  }
}
```

Pour tester la connexion sans client, envoyez vous-même la requête d'initialisation :

```
curl -X POST https://mcp.broadnet.me/mcp \
  -H "Authorization: Bearer $BROADNET_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
                 "clientInfo":{"name":"curl","version":"1.0"}}}'
```

Sans l'en-tête, le serveur refuse l'appel au niveau du protocole. Il s'agit de sa réponse réelle à une requête d'initialisation non authentifiée, vérifiée le 26 septembre 2026 :

```
event: message
data: {"jsonrpc":"2.0","id":1,"error":{"code":-32001,
  "message":"Authorization bearer token is required. Connect with an
  'Authorization: Bearer <BroadNet token>' header."}}
```

## Est-il sûr de donner une clé d'API de messagerie à un agent d'IA ?

Seulement avec des limites autour. Le jeton est un identifiant d'accès d'envoi : toute personne, ou tout agent, le détenant peut envoyer des messages depuis votre compte, et chaque envoi coûte de l'argent et atteint une personne réelle. Les agents agissent également sur des instructions en langage naturel, et une partie de ce texte provient de l'extérieur : un message client entrant ou une page web peut contenir des instructions que le modèle peut essayer de suivre. La spécification MCP est directe à ce sujet. Elle stipule que les hôtes doivent obtenir le consentement explicite de l'utilisateur avant d'invoquer tout outil, qu'il DEVRAIT toujours y avoir un humain dans la boucle avec la capacité de refuser les invocations d'outils, et que les clients doivent traiter les annotations d'outils comme non fiables à moins qu'elles ne proviennent d'un serveur de confiance.

## Quelles barrières de sécurité empêchent un agent de spammer les clients ?

Placez les contrôles là où le modèle ne peut pas les contourner : dans la configuration client, dans votre propre middleware ou dans les paramètres du compte, et non dans l'invite.

| Risque | Contrôle | Emplacement |
|---|---|---|
| Envoyer un message à quelqu'un qui n'a pas donné son consentement | Vérifier le consentement et le statut de désinscription avant l'exécution de tout outil d'envoi | Votre middleware ou CRM |
| Envoyer la nuit ou le mauvais jour | Plages de non-sollicitation selon le fuseau horaire du destinataire et les règles du marché | Votre middleware |
| Utiliser des outils dont la tâche n'a pas besoin | Activez uniquement les outils requis ; désactivez les outils de modèle, d'onboarding et de compte | Paramètres de l'outil client MCP |
| Boucles incontrôlées et envois en masse | Plafonds d'envoi par agent et limites de débit ; la spécification exige que les serveurs limitent le débit des invocations d'outils | Votre middleware et le serveur |
| Messages en double après une tentative de réessai | Conservez l'ID du message retourné et vérifiez son statut avant de renvoyer | Votre logique d'agent (voir le guide sur l'idempotence) |
| Marketing envoyé sans révision | Approbation humaine pour tout envoi marketing ou à plusieurs destinataires | Invites de confirmation client MCP |
| Instructions cachées dans les messages entrants | Traitez les textes entrants comme des données ; ne permettez jamais qu'ils déclenchent un envoi sans une demande de l'utilisateur | Conception des prompts et règles d'approbation dans l'hôte IA |
| Jeton divulgué | Clés temporaires pour les expérimentations, variables d'environnement, révoquer et réémettre en cas d'exposition | Administrateur de compte BroadNet |
| Aucune piste d'audit | Journalisez chaque appel d'outil avec les entrées et les résultats | Client MCP ; la spécification indique que les clients devraient journaliser l'utilisation des outils |

Le BroadNet API n'a pas d'en-tête d'idempotence, donc une tentative après un délai d'expiration peut envoyer deux fois. Le modèle sûr consiste à stocker l'ID du message que l'API renvoie et à vérifier le statut de la livraison avant de renvoyer ; nos guides sur l'[idempotence](https://www.broadnet.me/developers/idempotency) et les [tentatives](https://www.broadnet.me/developers/retries) montrent comment.

## Quelles actions de messagerie devraient nécessiter une approbation humaine ?

| Action | Défaut suggéré | Pourquoi |
|---|---|---|
| Lire les rapports de livraison, lister les modèles | Automatique | Lecture seule ; rien n'atteint un client |
| Un message transactionnel à un client connu qui l'a demandé | Automatique dans la limite d'un plafond d'envoi, ou confirmation en un clic | Risque faible, valeur élevée, facile à auditer |
| Tout message marketing | Toujours une approbation humaine | Risque lié au consentement, au contenu et au coût |
| Tout envoi à plus d'un destinataire | Toujours une approbation humaine | Une erreur se multiplie |
| Création ou soumission de WhatsApp modèles | Approbation humaine | Les modèles sont examinés par Meta et représentent votre marque |
| Outils de compte, de facturation ou d'intégration | Désactivé | Un agent ne devrait pas modifier le compte sur lequel il s'exécute |

## MCP ou un REST API simple : lequel un agent devrait-il utiliser ?

Les deux atteignent la même plateforme. La différence réside dans la décision de qui effectue l'appel.

|  | Serveur BroadNet MCP | BroadNet REST API |
|---|---|---|
| Qui choisit l'appel | Le modèle, à partir de la liste d'outils | Votre code |
| Point de terminaison | https://mcp.broadnet.me/mcp | https://api.broadnet.me, par exemple POST /sms/sendSms |
| Authentification | Authorization: Bearer <jeton> | Authorization: Bearer <jeton> |
| Bibliothèque client | Tout client MCP prenant en charge les serveurs distants et un en-tête Authorization personnalisé | Un SDK officiel, @broadnet/cpaas-sdk (TypeScript/Node.js) ; générer d'autres clients à partir de la spécification OpenAPI |
| Idéal pour | Assistants, copilotes d'opérations, tâches ad hoc en langage naturel | Flux de production avec logique fixe : OTP, alertes, campagnes |

Une répartition cohérente : utilisez MCP lorsqu'une personne pilote l'agent et qu'une invite de confirmation est acceptable, et utilisez le REST API, avec le [guide de démarrage rapide](https://www.broadnet.me/developers/quickstart) et le [générateur curl](https://www.broadnet.me/tools/curl-generator), pour les flux qui doivent s'exécuter de la même manière à chaque fois. Notre [référence API](https://www.broadnet.me/developers/api) documente les points de terminaison derrière les outils MCP.

## Foire aux questions

### Qu'est-ce qu'un serveur MCP pour la messagerie ?

Un serveur qui expose une API de messagerie, telle que l'envoi de SMS, l'envoi de messages WhatsApp ou la récupération de rapports de livraison, en tant qu'outils qu'un agent d'IA peut découvrir et appeler via la Model Context Protocol.

### Quelle est l'URL du serveur BroadNet MCP ?

https://mcp.broadnet.me/mcp. Il utilise le transport MCP Streamable HTTP et nécessite un en-tête Authorization: Bearer avec votre jeton BroadNet sur chaque requête.

### Quels clients d'IA peuvent s'y connecter ?

Tout client MCP capable de se connecter à un serveur distant via Streamable HTTP et d'envoyer un en-tête Authorization personnalisé. L'enregistrement de la démo BroadNet utilise Cursor.

### L'agent peut-il envoyer de vrais messages ?

Oui. Les outils agissent avec les permissions de votre jeton, exactement comme le feraient vos propres appels API. Traitez chaque envoi comme réel : n'activez que les outils dont l'agent a besoin et exigez une confirmation avant les envois.

### Comment fonctionne l'authentification Bearer avec MCP ?

Pour HTTP, le client envoie Authorization: Bearer suivi du jeton lors de chaque requête, même au sein d'une même session, et jamais dans la chaîne de requête de l'URL. Le serveur de BroadNet rejette les requêtes sans celui-ci.

### Quelle est la différence entre stdio et Streamable HTTP ?

stdio exécute le serveur en tant que sous-processus local et échange des JSON-RPC délimités par des sauts de ligne via l'entrée et la sortie standard. Streamable HTTP exécute le serveur en tant que service web où chaque message client est un POST HTTP vers un point de terminaison unique.

### Comment empêcher un agent d'IA de spammer les clients ?

Appliquez des contrôles de consentement, des plages de non-sollicitation et des limites d'envoi en dehors du modèle, n'activez que les outils dont vous avez besoin, exigez une approbation humaine pour les envois de modèles marketing et multi-destinataires, et journalisez chaque appel d'outil.

### Devrais-je utiliser MCP ou l'API REST ?

Utilisez MCP lorsqu'une personne dirige un agent en langage naturel. Utilisez l'API REST ou le SDK TypeScript pour des flux de production fixes tels que OTP et les alertes, où votre code, et non un modèle, décide de ce qui doit être envoyé.

## Sources

- Model Context Protocol, [Aperçu de la spécification (révision 2026-07-28)](https://modelcontextprotocol.io/specification/latest), consulté le 26 septembre 2026.
- Model Context Protocol, [Transports (2025-06-18)](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports) et [Transports (2026-07-28)](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports), consultés le 26 septembre 2026.
- Model Context Protocol, [Authorization (2025-06-18)](https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization), consulté le 26 septembre 2026.
- Model Context Protocol, [Outils (2026-07-28)](https://modelcontextprotocol.io/specification/2026-07-28/server/tools), consulté le 26 septembre 2026.
- BroadNet, [documentation du serveur MCP](https://www.broadnet.me/developers/mcp), et une sonde en direct de https://mcp.broadnet.me/mcp le 26 septembre 2026.

Lectures connexes : [les agents d'IA dans la messagerie client](https://www.broadnet.me/blog/ai-agents-customer-messaging-agentic-cpaas-2026) et [choisir une plateforme d'IA agentique d'entreprise](https://www.broadnet.me/blog/enterprise-agentic-ai-platform-2026).