LLM Prompt-cachning: Sänk API-kostnaderna med 90% (Alla 3 Leverantörer)

LLM Prompt-cachning: Sänk API-kostnaderna med 90% (Alla 3 Leverantörer)

LLM prompt-cachning låter dig återanvända tidigare bearbetade tokens mellan API-anrop -- vilket sänker inmatningskostnaderna med upp till 90% och minskar tiden till första token med upp till 85%. Om du skickar samma systemprompt, verktygsdefinitioner eller few-shot-exempel vid varje förfrågan betalar du fullt pris för arbete som GPU:n redan har gjort.

Den här guiden täcker OpenAI, Anthropic och Gemini med samma chatbot implementerad i alla tre SDK:er -- något ingen annan guide gör. Vi täcker även Anthropics automatiska cachningsuppdatering från februari 2026, produktionskostnadsscenarier med riktiga dollarbelopp och de anti-mönster som tyst förstör din cache-träffkvot.

Snabbsammanfattning -- Alla Tre Leverantörer i ett Ögonkast

Innan vi dyker ner i implementeringsdetaljer, här är den fullständiga jämförelsen. Om du redan vet vilken leverantör du använder, hoppa direkt till det avsnittet. Om du utvärderar berättar den här tabellen allt på 10 sekunder.

Nyckelinsikt: OpenAI är enklast (noll konfiguration, 50% rabatt). Anthropic ger den djupaste rabatten (90%) med mest kontroll. Gemini erbjuder konfigurerbar TTL och implicit cachning på 2.5+-modeller med jämförbara rabatter som Anthropic.

Hur Fungerar LLM Prompt-cachning?

Du behöver inte förstå transformers interna mekanismer för att använda prompt-cachning effektivt. Men du behöver förstå ett koncept: prefixmatchning.

KV-cachen på 60 Sekunder

När ett LLM bearbetar din prompt beräknar det uppmärksamhetstillstånd (nyckel-värdepar) för varje token. Dessa KV-cache-poster är den kostsamma delen -- de förbrukar GPU-minne och beräkningstid. Prompt-cachning lagrar dessa beräknade tillstånd så att nästa förfrågan med samma prefix helt hoppar över omberäkning.

Det kritiska ordet är prefix. Cachen matchar från början av din prompt. Om de första 2 000 tokenerna matchar en cachad post men token 2 001 skiljer sig, serveras de första 2 000 tokenerna från cachen. Allt efter divergenspunkten beräknas på nytt.

Det är därför promptordningen spelar roll. Strukturera dina promptar så här:

1. Verktygsdefinitioner (mest statiska)
2. Systemprompt
3. Statiska few-shot-exempel
4. Hämtat sammanhang (halvdynamiskt)
5. Konversationshistorik (växer per tur)
6. Användarfråga (alltid annorlunda)

Statiskt innehåll först, dynamiskt innehåll sist. Ju fler tokens som matchar det cachade prefixet, desto större är besparingarna.

Prompt-cachning vs Semantisk Cachning vs Svarscachning

Dessa tre termer blandas ständigt ihop. Prompt-cachning (vad den här guiden handlar om) återanvänder beräknade KV-tillstånd på GPU-nivå för identiska tokenprefixar -- noll noggrannhetsförlust, samma utdata som utan cache. Semantisk cachning använder inbäddningslikhet för att returnera tidigare genererade svar för "tillräckligt liknande" frågor -- snabbare men kan returnera felaktiga svar. Svarscachning lagrar exakta input-output-par och returnerar det cachade svaret ordagrant -- fungerar bara för verkligt identiska förfrågningar.

Prompt-cachning är den enda "gratisoptimeringen" -- den minskar kostnad och latens utan noggrannhetsavvägningar. För den djupgående transformermatematiken bakom KV-cachning mätte Hugging Faces tekniska artikel en ~5,21x hastighetsökning på T4-GPU:er.

Hur Hanterar OpenAI Prompt-cachning?

