MCP : Model Context Protocol - FAQ

Le Model Context Protocol (MCP) connecte Claude Code à des outils externes - GitHub, navigateur, bases de données - via un standard ouvert. Cette FAQ couvre la configuration des serveurs MCP, leur sécurisation et les cas d'usage concrets pour automatiser vos workflows de développement.

MCP (Model Context Protocol) est un protocole ouvert créé par Anthropic qui standardise la communication entre les modèles d'IA et les outils externes. MCP permet à Claude Code d'interagir avec plus de 50 serveurs communautaires couvrant des services comme GitHub, Brave Search ou Playwright. MCP a été adopté par plus de 10 000 développeurs dans les six premiers mois suivant sa publication.

Ce protocole fonctionne sur un modèle client-serveur où Claude Code agit comme client MCP et se connecte à un ou plusieurs serveurs exposant des outils.

Pour comprendre les fondamentaux du protocole, consultez la page dédiée au Model Context Protocol qui détaille l'architecture complète.

À retenir : MCP est un standard ouvert qui sépare le modèle IA des outils qu'il utilise, rendant l'écosystème extensible.

Comment fonctionne le Model Context Protocol (MCP) ?

MCP fonctionne sur un modèle client-serveur avec trois couches : transport, protocole et outils. Claude Code, en tant que client MCP, découvre les outils disponibles au démarrage de session, puis les invoque à la demande.

Le transport définit comment les messages circulent. Le protocole stdio lance un processus local et communique via stdin/stdout. Le transport SSE (Server-Sent Events) utilise HTTP pour les serveurs distants. Depuis la spécification MCP 2025-03-26, le transport HTTP streamable remplace progressivement SSE.

Chaque serveur expose une liste d'outils avec leur schéma JSON. Claude Code reçoit cette liste et décide quand appeler un outil en fonction du contexte de votre conversation. Le temps de découverte des outils prend moins de 200 ms en transport stdio.

Pour configurer votre environnement initial, suivez le guide d'installation et premier lancement avant d'ajouter des serveurs MCP.

À retenir : MCP sépare transport, protocole et outils - Claude Code découvre automatiquement les outils exposés par chaque serveur connecté.

Comment ajouter un serveur MCP à Claude Code ?

Exécutez la commande claude mcp add suivie du nom du serveur et de la commande de lancement. Claude Code enregistre la configuration dans votre fichier .claude.json.

Voici comment ajouter un serveur stdio en une commande :

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

Pour un serveur SSE distant, spécifiez le transport avec le flag --transport :

claude mcp add my-remote-server --transport sse https://api.example.com/mcp

Pour un serveur HTTP streamable (spécification 2025-03-26) :

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

Concrètement, la commande claude mcp add accepte trois transports : stdio (par défaut), sse et http. Chaque serveur ajouté persiste entre les sessions grâce au fichier de configuration.

Consultez l'aide-mémoire MCP pour retrouver toutes les commandes en un coup d'œil.

À retenir : claude mcp add -- suffit pour connecter un serveur local ; ajoutez --transport sse ou --transport http pour les serveurs distants.

Comment lister et gérer les serveurs MCP configurés ?

Utilisez claude mcp list pour afficher tous les serveurs MCP enregistrés dans votre configuration. Cette commande affiche le nom, le transport et le statut de chaque serveur.

claude mcp list

Pour supprimer un serveur devenu inutile, exécutez :

claude mcp remove github

Pour obtenir le détail JSON d'un serveur spécifique :

claude mcp get github

En pratique, Claude Code stocke la configuration MCP dans .claude.json à la racine de votre projet ou dans ~/.claude.json pour une configuration globale. Vous pouvez éditer ce fichier manuellement si vous préférez.

Les commandes slash essentielles couvrent d'autres commandes utiles pour piloter votre session Claude Code au quotidien.

À retenir : claude mcp list, claude mcp get et claude mcp remove vous donnent un contrôle complet sur vos serveurs configurés.

Comment utiliser les outils MCP pendant une session Claude Code ?

Les outils MCP sont disponibles automatiquement dès que le serveur est configuré. Claude Code les invoque en fonction du contexte de votre conversation, sans syntaxe spéciale de votre part.

Par exemple, avec le serveur GitHub configuré, demandez simplement :

Crée une issue sur le repo my-org/my-project avec le titre "Bug: crash au démarrage"

Claude Code identifie l'outil create_issue du serveur GitHub et l'appelle avec les paramètres appropriés. Le système de permissions et sécurité vous demande confirmation avant toute action sensible.

Voici comment vérifier les outils disponibles en session. Tapez /mcp dans votre session Claude Code pour afficher la liste des serveurs connectés et leurs outils. En pratique, un serveur GitHub expose en moyenne 15 outils distincts (create_issue, search_repositories, create_pull_request, etc.).

Pour approfondir l'utilisation des outils en conversation, explorez la FAQ sur vos premières conversations avec Claude Code.

À retenir : vous n'avez pas besoin de syntaxe spéciale - décrivez votre intention en langage naturel et Claude Code sélectionne l'outil MCP adapté.

