Les meilleurs serveurs MCP pour Claude Code : le classement par budget de contexte

Un serveur MCP, c'est un pont entre Claude Code et un outil externe : ton GitHub, ta base Postgres, ton navigateur, ta doc. Le protocole MCP (Model Context Protocol) est un standard ouvert, et le registre officiel en recense des milliers.

Sauf qu'un serveur MCP n'est pas gratuit. Il ne coûte pas d'argent : il coûte du contexte. Et ça, personne ne te le dit quand on te vend un "top 20 des MCP indispensables".

Voilà le mécanisme. Quand tu branches un serveur, il déclare ses outils : nom, description, schéma de paramètres, valeurs d'enum. Historiquement, tout ce bloc était injecté dans le contexte à chaque tour de conversation, que tu t'en serves ou non. Le serveur MCP GitHub complet, avec ses 93 outils, pèse environ 55 000 tokens de définitions. Sur les 200 000 tokens de la génération précédente, ça revenait à brûler un quart de ton budget avant d'écrire un caractère.

Sauf que la fenêtre a changé d'échelle. Opus 5, Sonnet 5 et toute la série Opus 4.x tournent aujourd'hui à 1 million de tokens de contexte, ce qui ramène ces mêmes 55 000 tokens à 5,5 % du budget. C'est nettement moins dramatique, et c'est déjà une bonne raison de se méfier des classements qui recyclent les calculs de 2025. Deux nuances quand même : Haiku 4.5 reste à 200 000 tokens, et un contexte plus grand n'est pas un contexte gratuit.

C'est pour ça que le bon classement n'est pas "quels sont les 20 meilleurs serveurs MCP". C'est combien tu peux t'en permettre, et lesquels méritent leur place.

Sauf qu'en 2026, la réponse a changé. Et la plupart des articles que tu vas trouver sont périmés.

Ce qui a changé en 2026 : le tool search

Anthropic a livré la réponse au problème : le tool search tool. Au lieu de charger toutes les définitions d'outils d'entrée, Claude ne voit qu'un outil de recherche, et va chercher les schémas dont il a besoin, à la demande.

Les chiffres officiels d'Anthropic sur leur setup de démonstration : 77 000 tokens de définitions passent à 8 700, soit 85 % de réduction. Le contexte préservé passe de 122 800 à 191 300 tokens.

Et le gain n'est pas que comptable. La précision de sélection d'outil monte aussi, parce qu'un modèle noyé sous 90 outils choisit mal. Toujours selon Anthropic, sur les mêmes tâches : Opus 4 passe de 49 % à 74 %, et Opus 4.5 de 79,5 % à 88,1 %.

Le point décisif, que beaucoup ratent : dans Claude Code, le tool search est activé par défaut. Les outils MCP sont différés, seuls les noms d'outils et les instructions de serveur se chargent au démarrage. La doc officielle est explicite : "adding more MCP servers has minimal impact on your context window", et Claude Code n'impose aucun plafond fixe d'outils par serveur.

Donc non, tu n'as plus à débrancher tous tes MCP comme on le conseillait en 2025. Mais tu ne peux pas non plus tout brancher les yeux fermés, et voilà pourquoi.

Pourquoi le budget de contexte compte encore

Quatre raisons, très concrètes.

1. Le tool search n'est pas toujours actif. D'après la doc, il est désactivé par défaut sur Google Cloud Agent Platform, et quand ANTHROPIC_BASE_URL pointe vers un host non first-party (la plupart des proxies ne relaient pas les blocs tool_reference). Il exige aussi un modèle compatible : Sonnet 4.5, Haiku 4.5, Opus 4.5 ou plus récent, ce qui couvre toute la génération actuelle (Opus 5, Sonnet 5, Opus 4.8 et 4.7). Si tu passes par un proxy d'entreprise ou Bedrock, tu payes encore plein tarif.

2. Le coût ne disparaît pas, il se déplace. Les noms d'outils et les instructions de serveur restent chargés au démarrage. Avec quinze serveurs branchés, ça finit par peser. Et chaque recherche d'outil ajoute un aller-retour.

3. La sélection reste un problème. Même avec le tool search, plus tu as d'outils sémantiquement proches, plus Claude hésite. Trois serveurs qui font tous "de la recherche web", c'est trois façons de se tromper.

4. Certains serveurs contournent le mécanisme. Le champ alwaysLoad force le chargement complet d'un serveur au démarrage, quel que soit le réglage de tool search. Un serveur mal conçu qui l'active te ramène au monde d'avant.

