Guide de mise en cache des prompts GPT-6 Astra : Comment réduire les coûts de contexte répétés

Les prompts d'agents longs répètent souvent la même politique système, les définitions d'outils, la documentation produit, les exemples et l'historique de conversation. Renvoyer ce matériel est parfois inévitable ; payer le coût complet d'entrée et la latence pour un préfixe identique ne l'est pas. GPT-6 Astra prend en charge la mise en cache des prompts dans l'API Responses afin que les préfixes répétés puissent être réutilisés.

La mise en cache est une optimisation, pas une mémoire. Elle ne permet pas à un modèle de se souvenir d'un client entre les requêtes et ne modifie pas ce que le modèle voit. La requête a toujours besoin de l'entrée pertinente. La différence est qu'un préfixe identique et éligible peut être servi depuis le cache à un tarif d'entrée mise en cache inférieur.

Ce que GPT-6 Astra met en cache

Le cache est basé sur le préfixe. OpenAI peut réutiliser les tokens du début d'une invite lorsque la requête suivante commence par un contenu correspondant. Un modèle mental utile est celui d'un document dont les chapitres stables viennent en premier et dont l'annexe spécifique à la requête vient en dernier.

Mettez ceux-ci près de l'avant :

• instructions stables pour développeurs ;
• les schémas d'outils dans un ordre stable ;
• documents de référence longs utilisés dans plusieurs requêtes ;
• exemples canoniques et règles de sortie.

Placez-les près de la fin :

• le message actuel de l'utilisateur ;
• horodatages, identifiants de requête et état temporaire ;
• passages récupérés qui changent à chaque appel ;
• préférences par utilisateur qui ne sont pas partagées.

Un timestamp inséré près du haut peut invalider tout ce qui suit. De même, générer des tableaux d'outils à partir d'une map non ordonnée peut produire des préfixes sémantiquement identiques mais différents au niveau des octets. Construisez les prompts de manière déterministe.

Mise en cache implicite et explicite

GPT-5.6 et les modèles ultérieurs exposent prompt_cache_options. En mode implicite, le service identifie automatiquement un point de rupture réutilisable. C'est le point de départ le plus simple et il convient lorsque votre prompt possède un préfixe large et stable.

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  prompt_cache_key: "support-agent:v4",
  prompt_cache_options : { mode : "implicite", ttl : "30m" },
  input: [
    { role: "developer", content: "Politique stable et instructions d'exploitation..." },
    { role: "user", content: "Pourquoi ma facture a-t-elle été dupliquée ?" }
  ]
});

La valeur TTL actuellement documentée est 30m, et 30 minutes est la valeur par défaut. Ne concevez pas autour de durées non documentées. OpenAI marque également l'ancien champ prompt_cache_retention comme obsolète.

Le mode explicite donne à l'application plus de contrôle. Vous ajoutez des éléments de contenu prompt_cache_breakpoint aux limites qu'il vaut la peine de préserver. Cela est utile lorsqu'une invite est assemblée à partir de plusieurs blocs stables suivis de matériel volatile. Une requête peut écrire au maximum quatre points de rupture, et le service prend en compte jusqu'aux 80 derniers points de rupture. Plus de points de rupture ne sont pas automatiquement meilleurs : chaque écriture a un coût, et les préfixes fragmentés peuvent être plus difficiles à raisonner.

Une architecture de préfixe pratique

Pour un agent de production, utilisez quatre couches :

1. Identité et sécurité

Placez d'abord le rôle durable, les contraintes de sécurité et le contrat de réponse. Versionnez ce bloc délibérément. Une modification de politique doit créer une nouvelle clé de cache au lieu de mélanger silencieusement les mesures de deux versions.

2. Définitions des outils

Les schémas d'outils sont souvent volumineux et répétés. Gardez les noms, les descriptions, les propriétés et l'ordre stables. Supprimez les outils inutilisés lorsque c'est possible ; cela réduit à la fois le contexte non mis en cache et mis en cache, et diminue l'ambiguïté de sélection des outils.

3. Connaissances partagées

Ajoutez des manuels durables, des taxonomies, des guides de style ou de la documentation produit. Si les connaissances changent fréquemment, la recherche de fichiers peut être préférable à leur intégration dans chaque prompt. Mettez en cache les connaissances opérationnelles stables ; récupérez les faits changeants.

4. État de requête dynamique

Ajoutez l’entrée utilisateur, les enregistrements actuels, les résultats de recherche en direct et l’état temporaire. Ce placement protège le préfixe réutilisable des modifications courantes.

Pour un flux de travail créatif, la couche stable pourrait contenir les règles de production d'animation et un style maison, tandis que la queue dynamique contient la scène actuelle. Une plateforme comme Elser AI pourrait appliquer le même principe à un contexte répété de bible narrative ou de cohérence des personnages sans sous-entendre que la mise en cache elle-même crée la cohérence.

Mesurez les économies au lieu de les supposer

