Guide de terrain · octobre 2026

Guide de terrain MCP

Connecter les modèles au monde, un serveur à la fois
par Mat Siems
Partie I

Le problème N par M

Pourquoi un protocole existe, et pourquoi maintenant.

Chapitre 1 · Partie I

Une prise pour chaque fiche

Bienvenue. Ceci est un guide de terrain consacré au Model Context Protocol, que l'on abrège généralement en MCP, tel qu'il se présente en octobre 2026. Il compte cent chapitres courts, chacun destiné à vous apprendre une chose utilisable dès cette semaine, que vous construisiez des serveurs, que vous fassiez tourner les hôtes qui s'y connectent, ou qu'une personne haut placée vous ait demandé d'« avoir un avis sur MCP » d'ici vendredi.

Commençons par la description sans fioritures. MCP est un protocole ouvert qui permet à une application d'IA de se connecter à des outils et à des données externes au moyen d'une interface standard unique. D'un côté se trouve quelque chose qui parle à un modèle : une application de chat, un agent de programmation, un IDE. De l'autre, quelque chose qui sait faire un travail : chercher dans un outil de tickets, interroger une base de données, lire un dossier, envoyer un message. MCP est la forme convenue de la conversation entre les deux. L'application demande ce qui est disponible, l'autre côté le décrit, et à partir de là le modèle peut demander qu'un travail soit effectué et en recevoir les résultats.

La comparaison que tout le monde dégaine est l'USB-C, et pour une fois le cliché mérite sa place. Avant un port commun, chaque appareil arrivait avec son propre câble et chaque tiroir se remplissait des mauvais. Après, un fabricant construit une seule prise et compte sur le fait que tout ce qui arrivera s'y branchera. MCP fait la même chose pour l'espace entre les modèles et le monde. Construisez un serveur une fois, et n'importe quel hôte qui parle le protocole pourra le brancher. Construisez un hôte une fois, et il pourra utiliser n'importe quel serveur.

Un protocole est ennuyeux à dessein. C'est ainsi qu'il finit par être partout.

Qu'est-ce que cela signifie concrètement ? Que lorsque vous voulez que votre assistant lise le wiki de votre entreprise, vous n'attendez plus que l'éditeur de l'assistant écrive une intégration pour wiki, et vous n'en écrivez pas une vous-même dans un format de plugin propriétaire qui sera déprécié d'ici le printemps. Vous trouvez, ou construisez, un serveur MCP pour le wiki, et vous le connectez. Le même serveur fonctionne ensuite dans votre agent de programmation, dans votre application de chat sur ordinateur et dans l'outil interne que votre équipe plateforme est en train de bâtir, parce que tous parlent la même langue.

Cela implique aussi un léger changement dans la manière dont vous pensez le modèle. Un modèle seul sait ce sur quoi il a été entraîné et ce que vous y collez. Un modèle relié à des serveurs MCP peut chercher des informations, agir et aller chercher du contexte frais quand il en a besoin, dans les limites que vous fixez. Cette dernière précision occupera bien un tiers de ce livre, car une prise qui s'adapte à tout s'adapte aussi à des choses que vous n'aviez pas prévues.

Le reste de la première partie explique pourquoi le protocole existe, d'où il vient et ce qu'il n'est pas. Si vous êtes impatient, sautez au dixième chapitre et connectez quelque chose. Vous reviendrez. Tout le monde revient, généralement juste après le premier appel d'outil qui l'a surpris.

Une prise, toute fiche HÔTES · parlent au modèle SERVEURS · font un métier App de chat bureau · web Agent de code terminal IDE éditeur MCP une interface standard 1 qu'est-ce qui existe ? 2 le serveur décrit 3 demander le travail 4 retour des résultats Suivi de tickets chercher Base requête Dossier lire Messages envoyer Construisez un serveur une fois : tout hôte qui parle MCP peut l'utiliser. Construisez un hôte une fois : il peut utiliser tous les serveurs.
Fig. 1 · Une prise pour chaque fiche. Hôtes et serveurs se rencontrent via une interface standard : demander, décrire, requérir, renvoyer.
Chapitre 2 · Partie I

La multiplication est l'ennemie

Tout problème d'intégration est secrètement un problème de multiplication, et la multiplication est l'ennemie. Supposons que votre organisation tienne à cinq applications d'IA et à vingt systèmes que vous voulez qu'elles atteignent. Si chaque application s'intègre à chaque système selon ses propres termes, il vous faut cent intégrations. Chacune sera écrite par une personne différente, dans un style différent, avec une idée différente de ce à quoi ressemble une erreur. Chacune cassera selon son propre calendrier.

C'est le problème N par M, et il est plus ancien que les modèles de langage. C'est la raison pour laquelle nous avons des pilotes SQL, des pilotes d'imprimante, HTTP et l'humble prise de courant. Chaque fois, la solution a été la même : s'entendre sur une forme au milieu. Ensuite, chaque application implémente cette forme une fois, chaque système l'implémente une fois, et les cent intégrations se réduisent à vingt-cinq chantiers. N plus M, et non N fois M. L'arithmétique devient plus persuasive à mesure que les nombres grandissent, et dans l'outillage de l'IA, les nombres ont grandi très vite.

