---
title: "Structure de prompt pour le cache : un préfixe stable"
description: "Organiser un prompt LLM pour garder le préfixe en cache identique : prompt système, schémas d’outils, documents, historique en ajout seul, et un test qui le prouve."
url: https://broadrouter.com/fr/blog/prompt-structure-for-caching/
lang: fr
updated: 2026-11-14
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/prompt-structure-for-caching/) (mis à jour le 2026-11-16).

# Structurer ses prompts pour que le préfixe soit mis en cache

Par l’équipe BroadNet Inference · 4 min de lecture · Publié 2026-11-14 · Mis à jour 2026-11-16

Ordonnez chaque requête du plus stable au moins stable : prompt système, définitions d’outils, documents de référence, historique de conversation, puis le nouveau message. Rendez chaque couche identique à l’octet près d’un appel à l’autre : pas d’horodatage ni d’ID en tête, outils triés, JSON sérialisé de façon déterministe et historique uniquement complété. Mesurez ensuite cached\_tokens pour confirmer que le préfixe est bien réutilisé.

## À retenir

-   Les caches comparent un préfixe exact. Un seul octet modifié invalide tout ce qui suit : l’ordre des couches compte donc plus que leur taille.
-   Quatre couches, la plus stable en premier : prompt système, outils, documents, historique. Le nouveau message utilisateur vient en dernier.
-   Sérialisez outils et documents JSON avec des clés triées et des séparateurs fixes ; l’ordre des dictionnaires casse le cache en silence.
-   Restreignez les outils par appel avec tool\_choice au lieu de retirer des définitions d’outils.
-   Testez : envoyez deux fois le même préfixe et vérifiez que prompt\_tokens\_details.cached\_tokens augmente au second appel.

**Sur cette page**

1.  Pourquoi l’ordre du prompt détermine-t-il le taux de succès du cache ?
2.  Quel est le bon ordre des couches ?
3.  Qu’est-ce qui casse le préfixe sans que vous le remarquiez ?
4.  Comment construire une requête favorable au cache dans le code ?
5.  Comment prouver que le préfixe est en cache ?
6.  Qu’est-ce qui change pour les agents et le contexte long ?
7.  La place de BroadNet Inference

