Accueil › Guides › MCP Protocol

MCP (Model Context Protocol) : guide complet du standard universel de l’IA

Le Model Context Protocol (MCP) est le standard ouvert qui connecte les modèles d’IA à vos outils, bases de données et services externes. Pensez-y comme un « port USB-C de l’IA » : une interface universelle qui remplace des dizaines d’intégrations custom par un seul protocole. Plus de 10 000 serveurs actifs, 97 millions de téléchargements mensuels des SDK, adopté par Anthropic, OpenAI, Google et Microsoft.

Le problème que MCP résout

Avant MCP, connecter une IA à un outil externe nécessitait un développement spécifique pour chaque combinaison. Vous voulez que Claude accède à GitHub ? Un connecteur custom. Qu’il interroge votre base PostgreSQL ? Un autre connecteur. Qu’il lise Slack ? Encore un autre. Si vous avez N applications IA et M outils, vous vous retrouvez avec N × M intégrations à développer et maintenir. C’est le « problème N×M ».

MCP renverse cette logique. Chaque outil expose un serveur MCP standardisé. Chaque application IA embarque un client MCP. Résultat : N + M intégrations au lieu de N × M. Un serveur MCP GitHub fonctionne avec Claude, ChatGPT, Cursor, Gemini, et tout autre client compatible. Un client MCP dans Claude Code peut se connecter à n’importe quel serveur MCP sans code spécifique.

C’est exactement la logique du Language Server Protocol (LSP) qui a standardisé l’intégration des langages de programmation dans les éditeurs de code. Avant LSP, chaque éditeur devait implémenter le support de chaque langage. Après LSP, un seul serveur par langage suffit. MCP fait la même chose pour l’IA et les données.

Architecture : comment ça fonctionne

MCP repose sur trois composants :

Host : l’application qui initie les requêtes. C’est votre client IA : Claude Desktop, Cursor, VS Code avec Copilot, ou toute application intégrant un client MCP.

Client : la couche de communication dans le host qui gère le protocole MCP. Le client découvre les serveurs disponibles, négocie les capacités, et transmet les requêtes.

Serveur : un programme léger qui expose des outils et des ressources à l’IA. Chaque serveur encapsule la logique d’accès à un service externe (API GitHub, base de données, moteur de recherche, système de fichiers).

Le protocole fonctionne via trois primitives :

Tools (contrôlés par le modèle) : des fonctions que l’IA peut invoquer. Exemple : create_issue, run_query, search_web. Le modèle décide quand et comment les utiliser en fonction de la conversation.

Resources (contrôlés par l’application) : des données contextuelles que le host charge dans le contexte de l’IA. Exemple : le contenu d’un fichier, le schéma d’une base de données.

Prompts (contrôlés par l’utilisateur) : des templates de prompts pré-définis que l’utilisateur peut invoquer. Exemple : un template « Code Review » qui structure automatiquement la demande.

Le transport se fait via trois modes : stdio (processus local), SSE (Server-Sent Events) et HTTP streamable. Pour les serveurs locaux (qui tournent sur votre machine), stdio est le plus courant. Pour les serveurs distants (hébergés), HTTP streamable est recommandé.

Les serveurs MCP essentiels

Le trio de base pour les développeurs

GitHub : 15 outils couvrant les issues, pull requests, fichiers et recherche de code. Maintenu par Anthropic. 92% des utilisateurs Claude Code avec MCP activent ce serveur en premier.

claude mcp add github -e GITHUB_TOKEN=ghp_xxx -- npx -y @modelcontextprotocol/server-github

Brave Search : accès à la recherche web directement depuis l’IA. Résultats structurés en ≈ 400 ms. Idéal pour que l’agent accède à des informations en temps réel.

claude mcp add brave -e BRAVE_API_KEY=BSA_xxx -- npx -y @anthropic/mcp-server-brave-search

Playwright : transforme l’IA en agent de navigation web. L’agent peut ouvrir des pages, cliquer, remplir des formulaires, extraire des données. Indispensable pour les workflows d’automatisation web.

claude mcp add playwright -- npx -y @anthropic/mcp-server-playwright

Serveurs populaires par catégorie

La liste complète est disponible dans le MCP Registry (≈ 2 000 entrées) sur modelcontextprotocol.io.

Comment configurer MCP

Dans Claude Code (terminal)