Avant MCP, chaque fournisseur de modèles et chaque framework d'agents avait sa propre façon de décrire un outil. Elles se ressemblaient, puisqu'il s'agissait toujours de JSON Schema avec un nom et une description, mais se ressembler n'est pas être identique. Un outil écrit pour un framework devait être réemballé pour le suivant. Une entreprise qui voulait que son produit soit accessible depuis des assistants d'IA devait choisir ses favoris, ou livrer cinq plugins légèrement différents et les maintenir tous. La plupart en choisissaient un et croisaient les doigts.

Le coût d'intégration croît avec le produit de vos choix. Les standards le font croître avec leur somme.

MCP descend l'accord d'un étage. Peu lui importe quel modèle se trouve derrière l'hôte, ou dans quel langage le serveur est écrit. Ce qui lui importe, c'est que les deux côtés échangent les mêmes messages : liste tes outils, appelle celui-ci, voici le résultat. Une fois cela fixé, les gens qui connaissent l'outil de tickets construisent le serveur de l'outil de tickets, et ceux qui construisent des hôtes se concentrent sur l'hébergement. Chacun fait le travail qu'il est le mieux placé pour faire, une seule fois.

Il y a un coût, et il mérite d'être nommé. Une forme partagée est un compromis. Certains systèmes ont des capacités que le protocole n'exprime pas proprement, et certains hôtes aimeraient des fonctionnalités que le protocole n'offre pas encore. Vous rencontrerez ces deux frustrations. L'échange reste avantageux, pour la même raison que personne ne conçoit une prise sur mesure pour sa bouilloire : la valeur de s'adapter partout dépasse celle de s'adapter parfaitement quelque part.

Alors, quand quelqu'un vous demande pourquoi votre équipe devrait utiliser MCP plutôt que d'écrire une intégration directe, faites le calcul à voix haute. Comptez les hôtes que vous voudrez prendre en charge dans deux ans, comptez les systèmes, et multipliez. Puis recomptez, et additionnez. L'écart entre ces deux nombres constitue tout l'argumentaire, et il a rarement besoin d'une diapositive.

La multiplication, l'ennemie Point à point apps systèmes Une forme au milieu apps systèmes MCP chaque paire construite et cassée à part chaque côté implémente la forme une fois N × M = 5 × 20 = 100 intégrations à écrire et maintenir N + M = 5 + 20 = 25 tâches, chacune faite une fois Le coût croît avec le produit de vos choix ; un standard en fait la somme.
Fig. 2 · La multiplication est l'ennemie. Cinq apps et vingt systèmes : cent liens point à point contre vingt-cinq via MCP.
Chapitre 3 · Partie I

La vie avant le protocole

Il est utile de se rappeler comment on faisait avant, ne serait-ce que pour empêcher quiconque de proposer, par nostalgie, qu'on recommence. Les modèles de langage ont appris à appeler des fonctions un certain temps avant que MCP n'existe. Vous décriviez une fonction avec un nom, une phrase d'explication et un JSON Schema pour ses arguments ; le modèle répondait, non pas en prose, mais par une demande structurée de l'appeler ; votre code exécutait la fonction et lui renvoyait la réponse. Cela fonctionnait. Cela fonctionne encore. C'est même exactement ce qui se passe sous MCP.

Le problème, c'était tout ce qu'il y avait autour. L'API de chaque fournisseur avait sa propre enveloppe pour les définitions et les résultats d'outils. Chaque framework d'agents réemballait ces enveloppes dans ses propres abstractions, avec ses propres décorateurs et ses propres classes de base. Une équipe qui voulait que son assistant cherche dans sa documentation écrivait une fonction de recherche, la branchait dans un framework, et découvrait six mois plus tard que la moitié de l'entreprise utilisait un autre assistant, qui ne la voyait pas. La fonction allait très bien. Le problème, c'était la colle, et la colle était faite main à chaque fois.

Puis vinrent les écosystèmes de plugins. Plusieurs produits offraient aux tiers un moyen de les étendre, chacun avec son propre format de manifeste, son processus de validation et son cycle de vie. Un plugin construit pour un produit ne servait à rien dans un autre. Certains de ces écosystèmes ont été fermés, emportant leurs plugins avec eux. Si vous aviez construit dessus, vous avez appris la leçon que toute plateforme finit par enseigner : vous étiez locataire, pas propriétaire.

Le code de colle est la matière noire du logiciel. Il tient tout ensemble et personne ne sait combien il y en a.

Il existait aussi un coût plus subtil. Comme chaque intégration vivait à l'intérieur d'une application donnée, elle en savait trop sur cette application. Elle supposait un certain modèle, un certain style de prompt, une certaine façon de demander la permission à l'utilisateur. La déplacer obligeait à démêler ces hypothèses. La tester obligeait à faire tourner toute l'application. La réutiliser obligeait à la copier, et copier signifiait deux versions qui divergent.