OpenAIs prompt-cachning är helt automatisk. Sedan oktober 2024 drar varje API-anrop med 1 024+ inmatningstokens automatiskt nytta av cachning. Ingen opt-in, inga headers, inga kodändringar.

Hur OpenAIs Automatiska Cachning Fungerar

När du skickar en förfrågan med minst 1 024 tokens kontrollerar OpenAI om prefixet matchar en nylig förfrågan från din organisation. Cache-träffar kostar 50% av standardpriset för inmatningstoken. Efter det initiala tröskelvärdet på 1 024 tokens matchar cachen i 128-tokensteg.

Cachen lever i 5-10 minuter under normal användning och kan bestå i upp till 24 timmar under lågtrafikperioder. Den är avgränsad per organisation, så olika projekt inom samma organisation drar nytta av delade cachar.

Stödda modeller inkluderar GPT-4o, GPT-4o-mini, GPT-4.1, o1, o3-mini och alla nyare modeller.

OpenAI Python SDK Exempel

from openai import OpenAI

client = OpenAI()

# Den här systempromptens är ~2 000 tokens -- väl över minimumet på 1 024
SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

def chat(user_message: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_message},
        ],
    )

    # Kontrollera om cachning aktiverades
    usage = response.usage
    cached = usage.prompt_tokens_details.cached_tokens
    total_input = usage.prompt_tokens
    print(f"Cached: {cached}/{total_input} tokens ({cached/total_input*100:.0f}%)")

    return response.choices[0].message.content

# Första anropet: cache-miss (fullt pris)
chat("Review this async function for race conditions...")

# Andra anropet inom 5-10 min: cache-träff (50% rabatt på cachade tokens)
chat("Now optimize the same function for throughput...")

Det första anropet bearbetar allt till fullt pris och fyller cachen. Det andra anropet återanvänder de cachade systemprompt-tokenerna till halvpris. Du ser något som Cached: 1920/2048 tokens (94%) i utdata.

Slutsats: OpenAI är lättast att börja med -- noll konfiguration, cachning sker bara. 50%-rabatten är den lägsta av de tre leverantörerna, men ingenting slår enkelheten.

Hur Hanterar Anthropic/Claude Prompt-cachning?

Anthropic erbjuder två lägen: automatisk cachning (aktiverad som standard sedan februari 2026) och explicit cachning med cache_control-brytpunkter. Rubrikstalet är svårt att ignorera -- cachade läsningar kostar bara 10% av standardinmatningspriset, en 90%-rabatt.

Automatisk vs Explicit Cachning (Uppdatering 2026)

Från och med 5 februari 2026 aktiverar Anthropic automatisk cachning som standard för alla berättigade promptar. Du behöver inte längre den gamla beta-headern. Systemet bestämmer automatiskt optimala cache-brytpunkter.

Explicit cachning är fortfarande tillgängligt när du vill ha detaljerad kontroll. Du placerar cache_control: {"type": "ephemeral"} på specifika innehållsblock för att markera exakt var cache-gränsen ska vara. Det är användbart när din prompt har en specifik struktur och du vill garantera att vissa avsnitt cachas.

Det finns två TTL-alternativ:

• 5-minuters cache (standard): skrivningar kostar 1,25x basisinmatningspriset, läsningar kostar 0,1x. Lönar sig efter 1 cache-träff.
• 1-timmes cache: skrivningar kostar 2x basisinmatningspriset, läsningar kostar 0,1x. Lönar sig efter 2 cache-träffar. Tillgänglig på Claude 4.5+-modeller.

Cache-isolering ändrades från organisationsnivå till arbetsytenivå den 5 februari 2026. Det innebär att olika arbetsytor inom samma organisation har separata cachar.

När du arbetar med Anthropics cachning hjälper det att strukturera din prompt för optimal cachning -- att placera statiskt innehåll före dynamiskt är ännu viktigare här eftersom du betalar en skrivpremie.

Anthropic Python SDK Exempel

import anthropic

client = anthropic.Anthropic()

SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

