MCP expliqué en français : connecter une IA à ses outils, exemple concret

Par Sam Accolade · Publié le 17 août 2026

Si vous suivez un peu l'actualité des assistants IA, vous avez forcément croisé ces trois lettres : MCP. C'est devenu en un an et demi la prise standard qui permet de brancher une IA sur vos propres outils et données, et c'est une notion de plus en plus posée en entretien dès qu'un poste touche à l'IA. Le problème : la quasi-totalité des explications sont en anglais, et beaucoup s'adressent à des gens qui ont déjà construit des agents. Cet article prend le chemin inverse : partir de zéro, en français, et finir avec un vrai serveur MCP qui tourne chez vous.

Précision de méthode habituelle sur ce blog : tout le code de cette page a été écrit, exécuté et testé pendant la rédaction, le 17 août 2026, avec Node.js 24 et le SDK officiel TypeScript de MCP en version 1.30.0 (publiée le 27 juillet 2026 sur npm). Les sorties de terminal sont citées telles quelles, erreurs comprises. Un peu de TypeScript suffit pour suivre ; si les annotations de types vous sont étrangères, l'article sur les génériques TypeScript donne le niveau de lecture nécessaire.

Le problème : une IA enfermée dans sa bulle

Un modèle de langage ne sait que deux choses : ce qu'il a appris pendant son entraînement, et ce que vous lui écrivez dans la conversation. Il ne connaît ni l'heure qu'il est, ni le contenu de vos fichiers, ni l'état de votre base de données. Demandez-lui l'heure : il ne peut que deviner ou refuser. Pour qu'une IA agisse sur le monde réel, il faut lui donner des outils : des petites fonctions qu'elle peut appeler, et dont elle lit le résultat.

Historiquement, chaque éditeur avait son propre format pour déclarer ces outils : un connecteur écrit pour un assistant ne marchait pas avec un autre. C'est exactement le problème qu'ont connu les chargeurs de téléphone avant l'USB-C. MCP, pour Model Context Protocol, est la réponse : un protocole ouvert, publié par Anthropic (l'entreprise derrière Claude) fin novembre 2024, qui standardise la façon dont une application d'IA découvre et appelle des outils externes. La documentation officielle assume d'ailleurs la comparaison (je traduis) : « pensez à MCP comme à un port USB-C pour les applications d'IA ». Et le pari du standard a pris : au moment où j'écris, Claude, ChatGPT, VS Code ou encore Cursor savent tous se brancher sur un serveur MCP, ce que confirme la page d'accueil du projet consultée aujourd'hui.

Trois rôles à connaître : hôte, client, serveur

Le vocabulaire MCP tient en trois mots. L'hôte, c'est l'application d'IA que vous utilisez (Claude, un éditeur de code, un chatbot maison). Le serveur, c'est le programme qui expose vos outils : c'est lui que nous allons écrire, et il tourne en général sur votre machine. Entre les deux, l'hôte embarque un client MCP qui parle au serveur dans un dialecte commun (du JSON-RPC), le plus souvent via l'entrée et la sortie standard du processus, ce qu'on appelle le transport « stdio ». Un serveur peut exposer trois familles de choses : des outils (des fonctions que l'IA peut appeler), des ressources (des données qu'elle peut lire) et des prompts (des gabarits d'instructions). Nous nous concentrons sur les outils, de très loin les plus utilisés.

On construit : un serveur MCP en une quarantaine de lignes

Créez un dossier, initialisez un projet Node et installez trois paquets : le SDK officiel, zod (la bibliothèque de validation qui décrit les paramètres des outils) et tsx (pour exécuter du TypeScript directement) :

mkdir mes-outils-mcp && cd mes-outils-mcp
npm init -y
npm install @modelcontextprotocol/sdk zod tsx

Un détail qui m'a réellement arrêté pendant la rédaction, autant que ça vous serve : le SDK s'utilise en modules ES, avec des await au niveau du fichier. Sans la ligne "type": "module" dans le package.json, l'exécution échoue avec l'erreur Top-level await is currently not supported with the "cjs" output format. Ouvrez donc votre package.json et ajoutez-la avant d'aller plus loin. Ensuite, créez serveur.ts :

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { readFileSync } from "node:fs";
import { z } from "zod";

// 1. On déclare le serveur : un nom, une version.
const serveur = new McpServer({ name: "mes-outils", version: "1.0.0" });

// 2. Premier outil : zéro paramètre. Un modèle de langage ne connaît
//    pas l'heure ; votre machine, si.
serveur.registerTool(
    "heure_actuelle",
    {
        description: "Donne la date et l'heure actuelles (fuseau Europe/Paris)",
    },
    async () => ({
        content: [
            {
                type: "text",
                text: new Date().toLocaleString("fr-FR", { timeZone: "Europe/Paris" }),
            },
        ],
    }),
);

// 3. Deuxième outil : un paramètre, validé par un schéma zod.
serveur.registerTool(
    "compter_mots",
    {
        description: "Compte les mots d'un fichier texte local",
        inputSchema: { chemin: z.string().describe("Chemin du fichier à analyser") },
    },
    async ({ chemin }) => {
        const texte = readFileSync(chemin, "utf-8");
        const mots = texte.split(/\s+/).filter(Boolean).length;
        return {
            content: [{ type: "text", text: `${chemin} contient ${mots} mots.` }],
        };
    },
);

