Tous les articles

Back-end13 min de lecture

Qu'est-ce que MCP (Model Context Protocol) ? Guide pratique

Qu'est-ce que le Model Context Protocol ? MCP expliqué avec deux serveurs que j'utilise chaque jour : host, client, server, tools, transports et serveur TypeScript.

Aussi en Português, English, Español

Si vous utilisez Claude Code, Cursor ou n'importe quelle IA dans votre éditeur, vous êtes déjà tombé sur le sigle MCP. Il apparaît dans la configuration, dans les listes de « connecteurs », dans chaque article sur les agents. Et presque toujours en anglais.

J'utilise MCP tous les jours. J'ai mon propre serveur qui dessine des personnages pour une de mes apps, et j'utilise une version étendue de Talk to Figma pour dessiner dans Figma directement depuis le terminal. Les illustrations de cet article viennent de là.

Voici donc l'article que j'aurais aimé lire quand j'ai commencé : ce qu'est MCP, comment les pièces communiquent entre elles et à quoi ressemble un vrai serveur de l'intérieur.

TL;DR#

  • MCP est un standard ouvert pour connecter des applications d'IA à des systèmes externes : fichiers, bases de données, API, Figma.
  • Trois pièces : le host (l'application que vous utilisez), un client par connexion et le server (celui qui propose les outils).
  • Le serveur propose des tools, des resources et des prompts. Les tools sont les plus utilisées : des actions que le modèle décide d'appeler.
  • En dessous, c'est du JSON-RPC 2.0, via stdio (processus local) ou Streamable HTTP (serveur distant).
  • La spec a changé le 2026-07-28 : elle est devenue sans état, sans la poignée de main initialize, et a marqué sampling et roots comme dépréciés. Un tutoriel de 2025 est déjà dépassé.
  • Une tool, c'est du code qui tourne avec vos permissions. Installez un serveur MCP avec le même soin qu'une dépendance.

Le problème que MCP résout#

Imaginez trois applications d'IA (Claude Code, Cursor et l'application que vous construisez) et quatre outils que vous voulez utiliser avec elles : GitHub, Figma, Postgres et Slack.

Sans standard, chaque application a besoin de sa propre intégration avec chaque outil. Cela fait 3 × 4 = 12 intégrations, chacune avec son format, son authentification et ses bugs. Une nouvelle application arrive ? Quatre de plus. Un nouvel outil ? Trois de plus.

Sans standard, chaque paire a besoin d'une intégration. Avec MCP, chaque côté implémente le protocole une seule fois

Avec MCP, le calcul devient une addition : chaque application implémente un client MCP et chaque outil reçoit un serveur MCP. Cela fait 3 + 4 pièces, et n'importe quelle application parle avec n'importe quel outil.

Un port USB-C pour les IA#

La documentation officielle définit MCP comme un standard open source pour connecter des applications d'IA à des systèmes externes. Et elle utilise une image qui aide beaucoup : voyez MCP comme un port USB-C pour les applications d'IA.

Avant l'USB-C, chaque appareil avait son propre câble. Aujourd'hui, un seul câble sert pour le chargeur, l'écran et le disque externe. MCP fait la même chose entre l'IA et les outils : l'application n'a besoin de rien savoir de Figma, elle a juste besoin de parler MCP.

Un peu d'histoire : Anthropic a lancé MCP en novembre 2024 et, en décembre 2025, a fait don du protocole à l'Agentic AI Foundation, rattachée à la Linux Foundation. Dans l'annonce du don, Anthropic parlait de plus de 10 000 serveurs MCP publics actifs.

Les trois pièces : host, client et server#

C'est la partie qui embrouille le plus, alors je vais prendre mon setup comme exemple.