def chat(user_message: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-5-20250514",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": SYSTEM_PROMPT,
                "cache_control": {"type": "ephemeral"},  # Explicit brytpunkt
            }
        ],
        messages=[
            {"role": "user", "content": user_message},
        ],
    )

    # Läs cache-statistik från svaret
    usage = response.usage
    created = usage.cache_creation_input_tokens
    read = usage.cache_read_input_tokens
    standard = usage.input_tokens
    print(f"Cache write: {created}, Cache read: {read}, Standard: {standard}")

    return response.content[0].text

# Första anropet: cache_creation_input_tokens = ~1920 (skrivning vid 1,25x)
chat("Review this async function for race conditions...")

# Andra anropet: cache_read_input_tokens = ~1920 (läsning vid 0,1x -- 90% rabatt!)
chat("Now optimize the same function for throughput...")

Förstå Priset för Cache-skrivning vs Cache-läsning

Här blir Anthropics prissättning intressant. Med Claude Sonnet 4.5 ($3/MTok basisinmatning) som exempel:

• Standardinmatning: $3,00 per miljon tokens
• Cache-skrivning (5 min): $3,75 per miljon tokens (1,25x) -- du betalar mer första gången
• Cache-läsning: $0,30 per miljon tokens (0,1x) -- 90% billigare vid varje efterföljande träff

5-minuterscachen lönar sig efter bara 1 läsning. 1-timmes-cachen ($6,00/MTok skrivning) lönar sig efter 2 läsningar. Om du gör fler än ett par förfrågningar per minut med samma prefix är matematiken överväldigande till din fördel.

Slutsats: Anthropic ger den djupaste rabatten (90%) och mest kontroll. Bäst för högt-volym, kostnadskänsliga arbetsbelastningar.

Hur Hanterar Google Gemini Prompt-cachning?

Gemini tar ett annat tillvägagångssätt med två distinkta cachningsmekanismer: explicit kontextcachning (namngivna cache-objekt som du skapar och refererar till) och implicit cachning (automatisk, noll konfiguration, tillagd 2026 för Gemini 2.5+-modeller).

Explicit Kontextcachning (Namngivna Cachar)

Till skillnad från OpenAI och Anthropic där cachning är transparent kräver Geminis explicita cachning att du först skapar ett namngivet cache-objekt och sedan refererar till det i efterföljande förfrågningar. Det minsta token-tröskelvärdet är 1 024 tokens för Gemini Flash-modeller och 4 096 tokens för Pro-modeller. TTL är konfigurerbar -- standard är 1 timme, men du kan ställa in det efter behov.

Cachade tokens på Gemini 2.5 Pro prissätts till $0,125/MTok jämfört med standardinmatningspriset på $1,25/MTok -- en 90%-rabatt. Det finns också en lagringskostnad på $4,50 per miljon tokens per timme för Pro och $1,00 för Flash.

Implicit Cachning i Gemini 2.5 (2026)

Från och med Gemini 2.5 Pro och Flash lade Google till implicit cachning -- automatisk cachning som fungerar som OpenAIs tillvägagångssätt. Ingen konfiguration behövs. Placera stort, gemensamt innehåll i början av din prompt och skicka förfrågningar med liknande prefix i snabb följd. Systemet identifierar automatiskt cache-berättigat innehåll och vidarebefordrar besparingarna.

Gemini Python SDK Exempel

from google import genai
from google.genai import types

client = genai.Client()

SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

# Steg 1: Skapa ett namngivet cache-objekt
cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        display_name="python-review-guidelines",
        system_instruction=SYSTEM_PROMPT,
        ttl="3600s",  # 1 timme
    ),
)

print(f"Cache created: {cache.name}, expires: {cache.expire_time}")

# Steg 2: Använd cachen i förfrågningar
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Review this async function for race conditions...",
    config=types.GenerateContentConfig(
        cached_content=cache.name,
    ),
)

# Kontrollera cache-användning i svaret
metadata = response.usage_metadata
print(f"Cached tokens: {metadata.cached_content_token_count}")
print(f"Total input tokens: {metadata.prompt_token_count}")