La réponse de MCP est la séparation. Le serveur connaît le système qu'il enveloppe et rien du modèle. L'hôte connaît le modèle et l'utilisateur et rien des entrailles du système. Le protocole est l'interstice étroit et bien spécifié entre les deux. C'est dans cet interstice que la réutilisation devient possible, et que les tests deviennent possibles sans modèle dans la boucle.

Rien de tout cela n'était un manque d'imagination de la part de ceux qui nous ont précédés. L'appel de fonctions était la bonne primitive. Les plugins étaient une expérience raisonnable. Il leur manquait simplement un milieu neutre, qui n'appartienne à personne et que tout le monde puisse implémenter. Si vous maintenez aujourd'hui une pile d'intégrations antérieures à MCP, nul besoin de tout réécrire en un week-end. Enveloppez la plus réutilisée sous forme de serveur, connectez-la à deux hôtes, et voyez si le tiroir à colle s'allège. C'est généralement le cas, et le tiroir ne s'alourdit plus jamais.

Trois voies vers un outil Appel de fonctions Plugins Serveur MCP Définition format du fournisseur manifeste produit un schéma partagé Réemploi réemballer inutile ailleurs tout hôte MCP Propriétaire l'application la plateforme personne ; tous Connaît modèle, prompt, app un seul produit son seul système Test isolé lancer toute l'app lancer le produit l'appeler direct L'appel de fonctions était la bonne primitive ; la colle autour était sur mesure. MCP ajoute le milieu neutre que personne ne possède et que tous implémentent.
Fig. 3 · La vie avant le protocole. Appel de fonctions, plugins et serveurs MCP comparés sur le format, le réemploi, le propriétaire et les tests.
Chapitre 4 · Partie I

Brève histoire d'un jeune standard

L'histoire est courte parce que le calendrier ne lui a pas laissé beaucoup de place. Anthropic a publié le Model Context Protocol sous forme de spécification ouverte en novembre 2024, avec des SDK et une poignée de serveurs de référence pour des choses comme les systèmes de fichiers, Git et les bases de données. Au lancement, c'était la proposition d'une seule entreprise, implémentée dans l'application de bureau de cette entreprise, avec la promesse que n'importe qui pourrait bâtir dessus. Les promesses de ce genre sont courantes. La plupart ne trouvent pas preneur.

Celle-ci, si. Tout au long de 2025, le protocole a été adopté par un éventail remarquable d'hôtes : les assistants et les boîtes à outils d'agents d'autres fournisseurs de modèles, les principaux IDE et agents de programmation, et une longue traîne d'outils plus modestes. Des entreprises ont commencé à livrer des serveurs officiels pour leurs produits, et le nombre de serveurs communautaires a grandi plus vite que quiconque ne pouvait utilement les compter. À la fin de l'année, « est-ce que ça prend en charge MCP ? » était devenu une question de routine dans les évaluations d'outils, posée sur le même ton que « est-ce qu'il y a une API ? ».

La spécification elle-même a évolué rapidement. Les révisions sont identifiées par une date plutôt que par un numéro de version, et chacune a ajouté ou resserré quelque chose : un transport HTTP en streaming pour remplacer un prédécesseur plus maladroit ; un cadre d'autorisation fondé sur OAuth ; une sortie d'outil structurée ; des moyens pour un serveur de poser une question à l'utilisateur ; une mécanique pour les travaux de longue durée. Certaines fonctionnalités des débuts ont été retirées lorsqu'elles se sont révélées plus encombrantes qu'utiles. C'est bon signe. Les standards qui ne retranchent jamais rien deviennent des musées.

Un standard devient réel le jour où son auteur cesse d'en être le seul implémenteur.

En décembre 2025, Anthropic a confié MCP à une fondation ouverte nouvellement créée sous l'égide de la Linux Foundation, aux côtés de contributions d'autres entreprises. L'effet pratique est que le protocole est désormais gouverné au grand jour, avec des propositions, des groupes de travail et des mainteneurs issus de plusieurs organisations, plutôt que d'être la feuille de route d'un seul éditeur. Pour un acheteur, cela répond à la question qu'on pose toujours à propos d'un jeune standard : que se passe-t-il si l'entreprise qui est derrière change d'avis ?

Que retenir de cette histoire ? Surtout une idée du tempo. Les détails ont changé tous les quelques mois et continueront de le faire. Des noms de champs sont renommés, des capacités sont ajoutées, des mécanismes dépréciés s'attardent un moment dans les serveurs plus anciens. Ce livre s'appuie donc sur des principes, et lorsqu'il nomme un mécanisme précis, il vous dit pourquoi ce mécanisme existe, afin que vous reconnaissiez son successeur.

Il y a aussi une leçon dans la manière dont il s'est répandu. MCP n'était pas la conception la plus astucieuse possible. Il était assez simple pour être implémenté en un après-midi, assez ouvert pour que personne n'ait à demander la permission, et utile dès le premier jour. Ces trois propriétés battent l'astuce presque à chaque fois. Si vous vous retrouvez un jour à concevoir un standard interne, souvenez-vous de l'ordre : utile, puis ouvert, puis simple, puis, seulement s'il reste du temps, astucieux.