Les [tokens d’entrée en cache](https://broadrouter.com/fr/glossary/cached-input-tokens/) coûtent peu : chez BroadNet Inference, DeepSeek V4.1 Flash les facture $0.0055 par million au lieu de $0.175. L’[explication des tokens en cache](https://broadrouter.com/fr/blog/cached-input-tokens-explained/) couvre le prix et la lecture du champ usage. Cet article porte sur la conception : comment organiser un prompt pour que le cache fasse vraiment mouche, et comment le prouver.

## Pourquoi l’ordre du prompt détermine-t-il le taux de succès du cache ?

Tous les grands fournisseurs mettent en cache par **préfixe**. Le guide d’OpenAI indique que la réutilisation exige que tout le préfixe rendu corresponde. La documentation de DeepSeek décrit la même règle : une requête n’obtient un succès que si elle correspond entièrement à un préfixe stocké, et une requête qui diverge en cours de route n’en obtient pas. Anthropic construit son cache dans l’ordre outils, système, messages.

En coulisses, le serveur réutilise le [cache KV](https://broadrouter.com/fr/glossary/kv-cache/) qu’il a construit pour ce préfixe. Le cache est donc une ligne droite à partir du premier token. Le premier octet qui diffère de l’appel précédent met fin à la partie réutilisable. Un horodatage d’une ligne en tête d’un prompt de 50 000 tokens vous fait payer les 50 000 tokens au plein tarif.

## Quel est le bon ordre des couches ?

| Couche | Change | Exemple | Règle |
| --- | --- | --- | --- |
| 1\. Prompt système | À chaque déploiement | Rôle, règles, format de sortie | Pas de dates, d’ID ni de noms d’utilisateur |
| 2\. Définitions d’outils | À chaque déploiement | Schémas de fonctions | JSON trié et déterministe |
| 3\. Documents de référence | Par session ou par tâche | Fichiers du dépôt, contrats, documentation produit | Ordre fixe, libellés stables |
| 4\. Historique de conversation | À chaque tour, en ajout seul | Tours précédents de l’utilisateur et de l’assistant | Ne jamais modifier ; seulement ajouter |
| 5\. Nouveau message | À chaque appel | La question, plus l’heure actuelle si besoin | Les données variables vont ici |

La couche 5 accueille tout ce qui varie : la date du jour, la locale de l’utilisateur, un ID de requête, les extraits récupérés qui changent selon la question.

## Qu’est-ce qui casse le préfixe sans que vous le remarquiez ?

1.  **L’ordre des dictionnaires.** Les frameworks construisent souvent le tableau `tools` à partir d’un dict ou d’un registre. Si les plugins se chargent dans un autre ordre, les octets changent.
2.  **Le formatage JSON.** `json.dumps(x)` et `json.dumps(x, indent=2)` sont des préfixes différents. Tout comme deux sérialiseurs avec des ordres de clés différents.
3.  **Les espaces du template.** Une espace en fin de ligne, ou un `\r\n` venant d’un chemin de code et un `\n` d’un autre.
4.  **Les listes d’outils dynamiques.** Retirer les outils qu’un utilisateur ne peut pas utiliser change le préfixe. Le guide d’OpenAI recommande de garder les définitions stables et de restreindre l’usage avec `tool_choice` ou un réglage d’outils autorisés.
5.  **Résumer l’historique sur place.** Réécrire d’anciens tours en résumé réinitialise tout ce qui suit le prompt système. Résumez rarement et par grandes étapes.
6.  **La récupération avant les instructions.** Des extraits RAG placés entre le prompt système et les outils changent à chaque requête et cassent aussi la couche des outils.

## Comment construire une requête favorable au cache dans le code ?

Faites dépendre chaque couche uniquement d’entrées stables, et sérialisez de façon déterministe :

```python
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

SYSTEM = open("prompts/system.md").read()  # versioned file, no templating

def stable_tools(registry: dict) -> list:
    # Sort by name, sort keys inside each schema.
    return [json.loads(json.dumps(registry[name], sort_keys=True)) for name in sorted(registry)]

def docs_block(paths: list[str]) -> str:
    parts = [f"=== {p} ===\n{open(p).read()}" for p in sorted(paths)]
    return "\n\n".join(parts)

def build_messages(history: list, user_text: str, now_iso: str, doc_paths: list[str]):
    return (
        [{"role": "system", "content": SYSTEM},
         {"role": "user", "content": docs_block(doc_paths)}]
        + history                                   # append-only
        + [{"role": "user", "content": f"(now: {now_iso})\n{user_text}"}]
    )

resp = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",
    messages=build_messages(history, question, now_iso, files),
    tools=stable_tools(TOOLS),
)
history += [{"role": "user", "content": question}, resp.choices[0].message.model_dump(exclude_none=True)]
```

Deux détails. L’heure actuelle va dans le dernier message, pas dans le prompt système. Et l’historique stocke le message de l’assistant exactement tel qu’il a été renvoyé, pour que l’appel suivant renvoie des octets identiques.

## Comment prouver que le préfixe est en cache ?

Lancez un test à deux appels dans la CI ou dans un notebook :

1.  Construisez une requête avec votre vrai prompt système, vos outils et vos documents.
2.  Envoyez-la. Notez `usage.prompt_tokens`.
3.  Modifiez uniquement le dernier message utilisateur et renvoyez.
4.  Lisez `usage.prompt_tokens_details.cached_tokens` au second appel. La valeur devrait couvrir presque tout le préfixe commun.
5.  Si elle est nulle ou faible, comparez octet par octet les corps de requête sérialisés. La première différence est ce qui casse votre cache.

Chez la plupart des fournisseurs, le cache fonctionne au mieux (best effort), et la documentation de DeepSeek le dit explicitement : un échec isolé ne prouve donc pas un bug. Un échec systématique, si. Suivez le ratio tokens en cache / tokens de prompt par requête dans vos [journaux d’usage](https://broadrouter.com/fr/blog/llm-api-usage-logging/), et utilisez le [calculateur de prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) pour voir ce qu’un meilleur taux de succès fait économiser.

## Qu’est-ce qui change pour les agents et le contexte long ?

Les agents en profitent le plus, car ils renvoient le même gros préfixe des dizaines de fois par tâche. Deux habitudes comptent :

-   **Une conversation par tâche.** Démarrer une nouvelle conversation pour chaque sous-étape jette le préfixe.
-   **Lire les fichiers une fois, près du début.** Si l’agent relit un fichier, ajoutez la nouvelle copie au lieu de remplacer l’ancienne, sauf si le fichier a changé.

Avec une [fenêtre de contexte de 1 M de tokens](https://broadrouter.com/fr/blog/million-token-context-window-guide/), la couche 3 peut contenir un dépôt entier. Avec une clé facturée au token, ce n’est abordable que si cela passe par le cache : c’est pourquoi l’ordre des couches compte davantage à mesure que les prompts grossissent. Les préfixes en cache réduisent aussi souvent le délai avant le premier token ; voir [TTFT ou débit](https://broadrouter.com/fr/blog/llm-latency-ttft-throughput/).

## La place de BroadNet Inference

Chez BroadNet Inference, le bloc usage indique `prompt_tokens_details.cached_tokens` quand le modèle le renvoie, et l’entrée en cache sur [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) et [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) est facturée au tarif réduit indiqué sur la [page de prix](https://broadrouter.com/fr/pricing/). Sa documentation ne propose ni points de rupture de cache explicites ni paramètre de clé de cache : l’organisation ci-dessus constitue donc toute la technique. Avec un forfait illimité, le cache ne change pas la facture, car les sessions n’ont pas de compteur de tokens, mais la même structure aide toujours la latence.

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.

[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.

[Prompt système (system prompt)](https://broadrouter.com/fr/glossary/system-prompt/)

Le prompt système est le texte d’instructions qu’une application envoie à un modèle de langage avant la conversation, généralement sous forme de message au rôle system ou developer. Il fixe le rôle, les règles, le ton et le format de sortie du modèle, qui est censé le suivre même face à des messages contradictoires de l’utilisateur.

[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.

[Time to first token (TTFT)](https://broadrouter.com/fr/glossary/time-to-first-token/)

Le time to first token (TTFT) est le temps écoulé entre l’envoi d’une requête à un modèle de langage et l’arrivée du premier token de sortie. Il comprend le temps réseau, la file d’attente côté serveur et le prefill, où le modèle lit tout le prompt : il augmente donc avec la longueur du prompt et la charge.

[Cache KV (KV cache)](https://broadrouter.com/fr/glossary/kv-cache/)

Le cache KV est la mémoire où un modèle de langage transformer stocke les clés et les valeurs d’attention calculées pour chaque token déjà traité, afin que chaque nouveau token les réutilise au lieu de recalculer toute la séquence. Il grossit avec la longueur du contexte et limite souvent le nombre de requêtes qu’un GPU peut servir.

[Débit (throughput)](https://broadrouter.com/fr/glossary/throughput/)

Le débit (throughput), dans le service de LLM, est la quantité totale de travail qu’un système accomplit par unité de temps sur toutes les requêtes simultanées, généralement mesurée en tokens de sortie par seconde ou en requêtes par seconde. Il se distingue de la vitesse par flux, c’est-à-dire la vitesse à laquelle une seule requête reçoit ses tokens.

[Fenêtre de contexte (context window)](https://broadrouter.com/fr/glossary/context-window/)

La fenêtre de contexte est le nombre maximal de tokens qu’un modèle de langage peut traiter dans une seule requête. Elle couvre le prompt, l’historique de conversation, les définitions d’outils, les images et la sortie générée, tokens de raisonnement compris. Ce qui ne tient pas doit être coupé, résumé ou réparti sur plusieurs requêtes.

## Questions fréquentes

### Pourquoi le taux de succès de mon cache de prompt est-il faible ?

Quelque chose au début du prompt change à chaque appel. Les causes habituelles sont un horodatage ou un ID de requête dans le prompt système, des outils sérialisés dans un ordre différent, des documents récupérés placés avant les instructions, ou un historique résumé et réécrit.

### La question de l’utilisateur doit-elle venir avant ou après les longs documents ?

Après. Placez les documents en premier et la question en dernier. Les documents forment alors un préfixe réutilisable, et beaucoup de modèles répondent aussi mieux quand la question suit le contenu.

### Les définitions d’outils cassent-elles le prompt caching ?

Seulement si elles changent. Les outils font partie du préfixe : gardez le même ensemble, dans le même ordre, avec le même JSON. Pour limiter les outils sur un appel, utilisez tool\_choice plutôt que de modifier la liste.

### L’ordre des exemples few-shot compte-t-il pour le cache ?

Oui. Des exemples mélangés produisent un préfixe différent à chaque fois. Fixez l’ordre, ou placez les exemples qui changent selon la requête après la partie stable.

## À 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/)
-   [Quand une fenêtre de contexte de 1M de tokens vaut le coup (ou pas)](https://broadrouter.com/fr/blog/million-token-context-window-guide/)
-   [API LLM : forfait ou paiement au token ? Le calcul de rentabilité](https://broadrouter.com/fr/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Streamer des chat completions et gérer les connexions coupées](https://broadrouter.com/fr/guides/streaming-chat-completions/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)

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-prompt-structure-for-caching&utm_content=page-cta) ·

**Sources**

-   [Référence de l’API de BroadNet Inference, tokens en cache dans usage (vérifiée le 2026-11-16) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-prompt-structure-for-caching&utm_content=sources)
-   [Guide du prompt caching d’OpenAI, correspondance de préfixe et conseils de structure (consulté le 2026-11-14)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Documentation du prompt caching d’Anthropic, ordre du cache : outils, puis système, puis messages (consultée le 2026-11-16)](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
-   [Documentation de l’API DeepSeek, context caching (consultée le 2026-11-14)](https://api-docs.deepseek.com/guides/kv_cache)
