Réponse rapide : Le prompt caching réduit les coûts d'entrée d'API LLM de 50% à 90% et diminue le délai TTFT jusqu'à 85% en réutilisant les tenseurs du KV cache entre les requêtes. Anthropic offre 90% de remise en lecture avec des points d'arrêt explicites (dès 1 024 tokens). OpenAI applique 50% de réduction automatique sans surcoût d'écriture. DeepSeek propose 80% à 90% d'économies dès 64 tokens grâce à son stockage persistant NVMe.
1. Introduction : L'économie de l'état dans les API LLM sans état (Stateless)
Les API modernes de modèles de langage (LLM) sont par définition sans état (stateless) : chaque requête HTTP POST transmise à /v1/chat/completions ou /v1/messages doit contenir l'historique complet de la discussion, les instructions système, les schémas d'outils et les documents de référence. Si cette conception facilite l'équilibrage de charge au sein des clusters de GPU, elle entraîne des gaspillages de calcul et des coûts considérables lors de flux d'agents multi-tours.
Dans les boucles d'agents autonomes — telles que Claude Code, Roo Code, Aider, Devin ou les pipelines RAG d'entreprise — l'agent réémet en permanence des prompts système identiques, des spécifications OpenAPI et des contextes de code source. Au 15e tour d'une tâche d'ingénierie logicielle classique, 95% à 98% des tokens transmis constituent des préfixes statiques que le modèle a déjà ingérés plusieurs fois.
Auparavant, les fournisseurs facturaient l'intégralité du tarif de base pour chaque token à chaque tour, contraignant les puces d'inférence à recalculer de lourdes multiplications matricielles (phase de pré-remplissage ou prefill) sur un contexte inchangé. Le Prompt Caching résout directement ce problème. En conservant les tenseurs d'activation Key-Value (KV) calculés lors du premier passage dans la mémoire HBM des GPU, la RAM système ou des disques NVMe ultrarapides, le moteur d'inférence élimine les calculs redondants de prefill.
Les équipes d'ingénierie adoptant le prompt caching constatent régulièrement des réductions de 60% à 88% de leurs factures d'API, tout en faisant chuter le délai de génération du premier token (TTFT) de plusieurs secondes à quelques centaines de millisecondes.
2. Analyse architecturale : Fonctionnement du KV Cache et goulot d'étranglement du Prefill
Pour appréhender la rentabilité du prompt caching, il convient d'analyser la physique d'exécution des Transformers sur accélérateurs d'IA modernes (NVIDIA H100/B200, Google TPU v5e/v6e).
Pipeline traditionnel sans état :
[Prompt système statique + Schémas d'outils + Historique (64 000 tokens)]
│
▼
[Phase complète de Prefill (O(N²) FLOPs)]
Multiplications matricielles recalculent tout Q, K, V
│
▼
[Premier token généré (TTFT: 2.8s)]
[Coût : Tarif de base plein × 64 000 tokens]
Pipeline avec Prompt Caching activé :
[Préfixe statique (60 000 tokens)] ──► [Hash du préfixe identique !] ──► [Chargement direct des tenseurs KV]
│ (Supprime les FLOPs matriciels)
[Requête dynamique (4 000 tokens)] ──► [Prefill sur le delta uniquement] ───────┤
▼
[Premier token généré (TTFT: 0.35s)]
[Coût : Tarif lecture × 60k + Base × 4k]Le goulot d'étranglement de l'attention
Dans l'attention multi-têtes standard, les tokens d'entrée sont projetés dans des matrices Query ($Q$), Key ($K$) et Value ($V$) de dimension $d_k$ :
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} ight)V$$
Durant la phase de prefill, le GPU évalue toutes les interactions croisées entre paires de tokens en parallèle. La complexité calculatoire en opérations flottantes (FLOPs) évolue de façon quadratique avec la longueur de la séquence $N$ :
$$\text{FLOPs}_{\text{prefill}} \approx 2 \cdot P \cdot N^2 + 4 \cdot N \cdot d_{\text{model}} \cdot d_{\text{ffn}}$$
Pour un modèle de 70 milliards de paramètres traitant un prompt de 64 000 tokens, la phase de prefill exige près de $5.8 \times 10^{14}$ opérations à virgule flottante avant même d'émettre le premier mot.
Lors de la phase de décodage, les tokens sont émis un par un. Pour éviter de recalculer le passé, les activations $K$ et $V$ sont mémorisées : c'est le KV Cache. La mémoire occupée par token pour $L$ couches avec $H_{kv}$ têtes de dimension $D$ est :
$$\text{Memory}_{\text{KV}} = 2 \times 2 \times L \times H_{kv} \times D \quad \text{(octets en FP16 / BF16)}$$
Le Prompt Caching partage ce cache KV entre requêtes HTTP distinctes : dès qu'un préfixe cryptographique correspond à un bloc existant, les tenseurs sont rechargés instantanément.
3. Matrice comparative des fournisseurs : Anthropic vs OpenAI vs DeepSeek
| Caractéristique | Anthropic Claude | OpenAI (GPT-4o / o1 / o3) | DeepSeek (V3 / V4 / R1) |
|---|---|---|---|
| Mécanisme de déclenchement | Points d'arrêt explicites (cache_control) |
Automatique (plus long préfixe commun) | Automatique (plus long préfixe commun) |
| Seuil d'activation minimal | 1 024 tokens (Sonnet/Opus) 2 048 tokens (Haiku) |
1 024 tokens | 64 tokens (Taille de bloc KV) |
| Granularité des blocs | Breakpoints explicites (max 4/requête) | Incréments de 128 tokens après 1 024 | Exactement aligné sur 64 tokens |
| Durée de vie du cache (TTL) | 5 minutes (standard éphémère) 1 heure (palier étendu) |
5 à 10 minutes (éviction dynamique LRU) | Plusieurs heures à persistant (NVMe) |
| Prolongation du TTL | Réinitialisé à 5m/1h à chaque succès | Prolongé lors d'appels continus | Conservé sur stockage SSD |
| Surcoût d'écriture (Write) | +25% (1.25x tarif base pour 5m) +100% (2.0x base pour 1h) |
$0.00 (1.0x tarif de base) | $0.00 (1.0x tarif base, zéro surcoût) |
| Remise de lecture (Read) | 90% de réduction (0.10x tarif base) | 50% de réduction (0.50x tarif base) | 75% à 90% de réduction (0.10x–0.25x base) |
| Frais de stockage | Inclus dans le surcoût d'écriture | Gratuit | Gratuit (déchargé sur NVMe) |
| Gain de latence (TTFT) | Jusqu'à 85% plus rapide | Jusqu'à 50% plus rapide | Jusqu'à 80% plus rapide |
4. Grille tarifaire complète par modèle (USD par million de tokens)
| Modèle | Entrée Standard ($/1M) | Écriture ($/1M) | Lecture ($/1M) | Remise Lecture | Sortie ($/1M) | Seuil Minimal |
|---|---|---|---|---|---|---|
| Claude 3.5 / 3.7 Haiku | $0.80 | $1.00 (5m) / $1.60 (1h) | $0.08 | 90.0% | $4.00 | 2 048 tokens |
| Claude 3.7 Sonnet | $3.00 | $3.75 (5m) / $6.00 (1h) | $0.30 | 90.0% | $15.00 | 1 024 tokens |
| Claude 3 Opus / Opus 4.6 | $15.00 | $18.75 (5m) / $30.00 (1h) | $1.50 | 90.0% | $75.00 | 1 024 tokens |
| OpenAI GPT-4o mini | $0.15 | $0.15 | $0.075 | 50.0% | $0.60 | 1 024 tokens |
| OpenAI GPT-4o | $2.50 | $2.50 | $1.25 | 50.0% | $10.00 | 1 024 tokens |
| OpenAI o1 | $15.00 | $15.00 | $7.50 | 50.0% | $60.00 | 1 024 tokens |
| OpenAI o3-mini | $1.10 | $1.10 | $0.55 | 50.0% | $4.40 | 1 024 tokens |
| DeepSeek V3 / V4 (Heures Creuses) | $0.14 | $0.14 | $0.014 | 90.0% | $0.28 | 64 tokens |
| DeepSeek V3 / V4 (Pointe) | $0.27 | $0.27 | $0.027 | 90.0% | $1.10 | 64 tokens |
| DeepSeek R1 (Raisonnement) | $0.55 | $0.55 | $0.14 | 74.5% | $2.19 | 64 tokens |
| Google Gemini 2.5 Flash | $0.15 | $0.15 | $0.0375 | 75.0% | $0.60 | 32 768 tokens |
| Google Gemini 2.5 Pro | $1.25 | $1.25 | $0.3125 | 75.0% | $5.00 | 32 768 tokens |
5. Formalisation mathématique et seuil de rentabilité
Calcul du seuil de rentabilité ($N^*$)
Pour Anthropic avec 25% de surtaxe à l'écriture ($R_{\text{write}} = 1.25 R_{\text{base}}$, $R_{\text{read}} = 0.10 R_{\text{base}}$) :
$$1.25 + 0.10(N - 1) \le N \implies 1.15 \le 0.90N \implies N \ge \frac{1.15}{0.90} \approx 1.278$$
Théorème 1 : Avec le TTL de 5 minutes d'Anthropic, le caching est rentable dès le 2e tour de conversation (N = 2).
Pour le TTL étendu de 1 heure ($R_{\text{write}} = 2.0 R_{\text{base}}$) :
$$2.0 + 0.10(N - 1) \le N \implies 1.90 \le 0.90N \implies N \ge 2.11$$
Théorème 2 : Avec le TTL étendu de 1 heure, la rentabilité nette est acquise dès le 3e tour (N = 3).
Preuve asymptotique des 90% d'économies
Sur les sessions prolongées ($N \to \infty$) :
$$\lim_{N \to \infty} S(N) = 1 - \frac{R_{\text{read}}}{R_{\text{base}}}$$
- Anthropic et DeepSeek : $1 - 0.10 = \mathbf{90.0\%}$ d'économie maximale.
- OpenAI : $1 - 0.50 = \mathbf{50.0\%}$ d'économie maximale.
6. Exemples d'implémentation en production
Anthropic Claude (Python)
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-3-7-sonnet-20250219",
max_tokens=2048,
system=[
{
"type": "text",
"text": "Documentation d'architecture complète...\n" * 400,
"cache_control": {"type": "ephemeral"} # Point d'arrêt
}
],
messages=[{"role": "user", "content": "Rédige le test d'intégration."}]
)
print("Tokens lus depuis le cache :", getattr(response.usage, "cache_read_input_tokens", 0))OpenAI (TypeScript / Node.js)
import OpenAI from "openai";
const openai = new OpenAI();
const res = await openai.chat.completions.create({
model: "gpt-4o",
messages: [
{ role: "system", content: "Directives immuables...\n".repeat(400) },
{ role: "user", content: "Vérifier le statut du compte #456" }
]
});
console.log("Tokens mis en cache :", (res.usage as any)?.prompt_tokens_details?.cached_tokens ?? 0);7. Retours d'expérience et cas d'usage réels
- Agents de code autonome (Claude Code, monorepo 250k lignes) : 20 ingénieurs ont vu leur facture mensuelle passer de 29 700 $ à 4 334 $/mois (85.4% d'économies nettes).
- RAG sur rapports financiers (OpenAI GPT-4o) : 50 000 requêtes mensuelles sur 45 000 tokens de conformité sont passées de 5 625 $ à 2 975,63 $/mois (47.1% d'économies).
- Support client à très grande échelle (DeepSeek V3/V4) : 2 millions de dialogues par mois sont passés de 3 360 $ à 378,34 $/mois (88.7% d'économies).
8. Les cinq erreurs classiques qui cassent le cache
- Horodatages dynamiques dans le prompt système : Chaque seconde modifie le hash SHA-256 et ramène le taux de succès à 0%.
- Ordre variable dans les listes d'outils (Tools) : La sérialisation désordonnée invalide le hash. Triez toujours les outils par ordre alphabétique.
- Variables dynamiques insérées au milieu du prompt : Le cache exige un préfixe commun contigu. Placez toujours les données dynamiques à la toute fin.
- Expiration de la fenêtre TTL de 5 minutes : Lors d'attentes utilisateur prolongées, privilégiez le TTL étendu de 1 heure.
- Envoi de prompts inférieurs au seuil minimum : Les textes de moins de 1 024 tokens ne sont pas éligibles au cache.
9. Conclusion et recommandations LLMPodium
- Pour le développement agentique multi-tours : Anthropic Claude 3.7 Sonnet offre un retour sur investissement incomparable grâce à ses 90% de remise.
- Pour les flux existants sans friction technique : OpenAI GPT-4o garantit 50% de gain immédiat sans toucher au code.
- Pour les volumes industriels massifs : DeepSeek V3/V4 propose le tarif le plus bas au monde avec un seuil de 64 tokens et 0,014 $/1M.