Det explicita tillvägagångssättet har en stor fördel: du styr TTL exakt. Om du vet att ditt batchjobb körs i 4 timmar, ange en TTL på 4 timmar och undvik att cachen löper ut mitt i bearbetningen.

Slutsats: Geminis konfigurerbar TTL och dubbla cachningslägen (explicit + implicit) gör det mångsidigt. Minimitröskeln är nu jämförbar med andra leverantörer, och 90%-rabatten på cachade läsningar matchar Anthropic.

Kodsjämförelse Sida vid Sida -- Samma Användningsfall, Alla 3 Leverantörer

Här är samma chatbot med en cachad systemprompt, implementerad i alla tre SDK:er. Jämför utvecklarupplevelsen direkt.

# --- OpenAI: Noll konfiguration, anropa bara API:et ---
from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},  # Cachas automatiskt
        {"role": "user", "content": user_message},
    ],
)
cached = response.usage.prompt_tokens_details.cached_tokens

# --- Anthropic: Explicit cache_control-brytpunkt ---
import anthropic
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"},  # Markera cache-gräns
    }],
    messages=[{"role": "user", "content": user_message}],
)
cached = response.usage.cache_read_input_tokens

# --- Gemini: Namngivet cache-objekt ---
from google import genai
from google.genai import types

client = genai.Client()
cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        system_instruction=SYSTEM_PROMPT,
        ttl="3600s",
    ),
)
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=user_message,
    config=types.GenerateContentConfig(cached_content=cache.name),
)
cached = response.usage_metadata.cached_content_token_count

Om du vill ha mühelos besparingar, välj OpenAI. Om du vill ha den djupaste rabatten och detaljerad kontroll, välj Anthropic. Om du behöver konfigurerbara cache-livslängder eller redan är på Google Cloud, välj Gemini.

Produktionskostnadskalkylator -- Verkliga Besparingar i Stor Skala

Abstrakta procenttal styr inte beslut. Dollarbelopp gör det. Här är tre produktionsscenarier med riktiga kostnadsuppskattningar med Claude Sonnet 4.5 ($3/MTok inmatning), GPT-4o ($2,50/MTok inmatning) och Gemini 2.5 Pro ($1,25/MTok inmatning).

Priser verifierade mars 2026. Kontrollera Anthropic, OpenAI och Gemini för aktuella tariffer.

Antaganden: 80% cache-träffkvot (realistisk för välstrukturerade promptar), utmatningstokens exkluderade eftersom cachning bara påverkar inmatningskostnader.

På Growth-nivå sparar Anthropic-cachning $576/månad trots ett högre baspris än OpenAI. På Enterprise-skala tittar vi på $7 200/månad i besparingar med Anthropic -- eller $86 400 per år. Det är en senior ingenjörs lön sparad från en konfigurationsändring.

Mönstret är tydligt: ju högre förfrågningsvolym och ju längre det statiska prefixet, desto mer sparar cachning. Anthropics 90%-rabatt dominerar i stor skala, men Geminis lägre baspris gör det konkurrenskraftigt när man beräknar totalkostnaden.

Prompt-cachning Anti-mönster -- När Man INTE ska Cача

Cachning verkar enkelt tills din cache-träffkvot mystiskt sitter på 0%. Här är misstagen som tyst förstör prompt-cachning -- och hur man fixar dem.

Cache-förstörande Misstag (Med Lösningar)

Tidsstämplar i systempromptar -- Det vanligaste misstaget. Om din systemprompt innehåller datetime.now() ändras cache-nyckeln varje sekund.

# DÅLIGT: Cache-missar vid varje enskild förfrågan
system_prompt = f"""You are a helpful assistant.
Current time: {datetime.now().isoformat()}
Always be helpful and accurate."""

# BRA: Flytta tidsstämpeln till användarmeddelandet
system_prompt = """You are a helpful assistant.
Always be helpful and accurate."""