Le host crée un client pour chaque serveur. Chaque connexion est dédiée
  • Le host est l'application d'IA que vous utilisez. Dans mon cas, Claude Code. Il garde la conversation, parle au modèle et vous demande la permission avant d'exécuter une tool (sauf si vous l'avez autorisée).
  • Le client est la pièce, à l'intérieur du host, qui maintient une connexion avec un serveur. Le host crée un client pour chaque serveur configuré.
  • Le server est le programme qui propose les outils. Il peut tourner sur votre machine ou ailleurs.

Mes deux serveurs locaux sont très différents à l'intérieur :

  • le serveur de personnages assemble des personnages en SVG à partir des pièces d'un brandbook et renvoie l'image finie ;
  • TalkToFigma ne dessine rien tout seul : il transmet les commandes, via un WebSocket local, à un plugin ouvert dans Figma. C'est le plugin qui touche aux calques.

Pour Claude Code, les deux sont pareils : un serveur MCP avec une liste de tools.

Ce que propose un serveur#

Un serveur peut proposer trois types de choses, que la spec appelle des primitives. La différence entre elles, c'est qui décide de les utiliser.

Tools, resources et prompts, et ce qui a changé côté client dans la spec 2026-07-28

Tools : le modèle décide#

Les tools sont des actions. Chercher quelque chose, créer un fichier, envoyer un message, générer un personnage. Le serveur liste ses tools avec un nom, une description et le format des paramètres, et c'est le modèle qui décide quand appeler chacune. C'est de loin la primitive la plus utilisée : mes deux serveurs n'ont que des tools.

Resources : l'application décide#

Les resources sont des données qui apportent du contexte : le contenu d'un fichier, le schéma d'une base de données, l'historique git. Chacune a une URI, et c'est l'application qui décide quoi joindre à la conversation.

Prompts : vous décidez#

Les prompts sont des modèles de message tout faits que vous choisissez sur le moment, comme une commande avec une barre oblique. Talk to Figma en propose quelques-uns, comme design_strategy, avec de bonnes pratiques pour travailler dans Figma.

Et côté client ?#

Le chemin inverse existe aussi : le serveur peut demander des choses au client. C'est là que la spec du 2026-07-28 a beaucoup changé :

  • Elicitation reste : le serveur vous demande une information au milieu de la tâche (un identifiant, une confirmation).
  • Sampling (le serveur qui demande une réponse au modèle du host) et Roots (le client qui indique au serveur quels dossiers il peut voir) ont été marqués comme dépréciés. Ils fonctionnent encore, mais une nouvelle implémentation ne devrait pas les utiliser.

Si vous lisez un tutoriel de 2025, c'est ici qu'il risque le plus de vous induire en erreur.

En dessous : JSON-RPC#

Toute conversation entre client et server est du JSON-RPC 2.0 : des messages JSON avec method, params et un id pour associer la question à la réponse. Pour appeler une tool, le client envoie un tools/call :

{ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { "name": "greet", "arguments": { "name": "Yasmin" } } }

Et le serveur répond avec le résultat. Cette réponse est réelle : elle vient du serveur minimal que je montre plus bas.

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [{ "type": "text", "text": "Hello, Yasmin!" }],
    "resultType": "complete"
  }
}

Dans la version actuelle, chaque requête transporte aussi la version du protocole et les capacités du client dans un champ _meta. La spec omet ce champ dans ses exemples pour les raccourcir, et j'ai fait pareil.

Les transports#

Le JSON doit bien voyager d'une manière ou d'une autre, et la spec définit deux transports :

  • stdio : le host lance le serveur comme processus enfant et communique par l'entrée et la sortie standard, un message par ligne. C'est ce qu'utilisent mes deux serveurs.
  • Streamable HTTP : chaque message est un POST vers un seul endpoint, et la réponse revient en JSON ou sous forme de flux SSE. C'est la façon de faire tourner un serveur distant, qui sert plusieurs clients.

L'ancien transport HTTP+SSE, qu'on voit dans beaucoup de tutoriels, est déprécié depuis la version 2025-03-26.

Un appel de tool, étape par étape#

En mettant tout bout à bout, voici ce qui se passe quand je demande un personnage à Claude Code :

