Avancerad prompt-cachning
På denna sida
Utöver automatisk cachning
Du såg grunderna för prompt-cachning i lektion 3. Där framstod cachning som en automatisk mekanism som gynnar dig utan särskild ansträngning, och det stämmer så länge din applikation skickar välordnade förfrågningar. Produktionsverkligheten är rörigare: flera användare träffar samma API samtidigt, var och en med sin egen mapp, sina dokument och sina frågor. Det gemensamma prefixet krymper då till nästan ingenting, och träfffrekvensen för cachen kraschar utan att någon märker det, eftersom inget går sönder – fakturan blir bara högre.
Fleranvändarsystem, flerdocumentshantering och bearbetningspipelines: vi tar oss an dessa komplexa scenarier ett efter ett för att maximera träfffrekvensen i cachen. Den ledande principen ryms i en mening: cachning är inte något som händer dig; det är något du designar.
Prompt-arkitektur för att maximera cachning
Cachning gäller för det längsta gemensamma prefixet över dina förfrågningar. Ju längre och stabilare detta prefix är, desto mer sparar du. Den praktiska konsekvensen är att en prompt måste organiseras från mest stabil till mest variabel, som en bok där de första sidorna aldrig ändras och bara det sista kapitlet skrivs om vid varje upplaga.
Exemplet nedan tillämpar denna princip på en dokumentanalyserande assistent för en advokatbyrå. Tre lager följer på varandra: globala instruktioner, som är frysta; kunskapsbasen, som revideras en gång i månaden; och ärendemappen samt frågan, som ändras vid varje anrop.
import openai
client = openai.OpenAI()
# Lagerarkitektur: från mest stabil till mest variabel
# Lager 1: Globala instruktioner (ändras 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
"""
# Lager 2: Kunskapsbas (ändras sällan)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
analysis templates here—this content changes at most once a month]
"""
# Lager 3: Ärendesammanhang (ändras per klient)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Current Case ---
{case_context}
--- Question ---
{question}"""
Det klassiska misstaget är att placera klientens namn eller dagens datum i början av systemprompten för att “personifiera” den. En enda variabel tecken på den första positionen räcker för att göra prefixet unikt, vilket reducerar träfffrekvensen för cachen till noll för alla efterföljande lager. Allt som varierar måste placeras sist.
Självklart måste du verifiera att teorin översätts till siffror. Följande övervakare läser input_tokens_details.cached_tokens vid varje svar och ackumulerar mätningarna, vilket ger dig en användbar genomsnittlig frekvens istället för en magkänsla.
class CacheMonitor:
"""Övervakar effektiviteten hos prompt-cachning."""
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 "Inga anrop."
return (
f"Anrop: {len(self.calls)} | "
f"Genomsnittlig cachefrekvens: {self.average_rate:.1%} | "
f"Sparade tokens: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Tre mönster som gör skillnad
Det första mönstret gäller bearbetningsordning. När du bearbetar en batch av heterogena förfrågningar växlar körning i ankomstordning mellan prefix och hindrar cachen från att hållas varm. Gruppering efter delat sammanhang löser problemet: samla först, kör senare, så att varje grupp drar nytta av det prefix som primats av sin första förfrågan.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Grupperar förfrågningar efter gemensamt prefix."""
groups = defaultdict(list)
for request in requests:
# Nyckel = hash av delat sammanhang
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Bearbetar grupperade förfrågningar för att maximera cachning."""
groups = group_by_context(requests)
for key, group in groups.items():
# Alla förfrågningar i gruppen delar samma prefix
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 andra mönstret hanterar kallstarter. Den första förfrågan i en serie betalar fullt pris eftersom inget är cachat än; om den första förfrågan kommer från en riktig användare på en måndag morgon klockan 09.00, är det de som bär latensen. En uppvärmningsförfrågan som skickas innan tjänsten öppnar flyttar den kostnaden till där den inte stör någon. Notera skyddet i början av funktionen: under 1 024 tokens gäller inte cachning, och föruppvärmning skulle vara ren utgift.
def warm_up_cache(system_prompt: str):
"""Skickar en minimal förfrågan för att primma cachen."""
if len(system_prompt) // 4 < 1024:
print("Prompten är för kort för cachning (< 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"Cachen primmad: {usage.input_tokens} input-tokens, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} cachade"
)
Det tredje mönstret gör cache-invalidiering synlig. Att fixa ett kommatecken i en systemprompt på 5 000 tokens verkar trivialt, men det kommatecket tömmer cachen för alla. Genom att fästa ett fingeravtryck på innehållet upptäcker du ändringen vid distribution istället för dagen efter på fakturan, och du kan omedelbart följa upp med föruppvärmning.
import hashlib
class VersionedPrompt:
"""Hanterar prompt-versioner för att styra cachning."""
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
# Om versionen ändras kommer cachen att invalidieras
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")
if not prompt_v1.is_same_version(prompt_v2):
print("Varning: prompten ändrad, cachen kommer att invalidieras")
warm_up_cache(prompt_v2.content)
Vad detta betyder i volym
Ta ett verkligt fall med 10 000 anrop per dag med en systemprompt på 3 000 tokens. Utan cachning faktureras 10 000 × 3 000, eller 30 miljoner input-tokens varje dag. Med en träfffrekvens på 80 % återstår 6 miljoner tokens till fullt pris och 24 miljoner sjunker till halva priset, vilket ger besparingar på cirka 40 % för input-tokens. Siffran verkar blygsam i relation till ett enskilt anrop; över ett år i produktion förändrar det applikationens kostnadsstruktur.
Viktiga punkter
- Strukturera dina prompts i lager från mest stabil till mest variabel
- Gruppera förfrågningar efter delat sammanhang för att hålla cachen varm
- Värm upp cachen innan trafiktoppningar
- Övervaka cachefrekvensen med
input_tokens_details.cached_tokens - Versionera dina prompts för att förutse cache-invalidieringar