La commande claude mcp add ajoute un serveur à votre configuration. Les serveurs sont stockés dans votre config Claude Code et s’activent automatiquement à chaque session.

# Ajouter un serveur
claude mcp add github -e GITHUB_TOKEN=ghp_xxx -- npx -y @modelcontextprotocol/server-github

# Lister les serveurs actifs
claude mcp list

# Supprimer un serveur
claude mcp remove github

Pour plus de détails, consultez notre guide Claude Code MCP.

Dans Claude Desktop

Éditez le fichier de configuration claude_desktop_config.json (macOS : ~/Library/Application Support/Claude/, Windows : %APPDATA%/Claude/) :

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_votre_token"
      }
    }
  }
}

Redémarrez Claude Desktop. L’icône MCP apparaît dans l’interface, indiquant les serveurs connectés et les outils disponibles.

Dans un projet (partagé avec l’équipe)

Créez un fichier .mcp.json à la racine de votre projet. Ce fichier est versionné avec le code et partagé automatiquement avec l’équipe :

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost/db"
      }
    }
  }
}

Créer votre propre serveur MCP

Un serveur MCP basique se crée en moins de 50 lignes de code. Le SDK officiel @modelcontextprotocol/sdk (TypeScript) ou mcp (Python) gère automatiquement la communication et la sérialisation.

Exemple minimal en TypeScript :

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new McpServer({ name: "mon-serveur", version: "1.0.0" });

