Model Context Protocol : le standard ouvert qui devient l'USB-C de l'intégration des outils d'IA

Tout développeur qui a essayé de construire une application d'IA utile a rencontré le même problème : les grands modèles de langage sont excellents pour raisonner sur du texte, mais ce sont des systèmes isolés. Ils n'ont pas accès à votre base de données, votre code source, votre calendrier ou le web. Les amener à utiliser des ressources externes nécessite de construire des intégrations personnalisées — et chaque modèle et chaque outil nécessite son propre connecteur sur mesure.

Le Model Context Protocol d'Anthropic, introduit en novembre 2024 et publié comme standard ouvert, tente de résoudre ce problème de la même manière que l'USB a résolu le problème de connexion des périphériques : définir un protocole unique et bien spécifié que chaque outil et chaque modèle peut implémenter une fois, et les faire interopérer automatiquement.

Ce qu'est réellement MCP

MCP est un protocole client-serveur construit sur JSON-RPC 2.0. Un serveur MCP expose des capacités — outils, ressources et prompts — qu'un client MCP (généralement une application d'IA ou un runtime LLM) peut découvrir et invoquer. Le protocole définit trois types primitifs de capacités :

Outils (Tools) sont des fonctions que l'IA peut appeler : chercher sur le web, interroger une base de données, exécuter une commande shell, envoyer un email, créer un fichier. Un outil a un nom, une description (en langage naturel, que le modèle utilise pour décider quand l'appeler) et un JSON Schema définissant ses entrées. Le modèle appelle un outil en émettant un message structuré de tool-use ; le client MCP achemine l'appel au serveur approprié ; le résultat est retourné et ajouté au contexte du modèle.

Ressources (Resources) sont des données que l'IA peut lire : fichiers, lignes de base de données, réponses API, documents. Contrairement aux outils, les ressources sont en lecture seule et adressables par URI. Un serveur de ressources peut exposer file:///home/user/project/README.md ou postgres://db/schema/users. Le client peut les récupérer à la demande et les inclure dans la fenêtre de contexte du modèle.

Prompts sont des modèles paramétrés qu'un serveur MCP peut exposer comme des modèles d'interaction réutilisables. Cela est moins utilisé dans les implémentations actuelles mais permet aux fournisseurs d'outils de livrer des stratégies de prompting optimisées avec leurs définitions d'outils.

