MCP : Model Context Protocol

Le Model Context Protocol (MCP) est un standard ouvert qui connecte Claude Code à des outils externes (GitHub, navigateurs, bases de données) via des serveurs légers. Ce guide vous montre comment configurer, sécuriser et exploiter les serveurs MCP pour transformer votre agent en hub de développement capable d'interagir avec tout votre écosystème technique. Consultez le démarrage rapide MCP pour une mise en route en 5 minutes.

Le Model Context Protocol (MCP) est un protocole standardisé, créé par Anthropic, qui permet à Claude Code d'appeler des outils externes via une interface unifiée. MCP supporte plusieurs modes de transport : principalement stdio, HTTP streamable et SSE (déprécié). Il donne accès à un écosystème de centaines de serveurs communautaires. MCP a été conçu pour résoudre le problème d'intégration fragmentée entre les modèles de langage et les outils de développement.

Comment fonctionne le Model Context Protocol (MCP) ?

MCP est une couche d'abstraction entre Claude Code et vos outils externes. Chaque serveur MCP expose un ensemble de « tools » que l'agent peut invoquer pendant une session interactive ou en mode headless et CI/CD.

Le protocole suit un modèle client-serveur. Claude Code agit comme client MCP. Le serveur MCP encapsule la logique d'accès à une ressource : API GitHub, navigateur Playwright, moteur de recherche Brave.

┌──────────────┐ JSON-RPC ┌──────────────┐
│ Claude Code │ ◄──────────────► │ Serveur MCP │
│ (client) │ stdio/HTTP/SSE* │ (ex: GitHub) │
└──────────────┘ └──────────────┘

En pratique, un serveur MCP reçoit des requêtes JSON-RPC et retourne des résultats structurés. Le temps de réponse dépend du serveur et de la latence réseau.

Chaque outil possède un schéma d'entrée/sortie typé. Claude Code lit ce schéma au démarrage de la session et sait comment formater ses appels.

À retenir : MCP standardise la communication entre Claude Code et tout outil externe via un protocole JSON-RPC reposant sur plusieurs modes de transport.

Quels sont les principaux modes de transport MCP disponibles ?

MCP propose plusieurs transports pour connecter Claude Code à un serveur. Les trois transports sont détaillés ci-dessous. Le choix dépend de votre architecture et de vos contraintes réseau. Pour une comparaison détaillée, consultez l'aide-mémoire MCP.

Transport stdio

Le mode stdio lance le serveur comme processus fils. Claude Code communique via stdin/stdout. C'est le mode par défaut, le plus simple à configurer.

claude mcp add github-server -- npx -y @modelcontextprotocol/server-github

Ce transport offre une très faible latence car il n'y a pas de couche réseau. Il convient aux serveurs Node.js ou Python exécutés localement.

Transport SSE (Server-Sent Events)

Le mode SSE connecte Claude Code à un serveur distant via HTTP. Ce transport est désormais déprécié : pour les serveurs distants ou partagés en équipe, préférez le transport HTTP streamable lorsqu'il est disponible.

claude mcp add --transport sse analytics-server https://mcp.example.com/sse

La connexion SSE maintient un flux unidirectionnel du serveur vers le client. Les requêtes du client passent par des appels HTTP POST classiques. La latence est plus élevée qu'en stdio car elle dépend du réseau.

Transport HTTP streamable

Depuis la spécification MCP 2025-03, le transport HTTP streamable remplace progressivement SSE. Il utilise un unique endpoint HTTP avec streaming bidirectionnel.

claude mcp add --transport http my-server https://mcp.example.com/mcp

À retenir : choisissez stdio pour le local et le transport HTTP streamable pour les serveurs distants. HTTP streamable est le standard recommandé. SSE reste pris en charge uniquement comme repli pour les anciens serveurs.

Comment ajouter et configurer un serveur MCP dans Claude Code ?

Ouvrez votre terminal et utilisez la commande claude mcp add pour enregistrer un serveur. Claude Code stocke la configuration des serveurs MCP dans ~/.claude.json (portée local ou user) ou, pour un projet partagé, dans le fichier .mcp.json à la racine du dépôt.

Ajout rapide en ligne de commande

# Ajouter le serveur GitHub HTTP distant avec un Personal Access Token
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer YOUR_GITHUB_PAT"

# Ajouter un serveur stdio local avec variables d'environnement
claude mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable -- npx -y airtable-mcp-server

# Lister les serveurs configurés
claude mcp list

# Supprimer un serveur
claude mcp remove github

Configuration via fichier JSON

Pour une configuration versionnée avec votre projet, concrètement, créez un fichier .mcp.json à la racine du dépôt. Ce fichier est lu automatiquement par Claude Code au lancement.

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

la syntaxe ${VAR} dans le fichier .mcp.json résout les variables depuis votre environnement shell. En pratique, vous stockez les secrets dans un fichier .env que vous ajoutez à .gitignore.

