---
title: "Cache des réponses LLM pour réduire le coût (Python, SQLite)"
description: "Un cache exact testé pour les réponses d’API LLM en Python : la clé, ce qu’il ne faut jamais cacher, TTL, confidentialité et mesure du taux de succès avant de coder."
url: https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/cache-llm-responses-cut-cost/) (mis à jour le 2026-11-15).

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

Par l’équipe BroadNet Inference · 8 min de lecture · Publié 2026-11-15

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.

## À retenir

-   Un cache exact économise tout l’appel, tokens de sortie et de raisonnement compris, mais seulement pour des requêtes identiques à l’octet près. Les questions reformulées le ratent toujours.
-   Mettez dans la clé chaque paramètre qui change la réponse, plus une version du prompt. En oublier un sert de mauvaises réponses ; ajouter du bruit comme un horodatage fait rater chaque requête.
-   Ne mettez pas en cache les réponses échantillonnées (temperature au-dessus de 0), les réponses en streaming, les appels d’outils ni les réponses tronquées à max\_tokens.
-   Mesurez d’abord : hachez chaque requête dans vos journaux d’usage et comptez les répétitions. Les économies publiées ailleurs ne disent rien de votre trafic.
-   Un cache stocke prompts et réponses. Si votre fournisseur ne conserve aucun contenu d’inférence, c’est désormais le cache qui le contient : donnez-lui un TTL et des règles d’accès.

**Sur cette page**

