AI Engineering Academy · leksjon

OpenAI-hurtigbufring av forespørselsprefiks

Leksjon 3 av 413 trinn

OpenAI-hurtigbufring av forespørselsprefiks er en gratis leksjon i AI Engineering Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI Engineering Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.

Hva er hurtigbufring av ledetekstprefikser?

Hurtigbufring av ledetekstprefikser er en optimalisering på serversiden som er innebygd i OpenAI sitt API. Den gir automatisk rabatt på tokenene i ledetekstprefikset som ble brukt i en nylig tidligere forespørsel. I motsetning til hurtigbufring på applikasjonsnivå, som returnerer et lagret svar, kaller hurtigbufring av ledetekstprefikser fortsatt modellen – men til en 50 prosent lavere pris for inputtoken for den bufrede delen av prefikset. Det reduserer kostnadene uten å ofre fersk generering.

Slik fungerer hurtigbufring av prefikser under panseret

Moderne LLM-er representerer ledetekster som KV-hurtigbuffere (key-value) i GPU-minnet. Behandling av en ledetekst innebærer å beregne oppmerksomhetsnøkler og -verdier for hvert token. Hvis de første N tokenene i to påfølgende forespørsler er identiske, kan OpenAI gjenbruke KV-hurtigbufferen fra den første forespørselen og hoppe over den kostbare beregningen for disse tokenene. API-et gjør dette automatisk og transparent – du betaler bare den lavere prisen for bufrede token når dette gjelder.

# No code changes needed to enable prefix caching!
# It is automatic on supported models.

# The API response shows you how many tokens were cached:
# response.usage.prompt_tokens_details.cached_tokens

# Example response usage:
# ChatCompletionUsage(
#   prompt_tokens=2048,
#   completion_tokens=256,
#   total_tokens=2304,
#   prompt_tokens_details=PromptTokensDetails(
#     cached_tokens=1984,   # these tokens were served from KV cache
#     audio_tokens=0,
#   )
# )

Kontrollere hurtigbuffertreff i svaret

Etter hvert API-kall undersøker du response.usage.prompt_tokens_details.cached_tokens for å se hvor mange inputtoken som ble levert fra KV-hurtigbufferen. Hvis cached_tokens > 0, betalte du den rabatterte prisen på 50 prosent for disse tokenene. Ved å logge denne verdien kan du følge den faktiske hurtigbuffereffektiviteten og beregne kostnadsbesparelsene fra prefikshurtigbufring over tid.

from openai import OpenAI

client = OpenAI()

SYSTEM_PROMPT = 'You are an expert AI engineer assistant. ' * 100  # long system prompt

def call_with_cache_check(user_message: str):
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': SYSTEM_PROMPT},
            {'role': 'user', 'content': user_message},
        ],
    )
    usage = response.usage
    cached = usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0
    print(f'Total prompt tokens: {usage.prompt_tokens}')
    print(f'Cached tokens: {cached} ({100*cached//usage.prompt_tokens}%)')
    return response.choices[0].message.content

Prefikset må være helt identisk

Prefikshurtigbufring gjelder bare når de første N tokenene er identiske byte for byte med en nylig tidligere forespørsel. Selv én enkelt tegnendring i systemmeldingen ugyldiggjør hurtigbufferen. OpenAI hurtigbufrer i blokker på 128 token – hurtigbufferen gjelder for komplette blokker som samsvarer nøyaktig. Det betyr at delen av ledeteksten som varierer fra forespørsel til forespørsel, bør komme etter det lange, stabile prefikset for å maksimere antallet bufrede token.

# Optimal structure for prefix caching:
# [LONG STABLE SYSTEM PROMPT] [CACHED DOCUMENTS] [USER QUERY]
#         ↑                              ↑                ↑
#    always same               always same         varies per request
#    → cached at 50%           → cached at 50%     → not cached, full price

# BAD structure (defeats prefix caching):
# [USER QUERY] [CACHED DOCUMENTS] [LONG STABLE SYSTEM PROMPT]
#       ↑                                       ↑
#  changes every request                 never cached because
#  so prefix never matches               it comes after the query

Strukturere ledetekster for maksimal hurtigbuffereffektivitet

Strukturer ledetekstene slik at de stabile delene kommer først, for å maksimere treffratene. I et RAG-system: (1) systemmelding med instruksjoner og persona, (2) hentede dokumenter som bare endres når spørringen endres betydelig, (3) samtalehistorikk, (4) brukerspørring helt til slutt. Selve systemmeldingen – ofte 500–2000 token – blir vanligvis bufret, noe som sparer 25–50 prosent av kostnadene for inputtoken.