La portée de configuration suit trois niveaux : local (défaut, ~/.claude.json), projet (.mcp.json, versionné) et user (~/.claude.json, partagé entre tous vos projets). La portée local est prioritaire, puis projet, puis user. Consultez le tutoriel MCP complet pour un guide pas à pas de chaque méthode.

À retenir : la commande claude mcp add enregistre un serveur en une ligne. Pour les projets en équipe, versionnez un fichier .mcp.json à la racine du dépôt.

Comment utiliser les outils MCP pendant une session Claude Code ?

Une fois le serveur MCP ajouté, ses outils sont disponibles dans votre session. Lancez Claude Code et vérifiez la connexion avec la commande /mcp.

# Démarrer Claude Code
claude

# Dans la session, vérifier les serveurs MCP
/mcp

Claude Code affiche la liste des serveurs connectés et leurs outils. Vous n'avez pas besoin d'appeler les outils manuellement : l'agent les invoque quand le contexte l'exige.

Exemples concrets d'utilisation

Voici comment Claude Code utilise les outils MCP en situation réelle. Si vous débutez, le guide des premières conversations vous aide à comprendre les interactions de base.

Recherche de code avec GitHub MCP :

Vous : "Trouve tous les fichiers qui importent le module auth dans le repo frontend"
Claude Code → appelle mcp__github__search_code({query: "import auth", repo: "org/frontend"})

Navigation web avec Playwright MCP :

Vous : "Va sur la page de pricing de Stripe et extrais les tarifs"
Claude Code → appelle mcp__playwright__navigate({url: "https://stripe.com/pricing"})
 → appelle mcp__playwright__screenshot()

Création d'issue avec GitHub MCP :

Vous : "Crée une issue pour tracker le bug de connexion SSL"
Claude Code → appelle mcp__github__create_issue({title: "Bug connexion SSL", body: "..."})

Chaque appel MCP nécessite votre approbation explicite. Claude Code affiche le nom de l'outil et ses paramètres avant exécution. Vous pouvez autoriser un outil de façon permanente via les permissions de session.

En pratique, les appels MCP via le transport stdio local offrent des temps de réponse très rapides.

À retenir : les outils MCP s'invoquent automatiquement selon le contexte. Vérifiez la connexion avec /mcp et contrôlez chaque appel via le système de permissions.

Comment sécuriser vos serveurs MCP ?

La sécurité MCP repose sur trois piliers : les permissions, les secrets et l'isolation. Configurez ces éléments avant de partager votre configuration en équipe. Pour les bonnes pratiques détaillées, consultez la checklist MCP.

Gestion des permissions

Claude Code applique un système de permissions à trois niveaux pour les outils MCP :

1. Demande systématique : l'outil demande confirmation à chaque appel (défaut)
2. Autorisation par session : vous approuvez une fois pour toute la session
3. Autorisation permanente : l'outil est ajouté à la liste blanche dans les settings

Vérifiez la portée de chaque autorisation. Un outil create_issue sur GitHub mérite une validation manuelle. Un outil search_code en lecture seule peut être autorisé par session.

Protection des secrets

Concrètement, ne stockez jamais de tokens en clair dans .mcp.json. Voici les méthodes recommandées :

# Méthode 1 : variable d'environnement
export GITHUB_TOKEN=ghp_votre_token
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# Méthode 2 : référence dans.mcp.json + fichier.env
echo "GITHUB_TOKEN=ghp_votre_token" >>.env
echo ".env" >>.gitignore

Les fuites de secrets dans les projets open-source proviennent souvent de fichiers de configuration non protégés. Exécutez git diff --cached avant chaque commit pour vérifier l'absence de tokens.

Isolation réseau

Pour les serveurs MCP distants (HTTP streamable, ou SSE déprécié), configurez un proxy ou un VPN si vos données sont sensibles. Le transport stdio offre une isolation native car il ne traverse pas le réseau.

L'intégration avec Git via Claude Code permet de versionner votre configuration MCP tout en excluant les fichiers sensibles grâce aux règles .gitignore.

À retenir : protégez vos secrets avec des variables d'environnement, utilisez le système de permissions granulaire et auditez chaque outil avant autorisation permanente.

Quels sont les serveurs MCP les plus utilisés ?

L'écosystème MCP compte des centaines de serveurs communautaires. Voici les trois serveurs parmi les plus adoptés par les développeurs.

GitHub MCP Server

Le serveur GitHub MCP couvre les issues, pull requests, fichiers et recherche de code. Le package npm @modelcontextprotocol/server-github est désormais déprécié : le serveur officiel et maintenu est le serveur HTTP distant de GitHub, qui s'authentifie avec un Personal Access Token passé en header. C'est l'un des serveurs MCP les plus utilisés par les développeurs.

claude mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer YOUR_GITHUB_PAT"

Brave Search MCP Server

