Pokročilé ukladanie promptov do vyrovnávacej pamäte
Na tejto strane
Za hranicami automatického ukladania do vyrovnávacej pamäte
Základy ukladania promptov do vyrovnávacej pamäte si videl v lekcii 3. Tam sa ukladanie javilo ako automatický mechanizmus, z ktorého máš prospech bez špeciálneho úsilia, a to platí dovtedy, kým tvoja aplikácia odosiela dobre usporiadané požiadavky. Realita v produkcii je však chaotická: viacerí používatelia zasahujú rovnaké API súčasne, každý so svojím priečinkom, dokumentmi a otázkami. Spoločná prefixová časť sa potom zmenší takmer na nulu a miera zásahu vyrovnávacej pamäte (cache hit rate) sa zrúti, pričom si to nikto nevšimne, keďže nič nefunguje nesprávne – len účet rastie.
Scenáre s viacerými používateľmi, viacerými dokumentmi a spracovateľskými pipeline: tieto zložité situácie budeme riešiť jednu po druhej, aby sme maximalizovali mieru zásahu vyrovnávacej pamäte. Usmerňujúci princíp sa zmestí do jednej vety: ukladanie do vyrovnávacej pamäte nie je niečo, čo sa ti deje; je to niečo, čo navrhneš.
Architektúra promptov na maximalizáciu ukladania do vyrovnávacej pamäte
Ukladanie do vyrovnávacej pamäte sa vzťahuje na najdlhší spoločný prefix naprieč tvojimi požiadavkami. Čím je tento prefix dlhší a stabilnejší, tým viac ušetríš. Praktickým dôsledkom je, že prompt musí byť organizovaný od najstabilnejších po najpremenlivejšie časti, ako kniha, ktorej prvé stránky sa nikdy nemenia a iba záverečná kapitola sa prepisuje s každým vydaním.
Nižšie uvedený príklad aplikuje tento princíp na asistenta na analýzu dokumentov pre advokátsku kanceláriu. Nasledujú tri vrstvy: globálne inštrukcie, ktoré sú nemenné; znalostná báza, revidovaná raz za mesiac; a spis prípadu spolu s otázkou, ktoré sa menia pri každom volaní.
import openai
client = openai.OpenAI()
# Vrstvená architektúra: od najstabilnejších po najpremenlivejšie
# Vrstva 1: Globálne inštrukcie (nikdy sa nemenia)
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
"""
# Vrstva 2: Znalostná báza (mení sa zriedka)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
analysis templates here—this content changes at most once a month]
"""
# Vrstva 3: Kontext prípadu (mení sa podľa klienta)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Current Case ---
{case_context}
--- Question ---
{question}"""
Klasickou chybou je umiestniť meno klienta alebo dnešný dátum na začiatok systémového promptu, aby bol „personalizovaný“. Jediný premenný znak na počiatočnej pozícii stačí na to, aby sa prefix stal jedinečným, čím sa miera zásahu vyrovnávacej pamäte pre všetky nasledujúce vrstvy zníži na nulu. Všetko, čo sa mení, musí ísť až na koniec.
Samozrejme, musíš overiť, či sa teória premietne do čísel. Nasledujúci monitor číta input_tokens_details.cached_tokens pri každej odpovedi a akumuluje merania, čím ti poskytne použiteľnú priemernú mieru namiesto pocitu založeného na odhade.
class CacheMonitor:
"""Monitoruje efektivitu ukladania promptov do vyrovnávacej pamäte."""
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 "Žiadne volania."
return (
f"Volania: {len(self.calls)} | "
f"Priemerná miera cache: {self.average_rate:.1%} | "
f"Ušetrené tokeny: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Tri vzory, ktoré robia rozdiel
Prvý vzor sa týka poradia spracovania. Keď spracovávaš dávku heterogénnych požiadaviek, ich spúšťanie v poradí príchodu strieda prefixy a bráni tomu, aby zostala vyrovnávacia pamäť „teplá“. Problém rieši zoskupenie podľa spoločného kontextu: najprv zozbieraj, potom vykonaj, aby každá skupina využila prefix pripravený jej prvou požiadavkou.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Zoskupí požiadavky podľa spoločného prefixu."""
groups = defaultdict(list)
for request in requests:
# Kľúč = hash zdieľaného kontextu
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Spracováva zoskupené požiadavky na maximalizáciu ukladania do cache."""
groups = group_by_context(requests)
for key, group in groups.items():
# Všetky požiadavky v skupine zdieľajú rovnaký 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)
Druhý vzor rieši studené štarty. Prvá požiadavka v sérii zaplatí plnú cenu, keďže zatiaľ nič nie je uložené v cache; ak táto prvá požiadavka príde od skutočného používateľa v pondelok ráno o 9:00, znáša oneskorenie práve on. Požiadavka na zahriatie (warm-up) odoslaná pred spustením služby presunie tieto náklady tam, kde nikomu neprekážajú. Všimni si ochranu na začiatku funkcie: pod 1 024 tokenov sa ukladanie do vyrovnávacej pamäte neuplatňuje a predhrievanie by bolo čistým výdavkom.
def warm_up_cache(system_prompt: str):
"""Odošle minimálnu požiadavku na prípravu vyrovnávacej pamäte."""
if len(system_prompt) // 4 < 1024:
print("Prompt je príliš krátky na ukladanie do cache (< 1 024 tokenov)")
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 pripravená: {usage.input_tokens} vstupných tokenov, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} uložených v cache"
)
Tretí vzor robí invalidáciu vyrovnávacej pamäte viditeľnou. Oprava čiarky v systémovom prompte s 5 000 tokenmi sa môže zdať triviálna, no táto čiarka vyprázdni vyrovnávaciu pamäť pre všetkých. Pripojením odtlačku (fingerprint) k obsahu zistíš zmenu pri nasadení, nie až o deň neskôr na účte, a môžeš okamžite nasledovať predhriatím.
import hashlib
class VersionedPrompt:
"""Spravuje verzie promptov na kontrolu ukladania do vyrovnávacej pamäte."""
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
# Ak sa verzia zmení, vyrovnávacia pamäť bude invalidovaná
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")
if not prompt_v1.is_same_version(prompt_v2):
print("Upozornenie: prompt sa zmenil, vyrovnávacia pamäť bude invalidovaná")
warm_up_cache(prompt_v2.content)
Čo to znamená vo veľkom objeme
Zoberme si reálny prípad 10 000 volaní denne so systémovým promptom obsahujúcim 3 000 tokenov. Bez ukladania do vyrovnávacej pamäte fakturuješ 10 000 × 3 000, čo je 30 miliónov vstupných tokenov každý deň. Pri 80 % miere zásahu zostane 6 miliónov tokenov za plnú cenu a 24 miliónov klesne na polovičnú cenu, čo prináša úspory približne 40 % na vstupných tokenoch. Toto číslo sa môže zdať modestné vzhľadom na jedno volanie; v priebehu roka prevádzky však mení nákladovú štruktúru aplikácie.
Kľúčové poznatky
- Štruktúruj svoje prompty vo vrstvách od najstabilnejších po najpremenlivejšie
- Zoskupuj požiadavky podľa zdieľaného kontextu, aby si udržal vyrovnávaciu pamäť teplú
- Pred nárastom prevádzky vyrovnávaciu pamäť predhrej
- Monitoruj mieru ukladania do vyrovnávacej pamäte pomocou
input_tokens_details.cached_tokens - Verziuj svoje prompty, aby si anticipoval invalidácie vyrovnávacej pamäte