Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Prompt-caching: Genbrug af beregninger

Lektion 3 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Hvad er prompt-caching?
  2. Hvordan det fungerer
  3. Strukturering for at maksimere cache
  4. Vigtige pointer

Hvad er prompt-caching?

Når du gentagne gange sender det samme prompt-præfiks – f.eks. en lang systemprompt, detaljerede instrukser eller et referencedokument – kan OpenAI automatisk cache dette præfiks. Efterfølgende kald, der deler dette præfiks, drager fordel af reduceret tid til første token (TTFT) og lavere omkostninger for input-tokens. Med andre ord gentages arbejdet med at indlæse den stabile kontekst ikke for hver eneste anmodning.

Prompt-caching har været automatisk siden 2025: Du behøver ikke aktivere noget. OpenAI registrerer identiske præfikser og cacher dem. Din mulighed for optimering ligger derfor ikke i at tænde eller slukke for funktionen, men i at skrive dine prompts, så mekanismen kan anvendes. Det handler om struktur, ikke konfiguration, og det er her, de fleste teams lader penge ligge på bordet.

Hvordan det fungerer

Cachen gælder for prompt-præfikser: De første tokens skal være strengt identiske fra kald til kald, og matchet stopper ved det første afvigende tegn. Der kræves en minimumsstørrelse på 1.024 tokens for at udløse caching, hvilket straks udelukker korte systemprompts. Cachen deles inden for en enkelt organisation, hvilket betyder, at flere tjenester i din virksomhed, der kalder det samme præfiks, hjælper hinanden. Dens levetid varierer fra få minutter til flere timer uden nogen fast garanti, og reduktionen udgør cirka 50 % på omkostningerne for cachet input-tokens.

Den praktiske konsekvens af præfiks-reglen er, at du skal placere stabile elementer i starten af promptet og variable elementer i slutningen. En tjeneste, der indsætter dagens dato eller et sessions-ID i toppen af sin systemprompt, ugyldiggør sin cache ved hvert eneste kald uden nogensinde at opdage det.

import openai

client = openai.OpenAI()

# ✅ God struktur: stabile elementer først
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:
    """Hvert kald genbruger systemprompt-cachen."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,  # Stabilt præfiks = cachet
        input=f"Analyze this clause: {clause}",  # Variabel del
    )
    return response.output_text

I dette eksempel udgør referencekontrakten og analyseframework’et den invariante blok, mens klausulen, der undersøges, ændrer sig ved hvert kald. Analyserer du fyrre klausuler fra den samme kontrakt, betaler du kun én gang fuld pris for konteksten.

Verificering af cachen

En optimering, du ikke måler, er en optimering, du kun tror, du har. API’en returnerer oplysninger om cache-brug i svaret:

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=SYSTEM_PROMPT,
    input="Analyze the non-compete clause.",
)

# Tjek cache-brug
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}")

# Hvis cached_tokens > 0: blev cachen brugt
cache_ratio = usage.input_tokens_details.cached_tokens / usage.input_tokens
print(f"Cache ratio: {cache_ratio:.1%}")

Log denne ratio i produktionen i stedet for kun at tjekke den én gang under udvikling. Et pludseligt fald i cache-raten er det mest pålidelige symptom på en utilsigtet ændring i prompt-konstruktionen, og du vil se det, før den månedlige regning fortæller dig om det.

Strukturering for at maksimere cache

Den første tilgang er bevidst at berige systempromptet. Det kan virke kontraintuitivt, når du forsøger at reducere antallet af tokens, men det stemmer overens med tærskelreglen: En systemprompt på 900 tokens bliver aldrig cachet, hvorimod den samme prompt beriget med few-shot-eksempler og et referencedokument krydser linjen og skifter til den reducerede sats for den cachet del.

# Berig systempromptet for at maksimere cachen
ENRICHED_PROMPT = """
[Detailed instructions - 500+ tokens]
[Few-shot examples - 500+ tokens]
[Reference document - 1,000+ tokens]
---
Total > 1,024 tokens = eligible for cache
"""

I en samtale med flere ture (multi-turn) arbejder mekanismen til din fordel uden ekstra indsats: Den akkumulerede historik danner et naturligt stabilt præfiks, der vokser med hver udveksling. Så længe du altid genindsætter beskeder i samme rækkefølge, drager tur nummer ti fordel af den cache, der er opbygget af de foregående ni.

def conversation_with_cache(history: list[dict], new_message: str):
    """Voksende historik maksimerer cachen automatisk."""
    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

Endelig, da cache-levetiden måles i minutter, bliver gruppering af anmodninger, der deler et præfiks, en beslutning om planlægning. Behandling af fyrre klausuler fra en kontrakt lige efter hinanden holder cachen “varm”; spreder du dem ud over dagen og fletter andre filer ind imellem, lader du den udløbe mellem kaldene.

import asyncio

async def batch_with_cache(clauses: list[str]) -> list[str]:
    """Sender anmodninger hurtigt for at udnytte cachen."""
    results = []
    for clause in clauses:
        result = analyze_clause(clause)
        results.append(result)
    return results

Tre fejl annullerer alt dette arbejde, og de ligner hinanden: At modificere starten af promptet, selv med ét enkelt tegn, ugyldiggør cachen for hele anmodningen; at randomisere rækkefølgen af instrukser, f.eks. ved at bygge promptet fra en usorteret ordbog, producerer den samme effekt lejlighedsvis og er derfor svær at diagnosticere; og at forvente gevinster under tærsklen på 1.024 tokens betyder, at du forsøger at optimere noget, der aldrig udløses.

Vigtige pointer

  • Prompt-caching er automatisk hos OpenAI – placer stabile elementer i starten af promptet
  • Minimumstærskel: 1.024 identiske tokens i præfikset
  • Gevinst: ~50 % på cachet input-tokens + reduceret TTFT
  • Tjek usage.input_tokens_details.cached_tokens for at bekræfte caching