Prompt caching: Berekeningen hergebruiken
Op deze pagina
Wat is prompt caching?
Wanneer u herhaaldelijk hetzelfde prompt-voorvoegsel verzendt—een lange systeemprompt, gedetailleerde instructies of een referentiedocument—kan OpenAI dit voorvoegsel automatisch cachen. Daaropvolgende oproepen die dit voorvoegsel delen, profiteren van een verkorte tijd tot de eerste token (TTFT) en lagere kosten voor invoertokens. Met andere woorden: het werk om de stabiele context te verwerken, hoeft niet bij elk verzoek opnieuw te worden gedaan.
Prompt caching is sinds 2025 automatisch: u hoeft niets in te schakelen. OpenAI detecteert identieke voorvoegsels en cachet deze. Uw hefboomwerking ligt er daarom niet in om het aan of uit te zetten, maar in het zo schrijven van uw prompts dat het mechanisme kan worden toegepast. Dit is een kwestie van structuur, niet van configuratie, en hier laten de meeste teams geld liggen.
Hoe het werkt
De cache geldt voor prompt-voorvoegsels: de eerste tokens moeten van oproep tot oproep strikt identiek zijn, en de overeenkomst stopt bij het eerste afwijkende teken. Er is een minimumgrootte van 1.024 tokens vereist om caching te activeren, wat korte systeemprompts direct uitsluit. De cache wordt gedeeld binnen één organisatie; meerdere services in uw bedrijf die hetzelfde voorvoegsel aanroepen, helpen elkaar dus. De levensduur varieert van enkele minuten tot enkele uren, zonder harde garantie, en de behaalde besparing bedraagt ongeveer 50% op de kosten van de gecachete invoertokens.
Het praktische gevolg van de regel voor voorvoegsels is dat u stabiele elementen aan het begin van de prompt moet plaatsen en variabele elementen aan het einde. Een service die de datum van vandaag of een sessie-ID aan het begin van de systeemprompt invoegt, ongeldig verklaart de cache bij elke oproep zonder het zelf te beseffen.
import openai
client = openai.OpenAI()
# ✅ Goede structuur: stabiele elementen eerst
SYSTEM_PROMPT = """You are a legal assistant specializing in French
contract law. You analyze contractual clauses according to the
Civil Code and recent case law. You always respond by
structuring your analysis: 1) Clause identification,
2) Legal analysis, 3) Potential risks, 4) Recommendations.
Here is the reference contract to analyze:
[Insert a 2,000+ token document here that does not change between calls]
"""
def analyze_clause(clause: str) -> str:
"""Elke oproep hergebruikt de cache van de systeemprompt."""
response = client.responses.create(
model="gpt-5.6-terra",
instructions=SYSTEM_PROMPT, # Stabiel voorvoegsel = gecachet
input=f"Analyze this clause: {clause}", # Variabel deel
)
return response.output_text
In dit voorbeeld vormen het referentiecontract en het analysekader het invariante blok, terwijl de te onderzoeken clausule bij elke oproep verandert. Analyseer veertig clausules uit hetzelfde contract en u betaalt de context slechts één keer tegen de volle prijs.
De cache verifiëren
Een optimalisatie die u niet meet, is een optimalisatie die u alleen denkt te hebben. De API geeft informatie over cachegebruik terug in het antwoord:
response = client.responses.create(
model="gpt-5.6-terra",
instructions=SYSTEM_PROMPT,
input="Analyze the non-compete clause.",
)
# Controleer cachegebruik
usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Input tokens (cached): {usage.input_tokens_details.cached_tokens}")
print(f"Output tokens: {usage.output_tokens}")
# Als cached_tokens > 0: de cache is gebruikt
cache_ratio = usage.input_tokens_details.cached_tokens / usage.input_tokens
print(f"Cache ratio: {cache_ratio:.1%}")
Log deze verhouding in productie in plaats van deze slechts één keer tijdens de ontwikkeling te controleren. Een plotselinge daling van de cachesnelheid is het meest betrouwbare symptoom van een onbedoelde wijziging in de constructie van de prompt; u ziet dit voordat de maandelijkse factuur u erover informeert.
Structureren om de cache te maximaliseren
De eerste aanpak is het bewust verrijken van de systeemprompt. Dit voelt contra-intuïtief wanneer u probeert tokens te verminderen, maar het sluit aan bij de drempelregel: een systeemprompt van 900 tokens wordt nooit gecachet, terwijl dezelfde prompt, verrijkt met few-shot voorbeelden en een referentiedocument, over de drempel gaat en overschakelt op het verlaagde tarief voor het gecachete deel.
# Verrijk de systeemprompt om de cache te maximaliseren
ENRICHED_PROMPT = """
[Detailed instructions - 500+ tokens]
[Few-shot examples - 500+ tokens]
[Reference document - 1,000+ tokens]
---
Total > 1,024 tokens = eligible for cache
"""
In een conversatie met meerdere beurten werkt het mechanisme in uw voordeel zonder extra inspanning: de geaccumuleerde geschiedenis vormt een natuurlijk stabiel voorvoegsel dat met elke uitwisseling groeit. Zolang u berichten altijd in dezelfde volgorde opnieuw injecteert, profiteert beurt nummer tien van de cache die door de vorige negen is opgebouwd.
def conversation_with_cache(history: list[dict], new_message: str):
"""Groeiende geschiedenis maximaliseert de cache automatisch."""
history.append({"role": "user", "content": new_message})
response = client.responses.create(
model="gpt-5.6-terra",
instructions=SYSTEM_PROMPT,
input=history,
)
history.append({
"role": "assistant",
"content": response.output_text,
})
return response.output_text
Tot slot, aangezien de levensduur van de cache in minuten wordt gemeten, wordt het groeperen van verzoeken die een voorvoegsel delen een planningsbeslissing. Het achter elkaar verwerken van veertig clausules uit een contract houdt de cache ‘heet’; ze over de dag verspreiden terwijl u andere bestanden ertussen voegt, laat de cache tussen de oproepen door verlopen.
import asyncio
async def batch_with_cache(clauses: list[str]) -> list[str]:
"""Verzendt verzoeken snel om de cache te benutten."""
results = []
for clause in clauses:
result = analyze_clause(clause)
results.append(result)
return results
Drie fouten maken al dit werk teniet, en ze lijken op elkaar: het wijzigen van het begin van de prompt, zelfs met één teken, ongeldig verklaart de cache voor het hele verzoek; het randomiseren van de volgorde van instructies, bijvoorbeeld door de prompt op te bouwen vanuit een ongeordende dictionary, produceert hetzelfde effect met tussenpozen en is daardoor moeilijk te diagnosticeren; en winst verwachten onder de drempel van 1.024 tokens betekent proberen iets te optimaliseren dat nooit wordt geactiveerd.
Belangrijkste punten
- Prompt caching is automatisch bij OpenAI—plaats stabiele elementen aan het begin van de prompt
- Minimumdrempel: 1.024 identieke tokens in het voorvoegsel
- Winst: ~50% op gecachete invoertokens + verminderde TTFT
- Controleer
usage.input_tokens_details.cached_tokensom caching te bevestigen