def build_rag_prompt_for_caching(
    system_prompt: str,
    retrieved_docs: list[str],
    conversation_history: list[dict],
    user_query: str,
) -> list[dict]:
    # Order: stable → semi-stable → variable
    context_block = '\n\n'.join(
        f'[Document {i+1}]\n{doc}' for i, doc in enumerate(retrieved_docs)
    )
    return [
        # 1. Stable system prompt (always cached after first request)
        {'role': 'system', 'content': system_prompt},
        # 2. Context injection as a user message (cached when same docs retrieved)
        {'role': 'user', 'content': f'Context documents:\n{context_block}'},
        {'role': 'assistant', 'content': 'I have read the documents.'},
        # 3. Conversation history (semi-stable)
        *conversation_history,
        # 4. Current user query (always different → never cached prefix)
        {'role': 'user', 'content': user_query},
    ]

Hurtigbufferens varighet og tømming

OpenAI sin KV-hurtigbuffer opprettholdes i GPU-minnet og har en tømmingspolicy. Prefikser som ikke har blitt brukt på nytt i løpet av omtrent 5–10 minutter, tømmes når andre forespørsler tar opp GPU-minne. Det betyr at fordelene ved prefikshurtigbufring er størst for applikasjoner med høy gjennomstrømming og hyppige forespørsler som deler samme prefiks. Applikasjoner med lav trafikk kan få få hurtigbuffertreff fordi prefikset tømmes mellom forespørsler som kommer med lang tid imellom.

Støttede modeller og priser

Fra og med 2025 er hurtigbufring av ledetekstprefikser tilgjengelig for modellene GPT-4o, GPT-4o-mini, o1 og o3-mini. Prisen for bufrede token er 50 prosent av standardprisen for inputtoken for de fleste modeller. Minste lengde på et prefiks som kan hurtigbufres, er 1024 token – kortere prefikser får ingen rabatt. Sjekk alltid OpenAI sin prisside for gjeldende priser, siden prisene endres etter hvert som funksjonen videreutvikles.

# Rough pricing reference (verify at platform.openai.com/pricing)
PRICING = {
    'gpt-4o': {
        'input_per_1M': 2.50,
        'cached_input_per_1M': 1.25,   # 50% off
        'output_per_1M': 10.00,
    },
    'gpt-4o-mini': {
        'input_per_1M': 0.15,
        'cached_input_per_1M': 0.075,  # 50% off
        'output_per_1M': 0.60,
    },
}

def estimate_cost_with_caching(prompt_tokens, cached_tokens, output_tokens, model):
    p = PRICING[model]
    uncached = (prompt_tokens - cached_tokens) * p['input_per_1M'] / 1_000_000
    cached_cost = cached_tokens * p['cached_input_per_1M'] / 1_000_000
    output_cost = output_tokens * p['output_per_1M'] / 1_000_000
    return uncached + cached_cost + output_cost

Anthropic sin hurtigbufring av ledetekster

Anthropic tilbyr en lignende funksjon kalt hurtigbufring av ledetekster for Claude-modeller, men krever at du aktivt melder deg på ved å markere hurtigbufferavbrudd i ledeteksten med et cache_control-felt. I motsetning til OpenAI sin automatiske hurtigbufring markerer du uttrykkelig hvilke deler av ledeteksten som skal hurtigbufres (opptil 4 hurtigbufferavbrudd per forespørsel). Bufrede token koster 10 prosent av standardprisen for input og lagres i 5 minutter.

import anthropic

client = anthropic.Anthropic()

LONG_DOCUMENT = 'This is a very long reference document...' * 500  # 2000+ tokens

response = client.messages.create(
    model='claude-sonnet-4-5',
    max_tokens=1024,
    system=[
        {
            'type': 'text',
            'text': 'You are a helpful assistant.',
        },
        {
            'type': 'text',
            'text': LONG_DOCUMENT,
            'cache_control': {'type': 'ephemeral'},  # mark for caching
        }
    ],
    messages=[{'role': 'user', 'content': 'Summarize the document.'}],
)
print(response.usage.cache_read_input_tokens)   # tokens served from cache
print(response.usage.cache_creation_input_tokens)  # tokens written to cache

Kombinere prefikshurtigbufring med hurtigbufring på applikasjonsnivå

Prefikshurtigbufring og hurtigbufring på applikasjonsnivå er komplementære. Prefikshurtigbufring reduserer kostnaden for hvert API-kall, men kaller fortsatt LLM-en. Eksakte og semantiske hurtigbuffere på applikasjonsnivå eliminerer API-kall helt for gjentatte spørringer. Bruk prefikshurtigbufring for alle forespørsler for å redusere kostnaden per kall, og legg hurtigbufring på applikasjonsnivå oppå dette for å eliminere kall helt for spørringer som gjentas ofte. Til sammen kan de redusere kostnadene for AI-infrastruktur med 60–80 prosent.

