MCP Claude Code : Le Guide Complet 2026 (Model Context Protocol)
Claude

MCP Claude Code : Le Guide Complet 2026 (Model Context Protocol)

Ugo LazzariUgo Lazzari20 avril 202614 min de lecture

MCP, pour Model Context Protocol, c’est l’une des briques les plus importantes de Claude Code en 2026. Si vous l’avez ignoré jusque-là, vous passez à côté d’environ 70% de la puissance de l’outil. Ce n’est pas une feature marketing, c’est la façon dont Anthropic a choisi de connecter Claude à votre stack : Linear, GitHub, Supabase, Figma, votre base de données interne, Slack, Notion, et tout ce que vous voulez brancher.

Dans ce guide, on va voir ce qu’est MCP concrètement, comment installer votre premier serveur en 2 minutes, les 10 serveurs qui valent vraiment le détour, et comment créer le vôtre si vos outils maison ne sont pas encore supportés. Pas de théorie fumeuse, que du pratique.

MCP, c’est quoi exactement ?

MCP (Model Context Protocol) est un standard ouvert conçu par Anthropic fin 2024 pour permettre aux modèles IA de communiquer avec des outils externes. L’idée est simple : au lieu de coder des intégrations ad hoc à chaque fois, vous lancez un « serveur MCP » qui expose des outils, des ressources et des prompts. Claude (ou n’importe quel client compatible MCP) s’y connecte et peut les utiliser.

Pour faire une analogie : MCP est aux modèles IA ce que le protocole LSP (Language Server Protocol) est aux IDE. Un standard unique qui permet à n’importe quel éditeur de parler à n’importe quel langage sans réécrire 50 plugins.

Concrètement, un serveur MCP peut exposer trois choses :

  • Des outils (tools) : des fonctions que le modèle peut appeler, comme « crée un ticket Linear » ou « lance cette requête SQL »
  • Des ressources (resources) : des données contextuelles que le modèle peut lire, comme un fichier, une table de base de données ou une page Notion
  • Des prompts (prompts) : des templates de prompts réutilisables et configurables

Pour Claude Code, MCP signifie concrètement : votre agent IA peut interagir avec votre stack de travail complète sans sortir du terminal.

Pourquoi MCP change la donne pour Claude Code

Avant MCP, Claude Code lisait et modifiait les fichiers de votre projet, lançait des commandes shell, et c’était tout. Utile, mais limité. Avec MCP, il peut maintenant :

  • Créer des tickets Linear ou Jira à partir de vos commits
  • Lire les issues GitHub assignées à vous et s’attaquer aux plus urgentes seul
  • Interroger votre base de données Postgres pour diagnostiquer un bug
  • Pousser un message Slack dans un channel quand un déploiement est prêt
  • Lire la doc de votre projet sur Notion pour appliquer les conventions
  • Récupérer les composants Figma d’une maquette pour les coder automatiquement

En pratique, j’utilise MCP au quotidien pour trois choses principales : GitHub (lire les issues, ouvrir des PR), Supabase (requêtes sur la prod en lecture seule pour comprendre un bug), et un serveur maison qui interroge notre backlog. Ça change la façon dont on travaille avec l’IA.

L’autre raison pour laquelle MCP est devenu central : l’écosystème explose. En avril 2026, on compte plus de 800 serveurs MCP publics, dont beaucoup maintenus officiellement par les éditeurs (GitHub, Linear, Supabase, Cloudflare, Sentry, etc.). Ce n’est plus un truc de niche.

Comment fonctionne un serveur MCP

Pas besoin de rentrer dans les détails techniques pour utiliser MCP, mais comprendre l’architecture aide à bien le configurer.

Un serveur MCP est un petit programme (en Node.js, Python, Go, TypeScript, peu importe) qui expose ses outils via un protocole standardisé. Il peut tourner :

  • Localement : il démarre avec Claude Code et parle via stdio (standard input/output). La plupart des serveurs fonctionnent comme ça.
  • À distance : il tourne sur un serveur web (SSE ou HTTP streaming) et Claude Code s’y connecte via URL. Utile pour des outils partagés ou des connexions centralisées.

Claude Code lit la liste des serveurs MCP disponibles dans votre fichier de config (~/.claude/claude_desktop_config.json ou équivalent), les démarre automatiquement, découvre les outils exposés et les ajoute à la boîte à outils du modèle. Tout ça se fait sans que vous ayez besoin de redémarrer quoi que ce soit.

