Maîtriser Claude Code Partie 7 : Les serveurs MCP

Tu es en train de débugger un problème et tu dois vérifier la base de données. Alors tu ouvres un terminal, tu te connectes à PostgreSQL, tu écris une requête, tu copies les résultats, tu les colles dans Claude, tu expliques le schéma... Ce ne serait pas plus simple si Claude pouvait interroger la base de données directement ?

C'est exactement ce que permettent les serveurs MCP. Ce sont des ponts qui connectent Claude à des services externes — bases de données, GitHub, plateformes cloud, sources de documentation — pour que Claude puisse travailler avec l'ensemble de ton écosystème de développement, pas seulement tes fichiers locaux.

Qu'est-ce que MCP ?

Le Model Context Protocol (MCP) est un standard ouvert pour les intégrations AI-outil. Pense à un adaptateur universel qui permet à Claude de se connecter à n'importe quel service qui parle le protocole.

Claude Code ←→ MCP Server ←→ External Service
                   │
            (Handles auth,
             data formatting,
             rate limiting)

Le serveur MCP gère toute la complexité — authentification, protocoles API, transformation des données — pour que Claude puisse interagir naturellement. Tu demandes « montre-moi les utilisateurs inscrits la semaine dernière » et Claude interroge directement ta base de données.

Pourquoi c'est important :

• Fini le copier-coller — Claude accède aux données à la source
• Information en temps réel — Toujours à jour, pas de contexte obsolète
• Sécurisé par conception — Les serveurs gèrent les identifiants, pas Claude
• Standard ouvert — Fonctionne avec tous les outils, pas seulement Claude

En s'appuyant sur les bases : Alors que les commandes essentielles de la Partie 1 contrôlent le comportement de Claude dans ton projet local, les serveurs MCP étendent ce à quoi Claude peut accéder au-delà de ton système de fichiers — bases de données, APIs, services externes, et plus encore.

La sécurité d'abord

Les serveurs MCP exécutent du code sur ton système. Avant d'utiliser un serveur :

1. Examine le code source — Vérifie quelles permissions il demande
2. Utilise le mode lecture seule quand c'est possible — Empêche les modifications accidentelles
3. Limite les accès — Accorde l'accès à des chemins/tables spécifiques uniquement
4. Fais confiance à tes sources — N'utilise que des serveurs bien maintenus
5. Protège tes identifiants — Utilise des variables d'environnement, ne code jamais en dur

Les serveurs MCP tiers ne sont pas vérifiés par Anthropic. Les serveurs qui récupèrent du contenu externe peuvent t'exposer à l'injection de prompt. Sois prudent.

Emplacements de configuration

Les serveurs MCP peuvent être configurés à différents niveaux :

Au niveau du projet (recommandé pour les équipes) :

.mcp.json                    # Versionné, partagé avec l'équipe
.claude/settings.local.json  # Surcharges locales, gitignored

Au niveau utilisateur (outils personnels) :

~/.claude/settings.json      # Pour tous tes projets
~/.claude/settings.local.json # Surcharges personnelles

La configuration au niveau projet (.mcp.json) est l'option la plus propre — commite-la dans git et toute ton équipe obtient la même configuration.

Structure de configuration

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@package/mcp-server"],
      "env": {
        "API_KEY": "${MY_API_KEY}"
      }
    }
  }
}

command — L'exécutable à lancer (généralement npx pour les serveurs Node)

args — Les arguments de la commande, typiquement le nom du package

env — Les variables d'environnement, avec la syntaxe ${VAR} pour les secrets

La commande /mcp

Gère les serveurs MCP depuis Claude Code :

# Vérifier le statut des serveurs
/mcp

# Output:
# MCP Server Status
# • github: connected
# • postgres: connected
# • context7: failed (connection timeout)

Depuis le terminal, utilise les commandes CLI :

# Ajouter un serveur
Claude mcp add github --scope user

# Lister les serveurs configurés
Claude mcp list

# Inspecter la config d'un serveur
Claude mcp get github

# Supprimer un serveur
Claude mcp remove github

Options de scope :

• --scope local — Session uniquement, temporaire
• --scope user — Persistant pour tous les projets
• --scope project — Sauvegardé dans .mcp.json pour le partage en équipe

