BroadRouter

Mettre en cache les réponses d’API LLM : un cache exact en Python

Par l’équipe BroadNet Inference · 8 min de lecture · Publié

Hachez la requête complète (modèle, messages, temperature, max_tokens, response_format, outils, réglages de raisonnement et version de votre prompt) pour obtenir une clé, et stockez la réponse sous cette clé avec une expiration. Ne servez une réponse stockée que pour des requêtes déterministes et sans effet de bord. Mesurez d’abord dans vos journaux la fréquence des requêtes identiques : cette part est le maximum qu’un cache exact peut économiser.

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 liste messages complète (prompt système compris), temperature, top_p, max_tokens, seed, response_format, tools, tool_choice et reasoning_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 user que 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=1200 laisse 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, car finish_reason vaut alors length, pas stop.
  • 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 temperature absent 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 :

  1. 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.
  2. 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.
  3. 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.

Questions fréquentes

Quelle est la différence entre prompt caching et cache de réponses ?

Le prompt caching est assuré par le fournisseur : un préfixe de prompt répété est facturé au prix réduit de l’entrée en cache, et le modèle écrit tout de même une nouvelle réponse. Le cache de réponses est assuré par vous : vous stockez la réponse entière et la renvoyez pour une requête identique sans appeler le modèle du tout.

Faut-il mettre en cache les réponses LLM à temperature 0 ?

Oui, si la requête n’a pas d’effet de bord et que la même réponse convient à tous ceux qui l’envoient. De toute façon, temperature 0 ne garantit pas une sortie identique de la part d’un moteur de service : un cache rend donc aussi la réponse cohérente. Évitez le cache quand temperature est au-dessus de 0 ou absente.

Combien fait économiser le cache des réponses LLM ?

La part des requêtes qui sont des répétitions exactes dans votre fenêtre d’expiration, multipliée par le coût de ces requêtes. Comptez les empreintes de requêtes répétées dans vos propres journaux pour obtenir cette part. Elle peut être proche de zéro pour un chat ouvert et élevée pour des FAQ ou des entrées de classification fixes.

Le cache sémantique vaut-il mieux que le cache exact ?

Il fait mouche plus souvent, car des questions similaires correspondent, mais il peut renvoyer la réponse à une autre question. Il faut aussi un modèle d’embeddings et une base vectorielle. Commencez par un cache exact, et n’ajoutez une couche sémantique que là où un faux succès coûte peu.

Peut-on mettre en cache les réponses en streaming ?

Pas avec le wrapper simple présenté ici. Il faudrait collecter le stream complet, vérifier qu’il s’est terminé normalement, le stocker, puis le rejouer plus tard sous forme de stream. La plupart des équipes ne mettent en cache que les appels sans streaming, comme la classification, l’extraction et les réponses de FAQ.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity