Mise en cache des préfixes d’invites d’OpenAI
Tirez parti de la mise en cache automatique des invites d’OpenAI, qui réduit de 50 % le coût des longs préfixes d’invites système répétés, et structurez vos invites pour maximiser le taux d’accès au cache.
Mise en cache des préfixes d’invites d’OpenAI est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.
Qu’est-ce que la mise en cache des préfixes de messages ?
La mise en cache des préfixes de messages est une optimisation côté serveur intégrée à l’API d’OpenAI, qui applique automatiquement une réduction aux jetons du préfixe ayant été vus dans une requête récente précédente. Contrairement à la mise en cache au niveau de l’application, qui renvoie une réponse stockée, la mise en cache des préfixes appelle toujours le modèle — mais avec un prix des jetons d’entrée réduit de 50 % pour la partie du préfixe mise en cache. Elle réduit les coûts sans sacrifier la génération d’une réponse à jour.
Fonctionnement interne de la mise en cache des préfixes
Les LLM modernes représentent les messages sous forme de caches KV (clé-valeur) dans la mémoire du GPU. Traiter un message consiste à calculer les clés et les valeurs d’attention pour chaque jeton. Si les N premiers jetons de deux requêtes consécutives sont identiques, OpenAI peut réutiliser le cache KV de la première requête et éviter le calcul coûteux pour ces jetons. L’API effectue automatiquement et de manière transparente cette opération : vous payez simplement le tarif inférieur des jetons mis en cache lorsqu’il s’applique.
# No code changes needed to enable prefix caching!
# It is automatic on supported models.
# The API response shows you how many tokens were cached:
# response.usage.prompt_tokens_details.cached_tokens
# Example response usage:
# ChatCompletionUsage(
# prompt_tokens=2048,
# completion_tokens=256,
# total_tokens=2304,
# prompt_tokens_details=PromptTokensDetails(
# cached_tokens=1984, # these tokens were served from KV cache
# audio_tokens=0,
# )
# )Vérifier le succès du cache dans la réponse
Après chaque appel à l’API, examinez response.usage.prompt_tokens_details.cached_tokens pour voir combien de jetons d’entrée ont été servis depuis le cache KV. Si cached_tokens > 0, vous avez payé le tarif réduit de 50 % pour ces jetons. La journalisation de cette valeur vous permet de suivre l’efficacité réelle de votre cache et de calculer au fil du temps les économies réalisées grâce à la mise en cache des préfixes.
from openai import OpenAI
client = OpenAI()
SYSTEM_PROMPT = 'You are an expert AI engineer assistant. ' * 100 # long system prompt
def call_with_cache_check(user_message: str):
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[
{'role': 'system', 'content': SYSTEM_PROMPT},
{'role': 'user', 'content': user_message},
],
)
usage = response.usage
cached = usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0
print(f'Total prompt tokens: {usage.prompt_tokens}')
print(f'Cached tokens: {cached} ({100*cached//usage.prompt_tokens}%)')
return response.choices[0].message.contentLe préfixe doit être strictement identique
La mise en cache des préfixes ne s’applique que lorsque les N premiers jetons sont identiques octet par octet à ceux d’une requête récente précédente. Même la modification d’un seul caractère dans le message système invalide le cache. OpenAI met les préfixes en cache par blocs de 128 jetons : le cache s’applique aux blocs complets qui correspondent exactement. La partie de votre message qui varie d’une requête à l’autre doit donc venir après le préfixe long et stable afin de maximiser le nombre de jetons mis en cache.
# Optimal structure for prefix caching:
# [LONG STABLE SYSTEM PROMPT] [CACHED DOCUMENTS] [USER QUERY]
# ↑ ↑ ↑
# always same always same varies per request
# → cached at 50% → cached at 50% → not cached, full price
# BAD structure (defeats prefix caching):
# [USER QUERY] [CACHED DOCUMENTS] [LONG STABLE SYSTEM PROMPT]
# ↑ ↑
# changes every request never cached because
# so prefix never matches it comes after the queryStructurer les messages pour optimiser l’efficacité du cache
Pour maximiser les taux de succès du cache, structurez vos messages de sorte que les parties stables apparaissent en premier. Dans un système RAG : (1) le message système avec les instructions et le persona, (2) les documents récupérés, qui ne changent que lorsque la requête évolue de manière importante, (3) l’historique de la conversation, (4) la requête utilisateur tout à la fin. Le message système seul — souvent de 500 à 2 000 jetons — sera généralement mis en cache, ce qui permettra d’économiser 25 à 50 % du coût des jetons d’entrée.
def build_rag_prompt_for_caching(
system_prompt: str,
retrieved_docs: list[str],
conversation_history: list[dict],
user_query: str,
) -> list[dict]:
# Order: stable → semi-stable → variable
context_block = '\n\n'.join(
f'[Document {i+1}]\n{doc}' for i, doc in enumerate(retrieved_docs)
)
return [
# 1. Stable system prompt (always cached after first request)
{'role': 'system', 'content': system_prompt},
# 2. Context injection as a user message (cached when same docs retrieved)
{'role': 'user', 'content': f'Context documents:\n{context_block}'},
{'role': 'assistant', 'content': 'I have read the documents.'},
# 3. Conversation history (semi-stable)
*conversation_history,
# 4. Current user query (always different → never cached prefix)
{'role': 'user', 'content': user_query},
]Durée de conservation et éviction du cache
Le cache KV d’OpenAI est conservé en mémoire sur le GPU et dispose d’une politique d’éviction. Les préfixes qui n’ont pas été réutilisés pendant environ 5 à 10 minutes sont supprimés lorsque d’autres requêtes occupent la mémoire du GPU. Les avantages de la mise en cache des préfixes sont donc les plus importants pour les applications à fort débit, qui reçoivent fréquemment des requêtes partageant le même préfixe. Les applications à faible trafic peuvent obtenir peu de succès, car le préfixe est supprimé entre deux requêtes espacées.
Modèles pris en charge et tarification
En 2025, la mise en cache des préfixes de messages est disponible avec les modèles GPT-4o, GPT-4o-mini, o1 et o3-mini. Le prix des jetons mis en cache correspond à 50 % du prix standard des jetons d’entrée pour la plupart des modèles. La longueur minimale d’un préfixe pouvant être mis en cache est de 1 024 jetons ; les préfixes plus courts ne bénéficient d’aucune réduction. Consultez toujours la page de tarification d’OpenAI pour connaître les tarifs actuels, car ils évoluent avec la maturation de cette fonctionnalité.
# Rough pricing reference (verify at platform.openai.com/pricing)
PRICING = {
'gpt-4o': {
'input_per_1M': 2.50,
'cached_input_per_1M': 1.25, # 50% off
'output_per_1M': 10.00,
},
'gpt-4o-mini': {
'input_per_1M': 0.15,
'cached_input_per_1M': 0.075, # 50% off
'output_per_1M': 0.60,
},
}
def estimate_cost_with_caching(prompt_tokens, cached_tokens, output_tokens, model):
p = PRICING[model]
uncached = (prompt_tokens - cached_tokens) * p['input_per_1M'] / 1_000_000
cached_cost = cached_tokens * p['cached_input_per_1M'] / 1_000_000
output_cost = output_tokens * p['output_per_1M'] / 1_000_000
return uncached + cached_cost + output_costMise en cache des messages avec Anthropic
Anthropic propose une fonctionnalité similaire appelée mise en cache des messages pour les modèles Claude, mais elle nécessite une activation explicite en indiquant des points de rupture du cache dans le message à l’aide d’un champ cache_control. Contrairement à la mise en cache automatique d’OpenAI, vous indiquez explicitement les parties du message à mettre en cache (jusqu’à 4 points de rupture du cache par requête). Les jetons mis en cache coûtent 10 % du prix standard des jetons d’entrée et sont conservés pendant 5 minutes.
import anthropic
client = anthropic.Anthropic()
LONG_DOCUMENT = 'This is a very long reference document...' * 500 # 2000+ tokens
response = client.messages.create(
model='claude-sonnet-4-5',
max_tokens=1024,
system=[
{
'type': 'text',
'text': 'You are a helpful assistant.',
},
{
'type': 'text',
'text': LONG_DOCUMENT,
'cache_control': {'type': 'ephemeral'}, # mark for caching
}
],
messages=[{'role': 'user', 'content': 'Summarize the document.'}],
)
print(response.usage.cache_read_input_tokens) # tokens served from cache
print(response.usage.cache_creation_input_tokens) # tokens written to cacheCombiner mise en cache des préfixes et mise en cache applicative
La mise en cache des préfixes et la mise en cache au niveau de l’application sont complémentaires. La mise en cache des préfixes réduit le coût de chaque appel à l’API, mais appelle toujours le LLM. Les caches exacts et sémantiques au niveau de l’application suppriment entièrement les appels à l’API pour les requêtes répétées. Utilisez la mise en cache des préfixes pour toutes les requêtes afin de réduire le coût d’entrée de chaque appel, puis ajoutez une mise en cache applicative par-dessus pour supprimer entièrement les appels des requêtes fréquemment répétées. Ensemble, ces mécanismes peuvent réduire de 60 à 80 % les coûts d’infrastructure liés à l’IA.
# Three-layer cost optimization stack
#
# Layer 1: Exact cache (Redis, hash-based)
# → Eliminates 100% of API cost for identical requests
# → Miss rate: ~60-80% (most queries are unique)
#
# Layer 2: Semantic cache (vector similarity)
# → Eliminates 100% of API cost for semantically similar requests
# → Miss rate: ~40-60% of remaining queries
#
# Layer 3: OpenAI prefix caching (automatic)
# → Reduces input token cost by 50% for long stable prefixes
# → Applies to ALL remaining API calls that escape layers 1 and 2
#
# Combined effect: 60-80% cost reduction in FAQ/support applicationsMesurer l’efficacité de votre cache
Suivez le ratio d’efficacité du cache comme indicateur composite : nombre total de jetons au prix fort divisé par le nombre total de jetons effectivement facturés. Cela prend en compte toutes les couches de mise en cache. Consignez cached_tokens dans chaque réponse de l’API et additionnez ces valeurs chaque semaine. Un système obtenant 50 % de jetons mis en cache sur l’ensemble des appels à l’API réduit effectivement de moitié le coût de ses jetons d’entrée, sans aucune modification du code de l’application pour la mise en cache des préfixes.
from dataclasses import dataclass, field
from typing import ClassVar
@dataclass
class CachingMetrics:
total_prompt_tokens: int = 0
total_cached_tokens: int = 0
app_cache_hits: int = 0
app_cache_misses: int = 0
@property
def prefix_cache_ratio(self) -> float:
if self.total_prompt_tokens == 0:
return 0
return self.total_cached_tokens / self.total_prompt_tokens
@property
def app_cache_hit_rate(self) -> float:
total = self.app_cache_hits + self.app_cache_misses
return self.app_cache_hits / total if total > 0 else 0
def report(self):
print(f'App cache hit rate: {self.app_cache_hit_rate:.1%}')
print(f'Prefix cache ratio: {self.prefix_cache_ratio:.1%}')
savings_multiplier = (1 - self.app_cache_hit_rate) * (1 - 0.5 * self.prefix_cache_ratio)
print(f'Effective cost vs no-cache: {savings_multiplier:.1%}')Quand la mise en cache des préfixes n’est d’aucune utilité
La mise en cache des préfixes n’apporte aucun bénéfice dans les cas suivants : (1) les messages courts de moins de 1 024 jetons (longueur minimale pouvant être mise en cache), (2) les préfixes très variables, lorsque le message système change selon l’utilisateur ou la requête, (3) les applications à faible trafic, lorsque le cache KV est supprimé entre les requêtes, ou (4) lorsque vous payez déjà le tarif minimal des jetons. Dans ces situations, concentrez vos efforts d’optimisation sur la mise en cache sémantique au niveau de l’application.
Vérification rapide
Vérifiez votre compréhension de la mise en cache des préfixes de messages d’OpenAI présentée dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que la mise en cache des préfixes de messages d’OpenAI applique automatiquement une réduction de 50 % aux jetons d’entrée mis en cache lorsque le préfixe du message correspond à une requête récente précédente, que le contenu stable doit apparaître en premier dans la structure de vos messages (message système, documents, puis requête utilisateur) afin de maximiser le nombre de jetons mis en cache, et qu’Anthropic exige des marqueurs cache_control explicites pour proposer une fonctionnalité similaire sur Claude. Combinez cette fonctionnalité avec la mise en cache au niveau de l’application pour réduire les coûts au maximum. Nous allons maintenant aborder le traitement par lots, le routage des modèles et les tableaux de bord des coûts afin de compléter notre boîte à outils d’optimisation.
Questions Fréquemment Posées
La leçon « Mise en cache des préfixes d’invites d’OpenAI » est-elle gratuite ?
Oui — le texte complet de « Mise en cache des préfixes d’invites d’OpenAI » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Mise en cache des préfixes d’invites d’OpenAI » ?
Tirez parti de la mise en cache automatique des invites d’OpenAI, qui réduit de 50 % le coût des longs préfixes d’invites système répétés, et structurez vos invites pour maximiser le taux d’accès au… Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?
Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Mise en cache des préfixes d’invites d’OpenAI » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?
Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Mise en cache exacte avec Redis
- Mise en cache sémantique avec des plongements
- Mise en cache des préfixes d’invites d’OpenAI
- Traitement par lots, routage des modèles et tableaux de bord des coûts