Le modèle ne voit pas « le code » du serveur MCP. Il voit juste les outils disponibles avec leur nom, leur description et leurs paramètres attendus. Quand il veut en appeler un, il envoie une requête, le serveur exécute, renvoie le résultat.

Installer votre premier serveur MCP

Commençons par du simple : un serveur MCP qui expose un système de fichiers en lecture seule. C’est l’équivalent du « hello world » MCP.

Étape 1 : éditer votre config MCP

Ouvrez votre fichier de configuration Claude Code :

  • Mac : ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows : %APPDATA%\Claude\claude_desktop_config.json
  • Linux : ~/.config/Claude/claude_desktop_config.json

S’il n’existe pas, créez-le avec ce contenu :

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

Remplacez le chemin par un dossier que vous voulez exposer à Claude (en lecture). Sauvegardez.

Étape 2 : redémarrer Claude Code

Fermez et rouvrez Claude Code. Il va détecter le nouveau serveur et le démarrer automatiquement via npx. Vérifiez que tout s’est bien passé avec claude /mcp dans votre session : vous devez voir « filesystem » listé comme serveur actif.

Étape 3 : tester

Demandez à Claude : « Liste les fichiers du dossier X et résume-moi les 3 plus récents ». Il utilise automatiquement les outils exposés par le serveur filesystem pour explorer le dossier sans que vous ayez à préciser comment.

Si ça marche, vous êtes prêt pour les vrais serveurs utiles. Sinon, lancez claude doctor pour diagnostiquer, et vérifiez que Node.js 20+ est installé (npx a besoin d’une version récente).

Top 10 des serveurs MCP les plus utiles en 2026

Voici les serveurs que j’installe en premier sur toute nouvelle machine, classés par utilité réelle au quotidien. Tous sont maintenus officiellement ou par des équipes sérieuses.

  1. GitHub : incontournable. Lire les issues, les PR, les commentaires, ouvrir des PR, commenter. C’est le serveur que j’utilise le plus.
  2. Filesystem : expose un dossier en lecture ou lecture/écriture. Utile pour laisser Claude parcourir des docs hors de votre projet.
  3. Postgres : interroge une base Postgres en lecture seule. Parfait pour « pourquoi cet utilisateur a ce bug ? »
  4. Supabase : version officielle Supabase qui gère tables, RLS, storage, auth. Si vous bossez avec Supabase, installez-le direct.
  5. Linear : crée et met à jour des tickets, lit le backlog, déplace les issues. Workflow produit <-> dev fluide.
  6. Slack : envoie des messages, lit des channels ciblés. Pratique pour poster des updates ou checker un thread.
  7. Notion : lit et écrit des pages Notion. Si votre doc produit vit là, c’est énorme pour garder le contexte.
  8. Cloudflare : gère vos Workers, KV, Pages, R2. Déploiements et debug sans quitter le terminal.
  9. Sentry : lit les erreurs reportées en prod, Claude peut diagnostiquer et proposer un fix directement.
  10. Puppeteer : contrôle un navigateur Chrome headless. Tests end-to-end, scraping ciblé, screenshots automatiques.

Pour installer l’un d’eux, ajoutez simplement son entrée dans mcpServers dans votre config. La plupart se lancent via npx avec une commande du type npx -y @modelcontextprotocol/server-github. Consultez la doc officielle de chacun pour les variables d’environnement attendues (tokens, URLs, etc.).

MCP GitHub : le cas d’école

Le serveur MCP GitHub est celui que je recommande d’installer en premier après filesystem. Il transforme Claude Code en coéquipier qui peut lire et écrire directement dans vos repos.

Installation

Créez d’abord un Personal Access Token GitHub avec les scopes repo (et workflow si vous voulez que Claude puisse modifier des GitHub Actions). Allez dans Settings > Developer Settings > Personal Access Tokens.

Ajoutez dans votre config MCP :

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

Redémarrez Claude Code. Le serveur GitHub expose maintenant une vingtaine d’outils : list_issues, create_pull_request, get_file_contents, search_code, etc.

Exemples d’usage concrets

  • « Liste les issues ouvertes sur mon repo X assignées à moi, classées par priorité »
  • « Prends l’issue #142, lis-la, implémente un fix, ouvre une PR »
  • « Résume-moi les 5 derniers commits sur la branche main et leur impact »
  • « Cherche toutes les occurrences de cette fonction dans notre organisation GitHub »

