Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Avanceret prompt-caching

Lektion 13 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Ud over automatisk caching
  2. Prompt-arkitektur for at maksimere caching
  3. Tre mønstre, der gør forskellen
  4. Hvad dette betyder i volumen
  5. Vigtige pointer

Ud over automatisk caching

Du så grundprincipperne for prompt-caching i lektion 3. Der fremstod caching som en automatisk mekanisme, der gavner dig uden særlig indsats, og det holder stik, så længe din applikation sender velordnede forespørgsler. Produktionsvirkeligheden er mere rodet: Flere brugere rammer den samme API samtidigt, hver med deres egen mappe, dokumenter og spørgsmål. Det fælles præfiks krymper derefter til næsten ingenting, og cache-hit-raten kollapser, uden at nogen lægger mærke til det, da intet går i stykker – regningen bliver bare højere.

Multi-bruger, multi-dokument, behandlingspipelines: Vi tackler disse komplekse scenarier ét ad gangen for at maksimere cache-hit-raten. Det bærende princip kan opsummeres i én sætning: Caching er ikke noget, der bare sker for dig; det er noget, du designer.

Prompt-arkitektur for at maksimere caching

Caching anvendes på det længste fælles præfiks på tværs af dine forespørgsler. Jo længere og mere stabilt dette præfiks er, desto mere sparer du. Den praktiske konsekvens er, at en prompt skal organiseres fra det mest stabile til det mest variable, ligesom en bog, hvor de første sider aldrig ændres, og kun det sidste kapitel omskrives med hver udgave.

Eksemplet nedenfor anvender dette princip på en dokumentanalyseassistent til en advokatfirma. Tre lag følger efter hinanden: Globale instrukser, der er frosne; vidensbasen, der revideres én gang om måneden; og sagsmappen samt spørgsmålet, som ændrer sig ved hvert kald.

import openai

client = openai.OpenAI()

# Lagdelt arkitektur: Fra mest stabil til mest variabel

# Lag 1: Globale instrukser (ændres aldrig)
GLOBAL_INSTRUCTIONS = """
You are a document analysis assistant for a law firm.
Rules:
- Always respond in French
- Cite relevant legal articles
- Structure as: Analysis / Risks / Recommendations
- Be factual and precise
"""

# Lag 2: Vidensbase (ændres sjældent)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# Lag 3: Sagssammenhæng (ændres pr. klient)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

--- Question ---
{question}"""

Den klassiske fejl er at placere klientens navn eller dagens dato i starten af system-prompten for at „personalisere” den. Et enkelt variabelt tegn i den indledende position er nok til at gøre præfikset unikt, hvilket reducerer cache-hit-raten til nul for alle efterfølgende lag. Alt, der varierer, skal placeres sidst.

Selvfølgelig skal du verificere, at teorien omsættes til tal. Følgende monitor læser input_tokens_details.cached_tokens ved hvert svar og akkumulerer målingerne, hvilket giver dig en brugbar gennemsnitlig rate i stedet for en mavefornemmelse.

class CacheMonitor:
    """Overvåger effektiviteten af prompt-caching."""

    def __init__(self):
        self.calls: list[dict] = []

    def record(self, usage) -> dict:
        total_input = usage.input_tokens
        cached_tokens = getattr(
            usage.input_tokens_details, "cached_tokens", 0
        )
        rate = cached_tokens / total_input if total_input > 0 else 0

        entry = {
            "total_input": total_input,
            "cached_tokens": cached_tokens,
            "cache_rate": rate,
        }
        self.calls.append(entry)
        return entry

    @property
    def average_rate(self) -> float:
        if not self.calls:
            return 0.0
        return sum(a["cache_rate"] for a in self.calls) / len(self.calls)

    def report(self) -> str:
        if not self.calls:
            return "Ingen kald."
        return (
            f"Kald: {len(self.calls)} | "
            f"Gennemsnitlig cache-rate: {self.average_rate:.1%} | "
            f"Tokens sparet: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Tre mønstre, der gør forskellen

Det første mønster vedrører behandlingsrækkefølgen. Når du behandler en batch af heterogene forespørgsler, vil kørsel i ankomstorden få præfikserne til at skifte og forhindre cachen i at forblive varm. Gruppering efter fælles kontekst løser problemet: Saml først, udfør senere, så hver gruppe drager fordel af det præfiks, der er primet af dens første forespørgsel.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Grupperer forespørgsler efter fælles præfiks."""
    groups = defaultdict(list)

    for request in requests:
        # Nøgle = hash af delt kontekst
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Behandler grupperede forespørgsler for at maksimere caching."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # Alle forespørgsler i gruppen deler samme præfiks
        for request in group:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=request["shared_context"],
                input=request["question"],
            )
            monitor.record(response.usage)

Det andet mønster håndterer kolde starter. Den første forespørgsel i en serie betaler fuld pris, da intet er cachet endnu; hvis den første forespørgsel kommer fra en rigtig bruger på en mandag morgen kl. 9, bærer de latensen. En opvarmningsforespørgsel sendt før tjenesten åbner, flytter den omkostning til et tidspunkt, hvor det ikke gener nogen. Bemærk vagten i starten af funktionen: Under 1.024 tokens gælder caching ikke, og foropvarmning ville være ren udgift.

def warm_up_cache(system_prompt: str):
    """Sender en minimal forespørgsel for at prime cachen."""
    if len(system_prompt) // 4 < 1024:
        print("Prompten er for kort til caching (< 1.024 tokens)")
        return

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=system_prompt,
        input="Confirm that you are ready.",
        max_output_tokens=10,
    )

    usage = response.usage
    print(
        f"Cache primet: {usage.input_tokens} input-tokens, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} cachet"
    )

Det tredje mønster gør cache-invalidatering synlig. At rette et komma i en system-prompt på 5.000 tokens virker trivielt, alligevel tømmer det komma cachen for alle. Ved at knytte et fingeraftryk til indholdet opdager du ændringen ved udrulning i stedet for dagen efter på regningen, og du kan straks følge op med foropvarmning.

import hashlib

class VersionedPrompt:
    """Administrerer prompt-versioner for at styre caching."""

    def __init__(self, content: str):
        self.content = content
        self.version = hashlib.md5(content.encode()).hexdigest()[:8]

    def is_same_version(self, other: "VersionedPrompt") -> bool:
        return self.version == other.version

# Hvis versionen ændres, vil cachen blive invalidet
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Advarsel: Prompt ændret, cache vil blive invalidet")
    warm_up_cache(prompt_v2.content)

Hvad dette betyder i volumen

Tag et realistisk tilfælde med 10.000 kald om dagen med en system-prompt på 3.000 tokens. Uden caching faktureres 10.000 × 3.000, eller 30 millioner input-tokens hver dag. Med en hit-rate på 80 % forbliver 6 millioner tokens til fuld pris, og 24 millioner falder til halv pris, hvilket bringer besparelsen op på ca. 40 % på input-tokens. Tallet virker beskedent i forhold til et enkelt kald; over et års produktion ændrer det applikationens omkostningsstruktur.

Vigtige pointer

  • Strukturér dine prompts i lag fra mest stabil til mest variabel
  • Gruppér forespørgsler efter fælles kontekst for at holde cachen varm
  • Varm cachen op før trafikspidsbelastninger
  • Overvåg cache-raten med input_tokens_details.cached_tokens
  • Versionér dine prompts for at forudse cache-invalideringer