Coût MCP : Ce que les serveurs Model Context Protocol ajoutent en tokens

MCP lui-même ne coûte rien. Le Model Context Protocol, ses SDK et la plupart des serveurs communautaires sont gratuits. Ce que vous payez, ce sont les tokens : les définitions d'outils de chaque serveur connecté sont injectées dans chaque requête, et un serveur avec environ 25 outils ajoute environ 3,000 à 8,000 tokens de schéma. Dix serveurs représentent environ 50,000 tokens par étape. Sur la référence d'exécution en 12 étapes, cela fait passer Claude Sonnet 5 de $0.39 à environ $1.53, GPT-5.4 de $0.50 à environ $1.93, Gemini 3.8 Flash de $0.15 à environ $0.58 et DeepSeek V4.1 Flash d'environ $0.06 à environ $0.23.

Ces chiffres sont avant la mise en cache des prompts. Avec la mise en cache, l'exécution de Sonnet 5 revient à environ $0.36. La suite de cet article montre d'où viennent les chiffres et quels leviers les font varier.

Un client MCP appelle le tools/list de chaque serveur au démarrage et convertit le résultat dans le format d'outil du fournisseur du modèle. Chaque outil devient un nom, une description et un schéma JSON pour ses arguments. Ce bloc est envoyé avec chaque appel de modèle, que le modèle utilise l'outil ou non, car le modèle ne peut pas appeler ce qu'il ne voit pas.

Deux choses rendent cela coûteux plutôt que simplement désordonné. Premièrement, les schémas sont verbeux : un serveur de base de données qui documente chaque colonne, ou un serveur de navigateur avec vingt actions de navigation, peut représenter plusieurs milliers de tokens à lui seul. Deuxièmement, une boucle d'agent renvoie tout le contexte à chaque étape, donc le coût du schéma est payé une fois par étape, pas une fois par run. Les mécanismes de ce renvoi sont couverts dans [combien coûte l'exécution d'un agent IA](/guides/how-much-does-an-ai-agent-cost-to-run).

Ne faites pas d'estimation. Demandez au compteur de tokens du fournisseur la requête avec et sans la liste d'outils ; la différence est le surcoût de schéma pour ce serveur. Cet extrait TypeScript récupère les outils d'un serveur via MCP, les convertit au format d'outil d'Anthropic et évalue le surcoût par étape sur Claude Sonnet 5 :

import Anthropic from "@anthropic-ai/sdk";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";

const anthropic = new Anthropic();

export async function toolListCost(mcp: Client, system: string) {
  const { tools } = await mcp.listTools();
  const anthropicTools: Anthropic.Tool[] = tools.map((t) => ({
    name: t.name,
    description: t.description ?? "",
    input_schema: t.inputSchema as Anthropic.Tool["input_schema"],
  }));
  const probe = [{ role: "user" as const, content: "ping" }];
  const withTools = await anthropic.messages.countTokens({
    model: "claude-sonnet-5", system, tools: anthropicTools, messages: probe,
  });
  const noTools = await anthropic.messages.countTokens({
    model: "claude-sonnet-5", system, messages: probe,
  });
  const schemaTokens = withTools.input_tokens - noTools.input_tokens;
  // Sonnet 5: $2 per 1M uncached, roughly $0.20 per 1M as a cache read
  const perStepUSD = (schemaTokens * 2) / 1_000_000;
  return { schemaTokens, perStepUSD, perStepCachedUSD: perStepUSD / 10 };
}

Exécutez-le une fois par serveur et conservez les chiffres dans la configuration de l'agent. Un serveur qui coûte 6,000 tokens par étape et qui est appelé sur 2% des runs est un bon candidat pour être supprimé.

Les schémas sont le coût fixe. Les résultats des outils sont le coût variable, et ils sont souvent plus importants. Une lecture de fichier, une page web ou un résultat SQL peuvent représenter 5 000 à 20 000 tokens. Une fois qu'un résultat entre dans la conversation, chaque étape ultérieure le renvoie.

Prenez la trace de référence (résultats de 1 500 tokens) et remplacez quatre des douze résultats par des dumps SQL de 15 000 tokens aux étapes 2, 4, 6 et 8. Chaque dump ajoute 13 500 tokens par rapport à la référence et est renvoyé à chaque étape suivante : 10 + 8 + 6 + 4 = 28 renvois, plus les quatre envois initiaux, soit 32 au total. Cela représente 13 500 × 32 = 432 000 tokens d'entrée supplémentaires, soit environ 0,86 $ sur Sonnet 5 à 2 $ par million, pour quatre requêtes qui auraient pu renvoyer un nombre de lignes et les vingt premières lignes.