Une nuance honnête avant le classement : la commande /context a longtemps surestimé le coût des MCP. Un développeur a montré que XcodeBuildMCP était reporté à ~45 000 tokens pour ~15 000 réels, parce que le prompt système caché était compté une fois par outil au lieu d'une fois par requête. Anthropic a corrigé depuis (12,6k reportés après fix). Retiens que les chiffres bruts circulant sur le web sont des ordres de grandeur, pas des mesures de laboratoire.

Le tableau : ce que coûte vraiment chaque serveur

Serveur	Ce qu'il fait	Outils	Coût contexte estimé	Verdict
Context7	Doc à jour et versionnée des libs, injectée dans le prompt	2	Négligeable	Garder
GitHub (toolsets ciblés)	Issues, PR, code, Actions	26	~4 200 tokens	Garder
GitHub (complet)	Toute la surface API GitHub	93	~55 000 tokens	Éviter
Postgres / Supabase	Requêter ta base, lire le schéma	Variable (1 outil minimal = ~35 tokens)	Faible si ciblé	Garder si tu as une base
Playwright	Piloter un navigateur, tester, scraper	24 core, 47 toutes catégories	Moyen à lourd	À la demande
Chrome DevTools	Debug perf, réseau, console d'un vrai Chrome	~26	Moyen	À la demande
Sentry	Lire les erreurs de prod, les traces	~10-15	Moyen	À la demande
Notion / Linear / Jira	Tickets, specs, docs produit	10-20 chacun	Moyen, cumulatif	À la demande
Figma	Lire les designs, extraire les tokens	~10	Moyen	À la demande
Filesystem	Lire et écrire des fichiers	~11	Faible	Éviter (redondant)
Agrégateurs de recherche web	Tavily, Exa, Perplexity, Firecrawl en un	20 outils = 14 214 tokens	Lourd	Éviter

Les tool counts marqués ~ sont des ordres de grandeur : ils bougent à chaque release. Vérifie toujours avec /mcp, qui affiche le nombre d'outils à côté de chaque serveur connecté.

Ma thèse : six serveurs suffisent

Au-delà de six, tu n'ajoutes plus de capacités, tu ajoutes de la confusion. Le classement, par ordre de rapport valeur / coût.

1. Context7. Le meilleur rapport qualité-prix du marché, sans discussion. Deux outils, un coût dérisoire, et il règle le problème le plus pénible de Claude Code : la doc périmée. Claude arrête d'halluciner l'API de la v2 quand tu es en v5. Si tu ne dois en garder qu'un, c'est celui-là.

2. GitHub, mais en toolsets ciblés. Le serveur officiel expose un flag --toolsets justement pour ça. La doc GitHub le dit noir sur blanc : "enabling only the toolsets that you need can help the LLM with tool choice and reduce the context size". Ils vont plus loin, avec de la configuration outil par outil depuis décembre 2025, en notant que charger repos et pull_request en entier active 27 outils quand tu n'en utilises souvent que deux. Ajoute --read-only si tu ne veux pas que Claude écrive.

3. Ta base de données. Postgres, Supabase, peu importe. Claude qui lit ton vrai schéma au lieu de le deviner, c'est un gain de qualité massif pour un coût minime si tu restes sur des outils ciblés. En lecture seule, de préférence.

4. Un serveur navigateur, un seul. Playwright ou Chrome DevTools, jamais les deux. Playwright expose 24 outils core et 47 toutes catégories confondues, donc active seulement les catégories dont tu as besoin. Chrome DevTools si tu debug de la perf, Playwright si tu écris des tests.