Gardez en tête que Claude obéit à vos instructions. Si vous lui demandez de merger une PR en prod sans review, il le fera. Utilisez un token avec les bons scopes et, pour la prod critique, préférez un token en lecture seule.

MCP pour bases de données (Postgres, Supabase)

C’est le cas d’usage qui change le plus ma façon de travailler : laisser Claude interroger directement une base de données pour diagnostiquer un bug ou comprendre un comportement.

Avant MCP : je lançais psql dans un autre terminal, je tapais une requête, je collais le résultat dans Claude, il analysait. Plusieurs allers-retours, friction max.

Avec MCP Postgres : je demande à Claude « pourquoi cet utilisateur X ne reçoit pas ses notifications ? ». Il formule lui-même la requête, la lance, lit le résultat, affine, finit par identifier la cause. Zéro copier-coller.

Configuration minimale pour Postgres :

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://user:pass@host:5432/dbname"
      ]
    }
  }
}

Règles de sécurité absolues :

  • Utilisez un compte base de données en lecture seule pour Claude. Jamais le compte qui peut DROP une table.
  • Ne branchez pas Claude sur la prod si vos données contiennent du personnel sensible sans anonymisation. Utilisez une réplique ou un dump masqué.
  • Ne stockez pas le password en clair dans le config. Passez par des variables d’environnement.

Pour Supabase, le serveur officiel est encore plus pratique parce qu’il gère aussi les RLS (Row Level Security), Storage et Auth. Si vous êtes sur Supabase, c’est le bon choix.

MCP local vs MCP remote

Deux modes coexistent en 2026, chacun avec ses usages.

MCP local (stdio)

Le serveur tourne sur votre machine, démarre avec Claude Code, communique via stdin/stdout. C’est le mode par défaut et celui de 90% des serveurs publics.

  • Avantage : pas de réseau, tout reste local, sécurité maximale
  • Avantage : aucune infra à maintenir
  • Inconvénient : chaque machine doit avoir le serveur installé et configuré

MCP remote (HTTP/SSE)

Le serveur tourne sur une URL web. Claude Code s’y connecte via HTTP streaming ou Server-Sent Events. Pratique pour des outils partagés dans une équipe.

  • Avantage : un serveur, N clients, zéro config côté utilisateur
  • Avantage : mise à jour centralisée
  • Inconvénient : besoin d’héberger quelque part, avec authentification sérieuse
  • Inconvénient : latence réseau, parfois sensible sur des tâches longues

Pour une équipe qui veut imposer des intégrations standardisées (GitHub d’entreprise, base de données interne, etc.), MCP remote est la bonne approche. Pour un usage perso ou dev, MCP local suffit dans 99% des cas.

Créer votre propre serveur MCP (exemple)

Si aucun serveur public ne colle à votre stack interne, créer le vôtre est plus simple qu’il n’y paraît. Anthropic fournit des SDK officiels en TypeScript, Python et Go.

Voici un exemple minimal en TypeScript qui expose un seul outil : compter les articles d’un CMS interne.

import { Server } from "@modelcontextprotocol/sdk/server/index.js"
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js"

const server = new Server(
  { name: "mon-cms-mcp", version: "1.0.0" },
  { capabilities: { tools: {} } }
)

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "count_articles",
      description: "Compte le nombre d'articles publies dans le CMS interne",
      inputSchema: { type: "object", properties: {}, required: [] }
    }
  ]
}))

server.setRequestHandler(CallToolRequestSchema, async (req) => {
  if (req.params.name === "count_articles") {
    const res = await fetch("https://mon-cms.internal/api/count")
    const data = await res.json()
    return { content: [{ type: "text", text: `Il y a ${data.count} articles publies.` }] }
  }
  throw new Error("Outil inconnu")
})

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

Pour l’utiliser, ajoutez-le à votre config MCP :

{
  "mcpServers": {
    "mon-cms": {
      "command": "node",
      "args": ["/chemin/vers/mon-cms-mcp/dist/index.js"]
    }
  }
}

Redémarrez Claude Code, vous verrez l’outil count_articles disponible. À partir de là, vous pouvez exposer ce que vous voulez : vos API internes, vos outils de déploiement, votre système de tickets maison. La limite, c’est votre imagination.

Le SDK officiel gère tout le boilerplate (validation, sérialisation, gestion d’erreurs). Vous écrivez juste la logique métier. Comptez 2 heures pour un premier serveur fonctionnel, beaucoup moins si vous partez d’un exemple existant.

Sécurité : ce qu’il faut savoir avant d’installer