Brave Search MCP offre un accès à la recherche web directement depuis Claude Code. Le serveur retourne des résultats structurés avec titres, URLs et snippets.

claude mcp add --env BRAVE_API_KEY=BSA_xxx --transport stdio brave -- npx -y @modelcontextprotocol/server-brave-search

Playwright MCP Server

Playwright MCP transforme Claude Code en agent de navigation web. Il peut ouvrir des pages, cliquer, remplir des formulaires et capturer des screenshots. Pour approfondir le coding agentique, ce serveur est un incontournable.

claude mcp add playwright -- npx -y @playwright/mcp@latest

Pour résoudre les problèmes de connexion avec ces serveurs, consultez le guide de dépannage MCP. Les astuces MCP vous aideront à optimiser les performances.

À retenir : GitHub, Brave Search et Playwright forment le trio de serveurs MCP essentiels. Installez-les en priorité pour couvrir la grande majorité des besoins de développement.

Comment créer votre propre serveur MCP ?

Vous pouvez créer un serveur MCP personnalisé en moins de 50 lignes de code. La dernière version du SDK officiel @modelcontextprotocol/sdk fournit les primitives nécessaires.

Serveur minimal en TypeScript

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

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

server.tool("hello", { name: z.string() }, async ({ name }) => ({
 content: [{ type: "text", text: `Bonjour ${name}` }]
}));

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

Enregistrez ce fichier puis ajoutez le serveur à Claude Code :

claude mcp add mon-serveur -- npx tsx mon-serveur.ts

SFEIR Institute propose une formation dédiée Claude Code d'une journée où vous construisez vos propres serveurs MCP lors de labs pratiques. Vous y apprenez à connecter Claude Code à vos APIs internes et bases de données métier.

Pour aller plus loin, la formation Développeur Augmenté par l'IA sur 2 jours couvre l'intégration MCP dans des workflows CI/CD complets, avec des exercices sur GitHub Actions et des pipelines de test automatisés.

Si vous maîtrisez déjà les bases, la formation Développeur Augmenté par l'IA – Avancé d'une journée approfondit la création de serveurs MCP multi-outils, l'orchestration d'agents et les patterns de prompt engineering avancé.

À retenir : le SDK officiel MCP permet de créer un serveur personnalisé en moins de 50 lignes. Testez votre serveur localement avec le transport stdio avant tout déploiement.

Quels problèmes courants rencontrer avec MCP et comment les résoudre ?

Les erreurs MCP les plus fréquentes concernent la connexion, l'authentification et les timeouts. Consultez la FAQ MCP pour les questions récurrentes.

Le serveur ne démarre pas

Vérifiez que Node.js 18 ou supérieur est installé et que le package npm est accessible. La plupart des erreurs de démarrage proviennent d'une version de Node.js trop ancienne.

node --version # Doit afficher v18.x ou supérieur
npx -y @modelcontextprotocol/server-github --help

Timeout de connexion

Le timeout de démarrage d'un serveur MCP se configure via la variable d'environnement MCP_TIMEOUT (en millisecondes, ex : MCP_TIMEOUT=10000 claude). Le timeout d'exécution d'un outil se règle par serveur via le champ timeout (en ms) de son entrée .mcp.json, ou globalement via MCP_TOOL_TIMEOUT. Si un serveur SSE distant ne répond pas, vérifiez la latence réseau et les règles de pare-feu.

Token invalide ou expiré

Claude Code affiche l'erreur 401 Unauthorized quand le token est manquant ou expiré. Exécutez la commande suivante pour mettre à jour le token :

claude mcp remove github
claude mcp add --env GITHUB_TOKEN=ghp_nouveau_token --transport stdio github -- npx -y @modelcontextprotocol/server-github

Pour une procédure complète d'installation de Claude Code incluant la configuration MCP initiale, suivez le guide dédié.

À retenir : la majorité des problèmes MCP se résolvent en vérifiant la version de Node.js, la validité du token et la connectivité réseau. Consultez le dépannage MCP pour les cas avancés.

Pourquoi adopter MCP dans votre workflow de développement ?

MCP transforme Claude Code d'un assistant de code en un agent capable d'interagir avec tout votre écosystème. les développeurs utilisant MCP réduisent significativement le temps passé sur les changements de contexte entre outils.

Sans MCP, vous copiez-collez des informations entre GitHub, votre terminal et votre navigateur. Avec MCP, Claude Code accède directement à ces ressources dans le flux de conversation.

MCP s'inscrit dans la logique du coding agentique où l'agent orchestre plusieurs outils pour accomplir des tâches complexes. le protocole continue d'évoluer avec de nouveaux transports et mécanismes d'authentification OAuth 2.0.

À retenir : MCP élimine les changements de contexte et permet à Claude Code d'interagir nativement avec GitHub, les navigateurs et les bases de données. Adoptez-le pour accélérer chaque étape de votre workflow.