Outils MCP vs Données dans le Prompt : Comparaison Tarification & Efficacité
Comparaison des Prix
Scénario : Données météo pour 5 villes
Option 1 : Passer les Données Directement dans le Prompt
Prompt Utilisateur (données intégrées) :
─────────────────────────────────────────
"Voici les données météo :
San Francisco : 20°C, Partiellement nuageux, Vent 19km/h...
New York : 7°C, Pluvieux, Vent 13km/h...
Los Angeles : 24°C, Ensoleillé, Vent 8km/h...
Chicago : 0°C, Neigeux, Vent 24km/h...
Seattle : 13°C, Couvert, Vent 16km/h...
[500 lignes supplémentaires de prévisions détaillées]
En vous basant sur ces données, quelle ville a la meilleure météo ?"
─────────────────────────────────────────
TOKENS EN ENTRÉE : ~2 000 tokens (toutes les données comptées)
TOKENS EN SORTIE : ~100 tokens (réponse)
Coût avec les tarifs Claude Sonnet 4.5 :
Entrée : 2 000 × 3$/MTok = 0,006$
Sortie : 100 × 15$/MTok = 0,0015$
TOTAL : 0,0075$ par requête
Option 2 : Utilisation des Outils MCP (Traditionnel)
Prompt Utilisateur :
─────────────────────────────────────────
"Quelle ville a la meilleure météo parmi SF, NY, LA, Chicago, Seattle ?"
─────────────────────────────────────────
SÉQUENCE :
1. Requête utilisateur : 50 tokens
2. Définitions des outils préchargées : ~5 000 tokens
3. Claude décide d'appeler get_weather_comparison()
4. Résultat de l'outil retourné : 500 tokens
5. Claude génère la réponse : 100 tokens
TOKENS EN ENTRÉE : 5 550 tokens
TOKENS EN SORTIE : 100 tokens
Coût avec les tarifs Claude Sonnet 4.5 :
Entrée : 5 550 × 3$/MTok = 0,01665$
Sortie : 100 × 15$/MTok = 0,0015$
TOTAL : 0,01815$ par requête
Attendez, MCP est PLUS cher ici ? Oui, à cause de la surcharge des définitions d’outils !
Option 3 : Utilisation de MCP avec Appel d’Outils Programmatique
Prompt Utilisateur :
─────────────────────────────────────────
"Quelle ville a la meilleure météo parmi SF, NY, LA, Chicago, Seattle ?"
─────────────────────────────────────────
SÉQUENCE :
1. Requête utilisateur : 50 tokens
2. Claude génère du code Python : 200 tokens
3. Le code exécute les outils sans retourner à Claude
4. Seul le résultat final est retourné : 150 tokens
5. Claude génère la réponse : 100 tokens
TOKENS EN ENTRÉE : 400 tokens
TOKENS EN SORTIE : 300 tokens (génération de code + réponse)
Coût avec les tarifs Claude Sonnet 4.5 :
Entrée : 400 × 3$/MTok = 0,0012$
Sortie : 300 × 15$/MTok = 0,0045$
TOTAL : 0,0057$ par requête
MCP est maintenant MOINS CHER !
Tableau Récapitulatif des Coûts
| Méthode | Tokens Entrée | Tokens Sortie | Coût par Requête | Coût Relatif |
|---|---|---|---|---|
| Données Intégrées au Prompt | 2 000 | 100 | 0,0075$ | 132% |
| MCP Traditionnel | 5 550 | 100 | 0,01815$ | 318% |
| MCP Programmatique | 400 | 300 | 0,0057$ | 100% (référence) |
Quand Utiliser Chaque Approche
Utilisez les Données Intégrées Quand :
✅ Les données sont petites (< 500 tokens)
"La température est de 20°C. Est-ce que c'est chaud ?"
Coût : Différence négligeable
✅ Données à usage unique
"Voici mon CSV [100 lignes]. Trouvez les anomalies."
Pas besoin d'outils réutilisables
✅ Données de référence statiques
"Voici le catalogue produits [coller]. Quel article correspond à X ?"
Les données ne changent pas pendant la conversation
Utilisez les Outils MCP Quand :
✅ Les données sont volumineuses ou dynamiques
Utilisateur : "Quelle est la météo ?"
→ L'outil récupère les données actuelles (pas des données périmées)
→ Seules les données pertinentes sont retournées
✅ Requêtes multiples sur la même source de données
Conversation 1 : "Météo à SF ?" → get_weather(SF)
Conversation 2 : "Météo à NY ?" → get_weather(NY)
Définitions d'outils amorties sur plusieurs requêtes
✅ Données en temps réel/changeantes
Prix des actions, requêtes de base de données, systèmes de fichiers
Impossible de coller dans le prompt (serait obsolète)
✅ Grandes bibliothèques d’outils
100 outils disponibles, mais seulement 2-3 utilisés par requête
La recherche d'outils ne charge que les outils pertinents
Les Coûts Cachés
Le Vrai Problème : Surcharge des Définitions d’Outils
SANS RECHERCHE D'OUTILS (Ancien MCP) :
─────────────────────────────────────────────
Définitions d'outils préchargées : 46 000 - 80 000 tokens
Requête utilisateur : 50 tokens
Exécution de l'outil : 500 tokens
Réponse : 100 tokens
─────────────────────────────────────────────
TOTAL : 46 650 - 80 650 tokens par requête
Coût : 0,14$ - 0,24$ par requête !
Un utilisateur a documenté 67 000 tokens consommés juste en connectant quatre serveurs MCP à Claude Code avant même d’écrire un seul prompt.
Scott Spence a découvert que ses outils MCP consommaient plus de 66 000 tokens avant même de commencer une conversation – cela représente un tiers de la fenêtre de contexte de 200K de Claude juste pour charger les outils.
La Solution : Recherche d’Outils MCP
La Recherche d’Outils préserve 191 300 tokens de contexte comparé à 122 800 avec l’approche traditionnelle de Claude – une réduction de 85% de l’utilisation des tokens.
AVEC RECHERCHE D'OUTILS (Nouveau MCP) :
─────────────────────────────────────────────
Chargement initial : 5 000 tokens (juste l'outil de recherche)
Requête utilisateur : 50 tokens
Recherche d'outils : 200 tokens
Chargement des outils pertinents : 1 200 tokens
Exécution de l'outil : 500 tokens
Réponse : 100 tokens
─────────────────────────────────────────────
TOTAL : 7 050 tokens par requête
Coût : 0,022$ par requête
C’est une réduction de coût de 90% !
Comparaison Complète Mise à Jour
| Approche | Chargement Initial | Par Requête | Coût | Meilleur Pour |
|---|---|---|---|---|
| Intégré au Prompt | 0 | 2 100 | 0,0075$ | Données petites et statiques |
| MCP (Ancien/Statique) | 50 000 | 50 650 | 0,152$ | ❌ Obsolète |
| MCP + Recherche d’Outils | 5 000 | 7 050 | 0,022$ | ✅ Données dynamiques |
| MCP + Programmatique | 5 000 | 5 650 | 0,018$ | ✅ Workflows complexes |
Exemples Réels de Consommation de Tokens
Serveur MCP GitHub
Le serveur MCP GitHub rend 91 outils disponibles, consommant environ 46 000 tokens – près de 22% de la fenêtre de contexte de Claude Opus avant même qu’un utilisateur ne soumette une requête.
Configuration Multi-Serveurs
Une configuration avec les serveurs MCP GitHub, Grafana et Notion a consommé 93 600 tokens juste pour dire « bonjour ».
Exemple Extrême
Une configuration a consommé 82 000 tokens rien que pour les outils MCP, ne laissant que 12 000 tokens (5,8%) d’espace libre.
L’Impact Financier
Calculons un scénario mensuel réel :
Équipe de Développement : 20 devs, 100 requêtes/jour chacun
ANCIEN MCP (sans Recherche d'Outils) :
───────────────────────────────────────
20 devs × 100 requêtes × 0,152$ = 304$/jour
Mensuel : 9 120$/mois
Annuel : 109 440$/an
NOUVEAU MCP (avec Recherche d'Outils) :
───────────────────────────────────────
20 devs × 100 requêtes × 0,022$ = 44$/jour
Mensuel : 1 320$/mois
Annuel : 15 840$/an
ÉCONOMIES : 93 600$/an (réduction de 85% !)
Pourquoi les Données Intégrées Peuvent Toujours Gagner
Malgré les améliorations de MCP, les données intégrées sont moins chères pour :
1. Analyse Ponctuelle
Utilisateur : "Voici mes données de ventes [1000 tokens]. Analysez-les."
Coût : 0,003$
vs
MCP : Configuration serveur, outils, surcharge
Coût : 0,022$ minimum
2. Documents Déjà Disponibles
Utilisateur : "Examinez ce contrat [2000 tokens]"
Il suffit de le coller - pas besoin de serveur
3. Petites Données de Référence
Utilisateur : "Voici 10 codes produits. Lequel est le moins cher ?"
Intégré : 100 tokens
Surcharge MCP : 5 000+ tokens
Le Point de Basculement
Avec de grands documents ou des structures de données complexes qui dépassent les limites de la fenêtre de contexte, la capacité de MCP à filtrer les données avant qu’elles n’atteignent le modèle devient essentielle.
Utilisez MCP quand :
- Les données dépassent 10 000 tokens
- Vous avez besoin de données en temps réel/fraîches
- Requêtes multiples sur la même source de données
- Les données changent fréquemment
- Construction d’agents réutilisables
Utilisez les données intégrées quand :
- Données < 1 000 tokens
- Analyse ponctuelle
- Matériel de référence statique
- L’utilisateur a déjà les données prêtes
Insight Clé
La critique révèle une tension fondamentale : les outils sont incroyablement utiles pour rendre les LLM productifs, mais informer le LLM de l’existence de ces outils coûte cher en contexte.
Environ 90% des tâches qui ont du contexte MCP disponible n’en ont pas réellement besoin pour accomplir la tâche, et les tâches qui en ont besoin n’utilisent généralement que quelques outils.
La percée avec la Recherche d’Outils est que vous payez pour ce que vous utilisez, pas pour ce qui est disponible. Cela rend MCP économiquement viable pour la première fois à grande échelle.
Traduction:
MCP Tools vs Passing Data in Prompts: Pricing & Efficiency Comparison
Pricing Comparison
Scenario: Weather data for 5 cities
Option 1: Pass Data Directly in Prompt
User Prompt (embedded data):
─────────────────────────────────────────
"Here's the weather data:
San Francisco: 68°F, Partly Cloudy, Wind 12mph...
New York: 45°F, Rainy, Wind 8mph...
Los Angeles: 75°F, Sunny, Wind 5mph...
Chicago: 32°F, Snowy, Wind 15mph...
Seattle: 55°F, Overcast, Wind 10mph...
[500 more lines of detailed forecast data]
Based on this data, which city has the best weather?"
─────────────────────────────────────────
INPUT TOKENS: ~2,000 tokens (all data counted)
OUTPUT TOKENS: ~100 tokens (response)
Cost @ Claude Sonnet 4.5 rates:
Input: 2,000 × $3/MTok = $0.006
Output: 100 × $15/MTok = $0.0015
TOTAL: $0.0075 per query
Option 2: Using MCP Tools (Traditional)
User Prompt:
─────────────────────────────────────────
"Which city has the best weather among SF, NY, LA, Chicago, Seattle?"
─────────────────────────────────────────
SEQUENCE:
1. User query: 50 tokens
2. Tool definitions preloaded: ~5,000 tokens
3. Claude decides to call get_weather_comparison()
4. Tool result returned: 500 tokens
5. Claude generates response: 100 tokens
INPUT TOKENS: 5,550 tokens
OUTPUT TOKENS: 100 tokens
Cost @ Claude Sonnet 4.5 rates:
Input: 5,550 × $3/MTok = $0.01665
Output: 100 × $15/MTok = $0.0015
TOTAL: $0.01815 per query
Wait, MCP is MORE expensive here? Yes, because of tool definition overhead!
Option 3: Using MCP with Programmatic Tool Calling
User Prompt:
─────────────────────────────────────────
"Which city has the best weather among SF, NY, LA, Chicago, Seattle?"
─────────────────────────────────────────
SEQUENCE:
1. User query: 50 tokens
2. Claude generates Python code: 200 tokens
3. Code executes tools without returning to Claude
4. Only final result returned: 150 tokens
5. Claude generates response: 100 tokens
INPUT TOKENS: 400 tokens
OUTPUT TOKENS: 300 tokens (code generation + response)
Cost @ Claude Sonnet 4.5 rates:
Input: 400 × $3/MTok = $0.0012
Output: 300 × $15/MTok = $0.0045
TOTAL: $0.0057 per query
MCP is now CHEAPER!
Cost Summary Table
| Method | Input Tokens | Output Tokens | Cost per Query | Relative Cost |
|---|---|---|---|---|
| Embedded Data in Prompt | 2,000 | 100 | $0.0075 | 132% |
| MCP Traditional | 5,550 | 100 | $0.01815 | 318% |
| MCP Programmatic | 400 | 300 | $0.0057 | 100% (baseline) |
When Each Approach Makes Sense
Use Embedded Data When:
✅ Data is small (< 500 tokens)
"The temperature is 68°F. Is that warm?"
Cost: Negligible difference
✅ Single-use data
"Here's my CSV [100 rows]. Find anomalies."
No need for reusable tools
✅ Static reference data
"Here's the product catalog [paste]. Which item matches X?"
Data doesn't change during conversation
Use MCP Tools When:
✅ Data is large or dynamic
User: "What's the weather?"
→ Tool fetches current data (not stale prompt data)
→ Only relevant data returned
✅ Multiple queries on same data source
Conversation 1: "Weather in SF?" → get_weather(SF)
Conversation 2: "Weather in NY?" → get_weather(NY)
Tool definitions amortized across queries
✅ Real-time/changing data
Stock prices, database queries, file systems
Can't paste into prompt (would be outdated)
✅ Large tool libraries
100 tools available, but only 2-3 used per query
Tool search loads only relevant tools
The Hidden Costs
Context Window WasteExcellent additional context! Let me update my comparison with the real token overhead problem:
The Real Problem: Tool Definition Overhead
WITHOUT TOOL SEARCH (Old MCP):
─────────────────────────────────────────────
Tool definitions preloaded: 46,000 - 80,000 tokens
User query: 50 tokens
Tool execution: 500 tokens
Response: 100 tokens
─────────────────────────────────────────────
TOTAL: 46,650 - 80,650 tokens per query
Cost: $0.14 - $0.24 per query!
One user documented 67,000 tokens consumed just from connecting four MCP servers to Claude Code before writing a single prompt.
Scott Spence found his MCP tools were consuming 66,000+ tokens before he started a conversation – that’s burning through a third of Claude’s 200K context window just loading tools.
The Solution: MCP Tool Search
Tool Search preserves 191,300 tokens of context compared to 122,800 with Claude’s traditional approach – an 85% reduction in token usage.
WITH TOOL SEARCH (New MCP):
─────────────────────────────────────────────
Initial load: 5,000 tokens (just search tool)
User query: 50 tokens
Tool search: 200 tokens
Load relevant tools: 1,200 tokens
Tool execution: 500 tokens
Response: 100 tokens
─────────────────────────────────────────────
TOTAL: 7,050 tokens per query
Cost: $0.022 per query
That’s a 90% cost reduction!
Updated Complete Comparison
| Approach | Initial Load | Per Query | Cost | Best For |
|---|---|---|---|---|
| Embedded in Prompt | 0 | 2,100 | $0.0075 | Small, static data |
| MCP (Old/Static) | 50,000 | 50,650 | $0.152 | ❌ Deprecated |
| MCP + Tool Search | 5,000 | 7,050 | $0.022 | ✅ Dynamic data |
| MCP + Programmatic | 5,000 | 5,650 | $0.018 | ✅ Complex workflows |
Real-World Token Consumption Examples
GitHub MCP Server
The GitHub MCP server makes 91 tools available, consuming approximately 46,000 tokens – nearly 22% of Claude Opus’s context window before a user even submits a query.
Multi-Server Setup
A setup with GitHub, Grafana, and Notion MCP servers burned 93,600 tokens just to say « hello ».
Extreme Example
One configuration consumed 82,000 tokens from MCP tools alone, leaving just 12,000 tokens (5.8%) of free space.
The Financial Impact
Let’s calculate a real monthly scenario:
Development Team: 20 devs, 100 queries/day each
OLD MCP (without Tool Search):
───────────────────────────────
20 devs × 100 queries × $0.152 = $304/day
Monthly: $9,120/month
Annual: $109,440/year
NEW MCP (with Tool Search):
───────────────────────────────
20 devs × 100 queries × $0.022 = $44/day
Monthly: $1,320/month
Annual: $15,840/year
SAVINGS: $93,600/year (85% reduction!)
Why Embedded Data Can Still Win
Despite MCP’s improvements, embedded data is cheaper for:
1. One-Time Analysis
User: "Here's my sales data [1000 tokens]. Analyze it."
Cost: $0.003
vs
MCP: Set up server, tools, overhead
Cost: $0.022 minimum
2. Documents Already Available
User: "Review this contract [2000 tokens]"
Just paste it - no server needed
3. Small Reference Data
User: "Here are 10 product codes. Which is cheapest?"
Embedded: 100 tokens
MCP overhead: 5,000+ tokens
The Tipping Point
With large documents or complex data structures that exceed context window limits, MCP’s ability to filter data before it reaches the model becomes essential.
Use MCP when:
- Data exceeds 10,000 tokens
- You need real-time/fresh data
- Multiple queries on same data source
- Data changes frequently
- Building reusable agents
Use embedded data when:
- Data < 1,000 tokens
- One-time analysis
- Static reference material
- User already has data ready
Key Insight
The criticism reveals a fundamental tension: tools are incredibly useful for making LLMs productive, but letting the LLM know about those tools is context-expensive.
About 90% of tasks that have MCP context available don’t actually need it to complete the task, and tasks that do need it typically only use a few tools.
The breakthrough with Tool Search is that you pay for what you use, not for what’s available. This makes MCP economically viable for the first time at scale.