Un jeune standard, vite adopté Spéc. ouverte SDK + serveurs réf. nov. 2024 Adoption hôtes assistants · IDE 2025 Révisions de spéc. révisions datées 2025–26 Linux Foundation gouvernance ouverte déc. 2025 Question par défaut demandé comme l'API ? oct. 2026 ajouts : streamable HTTP · OAuth · sortie structurée · élicitation · tâches Pourquoi il s'est répandu : utile, puis ouvert, puis simple. L'astuce est venue en dernier.
Fig. 4 · Brève histoire d'un jeune standard. De la spéc. ouverte en novembre 2024 à la gouvernance de la Linux Foundation en décembre 2025.
Chapitre 5 · Partie I

Le modèle ne fait que parler

Le fait le plus utile à propos de MCP est aussi celui qu'on comprend le plus souvent de travers. Le modèle n'appelle jamais d'outil. Le modèle ne fait que parler. Quand on dit « le modèle a cherché dans la base de données », ce qui s'est réellement passé, c'est que le modèle a produit un texte disant, de manière structurée, j'aimerais que l'outil de recherche soit appelé avec ces arguments, et qu'un logiciel parfaitement ordinaire a décidé de le faire ou non.

Ce logiciel, c'est l'hôte : l'application de chat, l'agent de programmation, l'IDE. L'hôte a donné au modèle une liste d'outils qu'il peut demander, chacun avec un nom, une description et un schéma. Quand la réponse du modèle contient une demande d'outil, l'hôte la lit, vérifie ses propres règles, vous demande peut-être la permission, puis envoie la demande via MCP au serveur qui fournit cet outil. Le serveur fait le travail et renvoie un résultat. L'hôte replace le résultat dans la conversation, et le modèle, en le lisant, décide de ce qu'il va dire ou demander ensuite.

Pourquoi est-ce important ? Parce que chaque propriété de sécurité, chaque permission, chaque journal d'audit vit dans l'hôte et le serveur, pas dans le modèle. Un modèle ne peut pas dépasser ses outils, puisqu'il ne peut rien faire d'autre que produire du texte. Si un serveur expose un outil qui supprime des enregistrements, le modèle peut demander que des enregistrements soient supprimés ; que cela se produise dépend des règles d'approbation de l'hôte et des propres vérifications du serveur. Si ni l'un ni l'autre ne vérifie, le jugement du modèle est le seul garde-fou, et ce jugement peut être influencé par tout ce qui se trouve dans son contexte.

Le modèle propose. L'hôte dispose. Le serveur fait le travail et garde les reçus.

Cela explique aussi pourquoi les serveurs MCP n'ont pas besoin de savoir quel modèle ils servent. Ils reçoivent une requête bien formée et renvoient un résultat bien formé. Que cette requête vienne d'un modèle de pointe, d'un petit modèle local ou d'un banc de test qui tape du JSON à la main leur est invisible, et doit le rester. Une partie du meilleur débogage que vous ferez jamais consiste à appeler un serveur directement, sans le moindre modèle en vue, pour voir si le problème se situe au-dessus ou au-dessous du protocole.

Cela explique également pourquoi les descriptions d'outils comptent autant. Le modèle choisit ce qu'il demande uniquement sur la base de ce qu'on lui a dit. Un outil appelé query décrit comme « exécute une requête » sera demandé à des moments étranges avec des arguments étranges. Un outil appelé search_open_tickets décrit comme « trouve les tickets de support ouverts correspondant à une expression ; en renvoie vingt au maximum » sera demandé quand il le faut. Le modèle ne peut pas lire votre code source. Il lit vos adjectifs.

Gardez la séquence en tête : le modèle demande, l'hôte décide, le serveur agit, le résultat revient. Quand quelque chose tourne mal, demandez-vous laquelle des quatre étapes a échoué. La plupart des confusions au sujet des agents viennent de l'idée d'une cinquième étape, au cours de laquelle le modèle aurait tendu la main pour faire quelque chose de lui-même. Ce n'est pas le cas. Quelque chose que vous avez configuré l'y a autorisé.

Le modèle ne fait que parler Utilisateur Modèle Hôte Serveur pose une question question + liste d'outils texte : call search_tickets(q) vérifie ses règles permission ? tools/call fait le travail résultat résultat mis en contexte réponse Le modèle propose. L'hôte dispose. Le serveur fait le travail.
Fig. 5 · Le modèle ne fait que parler. Le modèle émet du texte ; l'hôte vérifie les règles, appelle le serveur et renvoie le résultat.
Chapitre 6 · Partie I

Le contexte est le produit

Le nom vous dit le métier, si vous le lisez lentement. Model Context Protocol. Pas un protocole d'outils, même si les outils sont sa fonctionnalité la plus célèbre, ni un protocole d'agents, même si les agents s'en servent abondamment. C'est un protocole pour acheminer du contexte jusqu'à un modèle : les bons faits, les bons fichiers, les bonnes capacités, au moment où le modèle en a besoin.

