- Accueil
- Centre d'apprentissage
- Mise en cache des prompts : comment elle réduit le coût des agents IA
Mise en cache des prompts : comment elle réduit le coût des agents IA
Mis à jour le
Fonctionnement de la mise en cache des prompts, son intérêt pour les agents de codage IA qui renvoient un contexte croissant à chaque tour, ce qui casse un cache et comment le vérifier.
Sur cette page
La mise en cache des prompts permet à un fournisseur de modèles de réutiliser le début déjà traité d'un prompt lorsqu'une requête ultérieure commence exactement par le même texte. L'entrée en cache est facturée à une fraction du tarif d'entrée normal, ce qui convient aux charges de travail qui renvoient de nombreuses fois le même long contexte. Les agents de codage IA en sont l'exemple le plus net : un agent renvoie toute sa conversation à chaque tour et, sans mise en cache, l'essentiel de la facture d'une longue session sert à faire traiter de nouveau le même historique. La mise en cache ne fonctionne que si le début de chaque requête reste identique octet pour octet ; elle récompense donc les agents qui ajoutent à leur contexte plutôt que de le réécrire.
Cette page approfondit la mise en cache, que présente Combien coûte le codage par IA, et comment maîtriser ce coût ?.
Comment fonctionne la mise en cache des prompts
Avant de générer quoi que ce soit, un modèle traite chaque token d'entrée. Pour un long prompt, c'est un vrai travail, et les fournisseurs le facturent en tokens d'entrée. Si la requête suivante commence par le même texte, le fournisseur peut conserver le résultat du traitement de ce début (le préfixe) et s'en dispenser la fois suivante.
Trois propriétés découlent de la façon dont cela fonctionne :
- C'est une correspondance de préfixe. Le cache sert pour la plus longue portion du début de la requête qui est identique à quelque chose en cache. Un seul caractère modifié met fin à la correspondance ; tout ce qui suit est traité et facturé normalement.
- Il expire. Les caches vivent peu de temps, généralement quelques minutes, et sont rafraîchis lorsqu'ils servent. Certains fournisseurs proposent une durée de vie plus longue à un prix d'écriture plus élevé.
- Il est propre à chaque modèle. Un cache construit pour un modèle ne peut pas servir à un autre, si bien que changer de modèle en cours de session repart de zéro.
Il existe aussi une longueur minimale. Les prompts très courts ne sont pas mis en cache du tout.
Comment les fournisseurs la facturent
La tarification a la même forme d'un fournisseur à l'autre, avec des détails différents :
- Les lectures du cache sont facturées avec une remise par rapport à l'entrée normale.
- Les écritures du cache peuvent coûter plus que l'entrée normale, autant, ou rien de plus.
- Le stockage est facturé par certains fournisseurs pour les caches à durée de vie plus longue.
Anthropic, par exemple, utilise des marqueurs de cache explicites dans la requête, établit la correspondance dans l'ordre outils, prompt système, puis messages, facture une écriture dans le cache par défaut de cinq minutes à 1.25 fois le prix de base de l'entrée, et facture les lectures du cache à une petite fraction du prix de base de l'entrée, la part exacte dépendant du modèle. OpenAI applique automatiquement la mise en cache aux prompts qui dépassent une longueur minimale, sans frais d'écriture distincts. L'API Gemini de Google propose à la fois une mise en cache automatique et des caches créés explicitement, facturés à la durée de stockage. Les prix et les règles changent : consultez la documentation du fournisseur avant de bâtir vos prévisions dessus.
Pourquoi les agents IA en profitent autant
Une session d'agent est une boucle : envoyer la conversation, recevoir une réponse, exécuter un outil, ajouter le résultat, renvoyer toute la conversation. L'entrée de chaque appel est celle de l'appel précédent plus un petit ajout. C'est exactement le schéma que récompense un cache de préfixe.
Une session illustrative, exprimée en nombres de tokens plutôt qu'en prix pour valoir quel que soit le modèle : 20 appels au modèle, le premier envoyant 20 000 tokens de contexte, chaque appel suivant ajoutant 4 000 nouveaux tokens.
- Sans mise en cache, l'entrée totale sur la session est de 1 160 000 tokens, tous facturés au plein tarif d'entrée.
- Avec mise en cache, chaque appel lit le contexte précédent depuis le cache et n'écrit que les 4 000 nouveaux tokens. Si une lecture du cache coûte un dixième du tarif d'entrée et une écriture 1.25 fois ce tarif (tarifs illustratifs ; vérifiez ceux de votre modèle), la facture revient à environ 226 000 tokens d'entrée au plein tarif : à peu près un cinquième du coût sans cache. Un tarif de lecture plus bas fait économiser davantage.
Plus la session est longue, plus la part de l'entrée constituée d'historique en cache est grande, et plus l'économie est importante. Les tokens de sortie ne sont pas concernés par la mise en cache.
Ce qui casse un cache
Comme la correspondance porte sur un préfixe exact, de petites modifications près du début d'une requête invalident tout ce qui les suit. Les causes fréquentes :
- Un contenu volatil tôt dans le prompt. Un horodatage, un identifiant de requête ou une valeur aléatoire dans le prompt système change à chaque appel.
- Un ordre instable. Des outils listés dans un ordre différent, ou du JSON sérialisé avec des clés dans un autre ordre, produisent des octets différents.
- La modification de l'historique. Réécrire ou résumer des messages antérieurs modifie le préfixe. Ajouter de nouveaux messages, non.
- Le changement de réglages en cours de session. Changer de modèle démarre toujours un nouveau cache et, chez certains fournisseurs, modifier certains réglages de la requête aussi.
- Les longues pauses. S'il s'écoule plus de temps entre deux appels que la durée de vie du cache, l'appel suivant paie pour écrire de nouveau le cache.
La règle générale : placez le contenu stable en premier et le contenu changeant en dernier, et traitez la conversation en ajout seul (append-only).
Comment savoir si la mise en cache fonctionne
Les fournisseurs indiquent les tokens en cache dans les données d'utilisation de chaque réponse, généralement sous forme de décomptes séparés pour les tokens lus depuis le cache et ceux qui y sont écrits. Trois vérifications valent la peine :
- Les lectures du cache doivent représenter l'essentiel de l'entrée à chaque appel après le premier dans une longue session. Si les lectures restent à zéro, quelque chose change au début du prompt.
- Les écritures doivent être faibles et régulières, à peu près de la taille de ce que chaque tour ajoute. De grosses écritures à chaque appel signifient que le cache est reconstruit.
- Le coût par session doit baisser après l'introduction de la mise en cache ou la correction d'une cause d'invalidation. S'il ne baisse pas, les requêtes ne tombent pas dans le cache.
Comparez le coût d'un même type de session avant et après un changement, et non des requêtes isolées.
La mise en cache aux côtés des autres contrôles de coûts
La mise en cache réduit le coût de l'entrée répétée. Elle ne limite ni la durée d'une session, ni le nombre de sessions que les gens lancent, ni le modèle qu'ils choisissent. Elle donne les meilleurs résultats avec les autres contrôles : des tâches plus courtes et bien définies, le bon modèle pour chaque étape, et un plafond strict sur les dépenses. Consultez Comment fixer un budget de codage par IA pour ce dernier point.
Comment AI CodeOps s'y prend
Les sessions AI CodeOps qui s'exécutent sur des modèles Claude utilisent la mise en cache des prompts. Le prompt système est mis en cache comme une entrée à part, et un marqueur placé à la fin de la conversation met en cache tout ce qui précède jusqu'à son dernier bloc, en avançant à chaque tour, si bien que la boucle d'outils d'un agent renvoie son historique sous forme de lectures du cache. Le coût enregistré compte les écritures et les lectures du cache à leurs propres tarifs, et non au prix plein de l'entrée.
Vous pouvez le voir fonctionner sur la page Usage : dans Usage History, ouvrez le nombre de tokens d'entrée ou de sortie d'un appel au modèle pour voir sa répartition en lectures du cache, écritures du cache et tokens de raisonnement, lorsque le modèle les indique. La page de chaque session affiche son coût par étape d'agent.
Consultez Utilisation et dépenses pour savoir où ces chiffres apparaissent, Modèles et niveaux pour les modèles qu'utilisent les sessions, et estimez le coût d'une session avec le calculateur de coûts du codage par IA gratuit.
Questions fréquentes
Qu'est-ce que la mise en cache des prompts ?
Une fonctionnalité des fournisseurs qui conserve la forme déjà traitée du début d'un prompt, afin qu'une requête ultérieure commençant exactement par le même texte puisse la réutiliser. L'entrée réutilisée est facturée à un tarif inférieur à celui de l'entrée nouvelle, et elle est généralement traitée plus vite.
La mise en cache des prompts change-t-elle les réponses du modèle ?
Non. Le modèle reçoit la même entrée dans les deux cas. La mise en cache change ce que le fournisseur doit recalculer et sa façon de facturer, pas ce que voit le modèle.
Pourquoi mon taux de succès du cache est-il faible ?
En général parce que le début du prompt change d'une requête à l'autre, par exemple un horodatage dans le prompt système, des outils listés dans un ordre différent ou des messages antérieurs modifiés. De longues pauses entre les appels peuvent aussi laisser le cache expirer.
Les écritures du cache coûtent-elles plus que l'entrée normale ?
Chez certains fournisseurs, oui. Anthropic facture un supplément pour l'écriture dans le cache et accorde une forte remise sur la lecture, tandis qu'OpenAI met en cache automatiquement sans frais d'écriture distincts. Consultez la page de tarifs de votre fournisseur.
Voir aussi
- Combien coûte le codage par IA, et comment maîtriser ce coût ?
- Utilisation et dépenses
- Modèles et niveaux
- Maîtrise des coûts du codage par IA avec limites de dépenses strictes
- Que faire lorsqu'un secret a été commité dans Git
- Budgets de codage IA : limites souples, plafonds stricts et par workflow
- Tout le centre d'apprentissage