L'aller-retour d'un appel de tool : demande, travail du serveur et résultat
Les neuf étapes, de la découverte du serveur jusqu'à l'image dans la conversation
  1. Le client découvre le serveur. Dans la spec actuelle, avec server/discover, qui renvoie les versions et les capacités. Dans les versions de 2025, c'était la poignée de main initialize.
  2. Le client demande la liste des tools (tools/list). Mon serveur en renvoie 11, chacune avec un nom, une description et le schéma des paramètres.
  3. Vous demandez, en langage naturel : « dessine une personne de 70 ans ».
  4. Le modèle choisit la tool en lisant les descriptions, et construit les arguments : { anos: 70 }.
  5. Le host vous demande la permission. Vous pouvez refuser.
  6. Le modèle passe l'appel au client.
  7. Le client envoie le tools/call et le serveur exécute le code.
  8. Le résultat revient : dans mon cas, une image PNG et un JSON avec la seed et les traits.
  9. Le modèle répond avec le personnage.

Remarquez que le modèle ne parle jamais au serveur. Il choisit seulement la tool et les arguments. Celui qui parle au serveur, c'est le client, à l'intérieur du host, et seulement après votre accord.

Un serveur minimal en TypeScript#

Le moyen le plus rapide de comprendre, c'est d'en écrire un. Le SDK officiel TypeScript en est à la version 2, avec des paquets séparés pour le serveur et le client :

npm install @modelcontextprotocol/server zod

Et voici un serveur complet, avec une tool :

src/index.ts
import { McpServer } from "@modelcontextprotocol/server";
import { serveStdio } from "@modelcontextprotocol/server/stdio";
import { z } from "zod";
 
// serveStdio calls this for every instance it needs
function createServer() {
  const server = new McpServer({ name: "hello-mcp", version: "1.0.0" });
 
  server.registerTool(
    "greet",
    {
      description: "Greets someone by name. Use it when the user asks to say hi to someone.",
      inputSchema: z.object({ name: z.string().describe("Who to greet") }),
    },
    async ({ name }) => ({
      content: [{ type: "text", text: `Hello, ${name}!` }],
    }),
  );
 
  return server;
}
 
serveStdio(createServer, {
  onerror: (error) => console.error("hello-mcp error:", error),
});
console.error("hello-mcp running on stdio"); // stderr: stdout belongs to the protocol

Trois détails qui comptent :

  • La description est ce que lit le modèle pour décider s'il appelle la tool. Écrivez-la comme si c'était pour quelqu'un de votre équipe.
  • Le schéma zod devient du JSON Schema dans le tools/list. C'est comme ça que le modèle sait quels arguments envoyer.
  • Pas de console.log. En stdio, la sortie standard appartient au protocole : le moindre texte qui traîne là casse les messages. Les logs vont dans console.error.

serveStdio gère aussi bien les nouveaux clients que ceux qui ouvrent encore avec l'initialize de 2025. J'ai testé les deux en envoyant les messages à la main, et le serveur a bien répondu dans chaque version.

Pour le brancher sur Claude Code, après la compilation :

claude mcp add hello-mcp -- node build/index.js

Et pour le tester sans aucune IA, l'Inspector liste les tools en ligne de commande :

npx @modelcontextprotocol/inspector --cli node build/index.js --protocol-era modern --method tools/list

À quoi ça ressemble dans mon vrai serveur#