Quels sont les serveurs MCP les plus populaires en 2026 ?

Les trois serveurs MCP les plus utilisés sont GitHub, Brave Search et Playwright. plus de 50 serveurs communautaires sont disponibles en open source.

GitHub (@modelcontextprotocol/server-github) expose 20+ outils : gestion d'issues, pull requests, recherche de code, lecture de fichiers. Il nécessite un token GITHUB_PERSONAL_ACCESS_TOKEN.

claude mcp add github -- npx -y @modelcontextprotocol/server-github
export GITHUB_PERSONAL_ACCESS_TOKEN=ghp_votre_token

Brave Search (@anthropic/server-brave-search) permet des recherches web en temps réel. Il consomme environ 200 ms par requête et nécessite une clé API Brave.

claude mcp add brave -- npx -y @anthropic/server-brave-search
export BRAVE_API_KEY=votre_cle

Playwright (@anthropic/server-playwright) automatise le navigateur : screenshots, navigation, interaction DOM. Chaque capture d'écran pèse environ 0.5 MB en PNG.

En pratique, 73 % des utilisateurs MCP commencent par configurer le serveur GitHub selon les statistiques communautaires de 2025. SFEIR Institute recommande d'ajouter GitHub et Brave Search comme socle minimal pour un workflow productif.

La checklist MCP vous guide pas à pas dans l'installation de ces serveurs essentiels.

À retenir : GitHub, Brave Search et Playwright couvrent 80 % des cas d'usage - commencez par ces trois serveurs.

Comment configurer les variables d'environnement pour un serveur MCP ?

Passez les variables d'environnement avec le flag --env ou -e lors de l'ajout du serveur. Ces variables sont stockées chiffrées dans votre configuration locale.

claude mcp add github -e GITHUB_PERSONAL_ACCESS_TOKEN=ghp_abc123 -- npx -y @modelcontextprotocol/server-github

Pour un serveur nécessitant plusieurs variables :

claude mcp add database \
  -e DATABASE_URL=postgresql://localhost:5432/mydb \
  -e DATABASE_TOKEN=secret123 \
  -- npx -y @example/server-postgres

Concrètement, vous pouvez aussi définir les variables dans votre shell (export VAR=value) avant de lancer Claude Code. Le serveur MCP hérite alors de l'environnement du processus parent.

La configuration manuelle dans .claude.json ressemble à ceci :

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

Pour une gestion avancée de vos fichiers de configuration, consultez la FAQ sur le système de mémoire CLAUDE.md qui explique la hiérarchie des fichiers de settings.

À retenir : utilisez --env pour injecter des tokens API au moment de l'ajout, ou configurez-les dans .claude.json pour un contrôle plus fin.

Comment sécuriser ses serveurs MCP ?

Appliquez le principe du moindre privilège : ne donnez à chaque serveur que les permissions strictement nécessaires. Claude Code demande votre autorisation avant chaque appel d'outil MCP non approuvé.

Trois règles de sécurité essentielles :

1. Limitez les scopes des tokens API (ex : GitHub token en read-only si vous n'avez pas besoin d'écriture)
2. Vérifiez la source des serveurs MCP avant installation - privilégiez les packages @modelcontextprotocol/ officiels
3. Auditez les outils exposés avec claude mcp get avant d'approuver les permissions

En pratique, 90 % des incidents de sécurité MCP proviennent de tokens avec des permissions trop larges. Créez un token GitHub dédié avec uniquement les scopes repo:read et issues:write si votre workflow le permet.

Le système de permissions de Claude Code ajoute une couche de protection. Chaque outil MCP est classé selon son niveau de risque. Les outils en lecture (search, get) sont approuvés une fois, tandis que les outils en écriture (create, delete) demandent confirmation à chaque appel.

Pour comprendre le modèle de permissions en détail, lisez la FAQ sur les permissions et la sécurité de Claude Code.

À retenir : moindre privilège sur les tokens, vérification de la source des serveurs, et audit des outils exposés - ces trois pratiques couvrent l'essentiel de la sécurité MCP.

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

Le problème le plus fréquent est l'échec de connexion au serveur, souvent causé par un binaire manquant ou une variable d'environnement absente. Vérifiez d'abord que la commande du serveur fonctionne manuellement.

Diagnostic rapide :

# Vérifier que npx trouve le package
npx -y @modelcontextprotocol/server-github --help

# Vérifier les variables d'environnement
echo $GITHUB_PERSONAL_ACCESS_TOKEN

# Relancer la découverte MCP en session
/mcp

Le guide de dépannage MCP couvre 25+ scénarios d'erreur avec leurs solutions détaillées.

À retenir : 80 % des erreurs MCP se résolvent en vérifiant trois choses - le binaire du serveur, les variables d'environnement et la connectivité réseau.

Peut-on créer son propre serveur MCP ?

Oui, vous pouvez créer un serveur MCP en moins de 50 lignes de code avec le SDK officiel TypeScript ou Python. Le SDK gère le transport et le protocole - vous n'implémentez que la logique métier.

Voici un serveur MCP minimal en TypeScript (Node.js 22+) :

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: "my-server", 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 à Claude Code :

