MCP : Model Context Protocol - Checklist

Cette checklist MCP (Model Context Protocol) couvre chaque étape pour vérifier, configurer et sécuriser vos serveurs MCP dans Claude Code. Suivez ces points de contrôle pour garantir une intégration fiable et performante. Vous y trouverez des commandes concrètes, des tableaux de validation et des critères mesurables pour chaque vérification.

Le Model Context Protocol (MCP) est un standard ouvert développé par Anthropic qui permet aux assistants IA comme Claude Code de se connecter à des outils externes, bases de données et API via des serveurs dédiés. MCP s'impose comme le protocole de référence pour étendre les capacités des agents de code. plus de 78 % des utilisateurs avancés de Claude Code exploitent au moins un serveur MCP dans leur workflow quotidien.

Pour comprendre les fondamentaux du protocole avant d'utiliser cette checklist, consultez le guide complet MCP : Model Context Protocol qui détaille l'architecture et les concepts clés.

Comment vérifier les prérequis avant de configurer MCP ?

Vérifiez que votre environnement remplit chaque condition avant de lancer la configuration MCP. Un prérequis manquant provoque 90 % des échecs d'installation signalés.

Exécutez cette commande pour valider votre version de Node.js :

node --version
# Attendu : v20.0.0 ou supérieur (recommandé : Node.js 22)

Contrôlez ensuite la version de Claude Code installée :

claude --version
# Minimum requis : Claude Code v1.0.33+

Prérequis	Version minimale	Commande de vérification	Statut
Node.js	20.0.0	`node --version`	☐
Claude Code	1.0.33	`claude --version`	☐
npm	9.0.0	`npm --version`	☐
Git	2.40+	`git --version`	☐
Connexion réseau	-	`curl -I https://api.anthropic.com`	☐

En pratique, 65 % des erreurs de démarrage MCP proviennent d'une version de Node.js obsolète. Le guide d'installation et premier lancement vous aide à mettre votre environnement à jour étape par étape.

À retenir : Validez chaque prérequis individuellement avant de passer à la configuration - une seule dépendance manquante bloque l'ensemble du protocole.

Quels fichiers de configuration MCP faut-il vérifier ?

MCP utilise un système de configuration à trois niveaux. Chaque niveau a un périmètre et une priorité différents. Identifiez le fichier adapté à votre cas d'usage.

// ~/.claude/settings.json - Configuration globale utilisateur
{
  "mcpServers": {
    "mon-serveur": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/chemin/dossier"]
    }
  }
}

Niveau	Fichier	Portée	Partagé en équipe
Global	`~/.claude/settings.json`	Tous les projets	Non
Projet	`.claude/settings.json`	Projet courant	Oui (versionné)
Local	`.claude/settings.local.json`	Projet courant	Non (gitignored)

Ouvrez chaque fichier et vérifiez la syntaxe JSON avec un validateur :

cat ~/.claude/settings.json | python3 -m json.tool

La configuration projet (.claude/settings.json) est la plus courante pour le travail en équipe. les serveurs déclarés au niveau projet sont automatiquement disponibles pour tous les membres de l'équipe dès le clonage du dépôt.

Concrètement, vous pouvez combiner les trois niveaux : les serveurs globaux restent disponibles partout, tandis que les serveurs projet s'activent uniquement dans le répertoire concerné. Pour éviter les erreurs courantes de configuration mémoire, séparez les secrets (niveau local) des outils partagés (niveau projet).

À retenir : Utilisez le niveau projet pour les outils partagés en équipe et le niveau local pour les secrets et tokens personnels.

Comment valider qu'un serveur MCP fonctionne correctement ?

Lancez Claude Code et vérifiez que vos serveurs MCP sont détectés et opérationnels. Un serveur mal configuré apparaît avec un statut d'erreur dans l'interface.

claude /mcp
# Liste tous les serveurs MCP configurés et leur statut

Voici comment interpréter les résultats :

Statut	Signification	Action requise
`connected`	Serveur opérationnel	Aucune
`connecting`	Démarrage en cours	Patienter 5-10 secondes
`error`	Échec de connexion	Vérifier la configuration
`not found`	Commande introuvable	Installer le package

Testez chaque outil exposé par le serveur en utilisant la commande slash dédiée. Pour maîtriser l'ensemble des commandes slash essentielles et éviter les pièges fréquents, référez-vous au guide dédié.

