Qu’est-ce que le MCP ?
Le protocole de contexte modèle (MCP) est une norme ouverte d’Anthropic permettant de connecter les assistants IA à des sources de données et outils externes. Pensez-y comme un protocole USB-C pour l’IA — un protocole qui fonctionne partout.
Pourquoi le MCP est important
Avant MCP, chaque intégration de l’IA était personnalisée. Chaque outil nécessitait son propre plugin, son propre envelopper d’API et sa configuration. MCP standardise cela.
Architecture
- MCP Host : L’application IA (par exemple, Claude Desktop, Cursor).
- MCP Server : Expose les outils et ressources via le protocole.
- MCP Client : Relie l’hôte aux serveurs.
Concepts clés
- Tools : Fonctions que l’IA peut appeler (recherche, création de fichiers, requête dans la base de données).
- Ressources : Données que l’IA peut lire (fichiers, enregistrements de base de données, réponses API).
- Prompts : Modèles de prompts réutilisables partagés entre applications.
Construire un serveur MCP
1. Définissez vos outils avec des schémas JSON.
2. Implémenter le protocole MCP (transport REST ou stdio).
3. Capacités d’enregistrement (outils, ressources, prompts).
4. Tester avec MCP Inspector ou Claude Desktop.
Écosystème
- GitHub : serveur MCP pour les dépôts et les numéros.
- PostgreSQL : serveur MCP pour les requêtes de base de données.
- Slack : serveur MCP pour la messagerie et les canaux.
- Système de fichiers : serveur MCP pour l’accès local aux fichiers.
Pour les développeurs
- SDK MCP disponibles en TypeScript et Python.
- Suivez la spécification à modelcontextprotocol.io.
- Les serveurs communautaires croissent rapidement — des centaines disponibles.
Construire votre premier serveur MCP
Voici un exemple minimal avec le SDK TypeScript :
L’ancienne API existe encore mais est dépréciée, utilisez donc le point d’entrée actuel :
- `npm install @modelcontextprotocol/sdk zod`
- `import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";`
- `import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";`
- `const server = new McpServer({ name: "my-tool", version: "1.0.0" });`
- `server.registerTool("search", { inputSchema: { query: z.string() } }, async ({ query }) => ({ content: [{ type: "text", text: JSON.stringify(await searchDatabase(query)) }] }));`
- `await server.connect(new StdioServerTransport());`
Source : le paquet @modelcontextprotocol/sdk sur npm, version 1.32.2, consulté le 2026-11-10. Le texte précédent importait @mcp/sdk, qui n’existe pas sur npm.
Considérations de sécurité
- Authentification : les serveurs MCP doivent exiger des clés d’API ou des jetons OAuth. N’exposez jamais un serveur publiquement sans authentification.
- Validation des entrées : validez toutes les entrées des outils par rapport à des schémas. MCP n’assainit pas les entrées automatiquement.
- Limitation de débit : mettez en place des limites de débit pour éviter les abus. Une limite courante est de 100 requêtes/minute par client.
- Journalisation d’audit : journalisez toutes les invocations d’outils pour le débogage et la conformité.
MCP face aux API traditionnelles
MCP ajoute une compréhension sémantique : l’IA sait ce que fait chaque outil et quand l’utiliser. Contrairement aux API REST, où le développeur code en dur la logique d’intégration, MCP laisse l’IA décider quels outils appeler selon le contexte. Cela rend MCP idéal pour les workflows agentiques où l’IA doit choisir ses actions dynamiquement.
La surface d’intégration, c’est le schéma de l’outil
Quand on évalue MCP, on compare souvent les transports et on oublie que la partie dont dépendent les autres systèmes est la définition de l’outil : son nom, sa description et la forme de ses arguments et de son résultat. Un outil dont la description est vague sera appelé au mauvais moment par tous les clients, et un résultat qui renvoie de la prose non structurée ne se compose avec rien en aval. Consacrez vos efforts au schéma et à la description, car le transport est un problème résolu et l’interface ne l’est pas.
Les descriptions sont des prompts. Écrivez-les pour un modèle qui décide s’il faut appeler cet outil, y compris quand il ne faut pas. Nommer clairement les arguments compte bien plus que les abréger, et un résultat qui est un petit objet typé bat un paragraphe de texte à chaque fois.
Les serveurs locaux sont le point de départ à faible friction
Un serveur stdio qui tourne sur la machine de l’utilisateur évite d’un coup les problèmes les plus difficiles : pas d’hébergement, pas d’infrastructure d’authentification, et une frontière de confiance naturelle puisque le processus tourne avec les permissions de l’utilisateur sur les données de l’utilisateur. Commencez là. Passez à un serveur HTTP distant seulement quand la capacité doit réellement être partagée entre machines ou utilisateurs, et acceptez qu’alors vous portez l’authentification, l’autorisation et le multi-tenant.
Où les intégrations cassent en pratique
Les serveurs qui écrivent sur stdout. En stdio, stdout est le canal du protocole, donc un print égaré corrompt le flux et la panne ressemble à un bug du client. Journalisez sur stderr, et testez en lançant le serveur et en surveillant les octets non JSON. Ce seul contrôle épargne des heures de débogage déroutant.
Un premier serveur raisonnable
Enveloppez un outil interne que vous avez déjà, exposez-le avec un schéma précis et une description honnête, et utilisez-le vous-même une semaine avant de le livrer à quiconque.