claude mcp add my-server -- node my-server.js

le SDK MCP TypeScript v1.12 supporte les trois transports (stdio, SSE, HTTP streamable). Le SDK Python v1.8 offre les mêmes fonctionnalités.

Pour explorer le paradigme de coding agentique et comprendre comment les agents utilisent ces outils, cette FAQ complémentaire apporte un éclairage utile.

À retenir : le SDK MCP gère transport et protocole - votre serveur custom ne contient que la logique métier, ce qui rend la création accessible en moins d'une heure.

Comment MCP s'intègre-t-il au workflow quotidien d'un développeur ?

MCP transforme Claude Code en hub central qui orchestre vos outils de développement. Au lieu de basculer entre terminal, navigateur et IDE, vous décrivez votre intention et Claude Code coordonne les appels MCP.

Un workflow typique avec MCP en 2026 :

1. Recherchez un bug signalé : Claude Code utilise search_issues (GitHub MCP)
2. Analysez le contexte : Claude Code lit les fichiers concernés via get_file_contents
3. Vérifiez une hypothèse : Claude Code lance brave_search pour trouver la documentation
4. Corrigez le code : Claude Code édite directement les fichiers
5. Validez visuellement : Claude Code capture un screenshot via playwright_screenshot
6. Créez la pull request : Claude Code appelle create_pull_request

En pratique, ce workflow réduit le temps de résolution d'un bug de 45 minutes à 12 minutes en moyenne selon les retours d'utilisateurs SFEIR. Le gain principal vient de l'élimination des changements de contexte entre outils.

Si vous souhaitez maîtriser ces workflows avancés, la formation Claude Code de SFEIR Institute vous permet en 1 jour de pratiquer la configuration MCP et l'orchestration d'outils sur des labs concrets. Pour aller plus loin, la formation Développeur Augmenté par l'IA sur 2 jours couvre l'intégration complète dans votre pipeline CI/CD.

À retenir : MCP élimine le changement de contexte entre outils - vous restez dans Claude Code pendant que le protocole orchestre GitHub, le navigateur et vos API.

Faut-il utiliser MCP en mode projet ou en mode global ?

Configurez MCP au niveau projet (.claude.json à la racine) pour les serveurs spécifiques à un repository, et en mode global (~/.claude.json) pour les outils transversaux. Cette séparation évite les conflits entre projets.

Serveurs à configurer en global :

• Brave Search (recherche web, utile partout)
• Playwright (tests visuels, transversal)

Serveurs à configurer par projet :

• GitHub (token et repo spécifiques)
• Base de données (connexion locale)
• Serveurs MCP custom (outils métier)

// ~/.claude.json (global)
{
  "mcpServers": {
    "brave": {
      "command": "npx",
      "args": ["-y", "@anthropic/server-brave-search"],
      "env": { "BRAVE_API_KEY": "votre_cle" }
    }
  }
}

En pratique, la configuration projet prévaut sur la configuration globale quand un serveur porte le même nom. Ce mécanisme de surcharge vous permet d'adapter les paramètres par environnement.

La formation Développeur Augmenté par l'IA – Avancé de SFEIR approfondit en 1 jour les stratégies de configuration multi-projets et les patterns d'architecture MCP en équipe.

À retenir : global pour les outils transversaux, projet pour les outils spécifiques - la configuration projet surcharge la globale en cas de conflit.

Combien de serveurs MCP peut-on connecter simultanément ?

Claude Code supporte jusqu'à 20 serveurs MCP simultanés sans dégradation notable de performance. Au-delà de 20 serveurs, le temps de découverte des outils dépasse 2 secondes, ce qui ralentit le démarrage de session.

Chaque serveur stdio consomme un processus système séparé. Concrètement, 10 serveurs stdio représentent 10 processus Node.js ou Python actifs en parallèle. Surveillez votre consommation mémoire avec htop si vous dépassez 10 serveurs.

Les serveurs SSE et HTTP ne consomment pas de processus local - seule la connexion réseau est maintenue. Privilégiez ces transports pour les serveurs que vous utilisez occasionnellement.

À retenir : visez 5 à 10 serveurs actifs pour un équilibre optimal entre fonctionnalités et performance - désactivez les serveurs inutilisés avec claude mcp remove.

Quelles sont les différences entre MCP et les appels d'API classiques ?

MCP standardise la découverte et l'invocation d'outils, là où les API classiques nécessitent une intégration manuelle pour chaque service. Le protocole MCP ajoute une couche d'abstraction qui permet au modèle de choisir l'outil adapté au contexte.

le protocole supporte trois primitives : Tools (actions), Resources (données) et Prompts (templates). Les API REST ne couvrent que l'équivalent des Tools.

MCP ne remplace pas les API - il les encapsule. Un serveur MCP GitHub appelle l'API REST GitHub en interne, mais expose ses fonctionnalités dans un format que Claude Code comprend nativement.

À retenir : MCP est une couche d'abstraction au-dessus des API - il ne les remplace pas mais les rend accessibles au modèle IA via un protocole standardisé.

---