L'utilité d'un modèle est bornée par ce qui se trouve dans sa fenêtre de contexte. Il ne peut raisonner que sur ce qu'il voit. Avant des protocoles comme MCP, les principales façons d'y faire entrer du contexte étaient de le coller à la main, de bourrer le prompt avec les meilleures suppositions d'un système de recherche, ou de procéder à un fine-tuning. Les trois ont leur place. Les trois partagent une faiblesse : quelqu'un devait décider à l'avance de ce dont le modèle aurait besoin. MCP permet au modèle, ou à l'application qui l'entoure, d'aller chercher le contexte à la demande. Posez une question sur les incidents de la semaine dernière, et l'assistant peut aller voir, au lieu de s'en remettre à ce qu'on aura bien voulu coller.

Ce cadrage explique les trois primitives côté serveur du protocole mieux que n'importe quel schéma. Les outils permettent au modèle d'aller chercher ou de modifier des choses quand il le décide. Les ressources permettent à l'application de joindre des données, comme un fichier ou un enregistrement, directement à la conversation. Les prompts permettent à l'utilisateur d'insérer une recette toute prête. Tous trois sont des moyens de faire entrer le bon matériau dans le champ de vision du modèle. Tous trois coûtent de la place dans une fenêtre finie.

Le contexte n'est pas gratuit. Chaque token que vous donnez au modèle est un token qu'il doit lire pour trouver celui qui compte.

Ce coût est la contrainte discrète derrière une bonne partie de la conception MCP réussie. Un serveur qui renvoie dix mille lignes n'a pas été généreux ; il a été impoli. Un hôte qui charge les définitions complètes de deux cents outils avant le premier message a dépensé une bonne part de son budget en menus. Les bons serveurs renvoient moins et indiquent où trouver davantage. Les bons hôtes chargent les définitions d'outils paresseusement et laissent le modèle chercher ce dont il a besoin. Vous retrouverez ces deux idées dans les parties suivantes.

Il en découle une habitude pratique. Quand vous évaluez un serveur, ne vous demandez pas seulement s'il peut faire le travail. Demandez-vous combien de contexte il dépense pour le faire. Appelez un outil à la main et regardez la taille de ce qui revient. Comptez les outils qu'il annonce et lisez leurs descriptions comme si vous étiez un modèle avec un petit bureau et une échéance. Un serveur qui répond en deux cents mots là où un concurrent répond en deux mille n'est pas moins capable. Il est plus attentionné, et les serveurs attentionnés produisent de meilleures réponses, parce que le modèle garde de la place pour réfléchir.

Le protocole transporte le contexte. Votre travail consiste à veiller à ce qu'il en transporte la bonne quantité. Un entonnoir, pas une lance à incendie.

Le contexte est le produit Outils le modèle récupère, agit Ressources l'app joint des données Prompts l'utilisateur tire une recette Contexte à la demande récupéré au besoin Fenêtre de contexte finie chaque token doit être lu La juste quantité de la place pour penser Meilleure réponse Déluge 10 000 lignes Entonnoir moins de données, plus de liens 200 défs d'outils d'emblée charger au besoin Chaque token que vous donnez au modèle est un token qu'il doit lire.
Fig. 6 · Le contexte est le produit. Outils, ressources et prompts se déversent dans une fenêtre finie : renvoyer moins, lier plus.
Chapitre 7 · Partie I

Idées empruntées, dettes reconnues

Les bons standards sont en grande partie empruntés, et MCP reconnaît honnêtement ses dettes. La plus évidente est envers le Language Server Protocol, qui avait résolu un problème étonnamment similaire pour les éditeurs de code une décennie plus tôt. Avant LSP, chaque éditeur avait besoin de son propre plugin pour chaque langage afin d'obtenir l'autocomplétion, l'aller-à-la-définition et les soulignements d'erreur. Après, une équipe de langage écrivait un serveur de langage et chaque éditeur qui parlait le protocole obtenait ces fonctionnalités. N par M devenait N plus M. Ça vous rappelle quelque chose ?

Les concepteurs de MCP ont pris plus que l'arithmétique. Ils ont pris la forme. Dans LSP, un client, l'éditeur, lance un serveur, souvent comme sous-processus communiquant par l'entrée et la sortie standard, et les deux échangent des messages JSON-RPC. Ils commencent par une poignée de main d'initialisation au cours de laquelle chaque côté déclare ses capacités, pour que ni l'un ni l'autre n'ait à deviner ce que l'autre prend en charge. Ils continuent avec des requêtes, des réponses et des notifications qui circulent dans les deux sens. Si vous avez déjà débogué un serveur de langage, vous comprenez déjà plus de MCP que vous ne le pensez.

