MCP, c'est le standard ouvert lancé par Anthropic en novembre 2024 pour connecter les IA à des outils et des données externes. Une seule prise, partout. Ici, je rassemble tout ce que tu dois savoir : la définition, l'architecture, les serveurs populaires en 2026, les vrais use cases, et comment construire ton premier serveur.
MCP, pour Model Context Protocol, est un standard ouvert publié par Anthropic en novembre 2024, qui permet à n'importe quel modèle de langage de se connecter de manière uniforme à des outils, des bases de données et des services externes. Au lieu d'écrire une intégration sur mesure entre chaque IA et chaque outil, tu écris un serveur MCP une fois, et tous les clients compatibles peuvent l'utiliser.
L'analogie qui revient partout, c'est celle de l'USB-C. MCP est à l'IA ce que l'USB-C est au matériel : une prise standard universelle. Avant l'USB-C, chaque marque avait son propre câble propriétaire — un pour Apple, un pour Samsung, un pour Sony, sans compter les vieux jacks ronds. Aujourd'hui tu branches un câble USB-C dans n'importe quel téléphone moderne et ça marche. MCP fait la même chose pour les IA et leurs outils.
Avant MCP, chaque éditeur d'IA avait son propre format pour brancher des outils. OpenAI avait son function calling, Anthropic avait son Tools API, Google avait ses function declarations, Cohere ses connectors. Résultat concret : si tu voulais qu'un assistant puisse lire ta base Postgres et écrire dans ton Notion, tu écrivais l'intégration trois fois — une pour ChatGPT, une pour Claude, une pour Gemini. Trois codebases à maintenir, trois formats différents, trois courbes d'apprentissage.
Anthropic a ouvert le code et la spec en open source sur le dépôt GitHub modelcontextprotocol, sous licence MIT. N'importe qui peut écrire un serveur, le publier, l'utiliser, le forker. Et le pari a marché : en quelques mois, Cursor, Claude Code, Continue, Cline, Windsurf et d'autres ont adopté le standard. En 2025, OpenAI a annoncé que ChatGPT Desktop le supporte aussi. MCP est devenu un standard de fait pour les agents IA.
MCP n'est pas un modèle d'IA. Ce n'est pas un concurrent de Claude, GPT ou Gemini. C'est une couche au-dessus, indépendante du modèle. Tu peux utiliser MCP avec Claude, GPT, Gemini, Mistral, ou un modèle local via Ollama, du moment que ton client supporte le protocole.
Ce n'est pas non plus un framework d'agents. MCP ne planifie pas les actions, ne décide pas quoi faire ensuite. Il définit comment un agent peut découvrir et appeler des outils. La logique d'orchestration reste celle du modèle (ou du framework qui pilote le modèle, comme LangChain, LlamaIndex ou Mastra).
Pour aller plus loin sur la définition, j'ai aussi écrit une fiche courte dans le lexique : MCP, définition simple. Et le terme parent à comprendre, c'est le tool use / function calling, qui décrit la capacité d'un modèle à appeler un outil au lieu de seulement répondre du texte.
MCP repose sur une architecture client-serveur classique, transportée en JSON-RPC. Côté client, tu as l'application qui héberge le modèle (Claude Desktop, Claude Code, Cursor, etc.). Côté serveur, tu as un processus indépendant qui expose des capabilities au client. Les deux se parlent en JSON-RPC, soit en local via stdio, soit à distance via HTTP.
┌────────────────────┐ JSON-RPC ┌────────────────────┐
│ CLIENT MCP │ ◄────────────────────► │ SERVEUR MCP │
│ (Claude Code, │ stdio OR HTTP │ (filesystem, │
│ Claude Desktop, │ │ GitHub, Postgres,│
│ Cursor, Cline) │ │ Notion, custom) │
└────────┬───────────┘ └─────────┬──────────┘
│ │
│ utilise │ expose
▼ ▼
┌────────────────────┐ ┌────────────────────┐
│ MODÈLE LLM │ │ 3 capabilities │
│ Claude · GPT │ │ • Resources │
│ Gemini · Local │ │ • Tools │
└────────────────────┘ │ • Prompts │
└────────────────────┘
Un serveur MCP expose trois grandes catégories de capabilities, c'est-à-dire trois types de choses qu'il met à disposition du client.
Le protocole supporte deux modes de transport selon le contexte.
Stdio (entrée/sortie standard), c'est le mode local. Le client lance le serveur comme un sous-processus et les deux communiquent par stdin/stdout. C'est le mode par défaut pour les serveurs qui tournent sur ta machine — filesystem, base locale, scripts perso. Avantage : pas de réseau, sécurité maximale, latence nulle.
HTTP (avec Server-Sent Events ou WebSocket), c'est le mode distant. Le serveur tourne sur une autre machine et le client se connecte par le réseau. C'est ce qu'on utilise pour des services qui doivent rester centralisés — un MCP partagé en équipe, une intégration SaaS, un connecteur cloud.
Quand un client MCP se connecte à un serveur, il commence par lui demander la liste de ses capabilities. Le modèle reçoit alors une description structurée de chaque tool, resource et prompt disponible. Pas besoin de coder en dur les outils dans le prompt système — l'IA découvre dynamiquement ce qu'elle peut faire à chaque démarrage. C'est ce qui rend MCP vraiment portable.
L'écosystème MCP s'est étoffé vite. L'organisation GitHub modelcontextprotocol maintient une vingtaine de serveurs officiels, et la communauté en a publié plusieurs centaines d'autres. Voici les serveurs les plus utilisés au quotidien, ceux que je vois revenir dans toutes les conversations sérieuses sur les agents IA.
| Serveur | Langage | Maintainer | Usage typique | Complexité |
|---|---|---|---|---|
| Filesystem | TypeScript | Anthropic (officiel) | Lire/écrire fichiers locaux | Facile |
| GitHub | TypeScript | Anthropic (officiel) | Issues, PRs, repos | Facile |
| Notion | TypeScript | Notion + communauté | Base de connaissances, notes | Moyen (auth OAuth) |
| Slack | TypeScript | Anthropic (officiel) | Lecture / envoi messages | Moyen (auth workspace) |
| PostgreSQL | TypeScript | Anthropic (officiel) | Queries SQL en lecture | Facile |
| Puppeteer | TypeScript | Anthropic (officiel) | Pilotage navigateur | Moyen |
| Brave Search | TypeScript | Anthropic (officiel) | Recherche web | Facile (clé API gratuite) |
| Tavily / Exa | TypeScript / Python | Communauté + éditeurs | Recherche web pour IA | Facile (clé API payante) |
| Custom (perso) | Python ou TS | Toi | Spécifique à ton métier | Variable |
Au-delà des serveurs officiels, la communauté publie des serveurs MCP pour à peu près tout. Linear, Jira, Trello côté gestion de projet. Stripe, PayPal côté paiements. HubSpot, Pipedrive côté CRM. Si un service a une API publique, il y a de grandes chances qu'il existe déjà un serveur MCP communautaire. Le réflexe avant d'en coder un : chercher sur le dépôt GitHub modelcontextprotocol/servers et sur les listes communautaires de type awesome-mcp-servers.
Et bien sûr, tu peux toujours rédiger les tiens. Pour mes propres workflows — agents qui pilotent mon site, qui interagissent avec ma newsletter, qui surveillent mes builds — j'ai écrit quelques serveurs MCP minimalistes en TypeScript. On voit comment faire un peu plus bas dans la section dédiée.
Un serveur MCP, c'est du code qui tourne sur ta machine avec accès à ce que tu lui donnes. Un serveur mal écrit ou malveillant peut lire tes fichiers, exfiltrer tes secrets ou poster en ton nom. Règle d'or : ne jamais installer un serveur dont tu n'as pas vérifié la source. Pour les serveurs officiels d'Anthropic, c'est safe. Pour les communautaires, regarde le repo, le nombre de stars, qui maintient, et la dernière mise à jour.
Quand on découvre MCP, la première question qui se pose, c'est : en quoi c'est différent de function calling ? Et c'est une bonne question, parce que les trois concepts se ressemblent superficiellement. Voici comment je les distingue.
Function calling, c'est la capacité d'un modèle à choisir d'appeler une fonction au lieu de générer du texte. OpenAI a popularisé le concept en juin 2023 avec GPT-3.5 puis GPT-4. Tu décris tes fonctions au modèle dans un format JSON spécifique à OpenAI, et le modèle peut décider de les appeler avec des arguments.
Limite : le format est propre à OpenAI. Si tu veux faire la même chose avec Claude ou Gemini, tu réécris ton intégration.
Tools API, c'est l'équivalent de function calling côté Anthropic, lancé début 2024. Même idée, format légèrement différent, supporté nativement par les modèles Claude. C'est le même paradigme que function calling, mais avec sa propre spécification.
Limite identique : le format est propre à Anthropic. Pas portable vers d'autres modèles.
MCP, c'est un standard ouvert au-dessus de tout ça. Concrètement : ton serveur MCP expose des tools (qui ressemblent fortement à des function calls), des resources et des prompts. Le client MCP s'occupe de traduire ces tools dans le format spécifique du modèle qu'il utilise. Si demain tu changes de modèle, ton serveur ne bouge pas.
Donc concrètement : function calling et Tools API sont des fonctionnalités de bas niveau, propres à chaque modèle. MCP est un protocole de plus haut niveau qui s'installe par-dessus. Les deux coexistent, ils ne se remplacent pas. Sous le capot, un client MCP utilise toujours du function calling ou des Tools API pour communiquer avec son modèle.
| Critère | Function Calling | Tools API | MCP |
|---|---|---|---|
| Éditeur | OpenAI | Anthropic | Anthropic (standard ouvert) |
| Année | 2023 | 2024 | Nov 2024 |
| Portabilité | OpenAI uniquement | Anthropic uniquement | Tout client compatible |
| Écosystème | Verticalement intégré | Verticalement intégré | Open, communautaire |
| Niveau | Bas (par modèle) | Bas (par modèle) | Haut (par-dessus) |
| Courbe d'apprentissage | Facile | Facile | Moyenne (init serveur) |
| À choisir si… | Tu codes une intégration verticale OpenAI rapide | Tu codes une intégration verticale Claude rapide | Tu veux portabilité + écosystème partagé |
Pour creuser la couche tool use, lis la fiche tool use / function calling. Et pour comprendre comment MCP s'intègre dans un agent complet, regarde la définition d'agentic workflow.
Je ne suis ni développeur ni codeur. Pourtant, j'utilise plusieurs serveurs MCP au quotidien. Voici les use cases qui me servent vraiment, avec un exemple de prompt pour chacun et ce que j'attends en retour.
Setup · serveur filesystem officiel, scope limité à ~/Projets.
Prompt type · « Ouvre le dossier de mon site, identifie les articles qui parlent de MCP, et propose-moi un plan d'amélioration interne linking. »
Résultat attendu · Claude lit le contenu réel de mes fichiers, ne se base pas sur un copier-coller, et me sort une analyse fondée sur la matière. C'est l'usage le plus naturel et le plus utile.
Setup · serveur Notion communautaire + token d'intégration Notion.
Prompt type · « Lis ma base "Idées d'articles" dans Notion, repère les sujets sur lesquels j'ai déjà publié, et liste les idées à creuser cette semaine. »
Résultat attendu · L'IA croise mon Notion avec mes articles existants et me sort une todo-list priorisée. Pratique pour la veille éditoriale.
Setup · serveur calendrier communautaire (iCloud ou Google Calendar) + OAuth.
Prompt type · « Regarde mon calendrier de la semaine, identifie les créneaux libres de plus de 2h, et propose-moi un planning pour finir le pillar MCP. »
Résultat attendu · L'IA voit mes vrais créneaux et me produit un plan réaliste. Plus besoin de copier-coller mon planning.
Setup · serveur Brave Search officiel + clé API gratuite (2 000 requêtes/mois).
Prompt type · « Fais-moi un état de l'art de MCP en mai 2026. Cherche les annonces récentes, les benchmarks, et les comparaisons sérieuses. »
Résultat attendu · Claude lance plusieurs recherches en parallèle, agrège les résultats, et me sort une synthèse avec sources. Idéal pour ne pas se contenter de la connaissance figée du modèle.
Tous ces use cases tournent dans Claude Code ou Claude Desktop. La même logique fonctionne dans Cursor ou Cline pour ceux qui préfèrent un éditeur. Pour aller plus loin sur les workflows agentiques que je monte, lis mon article Superpowers · les skills Claude Code — où je parle aussi de la complémentarité skills + MCP.
Je ne vais pas te faire le tutoriel exhaustif ici — la doc officielle modelcontextprotocol.io le fait très bien et la techno évolue trop vite pour qu'un article statique soit fiable sur les détails. Mais voici la trame générale pour démarrer.
Anthropic maintient deux SDK officiels : Python et TypeScript. Les deux sont au même niveau de maturité.
Tu choisis selon ton stack. Si tu vis dans l'écosystème Node/JavaScript, prends TypeScript. Si tu fais de la data science ou de l'IA en Python, prends Python. Pour un premier serveur, les deux marchent aussi bien, le code est de complexité similaire.
Le SDK officiel fournit un template de démarrage. En TypeScript, tu peux lancer npx @modelcontextprotocol/create-server mon-serveur pour générer une arborescence prête. En Python, tu utilises le package mcp via uvx ou pip.
Tu obtiens un dossier avec le squelette du serveur, les dépendances installées, et un script de démarrage prêt à tourner.
Tu décides ce que ton serveur expose. Les trois catégories : tools (actions), resources (données), prompts (templates). Pour un premier serveur, commence avec un ou deux tools simples — par exemple, un tool qui retourne la météo d'une ville, ou qui liste les fichiers d'un dossier.
Pour chaque capability, tu déclares un nom, une description (l'IA s'en sert pour comprendre quand l'appeler), et un schéma d'arguments en JSON.
Anthropic fournit un outil de debug appelé MCP Inspector qui te permet de lancer ton serveur et de l'inspecter via une interface web. Tu vois la liste des capabilities, tu peux appeler tes tools manuellement, vérifier les réponses.
C'est l'étape la plus rentable. Tester avant de brancher dans un vrai client te fait gagner un temps fou pour identifier les bugs.
Tu ajoutes une entrée dans la config de ton client. Dans Claude Code, c'est un bloc dans ~/.claude/settings.json. Dans Claude Desktop, c'est dans ~/Library/Application Support/Claude/claude_desktop_config.json sur Mac. Tu précises la commande de lancement du serveur, les arguments et les variables d'environnement.
Tu relances le client. Si tout est bien configuré, ton serveur apparaît dans la liste des outils disponibles et l'IA peut l'appeler. Tu lui demandes en français d'utiliser ton tool, et tu vois si la magie opère.
Le repo modelcontextprotocol/servers contient une vingtaine de serveurs de référence en TypeScript. Le meilleur moyen d'apprendre, c'est de lire le code du serveur filesystem ou du serveur GitHub — ils sont simples, bien commentés, et tu peux les forker pour ton propre serveur.
Oui, à fond. MCP est conçu pour toi. Tu écris tes propres serveurs, tu intègres les serveurs officiels, tu construis des agents portables qui peuvent vivre dans Claude Code, Cursor ou Cline sans réécrire ton intégration. C'est la cible historique du protocole.
Oui, mais pas pour coder des serveurs. Tu utilises les serveurs MCP existants — filesystem, GitHub, Notion, Brave Search — pour donner du contexte à ton IA. Combiné avec les skills Claude Code, ça transforme ton terminal en assistant universel. C'est mon usage actuel.
Pas encore vraiment. En mai 2026, Claude.ai (l'app web grand public) ne supporte pas encore les serveurs MCP custom. C'est Claude Desktop et Claude Code qui ont la primeur. À surveiller — la fonctionnalité finira par arriver sur Claude.ai, mais on n'y est pas.
À monitorer, pas mature pour 2026. Si tu cherches à brancher ton chatbot client à ton CRM ou ton catalogue produit via MCP, c'est techniquement possible mais l'écosystème n'est pas encore prêt côté production. Les solutions verticales (Voiceflow, Botpress, plateformes spécialisées) restent plus solides pour l'instant. MCP devient pertinent quand tu dépasses le chatbot grand public et que tu construis un agent custom.
Mon avis honnête après plusieurs mois d'usage : MCP n'est pas une révolution pour le grand public, c'est une révolution pour les builders. Si tu construis des agents, des intégrations, des automations, c'est un cadeau. Si tu utilises l'IA seulement en mode chat, tu n'as probablement pas besoin d'apprendre MCP — tu en profites indirectement quand les outils que tu utilises (Cursor, Claude Code) l'intègrent.
Les 12 questions que je me suis posées en découvrant MCP, et que les gens me posent encore aujourd'hui. Réponses courtes et directes, honnêtes sur ce que je ne sais pas.
MCP, pour Model Context Protocol, est un standard ouvert lancé par Anthropic en novembre 2024 qui permet à n'importe quel modèle de langage de se connecter de manière uniforme à des outils, des bases de données et des services externes. C'est l'équivalent d'un USB-C pour l'IA : une seule prise pour brancher tout.
MCP a été conçu et publié par Anthropic, la société qui édite Claude. Le protocole a été annoncé en novembre 2024 et le code est publié en open source sur le dépôt GitHub modelcontextprotocol. Depuis, d'autres acteurs (OpenAI, communauté Cursor, éditeurs d'IDE) ont commencé à l'adopter, ce qui en fait un standard de fait.
Parce que c'est la première tentative crédible de standardiser les connexions entre IA et outils. Avant MCP, chaque éditeur d'IA avait son propre format de tools — OpenAI function calling, Anthropic Tools API, Google function declarations. Résultat : les développeurs réécrivaient les mêmes intégrations trois fois. MCP unifie tout, et l'adoption par Cursor, Claude Code et Windsurf en 2025 a accéléré le mouvement.
Oui. La spécification, les SDK officiels (Python et TypeScript) et la majorité des serveurs de référence sont publiés sous licence MIT sur GitHub, dans l'organisation modelcontextprotocol. N'importe qui peut écrire un serveur, le publier, le forker. Anthropic maintient le standard mais n'a pas la main exclusive dessus.
Function calling est une fonctionnalité propre à chaque modèle (OpenAI a son format, Anthropic le sien, Google le sien). MCP est un protocole ouvert qui s'installe par-dessus. Concrètement : avec function calling, tu écris une intégration pour chaque LLM ; avec MCP, tu écris un serveur une fois et n'importe quel client compatible peut l'utiliser. MCP, c'est le standard ; function calling, c'est l'implémentation interne du modèle.
Tu ajoutes une entrée dans ton fichier de configuration ~/.claude/settings.json en précisant la commande de lancement du serveur (souvent un npx ou un python -m), les arguments et les variables d'environnement. Tu relances Claude Code, le serveur apparaît dans la liste des outils disponibles. Pour les serveurs officiels, des assistants d'installation existent qui font ça pour toi.
Côté Anthropic, Claude Desktop et Claude Code supportent MCP nativement. Cursor le supporte aussi. Côté OpenAI, le ChatGPT desktop a annoncé un support en 2025. Côté open source, Continue, Cline et Zed l'intègrent. La liste évolue vite — la majorité des clients IA sérieux ont basculé ou prévoient de basculer.
Le protocole en lui-même est sécurisé par conception : chaque serveur tourne dans son propre processus, les capabilities sont explicitement déclarées, et le client peut filtrer les outils exposés. Le vrai risque, c'est ce que tu installes. Un serveur MCP mal écrit ou malveillant peut lire tes fichiers ou exposer tes secrets. Règle d'or : n'installer que des serveurs maintenus par des sources de confiance, et lire le code avant de brancher.
Tu choisis ton langage (Python ou TypeScript, les SDK officiels couvrent les deux), tu installes le template officiel, tu déclares les capabilities (tools, resources, prompts) que ton serveur expose, tu implémentes leurs handlers, puis tu connectes ton client. La doc modelcontextprotocol.io a un tutoriel complet. Pour un premier serveur simple, compte une à deux heures.
LangChain Tools est une couche d'abstraction côté framework (tu utilises LangChain pour orchestrer ton agent et ses outils). MCP est un protocole de communication entre client et serveur. Les deux peuvent coexister : tu peux exposer un serveur MCP qui est ensuite consommé par un agent LangChain, ou inversement. MCP est plus bas niveau et plus universel ; LangChain est plus haut niveau et lié à son écosystème.
Trois limites que je constate en 2026 : la documentation est encore inégale selon les serveurs (certains sont très bien documentés, d'autres pas du tout), la sécurité repose sur ta vigilance (pas de marketplace centralisé qui audite), et l'expérience utilisateur côté installation reste technique (édition manuelle d'un fichier JSON). Anthropic et la communauté travaillent à corriger les trois, mais on n'y est pas encore.
Trois axes annoncés par Anthropic et la communauté : un registre officiel des serveurs MCP (équivalent npm pour MCP), une meilleure gestion des permissions (un client peut autoriser un outil mais pas un autre), et l'extension du transport HTTP pour les serveurs distants (au-delà du stdio local). La roadmap publique vit sur le GitHub modelcontextprotocol.
Pour creuser MCP au-delà de ce que je couvre ici, voici les sources que je consulte régulièrement. La spec et l'écosystème évoluent vite, donc je préfère pointer vers les sources de référence plutôt que de tout figer dans un article statique.
Le site officiel d'Anthropic dédié à MCP. Spec complète, tutoriels, exemples, guide de démarrage. La source de vérité, mise à jour à chaque release.
GitHubL'organisation officielle. Tu y trouves la spec, les SDK Python et TypeScript, le repo des serveurs de référence et le repo des clients. Le meilleur endroit pour voir le code réel.
ServeursUne vingtaine de serveurs MCP officiels, prêts à utiliser ou à forker. Filesystem, GitHub, Slack, PostgreSQL, Puppeteer, Brave Search. Le code est lisible et bien commenté.
CommunautéLe Discord officiel d'Anthropic héberge un canal dédié à MCP. Annonces, support, échanges avec l'équipe MCP. Pratique pour suivre les nouveautés en direct.
Vidéo officielleTalks et tutos MCP par les équipes Anthropic. Pratique pour voir un serveur être construit en live et comprendre la philosophie du protocole.
Podcast ENUn des meilleurs podcasts IA en anglais. Ils ont fait plusieurs épisodes dédiés à MCP, avec interviews des fondateurs d'Anthropic et de mainteneurs de serveurs MCP populaires.
Mon guideMon guide complet sur Claude Code, le client MCP qui m'a tout fait découvrir. Installation, workflows, skills, et bien sûr la section dédiée à MCP côté Claude Code.
Mon articleL'article où je raconte comment je combine les skills Claude Code et les serveurs MCP pour construire mes propres agents. Concret, avec exemples.
Et si tu veux que je te tienne au courant des évolutions MCP — nouveaux serveurs intéressants, releases de la spec, intégrations qui marchent vraiment — ma newsletter AI Playbook tombe tous les vendredis matin à 9 h. Inscription dans le footer ci-dessous.
MCP évolue vite. Nouveaux serveurs, nouveaux clients qui l'adoptent, nouvelles versions de la spec. Si tu veux suivre ce qui mérite vraiment ton attention — sans lire 80 newsletters tech par semaine — la mienne, AI Playbook, tombe le vendredi matin. Je résume mes tests réels, je donne les commandes qui fonctionnent, et je signale les fausses pistes.
Voir mes newsletters →