Si vous voulez que Claude, ChatGPT ou votre propre agent consulte un capteur ou commute un relais, il lui faut un moyen de savoir quels appareils existent, ce qu’ils remontent et ce qu’ils ont le droit de faire. Un serveur MCP pour appareils IoT est cette porte d’entrée. Il expose vos capteurs et vos contrôleurs sous forme d’outils que l’agent peut appeler, il exécute ces appels sur le système réel et il contrôle qui a le droit de faire quoi.
Le protocole lui-même est simple. Ce sont les appareils qui compliquent la conception, parce qu’ils ne se comportent pas comme des documents ou des bases de données : certains dorment plusieurs minutes d’affilée, les mesures vieillissent, et un mauvais appel peut ouvrir une vanne. Ce guide explique comment les éléments s’articulent, comment fonctionne la découverte quand chaque appareil a des commandes différentes, et ce qu’il faut décider avant de développer ou de connecter un serveur.
L’essentiel
- Le Model Context Protocol donne aux clients d’IA une seule méthode standard pour découvrir et appeler des outils : un même serveur peut donc servir Claude, ChatGPT, Cursor et d’autres.
- Pour les appareils, la découverte se fait généralement en deux niveaux : l’agent liste d’abord les appareils, puis demande quelles mesures et quelles commandes possède un appareil précis.
- Développer son propre serveur consiste surtout à encapsuler une API d’appareils existante, avec des noms d’outils clairs, des limites sur les entrées et des contrôles d’autorisation côté serveur.
- Commencez en lecture seule, ajoutez plus tard un petit ensemble de commandes prédéfinies, et faites confirmer par une personne tout ce qui modifie un état physique.
Comment utiliser le Model Context Protocol avec des appareils IoT ?
Le Model Context Protocol, généralement abrégé en MCP, est une norme ouverte qui relie les applications d’IA à des outils et à des données externes. L’application d’IA (le client) dialogue avec un serveur MCP, qui propose trois types d’éléments : des outils (tools) que le modèle peut appeler, des ressources (resources) qu’il peut lire comme contexte, et des prompts qu’une personne peut choisir dans un menu. Dans un contexte de bureau, il pourrait s’agir de « rechercher des tickets » ou de « lire un tableur ». Dans l’IoT, ces éléments correspondent au site physique.
| Concept MCP | Ce qu’il désigne généralement pour les appareils |
|---|---|
| Outil (tool) | Une action : lire la dernière valeur, récupérer l’historique, envoyer une commande prédéfinie |
| Ressource (resource) | Un contexte que le client peut charger : une liste d’appareils, un plan des locaux, une semaine de mesures |
| Prompt | Une requête réutilisable, par exemple « résume les alarmes de la nuit pour le bâtiment B » |
| Serveur | L’adaptateur qui détient les identifiants et dialogue avec la plateforme d’appareils |
| Client | Claude, ChatGPT, Cursor ou un agent que vous avez écrit, qui décide quel outil appeler |
Trois points distinguent l’IoT des exemples habituels. Les données vieillissent : une température relevée il y a 40 minutes peut ne plus servir à rien, donc chaque mesure renvoyée par le serveur doit porter son horodatage. Les appareils ne sont pas toujours joignables : beaucoup de capteurs sur batterie n’émettent qu’à quelques minutes d’intervalle et n’écoutent que brièvement ensuite. Et les actions ont des conséquences au-delà de l’écran, puisqu’une mauvaise commande peut laisser une pompe en marche ou une vanne ouverte. Chacun de ces points pèse sur la conception du serveur.
Prenons une question simple comme « la salle serveurs est-elle trop chaude ? ». Si le capteur remonte une mesure toutes les 15 minutes et que le dernier message est arrivé il y a 50 minutes, la réponse honnête est « je ne sais pas ; le capteur ne donne plus signe de vie ». Un serveur qui ne renvoie que le nombre, sans l’heure de la mesure, pousse le modèle à répondre avec assurance à partir de données anciennes. Renvoyer la valeur, l’unité, l’horodatage et l’heure de dernière communication de l’appareil permet au modèle de dire ce qu’il sait et ce qu’il ne sait pas.
Comment fonctionne la découverte d’outils pour les agents IA ?
La découverte d’outils pour les agents IA est l’étape où le client demande à un serveur ce qu’il sait faire. Avec MCP, le client envoie une requête tools/list, et le serveur répond avec le nom de chaque outil, une description en langage courant et un schéma JSON de ses entrées. Le client présente ces descriptions au modèle, qui choisit un outil en les lisant, comme un nouveau collègue lirait les étiquettes d’un pupitre de commande.
Un outil de lecture d’appareil pourrait être décrit ainsi :
{"name": "get_latest_reading",
"description": "Latest value of one metric on one device, with its timestamp and unit.",
"inputSchema": {"type": "object",
"properties": {"device_id": {"type": "string"}, "metric": {"type": "string"}},
"required": ["device_id", "metric"]}}
Cela fonctionne bien pour les actions génériques. Les commandes sont plus délicates : un variateur accepte une luminosité de 0 à 100, un contrôleur de vanne accepte ouvrir ou fermer, et un thermostat accepte une consigne dans certaines limites. Si vous transformiez chaque commande de chaque appareil en outil distinct, un site de 300 appareils pourrait publier des milliers d’outils, et le modèle s’y noierait.
La réponse habituelle est une découverte en deux étapes. Le serveur expose un petit ensemble stable d’outils pour agents IA, comme list_devices, list_commands et run_command. L’agent appelle list_devices pour trouver le variateur de la salle de réunion 3, puis list_commands pour cet appareil précis, qui renvoie ses commandes définies avec leurs paramètres et leurs limites. Ce n’est qu’ensuite qu’il appelle run_command avec une luminosité de 40. Le protocole permet aussi à un serveur de notifier les clients quand sa liste d’outils change, ce qui aide quand des appareils sont ajoutés en cours de session.
C’est dans ce genre de cas que le schéma prouve son utilité. Supposons qu’on demande à l’agent de « baisser un peu la lumière de la salle 3 » et que l’éclairage soit à 70. Sans limites, il pourrait envoyer 7, en interprétant mal « un peu ». Avec un schéma indiquant que la luminosité est un entier de 10 à 100, et une description de commande précisant que « les pas habituels sont de 10 », il est bien plus probable qu’il envoie 60. Le serveur doit malgré tout rejeter toute valeur hors plage, car le modèle interprète une description et peut encore se tromper.
Comment créer un serveur MCP
Pour créer un serveur MCP pour des appareils, on ne part pas des protocoles radio. On part de ce qui détient déjà les données des appareils, généralement une plateforme IoT ou une passerelle dotée d’une API, et on l’encapsule. Un ordre de travail pratique :
- Définir le périmètre. Choisissez les questions et les actions dont l’agent a réellement besoin. « Lire n’importe quel capteur, récupérer 30 jours d’historique, exécuter les cinq commandes que nous avons définies » est un meilleur premier périmètre que « tout ce que l’API sait faire ».
- Choisir un SDK. Les kits de développement logiciel officiels gèrent les messages du protocole : votre code se contente de définir les outils et leurs handlers.
- Encapsuler l’API de la plateforme. Chaque handler d’outil appelle l’API existante avec les identifiants du serveur et transforme la réponse en résultats courts et lisibles, avec unités et horodatages.
- Écrire les descriptions pour un lecteur sans contexte. Indiquez ce que l’outil renvoie, quelles unités il utilise et quand ne pas l’utiliser. C’est de là que vient l’essentiel de la qualité.
- Appliquer les autorisations côté serveur. Vérifiez chaque appel au regard des droits de l’utilisateur et des limites de paramètres de la commande, quoi que le modèle ait demandé.
- Tester avec un inspecteur avant tout client. L’outil officiel MCP Inspector permet d’appeler chaque outil à la main et de lire les réponses brutes.
- Choisir un transport. Un serveur local pour un seul développeur peut tourner comme processus sur sa machine ; un serveur partagé nécessite un hébergement distant et une autorisation par utilisateur.
Quand les appareils sont déjà dans Kilo, la couche d’encapsulation reste mince. Vous construiriez vos handlers sur les API REST et gRPC de Kilo pour les développeurs, avec une clé API dont les droits sont définis par domaine et liée à une seule organisation ; une clé limitée aux droits de lecture est un premier identifiant judicieux pour un serveur maison.
Avant de développer quoi que ce soit, vérifiez si la plateforme parle déjà le protocole. Kilo expose son propre endpoint MCP, et il signale l’outil de commande comme destructif afin que les clients puissent vous demander confirmation avant l’envoi d’une commande.
Comment connecter Claude à des appareils IoT avec MCP
Connecter un client à un serveur existant prend quelques minutes, et les étapes se ressemblent à peu près d’un client à l’autre :
- Ajoutez le serveur dans les paramètres du client. Pour un serveur distant, vous collez son URL ; dans Claude, il s’ajoute comme connecteur personnalisé. Un serveur local est généralement déclaré dans un fichier de configuration, avec la commande qui le démarre.
- Connectez-vous quand le client ouvre la page d’autorisation. Un serveur distant doit vous demander qui vous êtes, afin que ses outils agissent avec vos droits et ceux de personne d’autre.
- Vérifiez quels outils sont apparus. La plupart des clients affichent la liste et permettent de désactiver des outils un par un, ce qui est un moyen simple de commencer en lecture seule.
- Posez une question dont vous pouvez vérifier vous-même la réponse, comme la température actuelle d’une pièce où vous pouvez lire un thermomètre, et comparez la réponse.
- Activez les actions en dernier, et laissez activée dans le client l’approbation de chaque appel pour tout ce qui envoie une commande.
ChatGPT, Cursor, Codex et d’autres clients suivent le même principe avec leurs propres écrans de paramètres. Comme le côté serveur est identique pour tous, une équipe peut utiliser différents clients sans développer d’intégrations séparées, et l’accès se révoque à un seul endroit.
Il est aussi utile de rédiger trois ou quatre questions de test avant de déployer un serveur auprès d’une équipe, chacune avec une bonne réponse connue : une température de pièce que vous pouvez vérifier, un appareil que vous savez hors ligne, une commande qui doit être refusée parce que la valeur est hors plage. Relancez-les après chaque modification des descriptions d’outils du serveur, car une description reformulée peut changer l’outil que choisit le modèle.
Deux habitudes facilitent l’usage au quotidien. Nommez les appareils comme les gens en parlent (« porte chambre froide 2 », pas « node-4471 »), car le modèle rapproche les demandes de ces noms. Et gardez le rôle de l’agent clair : laissez-le chercher des informations, comparer des mesures et expliquer ce qu’il a trouvé, tandis que tout ce qui doit se produire à chaque fois, sans que personne le demande, relève d’une règle sur la plateforme, où elle s’exécute que quelqu’un ouvre un chat ou non.
FAQ sur les serveurs MCP pour appareils IoT
Un serveur MCP peut-il communiquer avec des appareils IoT MQTT ?
Oui, mais généralement pas en se branchant directement sur le broker. MQTT fonctionne en publish/subscribe : un serveur devrait donc s’abonner à des topics et mettre en cache les dernières valeurs pour répondre à une question du type « quelle est la mesure actuelle ». Diriger le serveur MCP vers une plateforme qui stocke déjà les données MQTT est plus simple, et cela donne à l’agent l’historique en plus de la valeur actuelle.
Quel langage utiliser pour créer un serveur MCP ?
N’importe quel langage capable de lire et d’écrire du JSON convient, car les messages suivent JSON-RPC 2.0. Des SDK officiels existent pour plusieurs langages, dont TypeScript, Python, Java, C# et Go ; c’est pourquoi la plupart des serveurs pour appareils sont écrits dans le même langage que le backend existant de l’équipe.
Quelles applications et quels clients prennent en charge le Model Context Protocol ?
La prise en charge s’est rapidement répandue depuis qu’Anthropic a publié la norme en novembre 2024. Claude Desktop, Claude Code, ChatGPT, Cursor, Codex et Visual Studio Code avec GitHub Copilot font partie des clients capables de se connecter à des serveurs MCP, même si chacun expose des paramètres différents pour les serveurs locaux et distants.
Un serveur MCP peut-il piloter des appareils IoT LoRaWAN ?
Oui, si l’appareil accepte des commandes, mais pas toujours instantanément. La plupart des capteurs LoRaWAN sur batterie fonctionnent comme des appareils de classe A, qui n’ouvrent leurs courtes fenêtres de réception que juste après l’envoi d’une trame montante (uplink) : un message qui leur est destiné attend donc la transmission suivante. Les appareils de classe C alimentés sur secteur écoutent en permanence et peuvent recevoir une commande presque immédiatement. Dans Kilo, les commandes d’appareils vont aux appareils MQTT et aux contrôleurs LoRaWAN de classe C : un capteur de classe A sur batterie est donc un appareil que l’on lit plutôt qu’un appareil que l’on pilote.
Toute la chaîne tient sur un bureau. Enregistrez un capteur de température et une prise connectée pilotable dans l’offre gratuite de Kilo, connectez Claude via l’endpoint MCP en n’activant que les outils de lecture, et posez des questions sur la pièce jusqu’à ce que les réponses correspondent au thermomètre accroché au mur. Définissez ensuite les commandes marche et arrêt de la prise et activez l’outil de commande, en laissant active dans Claude l’approbation de chaque appel.