MCP est puissant, donc il demande un minimum d’hygiène. Trois règles de base :

Règle 1 : installez uniquement des serveurs de confiance

Un serveur MCP tourne sur votre machine avec vos privilèges. S’il est malveillant, il peut lire vos fichiers, voler vos tokens, envoyer des données à l’extérieur. Privilégiez :

  • Les serveurs officiels maintenus par Anthropic ou l’éditeur du service (GitHub, Supabase, Cloudflare, etc.)
  • Les serveurs open source avec une communauté active et un historique de commits propre
  • Les serveurs que vous avez écrits vous-même

Évitez les serveurs trouvés sur un tutoriel obscur sans vérification du code source.

Règle 2 : principe du moindre privilège

Donnez à chaque serveur le minimum de droits dont il a besoin. Token GitHub en lecture seule si vous voulez juste consulter, pas en écriture. Compte Postgres sans DROP ni UPDATE. Clé API avec un scope restreint.

Règle 3 : séparez dev et prod

Ne branchez pas Claude directement sur votre prod critique. Utilisez des environnements de staging, des répliques read-only, des comptes de service dédiés. Si vous voulez absolument connecter la prod, ajoutez des garde-fous humains (confirmation avant chaque action destructrice).

Ces règles paraissent basiques, mais elles font la différence entre un MCP qui booste votre productivité et un MCP qui crée un incident à 2h du matin.

Questions fréquentes

MCP fonctionne-t-il avec d’autres IA que Claude ?

Oui, c’est un standard ouvert. Des clients compatibles MCP existent pour plusieurs IA, dont certaines versions d’OpenAI via des plugins communautaires. Mais l’écosystème le plus complet reste côté Anthropic et Claude Code en 2026.

Installer un serveur MCP coûte-t-il quelque chose ?

La plupart des serveurs MCP sont gratuits et open source. Vous payez seulement les services qu’ils interrogent (GitHub, Supabase, OpenAI pour certains, etc.). Aucun coût pour MCP en lui-même.

Claude Code peut-il utiliser plusieurs serveurs MCP en même temps ?

Oui, c’est même le cas d’usage principal. Dans mon setup quotidien, j’ai 8 serveurs MCP actifs simultanément : filesystem, GitHub, Postgres, Linear, Slack, Sentry, Puppeteer et un serveur maison. Claude les combine intelligemment selon la tâche.

MCP ralentit-il Claude Code ?

Très peu. Chaque serveur ajoute quelques centaines de ms au démarrage, et un appel d’outil MCP est quasi instantané (stdio local) ou proche de la latence réseau en remote. L’impact est négligeable comparé au temps gagné.

Puis-je utiliser MCP sans Claude Code, par exemple sur le web Claude.ai ?

Oui, Claude Desktop et Claude.ai supportent MCP directement dans l’interface. La configuration est la même. Vous pouvez donc utiliser MCP sur le web sans avoir besoin de Claude Code.

Que se passe-t-il si un serveur MCP plante ?

Claude Code continue à fonctionner, le serveur défaillant est marqué comme indisponible. Le modèle ne peut juste plus utiliser les outils de ce serveur. Consultez les logs avec claude /mcp pour diagnostiquer. Souvent, une variable d’environnement manquante ou un token expiré.

MCP permet-il à Claude d’accéder à Internet ?

Oui, si vous installez un serveur MCP qui expose des outils d’accès web (Puppeteer, fetch, scraping, API). Sans ça, Claude Code n’a pas d’accès internet natif.

Comment désactiver temporairement un serveur MCP ?

Commentez son entrée dans votre config JSON (ajoutez des guillemets autour de la clé pour la « désactiver », ou supprimez la section) et redémarrez Claude Code. Pour un toggle plus pratique, gardez deux configs (dev et prod) et basculez avec un script.

Aller plus loin avec Claude Code et MCP

MCP est une des 4 fonctionnalités majeures qui font la force de Claude Code (avec CLAUDE.md, Plan Mode et les subagents). Pour maîtriser l’ensemble :

Explorer la catégorie

Claude

Articles similaires

Dans la catégorie Claude

Claude

Hooks Claude Code : Automatiser Votre Workflow (Guide Complet 2026)

20 avril 2026
Claude

Skills Claude Code : Le Guide Complet pour Automatiser vos Procédures (2026)

20 avril 2026
Claude

Subagents Claude Code : Guide Complet pour Déléguer Intelligemment (2026)

20 avril 2026
Retour à Claude