Les serveurs MCP essentiels

GitHub

Intégration complète des dépôts — PRs, issues, revue de code, releases.

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

Ce que Claude peut faire :

• Créer et examiner des pull requests
• Gérer les issues et les labels
• Rechercher du code dans les dépôts
• Déclencher des workflows

Exemple :

"Examine les PRs ouvertes de notre repo et résume lesquelles sont prêtes à merger"

PostgreSQL

Accès direct à la base de données avec connaissance du schéma.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}",
        "READ_ONLY": "true"
      }
    }
  }
}

Ce que Claude peut faire :

• Interroger les tables en langage naturel
• Comprendre les relations du schéma
• Générer des migrations
• Débugger les problèmes de données

Exemple :

"Trouve tous les utilisateurs inscrits en janvier qui n'ont pas encore fait d'achat"

Context7

Documentation de bibliothèques en temps réel, spécifique à chaque version.

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@context7/mcp-server"]
    }
  }
}

Ce que Claude peut faire :

• Récupérer la documentation actuelle de n'importe quel package npm
• Obtenir les détails d'API spécifiques à une version
• Éviter les APIs hallucinées
• Rester à jour avec les changements de bibliothèques

Exemple :

"use context7 to look up the correct API for React Query's useInfiniteQuery hook"

C'est particulièrement précieux car les données d'entraînement de Claude ont une date limite — Context7 lui donne accès à la documentation publiée après l'entraînement.

Filesystem

Accède à des fichiers au-delà de ton projet actuel.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    }
  }
}

Ce que Claude peut faire :

• Lire des fichiers depuis d'autres répertoires
• Accéder à la configuration partagée
• Travailler sur plusieurs projets

Exemple :

"Vérifie mon repo de dotfiles pour voir comment j'ai configuré ESLint"

Supabase

Intégration complète de la plateforme Supabase.

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server"],
      "env": {
        "SUPABASE_URL": "${SUPABASE_URL}",
        "SUPABASE_SERVICE_KEY": "${SUPABASE_SERVICE_KEY}"
      }
    }
  }
}

Ce que Claude peut faire :

• Interroger les tables Supabase
• Gérer les utilisateurs auth
• Travailler avec les buckets de stockage
• Générer des policies RLS

Web Fetch

Récupère et traite du contenu web.

{
  "mcpServers": {
    "fetch": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"]
    }
  }
}

Ce que Claude peut faire :

• Récupérer des pages web et des APIs
• Traiter des sites de documentation
• Vérifier le statut des services
• Rechercher des informations actuelles

Playwright

Automatisation du navigateur pour les tests et l'interaction web.

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-playwright"]
    }
  }
}

Ce que Claude peut faire :

• Naviguer sur des pages web et interagir avec les éléments
• Prendre des captures d'écran et capturer l'état de la page
• Remplir des formulaires et cliquer sur des boutons
• Exécuter des scénarios de test end-to-end
• Débugger les problèmes d'interface en voyant ce qui s'affiche à l'écran

Exemple :

"Use Playwright to navigate to our staging site and check if the login form works"

Catégories de serveurs

Bases de données

PostgreSQL — @modelcontextprotocol/server-postgres — Accès SQL complet

MySQL — @modelcontextprotocol/server-mysql — Intégration MySQL

SQLite — @modelcontextprotocol/server-sqlite — Bases de données locales

MongoDB — Serveurs communautaires disponibles — Bases de données document

Cloud & DevOps

GitHub — @modelcontextprotocol/server-github — API GitHub complète

GitLab — Serveurs communautaires — Intégration GitLab

Cloudflare — @cloudflare/mcp-server-cloudflare — Workers, KV, D1, R2

AWS — Serveurs communautaires — S3, Lambda, etc.

Tests & Automatisation

Playwright — @anthropic/mcp-server-playwright — Automatisation navigateur et tests E2E

Documentation & Recherche

Context7 — @context7/mcp-server — Documentation de bibliothèques en temps réel

Perplexity — Serveurs communautaires — Recherche alimentée par l'IA

Fetch — @modelcontextprotocol/server-fetch — Contenu web

Plusieurs serveurs ensemble

