Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Prompt-cachning: Återanvänd beräkningar

Lektion 3 av 20 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Vad är prompt-cachning?
  2. Hur det fungerar
  3. Strukturera för att maximera cachen
  4. Viktiga punkter

Vad är prompt-cachning?

När du upprepade gånger skickar samma prompt-prefix – en lång systemprompt, detaljerade instruktioner eller ett referensdokument – kan OpenAI automatiskt cacha detta prefix. Efterföljande anrop som delar detta prefix gynnas av kortare tid till första token (TTFT) och lägre kostnader för inmatningstokens. Med andra ord behöver arbetet med att bearbeta den stabila kontexten inte upprepas för varje begäran.

Prompt-cachning har varit automatisk sedan 2025: du behöver inte aktivera något. OpenAI identifierar identiska prefix och cachar dem. Din hävstångseffekt ligger därför inte i att slå på eller av funktionen, utan i att skriva dina prompter så att mekanismen kan tillämpas. Detta handlar om struktur, inte konfiguration, och det är här de flesta team lämnar pengar på bordet.

Hur det fungerar

Cachen gäller för prompt-prefix: de första token måste vara exakt identiska från ett anrop till nästa, och matchningen stoppar vid första avvikande tecken. En minsta storlek på 1 024 tokens krävs för att utlösa cachning, vilket omedelbart utesluter korta systemprompter. Cachen delas inom en enda organisation, vilket innebär att flera tjänster i ditt företag som anropar samma prefix hjälper varandra. Dess livslängd varierar från några minuter till några timmar, utan någon fast garanti, och den uppnådda besparingen är cirka 50 % på kostnaden för cachade inmatningstokens.

Den praktiska konsekvensen av prefixregeln är att du måste placera stabila element i början av prompten och variabla element i slutet. En tjänst som infogar dagens datum eller ett sessions-ID i början av sin systemprompt ogiltigförklarar sin cache vid varje anrop utan att ens inse det.

import openai

client = openai.OpenAI()

# ✅ Bra struktur: stabila element 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:
    """Varje anrop återanvänder systemprompt-cachen."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,  # Stabilt prefix = cachat
        input=f"Analyze this clause: {clause}",  # Variabel del
    )
    return response.output_text

I detta exempel utgör referensavtalet och analysramen det invarianta blocket, medan klausulen som granskas ändras vid varje anrop. Analysera fyrtio klausuler från samma avtal, så betalar du för kontexten en gång till fullt pris.

Verifiera cachen

En optimering du inte mäter är en optimering du bara tror att du har. API:et returnerar information om cacheanvändning i svaret:

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

# Kontrollera cacheanvändning
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}")

# Om cached_tokens > 0: cachen användes
cache_ratio = usage.input_tokens_details.cached_tokens / usage.input_tokens
print(f"Cache ratio: {cache_ratio:.1%}")

Logga denna kvot i produktion snarare än att kontrollera den en gång under utveckling. Ett plötsligt fall i cachefrekvensen är det mest tillförlitliga symtomet på en oavsiktlig ändring i promptkonstruktionen, och du kommer att se det innan den månatliga fakturan berättar det för dig.

Strukturera för att maximera cachen

Det första tillvägagångssättet är att medvetet berika systemprompten. Detta kan kännas kontraintuitivt när du försöker reducera antalet tokens, men det stämmer överens med tröskelregeln: en systemprompt på 900 tokens kommer aldrig att cachas, medan samma prompt berikad med few-shot-exempel och ett referensdokument korsar linjen och växlar till den reducerade taxan för den cachade delen.

# Berika systemprompten för att maximera 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 flerstegskonversation arbetar mekanismen till din fördel utan extra ansträngning: den ackumulerade historiken bildar ett naturligt stabilt prefix som växer med varje utbyte. Så länge du alltid matar in meddelanden i samma ordning drar tionde varv nytta av den cache som byggts upp av de tidigare nio.

def conversation_with_cache(history: list[dict], new_message: str):
    """Växande historik maximerar cachen automatiskt."""
    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

Slutligen, eftersom cachens livslängd mäts i minuter, blir gruppering av begäranden som delar ett prefix ett schemaläggningsbeslut. Att bearbeta fyrtio klausuler från ett avtal i direkt följd håller cachen varm; att sprida ut dem över dagen medan du växelvis bearbetar andra filer låter den löpa ut mellan anropen.

import asyncio

async def batch_with_cache(clauses: list[str]) -> list[str]:
    """Skickar begäranden snabbt för att utnyttja cachen."""
    results = []
    for clause in clauses:
        result = analyze_clause(clause)
        results.append(result)
    return results

Tre misstag kan upphäva allt detta arbete, och de liknar varandra: att modifiera början av prompten, även med ett enda tecken, ogiltigförklarar cachen för hela begäran; att slumpmässigt ändra ordningen på instruktionerna, till exempel genom att bygga prompten från en osorterad ordbok, ger samma effekt intermittent och är därför svår att diagnostisera; och att förvänta sig vinster under tröskeln på 1 024 tokens innebär att du försöker optimera något som aldrig utlöses.

Viktiga punkter

  • Prompt-cachning är automatisk med OpenAI – placera stabila element i början av prompten
  • Minsta tröskel: 1 024 identiska tokens i prefixet
  • Vinst: ~50 % på cachade inmatningstokens + reducerad TTFT
  • Kontrollera usage.input_tokens_details.cached_tokens för att bekräfta cachning