La deuxième dette est envers JSON-RPC 2.0, une spécification petite, ancienne et délibérément terne pour les appels de procédure à distance encodés en JSON. Un message est soit une requête avec un nom de méthode, des paramètres et un identifiant ; soit une réponse portant un résultat ou une erreur pour cet identifiant ; soit une notification, c'est-à-dire une requête qui n'attend pas de réponse. C'est presque tout. MCP ajoute ses propres méthodes par-dessus, comme lister les outils ou lire des ressources, mais l'enveloppe reste du JSON-RPC inchangé. Des bibliothèques existent dans tous les langages, ce qui explique en partie que des serveurs MCP soient apparus dans autant de langages aussi vite.

Personne n'est félicité pour avoir inventé l'enveloppe. Tout le monde gagne à ne pas la réinventer.

D'autres dettes sont moins directes. OAuth fournit le récit d'autorisation pour les serveurs distants, intégralement et pas seulement dans l'esprit. JSON Schema décrit les entrées et sorties des outils. Les URI nomment les ressources. Les server-sent events transportent les flux sur HTTP. Rien de tout cela n'a été inventé pour MCP, et c'est précisément ce qui en fait la valeur : chacun arrive avec son outillage, sa documentation et une génération d'ingénieurs qui en connaissent déjà les angles tranchants.

Pourquoi un praticien devrait-il se soucier de la généalogie ? Parce que les idées empruntées viennent avec des réponses empruntées. Quand vous vous demandez comment gérer une requête annulée, les mondes de LSP et de JSON-RPC ont un avis. Quand vous vous demandez comment valider un token, le monde d'OAuth a dix ans de leçons douloureuses, dont beaucoup rédigées sous forme d'avis de sécurité. Lire un bon article sur la conception des serveurs de langage fera de vous un meilleur auteur de serveurs MCP que d'en lire dix, essoufflés, sur les agents.

Le chevauchement est le protocole, et le protocole est surtout chevauchement. Ce n'est pas une critique. Le plus beau compliment qu'on puisse faire à un standard, c'est que ses pièces inspiraient déjà confiance avant que quiconque ne les assemble.

Idées empruntées, dettes reconnues COUCHE EMPRUNTÉ À Méthodes MCP tools/list · resources/read Propre à MCP Poignée de main + capacités initialize · déclarer LSP Enveloppe de message requête · réponse · notification JSON-RPC 2.0 Transports sous-processus stdio · flux HTTP LSP + SSE TRANSVERSAL JSON Schema entrées + sorties d'outils URI noms de ressources OAuth autorisation distante Le protocole est surtout du recouvrement ; ses pièces avaient déjà fait leurs preuves.
Fig. 7 · Idées empruntées, dettes reconnues. Les couches de MCP et ce que chacune emprunte à LSP, JSON-RPC, SSE, JSON Schema, URI, OAuth.
Chapitre 8 · Partie I

Ce que MCP n'est pas

Toute technologie à succès attire des promesses qu'elle n'a jamais faites. MCP a récolté sa part, et il vaut donc la peine de consacrer un chapitre à ce qu'il n'est pas. Cela épargne des réunions.

Ce n'est pas un framework d'agents. MCP ne décide pas quand appeler un outil, comment planifier une tâche en plusieurs étapes, comment réessayer ni quand s'arrêter. Ces choix appartiennent à l'hôte et au modèle qu'il abrite. Un framework peut utiliser MCP pour atteindre des outils, et beaucoup le font, mais le protocole n'a pas d'opinion sur les boucles, la mémoire ou le raisonnement. Si vous hésitez entre MCP et un framework d'agents, vous avez mal lu l'un des deux.

Ce n'est pas un remplaçant de votre API. Un serveur MCP se place généralement devant une API existante et la traduit dans une forme qu'un modèle peut bien utiliser. L'API existe toujours, sert toujours votre application web et vos partenaires, et porte toujours la véritable logique métier. Un serveur qui duplique cette logique au lieu de l'appeler finira par diverger. Voyez le serveur comme un réceptionniste bien briefé, pas comme un second bâtiment.

Ce n'est pas un modèle de sécurité. MCP spécifie comment l'autorisation doit fonctionner pour les serveurs distants et donne aux hôtes les informations nécessaires pour demander le consentement. Il ne peut pas rendre honnête un serveur malveillant, soigneux un serveur négligent, ni un modèle immunisé contre des instructions cachées dans des données. La sécurité est quelque chose que vous construisez avec MCP, à partir d'hôtes, de serveurs, de tokens et de politiques. Ce n'est pas quelque chose que MCP vous offre du simple fait d'être installé.

Un protocole vous dit comment parler. Il ne peut pas vous dire à qui faire confiance.

Ce n'est pas une fonctionnalité du modèle. Les modèles sont entraînés à utiliser des outils, mais MCP vit entièrement à l'extérieur du modèle, dans le logiciel qui l'entoure. C'est pourquoi le même serveur fonctionne avec différents modèles, et pourquoi un hôte peut prendre en charge MCP avec un modèle qui n'en a jamais entendu parler.

Ce n'est pas une place de marché, même si des registres existent ; pas une plateforme d'hébergement, même si beaucoup d'entreprises hébergeront des serveurs pour vous ; et pas une garantie de qualité, même si l'on traite parfois l'existence d'un serveur comme la preuve qu'il fonctionne. Un serveur est du code que quelqu'un a écrit. Une partie est excellente. Une autre a été écrite en un après-midi et jamais retouchée depuis.

