Cache avansat pentru prompturi
Pe această pagină
Dincolo de cache-ul automat
Ați văzut elementele de bază ale cache-ului pentru prompturi în Lecția 3. Acolo, cache-ul apărea ca un mecanism automat care vă avantajează fără niciun efort special, iar acest lucru este valabil atâta timp cât aplicația dumneavoastră trimite cereri bine ordonate. Realitatea din producție este mai haotică: mai mulți utilizatori accesează același API simultan, fiecare cu dosarul, documentele și întrebările sale proprii. Prefixul comun se reduce atunci la aproape nimic, iar rata de succes a cache-ului (cache hit rate) se prăbușește fără ca nimeni să observe, deoarece nimic nu se strică – doar factura crește.
Fluxuri de procesare cu mai mulți utilizatori și mai multe documente: vom aborda aceste scenarii complexe unul câte unul pentru a maximiza rata de succes a cache-ului. Principiul director se rezumă la o singură propoziție: cache-ul nu este ceva ce vi se întâmplă; este ceva ce proiectați.
Arhitectura promptului pentru maximizarea cache-ului
Cache-ul se aplică celui mai lung prefix comun dintre cererile dumneavoastră. Cu cât acest prefix este mai lung și mai stabil, cu atât economisiți mai mult. Consecința practică este că un prompt trebuie organizat de la cel mai stabil la cel mai variabil, asemenea unei cărți ale cărei prime pagini nu se schimbă niciodată, iar doar capitolul final este rescris la fiecare ediție.
Exemplul de mai jos aplică acest principiu unui asistent de analiză documentară pentru o firmă de avocatură. Trei straturi se succed: instrucțiuni globale, care sunt înghețate; baza de cunoștințe, revizuită o dată pe lună; și dosarul cazului împreună cu întrebarea, care se schimbă la fiecare apel.
import openai
client = openai.OpenAI()
# Arhitectură stratificată: de la cel mai stabil la cel mai variabil
# Stratul 1: Instrucțiuni globale (nu se schimbă niciodată)
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
"""
# Stratul 2: Baza de cunoștințe (se schimbă rar)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
analysis templates here—this content changes at most once a month]
"""
# Stratul 3: Contextul cazului (se schimbă per client)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Current Case ---
{case_context}
--- Question ---
{question}"""
Greșeala clasică este plasarea numelui clientului sau a datei de azi la începutul promptului de sistem pentru a-l „personaliza“. Un singur caracter variabil în poziția inițială este suficient pentru a face prefixul unic, reducând rata de succes a cache-ului la zero pentru toate straturile ulterioare. Orice variază trebuie plasat la final.
Desigur, trebuie să verificați dacă teoria se traduce în cifre. Monitorul de mai jos citește input_tokens_details.cached_tokens la fiecare răspuns și acumulează măsurătorile, oferindu-vă o rată medie utilizabilă în loc de o simplă intuiție.
class CacheMonitor:
"""Monitorizează eficiența cache-ului pentru prompturi."""
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 "Niciun apel."
return (
f"Apeluri: {len(self.calls)} | "
f"Rata medie de cache: {self.average_rate:.1%} | "
f"Tokeni economisiți: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Trei tipare care fac diferența
Primul tipar privește ordinea de procesare. Atunci când procesați un lot de cereri eterogene, rularea lor în ordinea sosirii alternează prefixele și împiedică menținerea cache-ului „cald“. Gruparea după context comun rezolvă problema: grupați mai întâi, executați ulterior, astfel încât fiecare grup să beneficieze de prefixul pregătit de prima sa cerere.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Grupează cererile după prefixul comun."""
groups = defaultdict(list)
for request in requests:
# Cheie = hash al contextului partajat
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Procesează cererile grupate pentru a maximiza cache-ul."""
groups = group_by_context(requests)
for key, group in groups.items():
# Toate cererile din grup partajează același 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)
Al doilea tipar gestionează starturile la rece (cold starts). Prima cerere dintr-o serie plătește prețul întreg, deoarece nimic nu este încă în cache; dacă acea primă cerere provine de la un utilizator real într-o luni dimineața la ora 9:00, acesta suportă latența. O cerere de încălzire (warm-up) trimisă înainte de deschiderea serviciului mută acel cost acolo unde nu deranjează pe nimeni. Observați garda de la începutul funcției: sub 1.024 de tokeni, cache-ul nu se aplică, iar preîncălzirea ar fi o cheltuială pură.
def warm_up_cache(system_prompt: str):
"""Trimite o cerere minimă pentru a pregăti cache-ul."""
if len(system_prompt) // 4 < 1024:
print("Prompt prea scurt pentru cache (< 1.024 tokeni)")
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 pregătit: {usage.input_tokens} tokeni de intrare, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} în cache"
)
Al treilea tipar face invalidarea cache-ului vizibilă. Corectarea unei virgule într-un prompt de sistem de 5.000 de tokeni pare trivială, totuși acea virgulă golește cache-ul pentru toată lumea. Prin atașarea unei amprente digitale (fingerprint) la conținut, detectați schimbarea la momentul implementării și nu a doua zi pe factură, și puteți continua imediat cu preîncălzirea.
import hashlib
class VersionedPrompt:
"""Gestionează versiunile de prompturi pentru a controla cache-ul."""
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
# Dacă versiunea se schimbă, cache-ul va fi invalidat
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")
if not prompt_v1.is_same_version(prompt_v2):
print("Avertisment: prompt modificat, cache-ul va fi invalidat")
warm_up_cache(prompt_v2.content)
Ce înseamnă acest lucru în volum
Luați un caz real de 10.000 de apeluri pe zi cu un prompt de sistem de 3.000 de tokeni. Fără cache, facturați 10.000 × 3.000, adică 30 de milioane de tokeni de intrare în fiecare zi. Cu o rată de succes de 80%, 6 milioane de tokeni rămân la preț întreg și 24 de milioane scad la jumătate de preț, aducând economiile la aproximativ 40% din tokenii de intrare. Cifra pare modestă raportat la un singur apel; pe parcursul unui an de producție, aceasta schimbă structura costurilor aplicației.
Puncte cheie
- Structurați prompturile în straturi, de la cel mai stabil la cel mai variabil
- Grupați cererile după contextul partajat pentru a menține cache-ul cald
- Încălziți cache-ul înainte de vârfurile de trafic
- Monitorizați rata de cache cu
input_tokens_details.cached_tokens - Versionați prompturile pentru a anticipa invalidările de cache