Le transport est flexible : la spécification actuelle prend en charge stdio (pour les outils locaux s'exécutant en tant que sous-processus) et SSE (Server-Sent Events, pour les serveurs distants basés sur HTTP). Un brouillon de transport WebSocket est en cours. Cela signifie qu'un serveur MCP peut être un script Python local fonctionnant à côté de votre IDE, une API distante s'exécutant dans une fonction cloud, ou tout ce qui se trouve entre les deux.

L'histoire de l'adoption

MCP a été lancé avec l'application Claude Desktop d'Anthropic comme premier client, et un ensemble d'implémentations de serveur de référence pour les intégrations courantes : accès au système de fichiers, recherche web, GitHub, Slack, PostgreSQL et plusieurs autres. L'adoption initiale était principalement dans la communauté des développeurs construisant des extensions pour Claude Desktop et pour Claude Code (l'agent de codage d'Anthropic).

Le statut du protocole a changé considérablement en mars 2025 lorsque OpenAI a annoncé qu'il adoptait MCP comme standard d'intégration pris en charge dans son API et ses propres produits. L'annonce était notable car OpenAI avait son propre format propriétaire d'appel d'outil — l'entreprise a explicitement choisi d'adopter le standard ouvert existant plutôt que d'étendre le sien. Google a suivi en mai 2025, annonçant le support de MCP dans Gemini API et dans le framework d'agent IA Android. Microsoft a intégré MCP dans Copilot Studio et GitHub Copilot en juin 2025.

À la mi-2026, l'écosystème MCP compte plus de 3 000 implémentations de serveur communautaires enregistrées dans le registre officiel, couvrant tout, des intégrations Jira et Linear à la gestion de clusters Kubernetes en passant par la recherche de littérature médicale. Tous les principaux fournisseurs d'API LLM prennent en charge les appels d'outils MCP comme format d'entrée officiel en plus de leur syntaxe d'appel d'outil native.

À quoi cela ressemble en pratique

L'expérience développeur d'ajout de MCP à une application s'est considérablement améliorée depuis le lancement initial. Le package @modelcontextprotocol/sdk JavaScript/TypeScript et la bibliothèque Python mcp gèrent le code passe-partout du protocole ; écrire un serveur MCP pour un nouvel outil implique généralement de définir quelques signatures de fonction avec des annotations de type et une description en langage naturel.

Un serveur MCP Python minimal qui expose un outil pour interroger la base de connaissances interne d'une entreprise ressemble à ceci :

from mcp.server import Server
from mcp.server.models import InitializationOptions
import mcp.types as types

server = Server("company-kb")

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [types.Tool(
        name="search_knowledge_base",
        description="Search the company knowledge base for policies, procedures, and documentation.",
        inputSchema={"type": "object", "properties": {
            "query": {"type": "string", "description": "The search query"}
        }, "required": ["query"]}
    )]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "search_knowledge_base":
        results = await kb_search(arguments["query"])
        return [types.TextContent(type="text", text=results)]

Toute application d'IA compatible MCP — Claude Desktop, une application personnalisée utilisant le SDK Anthropic, une extension GitHub Copilot — peut découvrir et utiliser cet outil automatiquement une fois le serveur enregistré.

Le modèle de sécurité

Les propriétés de sécurité de MCP sont une considération critique pour tout déploiement sérieux. Le protocole lui-même est indépendant du transport et n'inclut pas d'authentification intégrée — cela est laissé à l'implémentation du serveur et à l'environnement de déploiement. Pour les serveurs stdio locaux (s'exécutant sur la machine de l'utilisateur, lancés par l'application cliente), c'est généralement acceptable : le serveur a les mêmes privilèges que l'utilisateur qui l'a lancé. Pour les serveurs SSE distants, l'authentification est la responsabilité de l'opérateur du serveur.

Un risque plus subtil est l'empoisonnement d'outil (tool poisoning) : un serveur MCP malveillant qui déforme le comportement de son outil dans la description en langage naturel, incitant l'IA à l'appeler dans des contextes que l'utilisateur n'avait pas prévus. C'est un domaine actif de recherche en sécurité, et plusieurs mesures d'atténuation ont été proposées : signature cryptographique des manifests du serveur, approbation humaine pour les appels d'outils au-dessus d'un seuil de risque, et analyse statique des descriptions d'outils. La spécification MCP comprend une section sur les considérations de sécurité qui a été étendue à mesure que l'expérience de déploiement réel s'est accumulée.

Pourquoi c'est important pour l'écosystème

Avant MCP, chaque intégration d'IA était une intégration personnalisée. Construire un connecteur entre Claude et vos outils internes nécessitait un code différent que construire le même connecteur pour ChatGPT ou Gemini. Cela créait un travail dupliqué et un écosystème fragmenté où chaque nouveau modèle nécessitait une réimplémentation de chaque intégration existante.

L'impact pratique de MCP est que les implémentations d'outils sont désormais réutilisables dans tout l'écosystème d'IA. Une entreprise qui construit un serveur MCP pour sa documentation interne — une fois — obtient que cette intégration fonctionne avec Claude, ChatGPT, Gemini, Copilot et tout modèle futur qui prend en charge le protocole. C'est le même effet de réseau qui a rendu l'USB si durable : la valeur du standard augmente à mesure que davantage d'appareils et de périphériques le prennent en charge.

Le protocole est encore jeune et évoluera — la spécification actuelle est la v0.9 avec une finalisation de la v1.0 prévue pour fin 2026. Mais sa trajectoire d'adoption suggère qu'il a franchi le seuil de « standard ouvert intéressant » à « infrastructure de facto ». Si vous construisez des applications alimentées par l'IA en 2026 et que vous n'avez pas audité votre stratégie d'intégration d'outils par rapport à MCP, le moment est venu de le faire.