Chaque requête LLM identique que vous envoyez deux fois est payée deux fois. Un cache de réponses stocke la réponse la première fois et la renvoie la fois suivante, sans token facturé ni attente. L’idée est simple. Les difficultés : décider ce qui rend deux requêtes « identiques », quelles requêtes ne doivent jamais être servies depuis le stockage, et si votre trafic se répète assez pour que cela compte.
Cet article construit un petit cache exact en Python sur SQLite, testé contre un serveur factice compatible OpenAI, et montre comment mesurer le taux de succès à partir de vos journaux avant d’en écrire la moindre ligne.
Le cache de réponses est-il la même chose que le prompt caching ?
Non. Ils n’économisent pas la même chose, et vous pouvez utiliser les deux.
| Prompt caching (fournisseur) | Cache de réponses (vous) | |
|---|---|---|
| Ce qui est réutilisé | Le début répété du prompt | La réponse entière |
| Qui le gère | Le fournisseur de l’API | Votre code |
| Le modèle tourne-t-il quand même ? | Oui, il écrit une nouvelle réponse | Non |
| Ce que cela économise | Une partie du coût d’entrée | Tokens d’entrée, de sortie et de raisonnement, plus la latence |
| Quand il fait mouche | Préfixe commun, questions différentes | Exactement la même requête |
Les tokens d’entrée en cache expliquent le côté fournisseur, et structurer ses prompts pour le cache montre comment organiser un prompt pour que le préfixe soit réutilisé. Le calculateur de prompt caching le chiffre. Un cache de réponses se place devant tout cela : en cas de succès, aucune requête ne quitte votre serveur.
Un cache vous fera-t-il vraiment économiser de l’argent ?
Mesurez avant de construire. Les pourcentages d’économie de nombreux tutoriels sur le cache viennent du trafic de quelqu’un d’autre. Votre chiffre dépend d’une seule chose : la fréquence à laquelle la même requête revient dans votre fenêtre d’expiration.
Si vous journalisez déjà chaque appel, comme dans la journalisation de l’usage d’une API LLM, ajoutez un champ : request_hash, la clé de cache décrite plus bas. Il ne stocke aucun texte de prompt et convient donc à un journal qui exclut le contenu. Comptez ensuite les répétitions :
import json
from collections import Counter
def potential_hit_rate(log_path: str) -> float:
"""Share of calls whose request_hash was already seen: an upper bound for an exact cache."""
hashes = [json.loads(line)["request_hash"] for line in open(log_path)]
seen, repeats = set(), 0
for h in hashes:
repeats += h in seen
seen.add(h)
print("top repeated requests:", Counter(hashes).most_common(3))
return repeats / len(hashes) if hashes else 0.0
print(f"potential hit rate: {potential_hit_rate('calls.jsonl'):.1%}")
Sur un journal synthétique de 20 appels, avec une requête cinq fois, une autre trois fois et douze uniques, il a affiché un taux de succès potentiel de 30,0 %. C’est une borne supérieure : elle ignore l’expiration et suppose que chaque répétition peut être servie sans risque depuis le stockage.
Convertissez ensuite ce taux en argent :
monthly saving = hit rate × requests per month
× (input tokens × input price + output tokens × output price) ÷ 1,000,000
(Économie mensuelle = taux de succès × requêtes par mois × (tokens d’entrée × prix d’entrée + tokens de sortie × prix de sortie) ÷ 1 000 000.)
Les tokens de sortie incluent le raisonnement. La documentation de BroadNet indique que DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre et que le raisonnement compte dans max_tokens : un succès de cache économise donc des tokens que vous ne voyez jamais dans la réponse. Prenez completion_tokens dans l’usage journalisé, pas la longueur de la réponse.
Un exemple chiffré en tokens : 100 000 requêtes par mois de 1 200 tokens d’entrée et 150 de sortie chacune, avec un taux de succès de 30 %, évitent 36 millions de tokens d’entrée et 4,5 millions de tokens de sortie. Sur DeepSeek V4.1 Flash, ils sont facturés respectivement $0.175 et $0.52 par million ; saisissez vos propres chiffres dans le calculateur de coût d’API LLM. Si l’essentiel de cette entrée bénéficiait déjà du cache du fournisseur, l’économie sur l’entrée se calcule au tarif réduit du cache ($0.0055 par million sur le même modèle) : c’est donc souvent la sortie qui compte.
Que mettre dans la clé de cache ?
Tout ce qui peut changer la réponse, et rien d’autre.
- À inclure :
model, la listemessagescomplète (prompt système compris),temperature,top_p,max_tokens,seed,response_format,tools,tool_choiceetreasoning_effort. - Ajoutez une version de prompt que vous contrôlez, par exemple
faq-v3. Incrémentez-la quand vous modifiez des templates de prompt, des données de récupération ou un post-traitement que le corps de la requête ne montre pas. - À exclure : tout ce qui varie d’un appel à l’autre sans changer la réponse : ID de requête, horodatages, en-têtes de traçage, un champ
userque vous n’envoyez que pour la détection d’abus.
Sérialisez le contenu de la clé toujours de la même façon. json.dumps de Python avec sort_keys=True et separators=(",", ":") donne une chaîne canonique unique quel que soit l’ordre du dictionnaire ; ensure_ascii=False garde l’arabe et les autres écritures non latines en UTF-8 plutôt qu’en séquences d’échappement. Hachez le tout avec SHA-256.
Un champ manquant est l’erreur dangereuse. Si max_tokens n’est pas dans la clé, une réponse tronquée par une petite limite sera servie à une requête qui en autorisait une longue.
Le cache : SQLite, TTL et règle d’exclusion
import hashlib, json, sqlite3, time
# Every field that changes the answer belongs in the key.
KEY_FIELDS = ("model", "messages", "temperature", "top_p", "max_tokens", "seed",
"response_format", "tools", "tool_choice", "reasoning_effort")
def cache_key(params: dict, prompt_version: str) -> str:
material = {k: params[k] for k in KEY_FIELDS if k in params}
material["prompt_version"] = prompt_version
canon = json.dumps(material, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return hashlib.sha256(canon.encode("utf-8")).hexdigest()
class ResponseCache:
def __init__(self, path="llm_cache.sqlite", ttl_s=7 * 86400):
self.db, self.ttl = sqlite3.connect(path), ttl_s
self.db.execute("CREATE TABLE IF NOT EXISTS cache (k TEXT PRIMARY KEY, created REAL,"
" body TEXT, prompt_tokens INT, completion_tokens INT)")
self.hits = self.misses = self.skips = self.saved_in = self.saved_out = 0
def create(self, client, prompt_version: str, **params):
if params.get("stream") or params.get("temperature", 1) > 0:
self.skips += 1 # not cacheable: call the model directly
return client.chat.completions.create(**params)
k = cache_key(params, prompt_version)
row = self.db.execute("SELECT body, created, prompt_tokens, completion_tokens"
" FROM cache WHERE k = ?", (k,)).fetchone()
if row and time.time() - row[1] < self.ttl:
self.hits += 1; self.saved_in += row[2]; self.saved_out += row[3]
return json.loads(row[0]) # a plain dict, not an SDK object
self.misses += 1
r = client.chat.completions.create(**params)
choice = r.choices[0]
if choice.finish_reason == "stop" and not choice.message.tool_calls:
self.db.execute("INSERT OR REPLACE INTO cache VALUES (?, ?, ?, ?, ?)",
(k, time.time(), r.model_dump_json(),
r.usage.prompt_tokens, r.usage.completion_tokens))
self.db.commit()
return r.model_dump()
Et une exécution :
import os
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
cache = ResponseCache("demo.sqlite", ttl_s=86400)
SYSTEM = {"role": "system", "content": "Answer questions about our refund policy in one sentence."}
questions = ["How long do refunds take?", "Can I refund a gift card?",
"How long do refunds take?", "How long do refunds take?", "Can I refund a gift card?"]
for q in questions:
r = cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": q}])
print(r["choices"][0]["message"]["content"])
# a personalised, sampled request is never cached
cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0.7,
messages=[SYSTEM, {"role": "user", "content": "Write me a friendly reminder"}])
# a new prompt version is a new key
cache.create(client, "faq-v4", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": "How long do refunds take?"}])
print(f"hits={cache.hits} misses={cache.misses} skipped={cache.skips} "
f"saved_input={cache.saved_in} saved_output={cache.saved_out}")
Nous l’avons exécuté avec le SDK Python d’OpenAI 3.51.0 contre un serveur factice local qui comptait les appels en amont et indiquait 1 200 tokens de prompt et 150 de complétion par réponse (aucun appel à l’API réelle). Sept requêtes ont produit quatre appels en amont. Le script a affiché hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450. Relancées sur le même fichier de base de données, les six requêtes cachables ont toutes été des succès (hits=6 misses=0) : SQLite conserve le cache entre les redémarrages. Des clés construites à partir des mêmes champs dans un ordre différent correspondaient.
Remarques sur le code :
max_tokens=1200laisse de la place au raisonnement avant la réponse. Avec une petite limite, un modèle de raisonnement peut renvoyer une réponse vide (pourquoi). Ces réponses ne sont pas stockées, carfinish_reasonvaut alorslength, passtop.- Les succès renvoient un dict. Les échecs renvoient aussi
model_dump(): les appelants voient donc une seule forme. Si votre code attend des objets du SDK, enveloppez les deux. - Un
temperatureabsent compte comme échantillonné. Le serveur applique alors sa propre valeur par défaut, qui peut être supérieure à 0 : le wrapper ne met donc en cache que si vous réglez explicitement 0. - SQLite convient à un processus ou à quelques-uns. Pour plusieurs serveurs, placez la même logique de clé et de TTL dans Redis ou dans votre base de données.
Qu’est-ce qui ne doit jamais être servi depuis un cache ?
- Les réponses échantillonnées (temperature au-dessus de 0). Vous avez choisi la variété. Le cache la supprime, et l’utilisateur qui clique sur « régénérer » obtient le même texte.
- Les réponses personnalisées, sauf si l’ID de l’utilisateur est dans la clé. Deux utilisateurs qui envoient « résume mon compte » n’ont pas le même compte. Mieux : ne mettez en cache que les requêtes dont les messages ne contiennent aucune donnée propre à un utilisateur.
- Les appels d’outils. Un appel d’outil est une instruction d’agir. Rejouer « rembourser la commande 1182 » depuis le stockage peut répéter un effet de bord, et la bonne étape suivante dépend de l’état actuel. Le wrapper refuse de stocker toute réponse contenant
tool_calls. - Les réponses en streaming. Le wrapper contourne le cache pour
stream=True. Mettre un stream en cache implique de le mettre en mémoire tampon, de vérifier qu’il s’est terminé et de le rejouer, ce qui en vaut rarement la peine pour les interfaces de chat. - Les réponses tronquées ou en échec. Ne stockez que
finish_reason == "stop". Une réponse coupée ou une erreur mise en cache pendant une semaine est un bug qui ressemble à un problème de modèle. - Les réponses qui dépendent du moment. « Quel est le taux de change aujourd’hui ? » demande un TTL court ou pas de cache du tout.
Ce qui se met bien en cache : la classification d’un ensemble fixe d’entrées, l’extraction sur des documents que vous retraitez, les réponses de FAQ issues d’un prompt fixe, les suites de tests et les évaluations que vous relancez, et les boucles de développement où vous envoyez la même requête encore et encore.
Quand les réponses en cache doivent-elles expirer ?
Utilisez trois formes d’invalidation :
- TTL. Une durée de vie par entrée : des jours pour des réponses de FAQ stables, des minutes pour tout ce qui lit des données en direct.
- Version dans la clé. Changez la version du prompt quand le prompt système, l’index de récupération ou le schéma de sortie change. Les anciennes entrées cessent de correspondre et expirent.
- Modèle dans la clé. Il y figure déjà : passer d’un modèle à un autre démarre donc un cache neuf, ce qui est souhaitable pendant que vous évaluez un changement.
Supprimez les lignes expirées de façon planifiée (DELETE FROM cache WHERE created < ?). Sinon, le fichier ne fait que grossir.
Il y a un avantage secondaire. Les moteurs de service ne promettent pas une sortie identique pour une entrée identique : la documentation de vLLM indique qu’il « does not guarantee the reproducibility of the results by default » (traduction : « ne garantit pas par défaut la reproductibilité des résultats »). Un cache donne à chaque utilisateur la même réponse à la même question pendant toute la durée de vie de l’entrée.
Et le cache sémantique ?
Un cache sémantique calcule un embedding pour chaque question et renvoie une réponse stockée quand une nouvelle question est suffisamment proche : « combien de temps prend un remboursement ? » peut ainsi correspondre à « quel est le délai des remboursements ? ». GPTCache en est l’exemple open source le plus connu. Son README indique qu’il utilise une base vectorielle pour la recherche de similarité et un évaluateur de similarité pour décider d’un succès, prévient que « you may encounter false positives during cache hits and false negatives during cache misses » (traduction : « vous pouvez rencontrer des faux positifs lors des succès de cache et des faux négatifs lors des échecs ») et précise que désactiver les embeddings le transforme en cache par mots-clés.
Deux points pratiques. D’abord, il faut un modèle d’embeddings et une base vectorielle. BroadNet Inference ne propose pas d’embeddings : vous utiliseriez donc un autre fournisseur ou un modèle local pour cette couche ; le calculateur de coût des embeddings chiffre les options. Ensuite, un faux succès renvoie une réponse assurée à une autre question. Utilisez un seuil de similarité strict, testez-le sur de vraies paires de questions presque identiques et réservez le cache sémantique aux réponses à faible enjeu. Dans tous les cas, placez le cache exact devant : le vérifier ne coûte rien, et il ne se trompe jamais sur ce qui a été demandé.
Qu’implique un cache pour la confidentialité ?
Un cache est un stockage de prompts et de réponses. Cela change l’endroit où vivent vos données.
La déclaration de confidentialité de BroadNet pour l’inférence, vérifiée le 15/11/2026, indique que sa passerelle ne conserve ni prompts, ni messages, ni réponses, ni transcriptions, tandis que les enregistrements de trafic et d’usage sans contenu (nombre de tokens, coût, durées) sont conservés. Le contenu d’inférence n’est pas conservé. Les métadonnées nécessaires de compte, de facturation et de sécurité sont conservées comme le décrit cette déclaration. Dès que vous ajoutez un cache de réponses, votre système détient le contenu que le fournisseur ne garde pas. Traitez-le comme n’importe quel autre stockage de données utilisateur :
- Ne mettez en cache, si possible, que des requêtes sans données personnelles, ce qui augmente aussi le taux de succès.
- Fixez un TTL assez court pour votre politique de conservation, et supprimez de façon planifiée.
- Chiffrez le fichier ou la table au repos et limitez qui peut les lire.
- Incluez le cache dans les demandes de suppression de données s’il peut contenir du texte utilisateur.
Envoyer des données sensibles à une API LLM couvre le reste de cette checklist.
Comment le cache s’articule-t-il avec les autres leviers de maîtrise des coûts ?
Le cache supprime les appels répétés. Il ne fait rien pour les appels uniques : il vient donc s’ajouter aux autres leviers plutôt que les remplacer, à savoir des prompts plus courts, le prompt caching du fournisseur, un plafond max_tokens par requête, ainsi que les budgets et limites de boucle décrits dans la maîtrise des dépenses d’API LLM. Pour les gros travaux ponctuels, dédupliquez les entrées avant de les envoyer : c’est la même idée qu’un cache, appliquée une seule fois. Traiter un gros travail sans Batch API montre le côté traitement.
Avec un forfait, le calcul change. Les sessions DeepSeek de BroadNet n’ont pas de compteur de tokens : un succès de cache n’y fait donc pas économiser d’argent. Il fait quand même gagner du temps : une session traite une requête à la fois, donc chaque répétition évitée libère la session pour du nouveau travail.
La place de BroadNet Inference
BroadRouter est le site web de BroadNet. BroadNet Inference propose DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B et Gemma 4 VL 26B derrière un endpoint /v1/chat/completions compatible OpenAI : le wrapper ci-dessus fonctionne donc avec le SDK Python d’OpenAI en changeant l’URL de base. Il n’a pas de fonction de cache de réponses à lui ; le cache de cet article est le vôtre. Les succès du cache côté fournisseur sont indiqués dans usage.prompt_tokens_details.cached_tokens et facturés au prix de l’entrée en cache, selon sa référence de l’API. Les prix par modèle figurent sur la page de prix.
