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. Il est devenu un moyen courant d'étendre les capacités de Claude Code via des serveurs externes.

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 la grande majorité des échecs d'installation signalés.

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

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

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

claude --version
# Vérifiez que Claude Code est installé et à jour

Prérequis	Version minimale	Commande de vérification	Statut
Node.js	18	`node --version`	☐
Claude Code	dernière version	`claude --version`	☐
npm	fourni avec Node.js 18+	`npm --version`	☐
Git (optionnel)	aucune version minimale	`git --version`	☐
Connexion réseau	-	`curl -I https://api.anthropic.com`	☐

En pratique, la majorité 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.

// .mcp.json - configuration projet (versionnée, à la racine du dépôt)
{
 "mcpServers": {
 "mon-serveur": {
 "command": "npx",
 "args": ["-y", "@modelcontextprotocol/server-filesystem", "/chemin/dossier"]
 }
 }
}

Les définitions de serveurs MCP ne vivent pas dans settings.json. Selon la documentation officielle, elles se trouvent dans .mcp.json (portée projet, à la racine du dépôt) ou dans ~/.claude.json (portées local et utilisateur). Le fichier settings.json ne sert qu'à l'approbation et aux permissions des serveurs (enableAllProjectMcpServers, enabledMcpjsonServers, disabledMcpjsonServers).

Portée	Fichier	Périmètre	Partagé en équipe
Local	`~/.claude.json`	Projet courant, privé	Non
Projet	`.mcp.json`	Projet courant	Oui (versionné)
Utilisateur	`~/.claude.json`	Tous les projets, privé	Non

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

cat .mcp.json | python3 -m json.tool

La configuration projet (.mcp.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 list
# Liste tous les serveurs MCP configurés et leur statut
# Depuis une session Claude Code ouverte, tapez plutôt /mcp

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 rapidement au premier appel. Si la réponse tarde anormalement, vérifiez votre connectivité réseau ou les logs du serveur. Vous pouvez ajuster le délai de démarrage via la variable d'environnement MCP_TIMEOUT.

# Vérifier le statut des serveurs MCP
claude mcp list

À 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	Mettre à jour la version épinglée du package (ex : `@modelcontextprotocol/server-filesystem@`)	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}"
 }
 }
 }
}

une part significative 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 rapidement les fichiers de taille modérée. Les fichiers volumineux prennent davantage de temps et dépendent fortement de votre environnement (disque, mémoire, charge système), pensez donc à les tester en conditions réelles.

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, plus vous activez de serveurs, plus le temps de démarrage et la consommation de ressources augmentent : chaque serveur supplémentaire ajoute sa propre empreinte mémoire et son délai d'initialisation.

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

Profil	Temps de démarrage	Impact mémoire	Recommandation
Quelques serveurs	Rapide	Faible	Optimal
Nombre modéré	Plus long	Modéré	Acceptable
Nombreux serveurs	Sensiblement plus long	Élevé	À surveiller, réduire si possible

Ces ordres de grandeur dépendent de votre machine et des serveurs eux-mêmes : mesurez dans votre propre environnement plutôt que de vous fier à des chiffres absolus.

Désactivez les serveurs inutilisés plutôt que de les laisser tourner. Chaque serveur MCP actif consomme de la mémoire et allonge le démarrage, même lorsqu'il n'est pas sollicité.

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 au strict nécessaire 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é en lançant sa commande documentée dans un terminal (en remplaçant le nom par celui de votre serveur, par exemple npx -y @modelcontextprotocol/server-filesystem /chemin). Tous les serveurs n'exposent pas d'option --version : si la commande de lancement démarre sans erreur, le package est bien disponible.
Validez la syntaxe JSON du fichier qui contient la définition du serveur : python3 -m json.tool < .mcp.json (ou ~/.claude.json selon la portée)
Testez la commande du serveur manuellement dans un terminal séparé
Lancez Claude Code avec --verbose pour des logs détaillés

# Diagnostic rapide : lister les serveurs MCP
claude mcp list

Les catégories de panne les plus courantes :

Package non installé : la commande du serveur est introuvable
Délai dépassé : le serveur ne démarre pas dans le temps imparti (ajustable via MCP_TIMEOUT)
Syntaxe invalide : erreur de format dans le fichier de configuration JSON
Droits insuffisants : permissions manquantes sur le fichier ou le dossier ciblé
Connexion refusée : port déjà utilisé ou serveur distant inaccessible

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.

Pour relancer un serveur MCP, supprimez-le puis rajoutez-le :

claude mcp remove mon-serveur
claude mcp add 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.

MCP : Model Context Protocol - Checklist

En Bref (TL;DR)

Formation Claude Code

Développeur Augmenté par l'IA