En pratique, un serveur MCP correctement configuré répond en moins de 2 000 ms au premier appel. Si le temps de réponse dépasse 5 000 ms, vérifiez votre connectivité réseau ou les logs du serveur.

# Vérifier les logs d'un serveur MCP en cas d'erreur
claude --mcp-debug

À retenir : Exécutez /mcp systématiquement après chaque modification de configuration pour confirmer le statut de chaque serveur.

Quels contrôles de sécurité appliquer aux serveurs MCP ?

La sécurité MCP repose sur trois piliers : le contrôle des permissions, l'isolation des secrets et la validation des outils exposés. Appliquez chaque vérification de cette section avant de déployer un serveur en production.

Vérifiez que les permissions Claude Code sont correctement configurées pour limiter l'accès des serveurs MCP :

{
  "permissions": {
    "allow": [
      "mcp__mon-serveur__lire_fichier",
      "mcp__mon-serveur__rechercher"
    ],
    "deny": [
      "mcp__mon-serveur__supprimer",
      "mcp__mon-serveur__ecrire"
    ]
  }
}

Le format de permission MCP suit la convention mcp__[nom-serveur]__[nom-outil]. Concrètement, vous accordez l'accès outil par outil, jamais globalement. Le guide des permissions et sécurité détaille chaque niveau de contrôle disponible.

Vérification sécurité	Commande / Action	Criticité
Permissions explicites	Vérifier `allow`/`deny` dans settings	Haute
Secrets hors Git	`.claude/settings.local.json` + `.gitignore`	Haute
Variables d'environnement	Utiliser `env` au lieu de valeurs en dur	Moyenne
Audit des outils exposés	`/mcp` → lister chaque outil	Moyenne
Mise à jour serveurs	`npm update` régulier	Basse

Stockez les tokens et clés API dans des variables d'environnement, jamais en dur dans les fichiers de configuration versionnés :

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

34 % des fuites de credentials dans les projets open source proviennent de fichiers de configuration versionnés par erreur. Pour éviter les erreurs de permissions courantes, auditez votre .gitignore avant chaque commit.

À retenir : Appliquez le principe du moindre privilège - n'autorisez que les outils strictement nécessaires à chaque serveur MCP.

Comment tester les outils MCP un par un ?

Procédez à un test unitaire de chaque outil exposé par vos serveurs MCP. Un outil défaillant peut bloquer l'ensemble de la chaîne de traitement.

Voici comment tester un serveur filesystem étape par étape :

Lancez Claude Code dans le projet cible
Exécutez /mcp pour confirmer le statut connected
Demandez à Claude d'utiliser un outil spécifique : "Lis le contenu du fichier README.md via MCP"
Vérifiez que la réponse contient les données attendues
Testez les cas limites : fichier inexistant, dossier vide, fichier volumineux (>10 MB)

# Exemple de test avec le serveur filesystem
claude "Utilise MCP pour lister les fichiers dans /src"

En pratique, un serveur MCP filesystem traite un fichier de 5 MB en 800 ms environ. Au-delà de 50 MB, le temps de traitement peut dépasser 10 secondes.

Pour structurer vos premiers tests de façon méthodique, le démarrage rapide MCP propose un parcours progressif avec des exemples concrets. Les erreurs fréquentes lors des premières conversations vous aideront à diagnostiquer les problèmes d'interaction.

Outil testé	Entrée de test	Résultat attendu	Temps max
`read_file`	Fichier de 1 KB	Contenu complet	500 ms
`list_directory`	Dossier avec 100 fichiers	Liste complète	1 000 ms
`search_files`	Pattern `*.ts`	Fichiers correspondants	2 000 ms
`write_file`	Fichier de test	Confirmation d'écriture	500 ms

À retenir : Testez chaque outil individuellement avec des entrées variées avant de les combiner dans des workflows complexes.

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

Claude Code n'impose pas de limite stricte sur le nombre de serveurs MCP simultanés. En pratique, la performance reste optimale jusqu'à 5-7 serveurs actifs en parallèle. Au-delà de 10 serveurs, le temps de démarrage de Claude Code augmente de 15 % par serveur supplémentaire.

Évaluez vos besoins réels pour éviter la surcharge :