user_message = f"[Current time: {datetime.now().isoformat()}]\n{user_query}"

Användarspecifikt innehåll före statiskt innehåll -- Om du lägger session_id eller användarpreferenser i början, får varje användare ett unikt prefix.

# DÅLIGT: Unikt prefix per användare = noll cache-återanvändning
messages = [
    {"role": "system", "content": f"User ID: {user_id}\nPreferences: {prefs}\n{GUIDELINES}"},
    {"role": "user", "content": query},
]

# BRA: Statiskt innehåll först, användarkontext i slutet
messages = [
    {"role": "system", "content": GUIDELINES},  # Samma för alla användare -> cachat
    {"role": "user", "content": f"Context: User {user_id}, prefs: {prefs}\n{query}"},
]

När Prompt-cachning Verkligen Inte Hjälper

Vissa scenarier kommer inte att dra nytta av cachning även om du strukturerar dina promptar perfekt:

• Engångspromptar: Om varje förfrågan har ett helt unikt sammanhang utan delat prefix finns det inget att cacha.
• Mycket korta promptar: Under 1 024 tokens (OpenAI/Anthropic) eller 4 096 tokens (Gemini Pro) aktiveras inte cachning.
• Ovanliga förfrågningar: Om förfrågningar är timmar isär löper cachen ut innan en andra förfrågan anländer. OpenAIs 5-10-minutersfönster och Anthropics standard-TTL på 5 minuter innebär att du behöver konsekvent trafik.

Fungerar Prompt-cachning med Streaming?

Ja. Prompt-cachning och streaming är oberoende -- cachning verkar på inmatningstokens, streaming påverkar utdataleveransen. De löser olika problem i olika stadier av förfrågningens livscykel.

Cachen hanterar prefill-fasen (bearbetning av din inmatningsprompt). Streaming hanterar dekodfasen (inkrementell generering och sändning av utmatningstokens). Du drar nytta av båda fördelarna samtidigt: snabbare prefill från cache-träffen, plus progressiv utdataleverans från streaming.