Inspectez usage.input_tokens_details.cached_tokens et cache_write_tokens. Un nombre élevé de jetons en cache indique qu'une partie du préfixe a été réutilisée. Les jetons d'écriture en cache révèlent le coût de la création ou de l'actualisation des entrées.

Pour GPT-6 Astra, la tarification du modèle publiée à la date de vérification liste l'entrée en cache en dessous de l'entrée normale et les écritures de cache au-dessus de l'entrée normale. Cela soulève une question de seuil de rentabilité : un préfixe réutilisé de manière répétée peut faire économiser de l'argent ; un préfixe écrit une fois et jamais réutilisé peut coûter plus cher. La tarification change, calculez donc avec la page actuelle du modèle plutôt que d'intégrer des nombres dans des feuilles de planification.

Suivez au moins :

• taux de succès du cache par version de prompt ;
• jetons d'entrée mis en cache, écrits et totaux ;
• p50 et p95 du temps jusqu'au premier jeton ;
• coût par tâche terminée, et non simplement par requête ;
• échecs de cache causés par les versions.

Un tableau de bord regroupé uniquement par modèle masque la cause des échecs. Incluez une clé de cache ou une dimension de version d’invite dans votre propre télémétrie, mais ne mettez jamais de données personnelles ou de secrets dans les clés de cache.

Sept causes courantes d'échec de cache

Le contenu dynamique apparaît trop tôt

Déplacez les dates, les identifiants utilisateur et le matériel récupéré après le contenu réutilisable.

L'ordre de changement des schémas d'outils

Trier les outils et les propriétés de schéma de manière déterministe lors de l'étape de construction de l'application.

Les prompts sont « équivalents » mais pas identiques

Les espaces, les exemples ou la sérialisation peuvent différer. Générez des blocs partagés à partir d'artefacts versionnés plutôt que de chaînes ad hoc.

Le préfixe est trop court

La longueur minimale pouvant être mise en cache varie selon le modèle. Les invites très courtes peuvent ne pas en bénéficier. Confirmez via les données d'utilisation.

Le compactage a modifié le préfixe

La compaction aide à intégrer les longues conversations mais produit une représentation de contexte différente. Attendez-vous à ce que les schémas de réutilisation changent après la compaction et mesurez autour des limites des jalons.

Trop de points d'arrêt de faible valeur

Les points d'arrêt doivent correspondre à des couches réutilisables significatives. Quatre écritures autorisées sont un plafond, pas un objectif.

Une clé de cache est trop large ou trop étroite

Une clé unique pour chaque workflow sans lien produit un regroupement faible ; une clé unique par requête empêche la réutilisation. Privilégiez une clé sémantique telle que legal-review:v3:us.

Un plan de déploiement sécurisé

Commencez avec le mode implicite sur un flux de travail à volume élevé. Stabilisez la construction des invites, enregistrez les détails des jetons et comparez deux semaines de coûts et de latence. Ensuite, envisagez des points d'arrêt explicites si l'invite comporte plusieurs couches réutilisables ou des fins dynamiques fréquentes. Évaluez la qualité en parallèle des économies : une suppression agressive du contexte n'est pas une mise en cache et peut réduire la qualité des réponses.

Ne mettez en cache que le contenu que vous êtes déjà autorisé à envoyer à l'API. La mise en cache ne remplace pas la classification des données, l'isolation des locataires, les contrôles d'accès ou les décisions de conservation. Gardez les secrets hors des invites chaque fois qu'un outil peut les récupérer juste à temps.

FAQ

La mise en cache des prompts réduit-elle le coût des jetons de sortie ?

Non. Cela s'applique aux entrées répétées éligibles. La sortie est générée normalement et facturée au tarif de sortie.

Est-ce que previous_response_id rend les tours précédents gratuits ?

Non. OpenAI indique que les jetons d'entrée antérieurs dans une chaîne de réponse sont toujours facturés comme entrée. La mise en cache des invites peut réduire le coût des préfixes répétés éligibles, mais l'enchaînement des conversations et la mise en cache sont des mécanismes distincts.

Dois-je mettre en cache les résultats de recherche récupérés ?

Uniquement lorsqu'ils sont stables et réellement réutilisés. Les résultats en direct appartiennent normalement à la queue dynamique. Pour les corpus contrôlés, la recherche de fichiers peut éviter d'intégrer une collection entière dans chaque prompt.

Puis-je compter sur un cache hit ?

Traitez la mise en cache comme une optimisation opportuniste. Votre application doit rester correcte en cas d'absence.

Conclusion

La stratégie de mise en cache la plus performante pour GPT-6 Astra est architecturale : instructions et outils stables en premier, état volatile en dernier, sérialisation déterministe, versionnement délibéré et mesure via les détails des jetons. Commencez par une mise en cache implicite, ajoutez des points d'arrêt explicites uniquement lorsque les données les justifient, et optimisez le coût par tâche réussie plutôt que de chercher à atteindre un