Alors, qu'est-ce que c'est ? Un protocole : un accord précis sur des messages, leur ordre et leur signification, entre un client agissant pour un hôte et un serveur offrant des capacités. C'est une ambition plus modeste que le battage médiatique, et bien plus durable. Quand quelqu'un en réunion propose MCP comme réponse à un problème, posez d'abord une question : s'agit-il d'un problème de deux logiciels qui doivent s'entendre sur la manière de se parler ? Si oui, MCP peut fort bien aider. Si non, c'est le mauvais outil, aussi à la mode que soit l'acronyme.

Ce que MCP n'est pas MCP N'EST PAS… …CAR Un framework d'agents la planif. vit dans hôte + modèle Un substitut à votre API il se place devant l'API Un modèle de sécurité la sécurité se bâtit avec Un trait du modèle il vit hors du modèle Une place de marché ou un hôte registres et hébergement sont à part Une garantie de qualité un serveur est du code écrit par quelqu'un C'est un protocole : des messages, leur ordre et leur sens entre un client agissant pour un hôte et un serveur offrant des capacités
Fig. 8 · Ce que MCP n'est pas. Six choses que MCP n'est pas, et pourquoi ; ce qu'il est : un protocole entre client et serveur.
Chapitre 9 · Partie I

La forme d'un écosystème

Un protocole, à lui seul, est un document. Un écosystème, c'est ce qui se passe quand suffisamment de gens l'implémentent pour que l'implémenter devienne la norme. MCP a franchi cette ligne rapidement, et il est utile d'en connaître les principaux habitants avant de partir à la recherche de quoi que ce soit.

Les serveurs sont les plus nombreux. Certains sont officiels, construits et maintenus par l'entreprise dont ils enveloppent le produit : le serveur d'un outil de tickets lui-même, celui d'un fournisseur cloud, celui d'une société de paiement. Certains sont communautaires, souvent pour des produits qui n'ont pas encore de serveur officiel, et vont du superbe à l'abandonné. Certains sont internes, construits par des entreprises pour leurs propres systèmes et jamais publiés. Quand vous choisissez un serveur, ces trois catégories portent des attentes très différentes en matière de support et de sécurité, et vous devez savoir à laquelle vous avez affaire.

Les hôtes sont les applications qui se connectent aux serveurs pour le compte d'un utilisateur et d'un modèle. On y trouve des assistants de chat sur ordinateur et sur le web, des agents de programmation dans le terminal et l'IDE, et un nombre croissant d'outils métier devenus hôtes sans bruit parce qu'ils ont ajouté un assistant. Les hôtes diffèrent par les parties du protocole qu'ils prennent en charge. Presque tous gèrent les outils. Moins nombreux sont ceux qui gèrent chaque fonctionnalité côté client. La sixième partie fait le tour des principaux.

Les SDK se situent entre les deux. Des SDK officiels existent pour les principaux langages, maintenus en parallèle de la spécification, et ils prennent en charge les parties ingrates : le découpage des messages, la poignée de main, la négociation des capacités, les transports. La plupart des serveurs que vous croiserez ont été construits sur l'un d'eux. La plupart de ceux que vous construirez devraient l'être aussi.

Les écosystèmes sont bâtis par des gens qui résolvent leur propre problème d'une manière qui, par chance, résout le vôtre.

Les registres sont la façon dont chacun trouve quoi que ce soit. Il existe un registre officiel de métadonnées de serveurs, maintenu au grand jour, sur lequel d'autres catalogues et annuaires d'hôtes peuvent s'appuyer. Il existe des annuaires sélectionnés au sein des principaux hôtes, où un administrateur peut activer un connecteur vérifié sans que personne ne touche à un fichier de configuration. Et il y a les listes informelles que tout écosystème fait pousser, certaines soigneusement entretenues, d'autres surtout faites d'enthousiasme. La neuvième partie traite correctement de la découverte.

L'effet de réseau est réel et joue dans les deux sens. Chaque nouvel hôte augmente la valeur de chaque serveur existant, et chaque nouveau serveur rend chaque hôte plus utile. Cette boucle explique pourquoi MCP s'est répandu, et aussi pourquoi l'écosystème a un problème de qualité : quand construire un serveur est facile et le publier gratuit, le nombre de serveurs croît plus vite que la capacité de quiconque à les vérifier.

Votre geste pratique de la semaine est un petit inventaire. Listez les hôtes que votre équipe utilise déjà et, pour chacun, les serveurs auxquels il se connecte. Notez lesquels sont officiels, lesquels communautaires et lesquels internes. La plupart des équipes qui s'y livrent sont surprises par les deux listes. La surprise, ça va. L'ignorance, c'est la version coûteuse.