La plupart des projets tirent profit de plusieurs serveurs MCP travaillant ensemble :

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}",
        "READ_ONLY": "true"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@context7/mcp-server"]
    }
  }
}

Claude utilise automatiquement le bon serveur selon ta demande. Tu demandes le schéma de la base de données, il utilise PostgreSQL. Tu demandes une PR, il utilise GitHub.

Workflows pratiques

Développement piloté par la base de données

Toi : "Montre-moi le schéma de la table orders"

Claude : [Requête via postgres MCP]
La table orders contient :
- id (uuid, clé primaire)
- user_id (uuid, clé étrangère → users)
- total_amount (decimal)
- status (enum: pending, paid, shipped, delivered)
- created_at (timestamp)

Toi : "Trouve les commandes de plus de 500$ encore en attente"

Claude : [Exécute la requête]
23 commandes correspondent aux critères. La plus ancienne date d'il y a 3 jours...

Automatisation cross-services

Toi : "Crée une issue GitHub pour le bug dont on a parlé, assigne-la moi"

Claude : [Utilise le MCP github]
Issue #234 créée : "Fix race condition in order processing"
- Label ajouté : bug, priority-high
- Assignée à : @yourusername
- Liée aux commits récents mentionnant la table orders

Développement avec documentation en temps réel

Toi : "Use context7 to check the correct way to handle optimistic updates in TanStack Query v5"

Claude : [Récupère la doc actuelle via context7]
Dans TanStack Query v5, les mises à jour optimistes utilisent le callback onMutate...
[Fournit des indications précises et spécifiques à la version]

Dépannage

Le serveur ne se connecte pas

1. Vérifie le statut : Lance /mcp pour voir l'état de connexion
2. Active le mode debug : claude --mcp-debug pour des logs détaillés
3. Vérifie les identifiants : Assure-toi que les variables d'environnement sont définies
4. Teste manuellement : Lance la commande du serveur directement dans le terminal

Problèmes spécifiques à Windows

Sur Windows natif (pas WSL), npx nécessite un wrapper :

{
  "command": "cmd",
  "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-github"]
}

Sans cmd /c, tu auras des erreurs « Connection closed ».

Limites de tokens

Les sorties MCP ont des limites pour éviter le débordement de contexte :

• Seuil d'avertissement : 10 000 tokens
• Maximum par défaut : 25 000 tokens

Ajuste avec la variable d'environnement MAX_MCP_OUTPUT_TOKENS si nécessaire.

Serveur qui ne répond pas

Certains serveurs ont besoin de temps pour s'initialiser. Si un serveur affiche « failed » immédiatement après le démarrage, attends un moment et relance /mcp.

Bonnes pratiques

1. Principe du moindre privilège

Ne demande que les permissions nécessaires :

{
  "env": {
    "READ_ONLY": "true",
    "ALLOWED_PATHS": "/specific/directory"
  }
}

2. Variables d'environnement pour les secrets

Ne code jamais les tokens en dur :

{
  "env": {
    "GITHUB_TOKEN": "${GITHUB_TOKEN}"
  }
}

Définis les variables dans ton profil shell ou un fichier .env.

3. Scope projet vs utilisateur

• Scope projet (.mcp.json) : Connexions base de données, outils spécifiques au projet
• Scope utilisateur (~/.claude/settings.json) : GitHub, utilitaires personnels

4. Examine le code des serveurs

Avant d'installer un serveur MCP, vérifie :

• Quelles commandes il peut exécuter
• Quel accès réseau il nécessite
• Qui le maintient
• L'activité récente et les issues

Trouver des serveurs MCP

Serveurs officiels :

• modelcontextprotocol.io/examples

Répertoires communautaires :

• mcpservers.org
• mcpcat.io
• awesome-mcp-servers

Recherche sur GitHub :

• Topic : mcp-server
• Recherche : "@modelcontextprotocol" dans package.json

La suite

Les serveurs MCP étendent la portée de Claude aux services externes. Combinés avec tout ce qu'on a couvert — commandes, skills et subagents — tu disposes maintenant d'une boîte à outils puissante pour le développement assisté par IA.

Dans la Partie 8 : Workflows de production, on va assembler le tout avec des patterns concrets : intégration CI/CD, collaboration en équipe et workflows qui scalent du side project au système de production.