Le run de référence est un préfixe de 4,000 tokens (1,500 système, 2,500 d'outils codés à la main), une tâche de 500 tokens, et douze étapes qui ajoutent chacune un appel d'outil de 300 tokens et un résultat de 1,500 tokens. L'entrée non mise en cache sur l'ensemble du run est de 172,800 tokens ; la sortie est de 4,800.

Remplacez les 2,500 tokens d'outils codés à la main par dix serveurs MCP d'environ 5,000 tokens chacun. Le préfixe devient 52,000 tokens et l'étape 12 envoie à elle seule 52,000 + 11 × 1,800 = 71,800 tokens. L'entrée sur l'ensemble du run est de 12 × 52,000 + 118,800 = 742,800 tokens, soit 4.3 fois la ligne de base pour exactement le même travail.

La colonne mise en cache suppose que 71,800 tokens sont écrits une fois (le préfixe à l'étape 1 plus les 1,800 nouveaux tokens de chaque étape) et que 671,000 sont lus depuis le cache. La prime d'écriture est d'environ 125% chez Anthropic ; OpenAI et DeepSeek n'en ont pas. DeepSeek V4.1 Flash, nom d'API deepseek-flash, a remplacé V4 Flash, que DeepSeek a retiré. Les lignes DeepSeek utilisent les tarifs de pointe ; les heures creuses coûtent moitié moins. Les tarifs DeepSeek vérifiés le 2026-10-27 à l'adresse api-docs.deepseek.com. Tout dans cette colonne suit les règles décrites dans [mise en cache des prompts pour les agents IA](/guides/prompt-caching-for-ai-agents).

• Moins de serveurs par agent. Donnez à chaque agent les deux ou trois serveurs dont sa tâche a besoin. Trois serveurs au lieu de dix réduit le préfixe de 52 000 à 17 000 tokens et l'exécution non mise en cache de Sonnet 5 de 1,53 $ à environ 0,69 $ (322 800 × 2 $ + 0,048 $).
• Filtrage des outils et chargement paresseux. Les SDK OpenAI Agents et Claude Agent acceptent tous deux une liste d'autorisation de noms d'outils par serveur MCP, de sorte qu'un serveur de 25 outils peut en présenter 4. L'API d'Anthropic propose également un outil de recherche d'outils avec defer_loading sur le reste, de sorte que les schémas ne sont récupérés dans le contexte que lorsque le modèle les recherche. Dans les deux cas, le modèle ne paie jamais pour un schéma qu'il n'appellera pas.
• Tronquer les résultats à la source. Limitez chaque résultat d'outil à quelques milliers de tokens et renvoyez un indice tel que le nombre total de lignes, un décalage d'octets ou un "rappelez avec page=2". Quatre résultats SQL limités permettent d'économiser les 432 000 tokens calculés ci-dessus.
• Mettre en cache le préfixe. Les définitions d'outils sont rendues en premier et ne changent jamais, ce sont donc les tokens les plus faciles à mettre en cache dans la requête. Un point d'arrêt sur le dernier outil chez Anthropic, ou simplement un ordre d'outils stable chez OpenAI, convertit le coût du schéma en lectures de cache à environ 10 % du prix catalogue.

Faites les quatre. Ils se multiplient plutôt que de s'additionner : trois serveurs filtrés avec des résultats tronqués et un cache chaud donne une exécution où la surcharge MCP est inférieure à un centime.

Pour un agent dont les outils MCP sont bien spécifiés et dont la tâche est claire, DeepSeek V4.1 Flash ($0.30 / $1.20) exécute la trace à dix serveurs pour environ $0.23 et Gemini 3.8 Flash pour environ $0.58. Selon notre expérience, les deux effectuent des appels d'outils structurés corrects lorsque le schéma est sans ambiguïté. Claude Haiku 5.5, sorti en octobre à $0.10 / $0.50, est moins cher en prix : 742,800 × $0.10 + 4,800 × $0.50 = environ $0.077, bien que nous ne l'ayons pas testé sur cette trace. Surveillez son palier de prix : le plus grand appel ici est de 71,800 tokens, mais ajoutez six serveurs supplémentaires (environ 30,000 tokens) et l'étape 12 atteint 52,000 + 30,000 + 19,800 = 101,800 tokens, où Haiku 5.5 facture toute la demande à $0.50 / $2.50. Comparez le champ plus large dans [LLM le moins cher pour les agents IA](/guides/cheapest-llm-for-ai-agents) et le [catalogue de modèles](/models).

Payez pour Claude Sonnet 5 ou GPT-5.4 lorsque l'agent doit choisir entre de nombreux outils similaires (dix serveurs signifient souvent plusieurs outils "search" et "read" qui se chevauchent) ou se remettre des erreurs d'outil sans humain. Un modèle bon marché qui choisit le mauvais serveur et boucle renvoie le préfixe de 52,000 tokens à chaque étape gaspillée, et à ce moment-là, le modèle phare est moins cher par tâche terminée. Claude Opus 5 à $5 / $25 est rarement justifié pour la plomberie d'outils ; réservez-le pour l'étape de planification, comme décrit dans [coût du système multi-agent](/guides/multi-agent-system-cost).

Les grandes listes d'outils rendent les boucles incontrôlées coûteuses plus rapidement, donc les garde-fous comptent plus, pas moins :

• max_tokens sur chaque appel, dimensionné pour un appel d'outil, pas pour un essai
• Une limite d'étapes par exécution ; un agent de dix serveurs qui n'a pas terminé en 20 étapes est généralement confus, pas minutieux
• Une condition d'arrêt que le modèle peut déclencher explicitement
• Un plafond en dollars par exécution calculé à partir de usage sur chaque réponse, incluant les tokens de lecture et d'écriture du cache, qui interrompt la boucle lorsqu'il est dépassé

L'article [token budget guardrails](/guides/ai-agent-token-budget-guardrails) contient le code d'exécution. Pour les spécificités par fournisseur sur la facturation des définitions d'outils, consultez [Claude agent API cost](/guides/claude-agent-api-cost), et utilisez le [calculator](/calculator) pour évaluer le coût de votre propre liste de serveurs une fois que vous l'avez mesurée.