Qui peuple l'écosystème Écosystème MCP Serveurs officiels communauté internes Hôtes apps de chat agents de code outils métier SDK cadrage des messages poignée de main transports Registres registre MCP catalogues d'hôtes listes informelles Plus d'hôtes chaque serveur vaut plus Plus de serveurs chaque hôte plus utile effet de réseau trop de serveurs pour tout vérifier Cette semaine : listez vos hôtes, leurs serveurs, et qui a construit chacun.
Fig. 9 · La forme d'un écosystème. L'écosystème : serveurs, hôtes, SDK et registres, liés par un effet de réseau à double sens.
Chapitre 10 · Partie I

Vos dix premières minutes

La théorie est agréable, mais rien n'enseigne MCP comme le fait de regarder un appel d'outil se produire. Consacrez-y dix minutes maintenant, et les quatre-vingt-dix chapitres suivants auront plus de sens.

Choisissez un hôte que vous utilisez déjà. Si c'est Claude Code, ouvrez un terminal dans un projet et ajoutez un serveur avec la commande claude mcp add ; s'il s'agit d'une application de chat sur ordinateur, trouvez les réglages de connecteurs ou d'extensions. Choisissez un serveur dont vous comprenez parfaitement le rôle et dont le rayon d'explosion est petit : un serveur de fichiers pointé sur un dossier brouillon, un serveur de documentation pour une bibliothèque que vous connaissez, un connecteur en lecture seule vers un outil que vous utilisez tous les jours. Évitez tout ce qui peut envoyer des e-mails ou déplacer de l'argent. Vous apprenez, vous ne passez pas une audition.

Une fois la connexion faite, vérifiez que l'hôte le voit. La plupart des hôtes affichent les serveurs connectés et leurs outils à un endroit évident ; dans Claude Code, la commande /mcp les liste avec leur statut. Lisez les noms et descriptions des outils. C'est exactement ce que le modèle lira, et il vaut la peine de le voir avec ses yeux. Les descriptions sont-elles claires ? Sauriez-vous quand utiliser chacun ?

Posez maintenant une question qui nécessite le serveur. Pas « utilise l'outil de fichiers », qui ne vous apprend rien, mais une vraie question dont la réponse se trouve derrière le serveur : quels fichiers de ce dossier parlent de factures, ou que dit la documentation au sujet des nouvelles tentatives. Observez ce qui se passe. L'hôte affichera la demande d'outil du modèle, souvent avec ses arguments, et vous demandera peut-être la permission. Accordez-la. Puis regardez le résultat que le serveur a renvoyé avant que le modèle ne le résume.

Le premier appel d'outil est un tour de magie. Le second est un mécanisme. Visez d'arriver vite au second.

La dernière étape est celle que l'on saute. Vérifiez. Contrôlez vous-même la réponse à la source. Le modèle a-t-il appelé l'outil que vous attendiez, avec des arguments sensés ? Le serveur a-t-il renvoyé ce que vous auriez renvoyé ? Le résumé correspondait-il au résultat, ou le modèle a-t-il brodé ? Vous calibrez trois choses à la fois : la qualité du serveur, le jugement du modèle et votre propre idée du degré de confiance à accorder au duo.

Faites ensuite une dernière chose. Posez une question à laquelle le serveur ne peut pas répondre, et voyez si le modèle l'admet ou invente. Une bonne combinaison dira qu'elle n'a pas trouvé l'information. Une mauvaise l'inventera avec aplomb. Savoir laquelle vous avez vaut plus que n'importe quel benchmark.

Si vous avez suivi, vous comprenez désormais la boucle du protocole mieux que la plupart des gens qui en parlent : découvrir, demander, appeler, renvoyer. Tout le reste de ce livre est un approfondissement de l'un de ces quatre mots, plus les considérations de sécurité qui surgissent dès que vous connectez quelque chose de plus intéressant qu'un dossier brouillon. Profitez du dossier brouillon tant que ça dure.

Vos dix premières minutes Choisir un hôte déjà utilisé Ajouter un petit serveur un dossier brouillon Vérifier qu'il est visible /mcp · lire les outils Lire le résultat brut avant le résumé Approuver l'appel surveiller les arguments Poser une vraie question la réponse est derrière Vérifier la réponse la comparer à la source Sonder ses limites demander ce qu'il ignore Il l'admet ? oui Duo fiable dit n'avoir rien trouvé non Il invente : moins de confiance La boucle que vous venez de voir découvrir demander appeler retour tout le reste du livre est un détail de l'un de ces quatre mots Le premier appel d'outil est un tour de magie ; le second est un mécanisme.
Fig. 10 · Vos dix premières minutes. Une première session : brancher un petit serveur, demander, approuver, lire le résultat brut, vérifier.
Extrait gratuit · Partie I

Continuer la lecture

Vous avez lu les 10 premiers chapitres sur 100 de Guide de terrain MCP. Le livre complet contient chaque chapitre et chaque planche, en PDF et EPUB, en anglais, français, polonais et espagnol.

Le livre complet arrive bientôt dans la boutique.

Déjà acheté ? Lire l’édition complète en ligne

Guide de terrain MCP · Première édition, octobre 2026
100 chapitres · 10 parties · cent schémas
par Mat Siems · MS Books, No. 13 · 2026