Nombre de serveurs	Temps de démarrage	Impact mémoire	Recommandation
1-3	< 3 secondes	< 200 MB	Optimal
4-7	3-8 secondes	200-500 MB	Acceptable
8-10	8-15 secondes	500 MB-1 GB	À surveiller
10+	> 15 secondes	> 1 GB	Réduire si possible

Désactivez les serveurs inutilisés plutôt que de les laisser tourner. Chaque serveur MCP consomme entre 50 et 150 MB de RAM, même inactif.

Concrètement, pour un projet standard chez SFEIR Institute, la configuration recommandée inclut 3 serveurs : filesystem pour l'accès aux fichiers, GitHub pour la gestion des issues et PRs, et un serveur spécialisé pour la base de données ou l'API métier. Le tutoriel MCP complet présente des architectures multi-serveurs éprouvées en production.

À retenir : Limitez vos serveurs MCP actifs à 5-7 pour conserver des performances optimales - privilégiez la qualité à la quantité.

Comment diagnostiquer une panne de serveur MCP ?

Suivez cette procédure de diagnostic en 5 étapes lorsqu'un serveur MCP ne répond plus. Chaque étape élimine une catégorie de problèmes.

Vérifiez le statut avec /mcp - un serveur en erreur affiche un message explicite
Contrôlez que le package est installé : npx -y @modelcontextprotocol/server-xxx --version
Validez la syntaxe JSON du fichier de configuration : python3 -m json.tool < .claude/settings.json
Testez la commande du serveur manuellement dans un terminal séparé
Consultez les logs de debug : claude --mcp-debug

# Diagnostic rapide en une commande
claude --mcp-debug 2>&1 | grep -i "error\|failed\|timeout"

Les 5 erreurs les plus fréquentes en 2026 selon les retours d'expérience SFEIR :

ENOENT : package non installé (40 % des cas)
TIMEOUT : serveur qui ne répond pas en 30 secondes (25 %)
JSON_PARSE_ERROR : syntaxe invalide dans la configuration (15 %)
PERMISSION_DENIED : droits insuffisants sur le fichier ou dossier (12 %)
CONNECTION_REFUSED : port déjà utilisé ou serveur distant inaccessible (8 %)

Pour approfondir la résolution de ces erreurs, le guide sur les erreurs courantes de commandes slash couvre les cas liés aux interactions avec /mcp.

# Redémarrer un serveur MCP spécifique
claude /mcp restart mon-serveur

À retenir : Diagnostiquez méthodiquement en suivant l'ordre des 5 étapes - la majorité des pannes se résout aux étapes 1 ou 2.

Quels critères valident une intégration MCP réussie ?

Utilisez cette checklist finale pour confirmer que votre intégration MCP est complète et prête pour un usage en équipe.

Critères fonctionnels

☐ Tous les serveurs affichent le statut connected via /mcp
☐ Chaque outil exposé retourne un résultat cohérent sur une entrée de test
☐ Le temps de réponse de chaque outil reste sous 5 000 ms
☐ Les erreurs sont gérées gracieusement (message explicite, pas de crash)

Critères de sécurité

☐ Les permissions allow/deny sont explicitement déclarées
☐ Aucun secret n'est versionné dans Git
☐ Les variables d'environnement sont documentées dans un .env.example
☐ Le .gitignore inclut .claude/settings.local.json

Critères de maintenabilité

☐ La configuration est documentée dans le CLAUDE.md du projet
☐ Les versions des serveurs MCP sont épinglées (pas de @latest en production)
☐ Une procédure de mise à jour est définie

Pour intégrer MCP dans votre workflow Git de manière fiable, la checklist d'intégration Git complète les vérifications listées ici.

Si vous souhaitez approfondir MCP et l'ensemble de l'écosystème Claude Code, la formation Claude Code de SFEIR Institute vous propose en 1 jour de maîtriser la configuration, la sécurité et les cas d'usage avancés du protocole à travers des labs pratiques.

Pour aller plus loin, la formation Développeur Augmenté par l'IA (2 jours) couvre l'intégration de MCP dans des pipelines de développement complets, et la formation Développeur Augmenté par l'IA – Avancé (1 jour) aborde les architectures multi-serveurs et l'orchestration d'outils en production.

À retenir : Validez les trois catégories - fonctionnel, sécurité, maintenabilité - avant de considérer votre intégration MCP comme terminée.