Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Predpomnjenje pozivov: Ponovna uporaba izračunov

Lekcija 3 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Kaj je predpomnjenje pozivov?
  2. Kako deluje
  3. Strukturiranje za maksimiranje predpomnilnika
  4. Ključne ugotovitve

Kaj je predpomnjenje pozivov?

Ko večkrat pošlješ isto predpono poziva – dolg sistemski poziv, podrobna navodila ali referenčni dokument – lahko OpenAI to predpono samodejno predpomni. Naknadni klici, ki si delijo to predpono, imajo koristi od skrajšanega časa do prvega žetona (TTFT) in nižjih stroškov za vhodne žetone. Z drugimi besedami, delo vnosu stabilnega konteksta se ne ponavlja za vsako zahtevo posebej.

Predpomnjenje pozivov je od leta 2025 samodejno: ničesar ni treba vklopiti. OpenAI zazna identične predpone in jih predpomni. Tvoj vpliv torej ni v vklopu ali izklopu mehanizma, temveč v tem, kako napišeš svoje pozive, da se ta mehanizem lahko uporabi. To je vprašanje strukture, ne konfiguracije, in prav tu večina ekip pušča denar na mizi.

Kako deluje

Predpomnilnik velja za predpone pozivov: prvi žetoni morajo biti od klica do klica strogo identični, ujemanje pa se ustavi pri prvem različnem znaku. Za sprožitev predpomnjenja je potreben najmanjši obseg 1.024 žetonov, kar takoj izključi kratke sistemske pozive. Predpomnilnik je deljen znotraj ene organizacije, kar pomeni, da si več storitev v tvojem podjetju, ki kličejo isto predpono, medsebojno pomaga. Njegova življenjska doba se giblje od nekaj minut do nekaj ur, brez trdnih zagotovil, dosežen prihranek pa znaša približno 50 % stroška predpomnjenih vhodnih žetonov.

Praktična posledica pravila o predponi je, da moraš stabilne elemente postaviti na začetek poziva, spremenljive elemente pa na konec. Storitev, ki na začetek sistemskega poziva vstavi današnji datum ali ID seje, ob vsakem klicu invalidira svoj predpomnilnik, ne da bi se tega sploh zavedala.

import openai

client = openai.OpenAI()

# ✅ Dobra struktura: najprej stabilni elementi
SYSTEM_PROMPT = """You are a legal assistant specializing in French
contract law. You analyze contractual clauses according to the
Civil Code and recent case law. You always respond by
structuring your analysis: 1) Clause identification,
2) Legal analysis, 3) Potential risks, 4) Recommendations.

Here is the reference contract to analyze:
[Insert a 2,000+ token document here that does not change between calls]
"""

def analyze_clause(clause: str) -> str:
    """Vsak klic ponovno uporabi predpomnilnik sistemskega poziva."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,  # Stabilna predpona = predpomnjeno
        input=f"Analyze this clause: {clause}",  # Spremenljivi del
    )
    return response.output_text

V tem primeru referenčna pogodba in okvir analize predstavljata nespremenljiv blok, medtem ko se klavzula, ki jo analiziraš, ob vsakem klicu spremeni. Če analiziraš štirideset klavzul iz iste pogodbe, plačaš kontekst po polni ceni le enkrat.

Preverjanje predpomnilnika

Optimizacija, ki je ne meriš, je le optimizacija, za katero misliš, da jo imaš. API v odgovoru vrne informacije o uporabi predpomnilnika:

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=SYSTEM_PROMPT,
    input="Analyze the non-compete clause.",
)

# Preveri uporabo predpomnilnika
usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Input tokens (cached): {usage.input_tokens_details.cached_tokens}")
print(f"Output tokens: {usage.output_tokens}")

# Če je cached_tokens > 0: predpomnilnik je bil uporabljen
cache_ratio = usage.input_tokens_details.cached_tokens / usage.input_tokens
print(f"Cache ratio: {cache_ratio:.1%}")

To razmerje beleži v proizvodnem okolju, namesto da bi ga preveril le enkrat med razvojem. Nenaden padec stopnje predpomnjenja je najbolj zanesljiv simptom nenamerne spremembe v konstrukciji poziva in to boš opazil, preden ti o tem pove mesečni račun.

Strukturiranje za maksimiranje predpomnilnika

Prvi pristop je namerno obogatitev sistemskega poziva. To se morda zdi protislovno, ko poskušaš zmanjšati število žetonov, vendar se ujema s pravilom o pragu: sistemski poziv z 900 žetoni nikoli ne bo predpomnjen, medtem ko isti poziv, obogaten s primeri few-shot in referenčnim dokumentom, preseže mejo in preklopi na znižano stopnjo za predpomnjeni del.

# Obogati sistemski poziv za maksimiranje predpomnilnika
ENRICHED_PROMPT = """
[Detailed instructions - 500+ tokens]
[Few-shot examples - 500+ tokens]
[Reference document - 1,000+ tokens]
---
Total > 1,024 tokens = eligible for cache
"""

V pogovoru z več krogi mehanizem deluje v tvojo korist brez dodatnega napora: akumulirana zgodovina tvori naravno stabilno predpono, ki z vsako izmenjavo raste. Dokler sporočila vedno znova vstavljaš v istem vrstnem redu, deseti krog izkorišča predpomnilnik, ki so ga zgradili prejšnji štirje.

def conversation_with_cache(history: list[dict], new_message: str):
    """Rastoča zgodovina samodejno maksimira predpomnilnik."""
    history.append({"role": "user", "content": new_message})

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,
        input=history,
    )

    history.append({
        "role": "assistant",
        "content": response.output_text,
    })
    return response.output_text

Končno, ker se življenjska doba predpomnilnika meri v minutah, združevanje zahtev, ki si delijo predpono, postane odločitev o načrtovanju. Obdelava štiridesetih klavzul iz pogodbe zaporedoma ohranja predpomnilnik „vroč”; če jih razporediš čez dan in mednje vpleteš druge datoteke, predpomnilnik med klici poteče.

import asyncio

async def batch_with_cache(clauses: list[str]) -> list[str]:
    """Pošilja zahteve hitro, da izkoristi predpomnilnik."""
    results = []
    for clause in clauses:
        result = analyze_clause(clause)
        results.append(result)
    return results

Tri napake poničijo vse to delo in so si podobne: sprememba začetka poziva, četudi le za en znak, invalidira predpomnilnik za celotno zahtevo; naključno spreminjanje vrstnega reda navodil, na primer z gradnjo poziva iz neurejenega slovarja, povzroči enak učinek občasno in ga je zato težko diagnosticirati; pričakovanje dobičkov pod pragom 1.024 žetonov pa pomeni poskus optimizacije nečesa, kar se nikoli ne sproži.

Ključne ugotovitve

  • Predpomnjenje pozivov je pri OpenAI samodejno – stabilne elemente postavi na začetek poziva
  • Najnižji prag: 1.024 identičnih žetonov v predponi
  • Dobiček: ~50 % pri predpomnjenih vhodnih žetonih + zmanjšan TTFT
  • Za potrditev predpomnjenja preveri usage.input_tokens_details.cached_tokens