Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Napredno keširanje upita

Lekcija 13 od 20 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Iznad automatskog keširanja
  2. Arhitektura upita za maksimiziranje keširanja
  3. Tri obrasca koja čine razliku
  4. Što to znači u obujmu
  5. Ključne točke

Iznad automatskog keširanja

Osnove keširanja upita vidio si u Lekciji 3. Tamo se keširanje pojavilo kao automatski mehanizam koji ti koristi bez posebnog napora, i to je točno sve dok tvoja aplikacija šalje dobro uređene zahtjeve. Stvarnost u proizvodnji je kaotičnija: više korisnika istovremeno udara na isti API, svaki sa svojom mapom, dokumentima i pitanjima. Zajednički prefiks tada se smanjuje gotovo na ništa, a stopa pogodaka keša (cache hit rate) se urušava, a da to nitko ne primijeti, jer se ništa ne kvari – samo račun raste.

Višekorisnički okruženja, više dokumenata, obradni kanali: ove složene scenarije rješavat ćemo jedan po jedan kako bismo maksimizirali stopu pogodaka keša. Vodeće načelo staje u jednu rečenicu: keširanje nije nešto što ti se događa; to je nešto što dizajniraš.

Arhitektura upita za maksimiziranje keširanja

Keširanje se primjenjuje na najduži zajednički prefiks tvojih zahtjeva. Što je taj prefiks duži i stabilniji, to više štediš. Praktična posljedica je da upit mora biti organiziran od najstabilnijeg prema najpromjenjivijem dijelu, poput knjige čije se prve stranice nikada ne mijenjaju, a samo se posljednje poglavlje prepisuje sa svakim izdanjem.

Primjer u nastavku primjenjuje ovo načelo na asistenta za analizu dokumenata u odvjetničkom uredu. Tri sloja slijede jedno za drugim: globalne upute, koje su zamrznute; baza znanja, koja se revidira jednom mjesečno; te predmet i pitanje, koji se mijenjaju sa svakim pozivom.

import openai

client = openai.OpenAI()

# Slojevita arhitektura: od najstabilnijeg do najpromjenjivijeg

# Sloj 1: Globalne upute (nikada se ne mijenjaju)
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
"""

# Sloj 2: Baza znanja (rijetko se mijenja)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# Sloj 3: Kontekst predmeta (mijenja se po klijentu)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

--- Question ---
{question}"""

Klasična greška je stavljanje imena klijenta ili današnjeg datuma na početak sistemskog upita kako bi se on „personalizirao“. Jedan jedini promjenjivi znak na početnoj poziciji dovoljan je da prefiks postane jedinstven, smanjujući stopu pogodaka keša na nulu za sve naredne slojeve. Sve što varira mora ići na kraj.

Naravno, moraš provjeriti pretvara li se teorija u brojke. Sljedeći monitor čita input_tokens_details.cached_tokens na svakom odgovoru i akumulira mjerenja, dajući ti upotrebljivu prosječnu stopu umjesto osjećaja u trbuhu.

class CacheMonitor:
    """Prati učinkovitost keširanja upita."""

    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 "Nema poziva."
        return (
            f"Poziva: {len(self.calls)} | "
            f"Prosječna stopa keša: {self.average_rate:.1%} | "
            f"Ušteđeni tokeni: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Tri obrasca koja čine razliku

Prvi obrazac tiče se redoslijeda obrade. Kada obrađuješ šaržu heterogenih zahtjeva, njihovo pokretanje redom pristizanja izmjenjuje prefikse i sprječava da keš ostane „topao“. Grupiranje po zajedničkom kontekstu rješava problem: prvo prikupi, zatim izvrši, tako da svaka grupa ima koristi od prefiksa pripremljenog svojim prvim zahtjevom.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Grupira zahtjeve po zajedničkom prefiksu."""
    groups = defaultdict(list)

    for request in requests:
        # Ključ = hash zajedničkog konteksta
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Obrađuje grupirane zahtjeve za maksimiziranje keširanja."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # Svi zahtjevi u grupi dijele isti prefiks
        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 obrazac rješava hladne startove. Prvi zahtjev u nizu plaća punu cijenu jer još ništa nije keširano; ako taj prvi zahtjev dolazi od stvarnog korisnika u ponedjeljak ujutro u 9 sati, on snosi kašnjenje. Zahtjev za zagrijavanje poslan prije otvaranja usluge prebacuje taj trošak tamo gdje nikoga ne smeta. Obrati pažnju na zaštitu na početku funkcije: ispod 1.024 tokena, keširanje se ne primjenjuje, a predgrijavanje bi bio čisti trošak.

def warm_up_cache(system_prompt: str):
    """Šalje minimalni zahtjev za pripremu keša."""
    if len(system_prompt) // 4 < 1024:
        print("Upit prekratak za keširanje (< 1.024 tokena)")
        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"Keš pripremljen: {usage.input_tokens} ulaznih tokena, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} keširano"
    )

Treći obrazac čini invalidaciju keša vidljivom. Ispravljanje zareza u sistemskom upitu od 5.000 tokena čini se trivijalnim, no taj zarez briše keš za sve. Pripajanjem otiska prsta (fingerprint) sadržaju, promjenu detektiraš prilikom implementacije, a ne sutradan na računu, i možeš odmah nastaviti s predgrijavanjem.

import hashlib

class VersionedPrompt:
    """Upravlja verzijama upita za kontrolu keširanja."""

    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

# Ako se verzija promijeni, keš će biti invalidiran
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Upozorenje: upit promijenjen, keš će biti invalidiran")
    warm_up_cache(prompt_v2.content)

Što to znači u obujmu

Uzmimo stvarni slučaj od 10.000 poziva dnevno sa sistemskim upitom od 3.000 tokena. Bez keširanja, naplaćuješ 10.000 × 3.000, odnosno 30 milijuna ulaznih tokena svaki dan. Uz stopu pogodaka od 80%, 6 milijuna tokena ostaje po punoj cijeni, a 24 milijuna pada na pola cijene, što donosi uštedu od oko 40% na ulaznim tokenima. Brojka se čini skromnom u odnosu na jedan poziv; tijekom godine proizvodnje, ona mijenja strukturu troškova aplikacije.

Ključne točke

  • Strukturiraj svoje upite u slojeve, od najstabilnijih do najpromjenjivijih
  • Grupiraj zahtjeve po zajedničkom kontekstu kako bi keš ostao topao
  • Pripremi keš prije skokova u prometu
  • Prati stopu keša pomoću input_tokens_details.cached_tokens
  • Verzioniraj svoje upite kako bi anticipirao invalidacije keša