# Three-layer cost optimization stack
#
# Layer 1: Exact cache (Redis, hash-based)
#   → Eliminates 100% of API cost for identical requests
#   → Miss rate: ~60-80% (most queries are unique)
#
# Layer 2: Semantic cache (vector similarity)
#   → Eliminates 100% of API cost for semantically similar requests
#   → Miss rate: ~40-60% of remaining queries
#
# Layer 3: OpenAI prefix caching (automatic)
#   → Reduces input token cost by 50% for long stable prefixes
#   → Applies to ALL remaining API calls that escape layers 1 and 2
#
# Combined effect: 60-80% cost reduction in FAQ/support applications

Måle effektiviteten til hurtigbufferen

Følg forholdet for hurtigbuffereffektivitet som en sammensatt måleverdi: totalt antall token til full pris delt på totalt antall token det faktisk ble fakturert for. Dette tar hensyn til alle hurtigbufferlag. Logg cached_tokens fra hvert API-svar og summer dem ukentlig. Et system der 50 prosent av tokenene er bufret på tvers av alle API-kall, halverer i praksis kostnadene for inputtoken, uten at det kreves endringer i applikasjonskoden for prefikshurtigbufring.

from dataclasses import dataclass, field
from typing import ClassVar

@dataclass
class CachingMetrics:
    total_prompt_tokens: int = 0
    total_cached_tokens: int = 0
    app_cache_hits: int = 0
    app_cache_misses: int = 0

    @property
    def prefix_cache_ratio(self) -> float:
        if self.total_prompt_tokens == 0:
            return 0
        return self.total_cached_tokens / self.total_prompt_tokens

    @property
    def app_cache_hit_rate(self) -> float:
        total = self.app_cache_hits + self.app_cache_misses
        return self.app_cache_hits / total if total > 0 else 0

    def report(self):
        print(f'App cache hit rate: {self.app_cache_hit_rate:.1%}')
        print(f'Prefix cache ratio: {self.prefix_cache_ratio:.1%}')
        savings_multiplier = (1 - self.app_cache_hit_rate) * (1 - 0.5 * self.prefix_cache_ratio)
        print(f'Effective cost vs no-cache: {savings_multiplier:.1%}')

Når prefikshurtigbufring ikke hjelper

Prefikshurtigbufring gir ingen gevinst i følgende tilfeller: (1) korte ledetekster på under 1024 token (minste lengde som kan hurtigbufres), (2) svært variable prefikser der systemmeldingen endres per bruker eller forespørsel, (3) applikasjoner med lav trafikk der KV-hurtigbufferen tømmes mellom forespørsler, eller (4) når du allerede betaler minste tokenpris. I disse tilfellene bør du heller rette optimaliseringsarbeidet mot semantisk hurtigbufring på applikasjonsnivå.

Kunnskapssjekk

Test forståelsen din av OpenAI sin hurtigbufring av ledetekstprefikser fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte du at OpenAI sin hurtigbufring av ledetekstprefikser automatisk gir 50 prosent rabatt på bufrede inputtoken når ledetekstprefikset samsvarer med en nylig tidligere forespørsel, at stabilt innhold må komme først i meldingsstrukturen (systemmelding, dokumenter og deretter brukerspørring) for å maksimere antallet bufrede token, og at Anthropic krever uttrykkelige cache_control-markører for en lignende funksjon i Claude. Kombiner dette med hurtigbufring på applikasjonsnivå for maksimal kostnadsreduksjon. Neste tema er bunting, modellruting og kostnadsdashbord, som fullfører verktøykassen for optimalisering.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «OpenAI-hurtigbufring av forespørselsprefiks» gratis?

Ja – hele teksten i «OpenAI-hurtigbufring av forespørselsprefiks» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI Engineering Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «OpenAI-hurtigbufring av forespørselsprefiks»?

Utnytt OpenAI sin automatiske hurtigbufring av forespørsler, som gir 50 prosent rabatt på gjentatte, lange prefikser i systemforespørsler, og strukturer forespørslene for å maksimere treffraten i hur… Du øver på AI Engineering Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI Engineering Academy?

Ingen tidligere erfaring er nødvendig. AI Engineering Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «OpenAI-hurtigbufring av forespørselsprefiks»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI Engineering Academy-leksjonen?

Ja. Alle AI Engineering Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Eksakt hurtigbufring med Redis
Semantisk hurtigbufring med embedding-er
OpenAI-hurtigbufring av forespørselsprefiks
Gruppering, modellruting og kostnadsdashbord

← Tilbake til AI Engineering Academy