Här är ett streaming-exempel med cachning aktiverad:

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"},
    }],
    messages=[{"role": "user", "content": "Explain Python's GIL..."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    # Efter streaming slutförs, kontrollera cache-statistik
    usage = stream.get_final_message().usage
    print(f"\nCache read: {usage.cache_read_input_tokens} tokens")

TTFT-förbättringen från cachning är faktiskt mest märkbar med streaming. Utan cachning väntar du på den fullständiga prefill-fasen innan den första token strömmas tillbaka. Med cachning är prefill-fasen nästan omedelbar, så tokens börjar flöda nästan direkt.

Hur Man Övervakar Cache-träffkvoter i Produktion

Att konfigurera cachning är halva striden. Att veta om det faktiskt fungerar är den andra halvan. Om din cache-träffkvot sjunker under 50% har något förändrats i din promptstruktur och du lämnar pengar på bordet.

Leverantörsspecifik Cache-statistik

En Enkel Cache-träffkvot-loggare

Här är en hjälpfunktion du kan lägga in i vilket projekt som helst för att spåra cache-träffkvoter via API-svarsfält:

import logging

logger = logging.getLogger("cache_monitor")

def log_cache_metrics(provider: str, usage: dict) -> float:
    """Extraherar och loggar cache-statistik från vilken leverantörs svar som helst. Returnerar träffkvot."""

    if provider == "openai":
        cached = getattr(usage.prompt_tokens_details, "cached_tokens", 0)
        total = usage.prompt_tokens
    elif provider == "anthropic":
        cached = usage.cache_read_input_tokens
        created = usage.cache_creation_input_tokens
        total = cached + created + usage.input_tokens
    elif provider == "gemini":
        cached = getattr(usage, "cached_content_token_count", 0)
        total = usage.prompt_token_count
    else:
        raise ValueError(f"Unknown provider: {provider}")

    hit_rate = (cached / total * 100) if total > 0 else 0
    logger.info(f"[{provider}] Cache hit rate: {hit_rate:.1f}% ({cached}/{total} tokens)")

    if hit_rate < 50:
        logger.warning(f"[{provider}] Low cache hit rate! Check prompt structure.")

    return hit_rate

Ett hälsosamt produktionssystem bör upprätthålla 70-90% cache-träffkvoter. Om du är under 50% är det dags att se över anti-mönstersavsnittet igen. Du kan också integrera detta med automatiserade utvärderingsmätetal för att fånga regressioner i din promptpipeline.

Prompt-cachning i Verkliga Användningsfall

Chatbot-exemplen ovan illustrerar mekanismerna, men prompt-cachning lyser verkligen i specifika arkitekturmönster.

RAG-pipelines

I en RAG-konfiguration är din systemprompt och dina few-shot-exempel statiska för alla frågor. De hämtade dokumenten ändras varje gång. Strukturera din prompt för att maximera det cachade prefixet:

1. Systemprompt (cachad)
2. Few-shot-exempel (cachade)
3. Hämtade dokument (dynamiska -- kommer sist)
4. Användarfråga (alltid unik)

Med en systemprompt på 5 000 tokens och 3 000 tokens few-shot-exempel är det 8 000 cachade tokens vid varje förfrågan. Med 1 000 förfrågningar/dag på Anthropic skulle du spara ungefär $6,50/dag bara på det cachade prefixet. När du hämtar och cachar kontextblock se till att hämtningsutdata kommer efter det statiska prefixet.

Flerturschatbotar

Flerturskonversationer är en stark punkt för prompt-cachning. Varje tur läggs till konversationshistoriken, men hela den föregående konversationen är redan cachad från tidigare turer. Cache-fördelen ackumuleras -- vid tur 10 kan du ha 15 000 cachade historiktokens med bara 200 färska tokens från det senaste användarmeddelandet.

Agentiska System och MCP-verktygsdefinitioner

Om du bygger agenter med verktygsanvändning är dina verktygsdefinitioner statiska JSON-scheman som upprepas vid varje enskilt API-anrop. En typisk agent kan ha 20+ verktyg som totalt uppgår till 3 000-5 000 tokens med definitioner. Det är prima cachningmaterial.

Detta är särskilt relevant för MCP-baserade arkitekturer där serververktygsdefinitioner skickas vid varje anrop. Med Anthropics explicita cache_control kan du markera tools-arrayen för cachning och garantera att dessa tokens återanvänds.

Vilken Leverantör Bör Du Välja?

Om du redan använder en leverantör, börja där -- prompt-cachning kräver inte byte. LiteLLM fungerar som ett proxylager som normaliserar cachningsparametrar över leverantörer, vilket är användbart om du dirigerar förfrågningar till flera modeller.

FAQ -- LLM Prompt-cachning

Vad är prompt-cachning i LLM:ar?

Prompt-cachning lagrar de beräknade uppmärksamhetstillstånden (KV-cache) från tidigare bearbetade promptprefix. När en efterföljande förfrågan börjar med samma tokensekvens återanvänder leverantören de lagrade tillstånden istället för att omberäkna dem -- vilket minskar både kostnad och latens utan påverkan på utdatakvaliteten.

Hur mycket sparar prompt-cachning på API-kostnader?

Besparingar sträcker sig från 50% till 90% beroende på leverantör. OpenAI erbjuder 50% rabatt på cachade inmatningstokens. Anthropic erbjuder upp till 90% rabatt (cachade läsningar till 0,1x baspriset). Gemini erbjuder ungefär 90% rabatt på cachade läsningar. Faktiska besparingar beror på din cache-träffkvot, promptlängd och förfrågningsfrekvens.

Sker OpenAI prompt-cachning automatiskt?

Ja, sedan oktober 2024. Vilket API-anrop som helst med 1 024+ inmatningstokens drar automatiskt nytta av cachning. Ingen opt-in, inga headers, inga kodändringar krävs. Cachen matchar tokenprefixar från promptens början.

Vad är skillnaden mellan prompt-cachning och semantisk cachning?

Prompt-cachning matchar exakta tokenprefixar på GPU-nivå -- det finns ingen noggrannhetsförlust och utdata är identisk med icke-cachade förfrågningar. Semantisk cachning använder inbäddningslikhet för att hitta "tillräckligt nära" tidigare frågor och returnera cachade svar -- det är snabbare men kan returnera felaktiga eller föråldrade svar. De löser fundamentalt olika problem.

Hur länge varar prompt-cachen?

Det varierar per leverantör. OpenAI: 5-10 minuter (upp till 24 timmar med utökad lagring). Anthropic: 5 minuter (standard) eller 1 timme (tillgänglig på Claude 4.5+-modeller, kostar 2x skrivning). Gemini: konfigurerbar, standard är 1 timme för explicita cachar. Implicit cachnings-TTL hanteras automatiskt av Google.

Vad är den minsta token-längden för prompt-cachning?

OpenAI: 1 024 tokens. Anthropic: 1 024 tokens för de flesta aktuella modeller. Gemini: 1 024 tokens för Flash-modeller, 4 096 för Pro-modeller. Promptar under dessa tröskelvärden aktiverar inte cachning -- detta är det vanligaste "det fungerar inte"-problemet.

Fungerar prompt-cachning med strömmande svar?

Ja. Cachning och streaming verkar på olika faser av förfrågan. Cachning snabbar upp inmatningsprefill-fasen; streaming levererar utmatningstokens inkrementellt. Båda fungerar simultant och du märker faktiskt TTFT-förbättringen mer med streaming aktiverat.

När bör jag INTE använda prompt-cachning?

Undvik att förlita dig på cachning när dina promptar är under det minsta token-tröskelvärdet, när du inkluderar tidsstämplar eller sessions-ID:n i systemprompten, när du roterar few-shot-exempel mellan anrop, eller när förfrågningar är för ovanliga för att nå cachen innan den löper ut (5-10-minutersfönster för OpenAI/Anthropic).

Kan jag använda prompt-cachning med LangChain eller LiteLLM?

Ja. LangChain skickar leverantörsspecifika cachningsparametrar genom sina API-wrappers. LiteLLM tillhandahåller en enhetlig cachningssyntax som normaliserar cache_control för Anthropic, OpenAI, Gemini, Vertex AI och Bedrock -- särskilt användbart för multi-leverantörskonfigurationer.

Vad är en cache-träff vs en cache-miss?

En cache-träff innebär att leverantören hittade ett matchande prefix i minnet och återanvände de lagrade KV-tillstånden -- du betalar det rabatterade cachade tokenbeloppet och får snabbare TTFT. En cache-miss innebär att ingen matchning hittades, så hela prompten bearbetas från scratch till standardpriset. Kontrollera fälten cached_tokens (OpenAI), cache_read_input_tokens (Anthropic) eller cachedContentTokenCount (Gemini) i API-svaret för att se vilket som inträffade.

Slutgiltigt Omdöme

Prompt-cachning är den minsta-ansträngnings, högst-avkastnings-optimeringen i LLM API-stacken. Du ändrar inte din modell, du offrar inte kvalitet, och implementeringen sträcker sig från "gör ingenting" (OpenAI) till "lägg till ett fält" (Anthropic) till "skapa ett cache-objekt" (Gemini).

Börja med din nuvarande leverantörs automatiska cachning. Mät din cache-träffkvot med loggningshjälpmedlet ovan. Om du är under 70%, omstrukturera dina promptar (statiska först, dynamiska sist) och eliminera anti-mönstren. De flesta team ser 50-80% kostnadsreduktion inom en dag efter att ha implementerat dessa ändringar.

Källor

• Anthropic Prompt Caching Documentation
• OpenAI Prompt Caching Guide
• Gemini Context Caching Documentation
• Anthropic Model Pricing
• Gemini API Pricing
• KV Caching Explained -- Hugging Face Blog
• LiteLLM Prompt Caching Documentation