server.tool("get_status", "Retourne le statut du système", {}, async () => {
  const status = await fetchSystemStatus(); // votre logique
  return { content: [{ type: "text", text: JSON.stringify(status) }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);

Ce serveur expose un outil get_status que tout client MCP peut invoquer. L’IA découvre automatiquement l’outil et peut l’appeler quand elle le juge pertinent.

Pour un guide complet de développement de serveurs MCP, consultez la documentation officielle sur modelcontextprotocol.io et le cours Anthropic sur Skilljar.

Cas d’usage concrets

Agent de développement connecté : Claude Code + serveurs GitHub + PostgreSQL + Sentry. L’agent lit les issues, code la solution, requête la base de données pour vérifier les schémas, et consulte Sentry pour diagnostiquer les erreurs liées. Tout dans une seule session, sans copier-coller.

Assistant data connecté aux outils internes : un chatbot interne connecté via MCP à Notion (documentation), Slack (conversations), et votre CRM. Les employés posent des questions en langage naturel, l’IA interroge les bons systèmes et synthétise la réponse.

Automatisation multi-outils : un agent IA qui reçoit un brief marketing, cherche des données concurrentielles (Brave Search), génère du contenu (LLM), le publie dans Notion, et notifie l’équipe sur Slack. Le tout orchestré via MCP sans intégration custom entre chaque outil.

Workflow i18n : un serveur MCP connecté à votre système de gestion de traduction (TMS). L’agent détecte les clés de traduction manquantes, génère les traductions, et les pousse directement dans le TMS. Une opération qui prenait des heures se fait en minutes.

Sécurité : les risques et les bonnes pratiques

MCP donne aux modèles IA un accès à vos systèmes. C’est puissant, mais ça implique des risques sérieux :

Prompt injection via les serveurs : un serveur MCP malveillant ou compromis peut injecter des instructions dans les réponses d’outils, manipulant le comportement du modèle. Les descriptions d’outils (annotations) doivent être considérées comme non fiables sauf si le serveur est de confiance.

Exfiltration de données : un agent IA avec accès à votre base de données et à un outil d’envoi d’email pourrait théoriquement extraire des données sensibles. Limitez les permissions de chaque serveur au strict nécessaire.

Outils « sosies » : un serveur malveillant peut exposer un outil nommé comme un outil légitime mais avec un comportement différent. Vérifiez la provenance de chaque serveur MCP que vous installez.

Bonnes pratiques :

N’installez que des serveurs de sources fiables (serveurs officiels Anthropic, serveurs maintenus par les éditeurs comme GitHub, Notion, Stripe). Utilisez des tokens d’accès avec les permissions minimales (lecture seule quand c’est suffisant). Ne mettez jamais de secrets en dur : utilisez des variables d’environnement. En production, implémentez des flux de consentement explicite avant chaque invocation d’outil sensible (écriture, suppression, envoi de données).

La spécification MCP (version 2025-06-18) a introduit l’authentification avancée avec PKCE et les Resource Indicators (RFC 8707) pour prévenir les usurpations de tokens entre serveurs.

Patterns avancés

Code execution avec MCP : à mesure que le nombre d’outils connectés augmente, charger toutes les définitions d’outils dans le contexte du modèle ralentit l’agent et augmente les coûts. La solution avancée : présenter les serveurs MCP comme des API de code plutôt que comme des appels d’outils directs. L’agent écrit du code pour interagir avec les serveurs MCP, ce qui lui permet de charger les outils à la demande, de filtrer les données avant qu’elles n’atteignent le modèle, et d’exécuter des logiques complexes en une seule étape. Anthropic a documenté cette approche en détail dans son blog engineering.

Serveurs MCP chaînés : un agent peut utiliser la sortie d’un serveur comme entrée d’un autre. Exemple : requêter PostgreSQL pour obtenir des données de vente → les analyser avec un outil de calcul → générer un rapport dans Notion → notifier l’équipe sur Slack. Le tout dans une seule session conversationnelle.

MCP en CI/CD : Claude Code en mode headless peut utiliser MCP dans vos pipelines CI/CD. Un agent déclenché par un push Git peut analyser le diff, exécuter les tests via un serveur MCP, vérifier les erreurs dans Sentry, et créer un rapport de revue automatique. C’est l’intégration de l’IA directement dans votre chaîne de livraison.

Serveurs MCP privés pour l’entreprise : les entreprises peuvent créer des serveurs MCP internes qui exposent leurs systèmes propriétaires (ERP, CRM custom, bases métier) aux assistants IA. Les données sensibles restent dans l’infrastructure privée, seules les interfaces d’outils sont exposées via le protocole. C’est l’approche recommandée pour bénéficier de l’IA générative en enterprise tout en maîtrisant la sécurité des données.

MCP vs les alternatives

MCP vs Function Calling brut : le function calling est une fonctionnalité bas niveau intégrée dans les API des LLM. Vous définissez manuellement les schémas de fonctions, vous gérez l’exécution et le retour des résultats. MCP abstrait tout cela : découverte dynamique des outils, gestion de session, authentification, transport. Si le function calling est une brique, MCP est un protocole complet.

MCP vs LangChain Tools : LangChain propose sa propre abstraction d’outils, mais elle est spécifique à l’écosystème LangChain. MCP est agnostique : un serveur MCP fonctionne avec n’importe quel client compatible, quel que soit le framework utilisé côté application. MCP est un standard d’interopérabilité, LangChain est un framework applicatif.

MCP vs API REST classiques : une API REST est conçue pour des appels programmatiques entre systèmes. MCP est conçu pour des interactions IA : le modèle découvre dynamiquement les outils, décide lesquels utiliser, et maintient l’état de session entre les appels. La couche sémantique (descriptions des outils, schémas de paramètres) est native dans MCP et doit être ajoutée manuellement avec les API REST.

L’adoption en 2026

MCP est devenu le standard de facto en moins de 18 mois. L’adoption est massive et multi-acteurs :

Anthropic : support natif dans Claude Desktop, Claude Code et Claude.ai dès le lancement.

OpenAI : intégration dans l’Agents SDK, l’API Responses et l’application desktop ChatGPT (mars 2025).

Google : support annoncé pour Gemini, qualifiant MCP de « bon protocole » avec un essor rapide.

Microsoft : intégration dans les outils de développement et VS Code.

IDE : Cursor, VS Code (via GitHub Copilot), JetBrains, Zed, Replit, Windsurf intègrent nativement MCP.

Entreprises : Notion, Stripe, GitHub, Hugging Face, Postman, HashiCorp proposent des serveurs MCP officiels.

Écosystème français : Alpic (startup française, 5M€ levés en 2025) développe la première plateforme cloud native pour déployer et gérer des serveurs MCP en production. Mistral AI développe des intégrations MCP.

En décembre 2025, Anthropic a transféré la gouvernance de MCP à l’Agentic AI Foundation, un fonds sous la Linux Foundation, consolidant son statut de standard ouvert et neutre.

MCP est à l’IA ce que HTTP est au web : le protocole d’interconnexion qui rend l’écosystème possible. En 2026, ne pas supporter MCP, c’est comme ne pas supporter HTTP en 2000.