1.  Le cache de réponses est-il la même chose que le prompt caching ?
2.  Un cache vous fera-t-il vraiment économiser de l’argent ?
3.  Que mettre dans la clé de cache ?
4.  Le cache : SQLite, TTL et règle d’exclusion
5.  Qu’est-ce qui ne doit jamais être servi depuis un cache ?
6.  Quand les réponses en cache doivent-elles expirer ?
7.  Et le cache sémantique ?
8.  Qu’implique un cache pour la confidentialité ?
9.  Comment le cache s’articule-t-il avec les autres leviers de maîtrise des coûts ?
10.  La place de BroadNet Inference

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](https://broadrouter.com/fr/blog/cached-input-tokens-explained/) expliquent le côté fournisseur, et [structurer ses prompts pour le cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/) montre comment organiser un prompt pour que le préfixe soit réutilisé. Le [calculateur de prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) 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](https://broadrouter.com/fr/blog/llm-api-usage-logging/), 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 :

```python
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 :

```text
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](https://broadrouter.com/fr/models/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](https://broadrouter.com/tools/llm-api-cost-calculator/). 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

```python
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 :

```python
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](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)). 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](https://broadrouter.com/fr/glossary/tool-calling/) 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](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/).

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](https://broadrouter.com/fr/glossary/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](https://broadrouter.com/tools/embedding-cost-calculator/) 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](https://www.broadnet.ai/inference-privacy), 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](https://broadrouter.com/fr/blog/llm-api-sensitive-data/) 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](https://broadrouter.com/fr/blog/reduce-prompt-tokens/), 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](https://broadrouter.com/fr/blog/llm-api-spend-control/). 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](https://broadrouter.com/fr/blog/llm-batch-processing-without-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](https://broadrouter.com/fr/guides/openai-python-sdk/) 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](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-cache-llm-responses-cut-cost&utm_content=body). Les prix par modèle figurent sur la [page de prix](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-cache-llm-responses-cut-cost&utm_content=body).

Outils gratuits sur ce sujet (en anglais)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Embeddings (plongements vectoriels)](https://broadrouter.com/fr/glossary/embeddings/)

Les embeddings sont des listes de nombres à virgule flottante (des vecteurs) qu’un modèle produit pour représenter un texte, une image ou une autre entrée. Des entrées de sens proche obtiennent des vecteurs voisins : la distance entre vecteurs permet de classer des résultats de recherche, de regrouper des documents ou de trouver des éléments apparentés.

[Tokens d’entrée et de sortie](https://broadrouter.com/fr/glossary/input-and-output-tokens/)

Les tokens d’entrée sont les tokens qu’un modèle de langage lit dans une requête, dont le prompt système, l’historique de conversation, les définitions d’outils et les images. Les tokens de sortie sont ceux qu’il génère en réponse, raisonnement compris. Les API LLM les facturent généralement séparément, et la sortie coûte en général plus cher.

[Tokens d’entrée en cache (cached input tokens)](https://broadrouter.com/fr/glossary/cached-input-tokens/)

Les tokens d’entrée en cache sont des tokens de prompt qu’un fournisseur de LLM a traités récemment et peut réutiliser depuis un cache au lieu de les recalculer, en général un préfixe répété comme un prompt système ou un document. Les fournisseurs les facturent moins cher que les nouveaux tokens d’entrée.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[API batch (traitement par lots)](https://broadrouter.com/fr/glossary/batch-api/)

Une API batch est un endpoint LLM asynchrone qui accepte de nombreuses requêtes d’un coup, généralement sous forme de fichier, les traite dans une fenêtre définie plutôt qu’immédiatement et renvoie les résultats ensemble. Des fournisseurs comme OpenAI et Anthropic facturent les requêtes batch avec une remise par rapport à leurs API standard.

[API compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/)

Une API compatible OpenAI est une API HTTP qui accepte les mêmes formats de requête et de réponse que l’API OpenAI, comme POST /v1/chat/completions. Les SDK et outils OpenAI peuvent donc l’utiliser en changeant seulement l’URL de base, la clé d’API et le nom du modèle.

[Base de données vectorielle (vector database)](https://broadrouter.com/fr/glossary/vector-database/)

Une base de données vectorielle est un système de stockage qui conserve des vecteurs d’embedding, souvent avec leur texte source et des métadonnées, et répond aux requêtes de plus proches voisins : pour un vecteur de requête, elle renvoie les vecteurs stockés les plus similaires, en général selon la distance cosinus, la distance euclidienne ou le produit scalaire.

## 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 ensuite

-   [Tokens d’entrée en cache : réduire la facture d’une API LLM](https://broadrouter.com/fr/blog/cached-input-tokens-explained/)
-   [Structurer ses prompts pour que le préfixe soit mis en cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/)
-   [Maîtriser les dépenses d’API LLM : budgets, limites de clés, boucles](https://broadrouter.com/fr/blog/llm-api-spend-control/)
-   [Réduire les tokens du prompt : prompts, outils et données mesurés](https://broadrouter.com/fr/blog/reduce-prompt-tokens/)
-   [Journaliser l’usage d’une API LLM : coût par utilisateur, sans PII](https://broadrouter.com/fr/blog/llm-api-usage-logging/)
-   [Traitement par lots LLM sans Batch API : un exécuteur reprenable](https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Intégrer la relecture humaine à votre workflow d’IA documentaire](https://broadrouter.com/fr/blog/document-review-queues/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-cache-llm-responses-cut-cost&utm_content=page-cta) ·

**Sources**

-   [Référence de l’API de BroadNet Inference : le raisonnement compte dans max\_tokens, champs d’usage pour le raisonnement et les tokens en cache, limites du paiement à l’usage (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [Déclaration de confidentialité de BroadNet pour l’inférence : ni prompts, ni messages, ni réponses, ni transcriptions conservés ; enregistrements de trafic et d’usage sans contenu conservés (vérifiée le 2026-11-15) (en anglais)](https://www.broadnet.ai/inference-privacy)
-   [GPTCache sur GitHub : cache sémantique avec embeddings et évaluateur de similarité, faux positifs et faux négatifs, mode par mots-clés sans embeddings (vérifié le 2026-11-15)](https://github.com/zilliztech/GPTCache)
-   [Documentation de vLLM, Reproducibility : « vLLM does not guarantee the reproducibility of the results by default » (traduction : « vLLM ne garantit pas par défaut la reproductibilité des résultats ») (vérifiée le 2026-11-15)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Documentation de Python, module json : sort\_keys, separators et ensure\_ascii dans json.dumps (vérifiée le 2026-11-15)](https://docs.python.org/3/library/json.html)