Le serveur de personnages a 11 tools. Voici la principale, avec les noms traduits en anglais (sur le serveur, elle s'appelle gerar_personagem, le nom qui apparaît dans les schémas) :

mcp/server.ts
server.registerTool(
  "generate_character",
  {
    title: "Generate character",
    description:
      "Generates a character from a seed (the same seed always gives the same character). " +
      "Without a seed, draws a new one. Traits in 'locked' are kept. 'age' shows the same person in another phase of life. " +
      "Returns the image and the traits.",
    inputSchema: { seed: z.string().optional(), locked: partialTraits.optional(), ...visual },
    annotations: { readOnlyHint: true },
  },
  async ({ seed, locked, ...v }) => {
    const s = seed ?? newSeed();
    return respond(draw(s, locked), s, v);
  },
);

Et la réponse renvoie deux choses : l'image, pour que vous la voyiez, et un JSON, pour que le modèle puisse continuer le travail :

return {
  content: [
    { type: "image", data: png.toString("base64"), mimeType: "image/png" },
    { type: "text", text: JSON.stringify(info, null, 2) }, // seed, age and traits
  ],
};

C'est comme ça qu'est né le personnage de l'animation : j'ai demandé une personne de 70 ans, joyeuse, et le serveur a renvoyé l'image avec la seed 0d2kajwu. Avec la même seed, une autre tool montre la même personne à une autre étape de sa vie.

Ce serveur est encore sur le SDK v1 (@modelcontextprotocol/sdk), branché avec server.connect(new StdioServerTransport()). Il fonctionne avec le Claude Code que j'utilise aujourd'hui, mais la nouvelle documentation prévient que cette méthode ne sert que les clients de l'ère 2025. Un nouveau serveur, je le commencerais directement en v2, avec serveStdio.

Ce que j'ai appris#

La description, c'est le prompt. Le modèle ne lit pas votre code, il lit la description de la tool et des paramètres. Dans mon serveur, chacun des styles de dessin a une phrase qui explique ce qu'il change, parce que c'est tout ce que le modèle voit au moment de choisir.

Donnez au modèle un moyen de découvrir les valeurs valides. J'ai créé une tool listar_opcoes qui se contente de lister les ids des pièces et des couleurs. La description de la tool qui assemble les personnages demande de la consulter, et l'erreur de trait invalide renvoie aussi vers elle. Comme ça, le modèle sait où chercher, au lieu d'inventer un id qui n'existe pas.

Renvoyez ce dont le modèle aura besoin à l'étape suivante. La seed dans le JSON a l'air d'un détail, mais c'est elle qui permet de demander « maintenant cette même personne à 10 ans ».

Tout n'a pas besoin de passer par MCP. Les illustrations de cet article ont été dessinées dans Figma depuis le terminal, mais les commandes que j'ai ajoutées au plugin Talk to Figma, je les appelle avec un script qui parle directement au relais, dans un lot de plus de 200 étapes. MCP, c'est la porte qui permet à l'IA de parler à l'outil. Quand c'est un script qui pilote, un client simple suffit.

Précautions de sécurité#

La spec elle-même est claire : les tools représentent une exécution de code arbitraire. Donc :

  • Sachez qui exécute quoi. Un serveur stdio est un processus sur votre machine, avec vos permissions : il lit vos fichiers et accède à votre réseau. Un serveur distant tourne sur la machine de quelqu'un d'autre, et tout ce que vous lui envoyez quitte votre ordinateur.
  • Installez un serveur MCP comme vous installez une dépendance. Lisez le code, figez la version, méfiez-vous des serveurs sans propriétaire clair. Pour Talk to Figma, j'ai fait en sorte que le relais n'accepte que les connexions de 127.0.0.1 et j'ai retiré Google Analytics du plugin avant de l'utiliser.
  • N'approuvez pas tout automatiquement. La spec demande que le host obtienne votre consentement avant d'appeler n'importe quelle tool, et que vous puissiez toujours refuser. Tout autoriser, c'est y renoncer.
  • Les annotations sont des indices, pas des garanties. readOnlyHint: true indique que la tool ne fait que lire, mais la spec demande de traiter les annotations comme non fiables, sauf si le serveur est de confiance.
  • Méfiez-vous de ce qui revient. Le résultat d'une tool entre dans le contexte du modèle. Une page web ou une issue peuvent contenir des instructions cachées, et le modèle peut essayer de les suivre.

Références#

Écrit par

Ingénieure logiciel et designer. J'écris sur ce que je rencontre en créant des apps, des APIs et des produits.