Napredno predpomnjenje pozivov
Na tej strani
Onkraj samodejnega predpomnjenja
Osnove predpomnjenja pozivov si spoznal v 3. lekciji. Tam se je predpomnjenje kazalo kot samodejni mehanizem, ki ti koristi brez posebnega truda, in to drži, dokler tvoja aplikacija pošilja dobro urejene zahteve. Realnost v proizvodnem okolju je bolj kaotična: več uporabnikov hkrati obremenjuje isti API, vsak s svojo mapo, dokumenti in vprašanji. Skupna predpona se nato skrči na skoraj nič, stopnja zadetkov v predpomnilniku pa se zruši, ne da bi kdo kaj opazil, saj se nič ne pokvari – račun se le poveča.
Več uporabnikov, več dokumentov, obdelovalni procesi: te kompleksne scenarije bomo obravnavali enega za drugim, da bi maksimizirali stopnjo zadetkov v predpomnilniku. Vodilno načelo lahko strnemo v en stavek: predpomnjenje ni nekaj, kar se ti zgodi; nekaj je, kar načrtuješ.
Arhitektura poziva za maksimizacijo predpomnjenja
Predpomnjenje velja za najdaljšo skupno predpono med tvojimi zahtevami. Daljša in stabilnejša kot je ta predpona, več prihraniš. Praktična posledica je, da mora biti poziv organiziran od najbolj stabilnega do najbolj spremenljivega, kot knjiga, katere prve strani se nikoli ne spremenijo, pri vsaki izdaji pa se prepíše le zadnje poglavje.
Spodnji primer uporablja to načelo za asistenta za analizo dokumentov v odvetniški pisarni. Sledijo si tri plasti: globalna navodila, ki so zamrznjena; zbirka znanja, ki se posodablja enkrat mesečno; ter spis primera in vprašanje, ki se spreminjata z vsakim klicem.
import openai
client = openai.OpenAI()
# Plastna arhitektura: od najbolj stabilnega do najbolj spremenljivega
# Plast 1: Globalna navodila (se nikoli ne spremenijo)
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
"""
# Plast 2: Zbirka znanja (se redko spreminja)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
analysis templates here—this content changes at most once a month]
"""
# Plast 3: Kontekst primera (se spreminja za vsakega klienta)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Current Case ---
{case_context}
--- Question ---
{question}"""
Klasična napaka je postavitev imena klienta ali današnjega datuma na začetek sistemskega poziva, da bi ga „personaliziral”. Že en sam spremenljiv znak na začetnem položaju zadostuje, da postane predpona edinstvena, kar stopnjo zadetkov v predpomnilniku za vse naslednje plasti zniža na nič. Vse, kar se spreminja, mora biti na koncu.
Seveda moraš preveriti, ali se teorija prevede v številke. Naslednji monitor bere input_tokens_details.cached_tokens pri vsakem odgovoru in kopiči meritve, kar ti namesto občutka v želodcu poda uporabno povprečno stopnjo.
class CacheMonitor:
"""Spremlja učinkovitost predpomnjenja pozivov."""
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 "Ni klicev."
return (
f"Klici: {len(self.calls)} | "
f"Povprečna stopnja predpomnilnika: {self.average_rate:.1%} | "
f"Prihranjeni žetoni: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Trije vzorci, ki delajo razliko
Prvi vzorec se nanaša na vrstni red obdelave. Ko obdeluješ paket heterogenih zahtev, njihovo izvajanje po vrsti prihoda izmenjuje predpone in preprečuje, da bi predpomnilnik ostal „topel”. Težavo reši grupiranje po skupnem kontekstu: najprej zberi, nato izvrši, tako da ima vsaka skupina korist od predpone, ki jo je pripravila njena prva zahteva.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Grupira zahteve po skupni predponi."""
groups = defaultdict(list)
for request in requests:
# Ključ = hash skupnega konteksta
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Obdeluje grupirane zahteve za maksimizacijo predpomnjenja."""
groups = group_by_context(requests)
for key, group in groups.items():
# Vse zahteve v skupini delijo isto predpono
for request in group:
response = client.responses.create(
model="gpt-5.6-terra",
instructions=request["shared_context"],
input=request["question"],
)
monitor.record(response.usage)
Drugi vzorec obravnava hladne zagonе. Prva zahteva v seriji plača polno ceno, saj še nič ni predpomnjeno; če ta prva zahteva pride od stvarnega uporabnika v ponedeljek zjutraj ob 9. uri, ta nosi latenco. Zahteva za ogrevanje, poslana pred odprtjem storitve, ta strošek prestavi tja, kjer nikomur ne dela težav. Opazi varovalo na začetku funkcije: pod 1024 žetoni se predpomnjenje ne uporablja in predhodno ogrevanje bi bil čist strošek.
def warm_up_cache(system_prompt: str):
"""Pošlje minimalno zahtevo za pripravo predpomnilnika."""
if len(system_prompt) // 4 < 1024:
print("Poziv je prekratek za predpomnjenje (< 1.024 žetonov)")
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"Predpomnilnik pripravljen: {usage.input_tokens} vhodnih žetonov, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} predpomnjenih"
)
Tretji vzorec naredi invalidacijo predpomnilnika vidno. Popravek vejice v sistemskem pozivu z 5000 žetoni se zdi trivialen, vendar ta vejica izprazni predpomnilnik za vse. Z dodajanjem prstnega odtisa vsebini spremembo zaznaš ob uvedbi in ne šele naslednji dan na računu, takoj zatem pa lahko slediš s predhodnim ogrevanjem.
import hashlib
class VersionedPrompt:
"""Upravlja različice pozivov za nadzor predpomnjenja."""
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
# Če se različica spremeni, bo predpomnilnik invalidiran
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")
if not prompt_v1.is_same_version(prompt_v2):
print("Opozorilo: poziv spremenjen, predpomnilnik bo invalidiran")
warm_up_cache(prompt_v2.content)
Kaj to pomeni v obsegu
Vzemimo realen primer 10.000 klicev na dan s sistemskim pozivom, ki ima 3000 žetonov. Brez predpomnjenja zaračunaš 10.000 × 3000, kar je 30 milijonov vhodnih žetonov vsak dan. Pri 80-odstotni stopnji zadetkov ostane 6 milijonov žetonov polno zaračunanih, 24 milijonov pa pade na polovično ceno, kar prinese prihranek približno 40 % pri vhodnih žetonih. Številka se zdi skromna glede na en sam klic; skozi leto proizvodnje pa spremeni stroškovno strukturo aplikacije.
Ključne ugotovitve
- Strukturiraj svoje pozive v plasti od najbolj stabilnega do najbolj spremenljivega
- Grupiraj zahteve po skupnem kontekstu, da ohraniš predpomnilnik topel
- Ogrej predpomnilnik pred konicami prometa
- Spremljaj stopnjo predpomnilnika z
input_tokens_details.cached_tokens - Izdelaj različice svojih pozivov, da predvidiš invalidacije predpomnilnika