5. Sentry (ou ton outil d'erreurs). Uniquement si tu as de la prod. "Regarde l'erreur qui spike depuis ce matin et corrige-la" est un des rares workflows où le MCP est vraiment supérieur à un copier-coller.

6. Ton tracker de tickets. Notion, Linear ou Jira. Un seul. Celui où vivent vraiment tes specs.

Et ce que je ne garde pas, avec les raisons.

Filesystem : redondant. Claude Code a déjà Read, Write, Glob et Grep en natif, mieux intégrés et gratuits en contexte. Tu payes pour une capacité que tu as déjà.

Les agrégateurs de recherche web : trop chers. Le cas d'école mesuré par Scott Spence : mcp-omnisearch, 20 outils pour 14 214 tokens, soit 710 tokens par outil. Claude Code a déjà WebSearch et WebFetch. Au passage, son travail de consolidation est la meilleure démonstration du problème : en fusionnant les outils redondants et en dégraissant les descriptions, il est passé de 20 outils / 14 214 tokens à 8 outils / 5 663 tokens, soit 60 % d'économie. Son setup complet pesait 81 986 tokens, environ un tiers de la fenêtre.

GitHub complet : le piège classique. 93 outils quand tu en utilises cinq.

La config concrète

Les bases. La syntaxe officielle :

# Serveur distant en HTTP
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Serveur local (stdio) : tout ce qui suit -- est passé au serveur
claude mcp add --transport stdio playwright -- npx @playwright/mcp@latest

# Avec des variables d'environnement
claude mcp add --env AIRTABLE_API_KEY=TA_CLE --transport stdio airtable \
  -- npx -y airtable-mcp-server

# Inspecter et nettoyer
claude mcp list
claude mcp get github
claude mcp remove github

Le flag --scope détermine où vit la config : local (toi, ce projet), project (partagé via .mcp.json commité), user (toi, tous tes projets). La règle : user seulement pour Context7. Tout le reste en project, pour que le serveur Figma ne suive pas dans ton projet backend.

Profil léger vs profil complet

L'idée : ne pas mettre les mêmes serveurs partout. Un .mcp.json par projet, taillé pour le projet.

Profil léger, pour une lib ou un CLI :

{
  "mcpServers": {
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/mcp"
    }
  }
}

Profil complet, pour une app web en prod :

{
  "mcpServers": {
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/mcp"
    },
    "github": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server",
        "--toolsets", "repos,issues,pull_requests",
        "--read-only"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": ["@playwright/mcp@latest", "--caps=core"]
    }
  }
}

Note l'expansion ${GITHUB_TOKEN} : Claude Code la supporte dans .mcp.json, ce qui te permet de commiter le fichier sans commiter tes secrets. La syntaxe ${VAR:-defaut} marche aussi.

Régler le tool search

Le comportement se pilote via ENABLE_TOOL_SEARCH :

Valeur	Comportement
(non défini)	Tous les outils MCP différés, chargés à la demande. Le défaut.
`true`	Tout différé, en forçant le header beta même via proxy
`auto`	Chargement direct si les outils tiennent dans 10 % de la fenêtre, différé sinon
`auto:N`	Idem avec ton propre seuil, par exemple `auto:5` pour 5 %
`false`	Tout chargé d'entrée, comme en 2025

auto est le réglage le plus malin si tu as peu de serveurs : tes outils restent visibles directement (zéro latence de recherche) tant que tu tiens sous le seuil, et le mécanisme se déclenche uniquement quand tu déborde.

Et si un serveur doit toujours être visible sans étape de recherche, le champ alwaysLoad (Claude Code v2.1.121 ou plus) le sort du différé :

{
  "mcpServers": {
    "core-tools": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "alwaysLoad": true
    }
  }
}

Attention : ça bloque aussi le démarrage jusqu'à la connexion du serveur, dans la limite du timeout de 5 secondes. À réserver à deux ou trois outils utilisés à chaque tour.

Auditer ton budget en deux commandes

Rien de tout ça ne sert si tu ne mesures pas. Deux commandes, dans Claude Code :

/context   # répartition des tokens : système, outils MCP, mémoire, conversation
/mcp       # état de chaque serveur et son nombre d'outils

/context te donne la photo. Si la ligne "MCP tools" dépasse 10 % de ta fenêtre, tu as un problème. /mcp te dit qui est le coupable, et te permet de couper un serveur pour la session.

La règle d'hygiène qui vaut plus que tout le reste : si tu n'as pas invoqué un serveur depuis deux semaines, dégage-le. Les setups MCP pourrissent par accumulation, jamais par excès de zèle.

Ce qu'il faut retenir

Le tool search a changé la donne, et les articles qui te disent encore de tout débrancher datent d'avant. Avec 85 % de réduction de tokens et une précision de sélection qui monte de 79,5 % à 88,1 % sur Opus 4.5, tu peux te permettre plus de serveurs qu'en 2025.

Mais "plus" ne veut pas dire "tous". Le vrai classement reste celui du rapport valeur / coût, et il tient en une ligne : Context7 et ta base en permanence, GitHub en toolsets ciblés, un navigateur et un tracker à la demande, et rien qui duplique ce que Claude Code fait déjà nativement.

Six serveurs. Le reste, c'est de la collection.