// 4. On branche le tout sur l'entrée/sortie standard : c'est le "transport".
await serveur.connect(new StdioServerTransport());

Lisez-le comme une déclaration : voilà qui je suis, voilà mes deux outils, et pour chacun une description en langage naturel. Cette description n'est pas décorative, c'est elle que l'IA lit pour décider quel outil appeler et quand. Le inputSchema en zod joue le même rôle pour les paramètres : il documente et valide en même temps. Notez enfin ce que ce fichier n'a pas : aucune boucle, aucune gestion de requêtes. Le SDK s'occupe de tout le dialogue.

On teste, d'abord sans IA

Un serveur MCP est un programme comme un autre : on peut lui parler sans aucun modèle de langage, et c'est le bon réflexe avant de le brancher où que ce soit. Le SDK fournit aussi le côté client ; voici client-test.ts, qui lance le serveur en sous-processus, lui demande sa liste d'outils, puis les appelle :

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const client = new Client({ name: "client-test", version: "1.0.0" });
await client.connect(
    new StdioClientTransport({ command: "npx", args: ["tsx", "serveur.ts"] }),
);

const { tools } = await client.listTools();
console.log("Outils annoncés :", tools.map((t) => t.name).join(", "));

const heure = await client.callTool({ name: "heure_actuelle", arguments: {} });
console.log("heure_actuelle →", heure.content[0].text);

const mots = await client.callTool({
    name: "compter_mots",
    arguments: { chemin: "serveur.ts" },
});
console.log("compter_mots →", mots.content[0].text);

await client.close();

Chez moi, npx tsx client-test.ts affiche, tel quel :

Outils annoncés : heure_actuelle, compter_mots
heure_actuelle → 17/08/2026 11:04:05
compter_mots → serveur.ts contient 177 mots.

Tout y est : le serveur annonce ses deux outils, donne l'heure réelle de ma machine et compte les 177 mots de son propre code source. Le protocole fonctionne de bout en bout, sans qu'aucune IA ne soit encore entrée en scène.

On branche une vraie IA

Reste à donner ce serveur à un hôte. J'ai utilisé Claude Code, l'assistant en ligne de commande d'Anthropic, où l'enregistrement tient en une commande (chaque hôte compatible a la sienne ; dans VS Code ou Cursor, cela passe par un fichier de configuration JSON du même genre) :

claude mcp add mes-outils -- npx tsx /chemin/complet/vers/serveur.ts

Puis je lui ai posé, pendant la rédaction, la question piège du début d'article : « Quelle heure est-il exactement chez moi, et combien de mots fait le fichier serveur.ts ? ». Réponse obtenue, que je cite brute (mise en forme markdown comprise, c'est ainsi que l'outil me l'a rendue) :

Voici les informations que vous m'aviez demandées :

- **Heure exacte chez vous** : 11:04:41 (11h 04min 41sec) du 17 août 2026
- **Nombre de mots dans serveur.ts** : 177 mots

Regardez la cohérence avec le test précédent : 11:04:05 au test direct, 11:04:41 par l'IA 36 secondes plus tard, et le même compte de 177 mots. Le modèle n'a rien deviné : il a vu les deux outils annoncés par notre serveur, a décidé de les appeler, et a lu leurs résultats. C'est toute la mécanique de MCP, et vous venez de l'implémenter des deux côtés.

Un mot sérieux sur la sécurité

Le pouvoir de MCP est exactement son risque : un serveur MCP exécute du code sur votre machine, avec vos droits, à la demande d'une IA. Tant que vous écrivez le serveur vous-même, comme ici, vous savez ce qu'il fait. Le danger commence quand on installe des serveurs trouvés sur internet : un serveur malveillant ou mal écrit peut lire des fichiers sensibles ou exécuter n'importe quoi. Les règles de bon sens : n'installez que des serveurs dont vous pouvez lire le code ou qui viennent d'éditeurs identifiés, donnez-leur le minimum d'accès nécessaire, et méfiez-vous par principe d'un outil qui demande des droits sans rapport avec sa fonction. Les hôtes sérieux demandent d'ailleurs votre confirmation avant chaque appel d'outil sensible : ne désactivez pas ces garde-fous par confort.

Ce qu'il faut retenir

MCP n'est pas de la magie d'IA : c'est un protocole, au sens le plus classique du terme, comme HTTP en est un. Un serveur déclare des outils avec des descriptions lisibles, un client les découvre et les appelle, et le modèle de langage décide quand s'en servir. Une quarantaine de lignes de TypeScript suffit pour un premier serveur utile, et les compétences mobilisées sont celles que vous travaillez déjà en apprenant le développement web : du JavaScript, des fonctions, un peu de validation de données. Si vous avez suivi le projet Snake en JavaScript, vous avez le niveau pour refaire cette page de bout en bout, et c'est un excellent projet à montrer : peu de débutants en ont un dans leur portfolio.

Pour aller plus loin, la documentation officielle (modelcontextprotocol.io, en anglais) couvre ce que nous avons laissé de côté : les ressources et les prompts, le transport HTTP pour les serveurs distants, et la liste des hôtes compatibles. Dernier conseil d'honnêteté : cet écosystème bouge vite. Les versions et comportements décrits ici sont ceux du 17 août 2026 ; si quelque chose ne correspond plus au moment où vous lisez, la documentation officielle fait foi.