Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Täiustatud vihjekätkimine

Õppetund 13 / 20 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Automaatsest kätkimisest kaugemale
  2. Vihje arhitektuur kätkimise maksimeerimiseks
  3. Kolm mustrit, mis teevad erinevuse
  4. Mida see mahus tähendab
  5. Peamised punktid

Automaatsest kätkimisest kaugemale

Nägid vihjekätkimise aluseid 3. tunnis. Seal paistis kätkimine automaatse mehhanismina, mis toob kasu ilma erilise vaevata, ja see kehtib seni, kuni sinu rakendus saadab hästi järjestatud päringuid. Tootmise reaalsus on segasem: mitu kasutajat tabavad sama API-d samaaegselt, igal oma kaust, dokumendid ja küsimused. Ühine prefiks kahaneb siis peaaegu nulliks ning vahemälu tabamuste määr kukub kokku, ilma et keegi seda märkaks, sest midagi ei lähe katki – arve lihtsalt kasvab.

Mitme kasutajaga, mitme dokumendiga ja töötlemise torustikud: võtame need keerulised stsenaariumid ükshaaval ette, et maksimeerida vahemälu tabamuste määra. Juhtiv põhimõte mahub ühte lausesse: kätkimine pole midagi, mis sinuga juhtub; see on midagi, mida sa kavandad.

Vihje arhitektuur kätkimise maksimeerimiseks

Kätkimine rakendub sinu päringute pikimale ühisele prefiksile. Mida pikem ja stabiilsem see prefiks on, seda rohkem sa säästad. Praktiline järeldus on, et vihje tuleb organiseerida kõige stabiilsemast kõige muutuvamini, nagu raamat, mille esimesed leheküljed ei muutu kunagi ja ainult viimane peatükk kirjutatakse iga väljaandega ümber.

Allpool olev näide rakendab seda põhimõtet advokaadibüroo dokumendianalüüsi assistendile. Järgnevad kolm kihti: globaalsed juhised, mis on külmutatud; teadmiste baas, mida vaadatakse üle kord kuus; ning juhtumi fail ja küsimus, mis muutuvad iga väljakutsega.

import openai

client = openai.OpenAI()

# Kihiline arhitektuur: kõige stabiilsemast kõige muutuvamani

# Kiht 1: Globaalsed juhised (ei muutu kunagi)
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
"""

# Kiht 2: Teadmiste baas (muutub harva)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# Kiht 3: Juhtumi kontekst (muutub iga kliendi kohta)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

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

Klassikaline viga on paigutada kliendi nimi või tänane kuupäev süsteemivihje algusse, et seda „isikupärastada“. Üksainus muutuv märk algpositsioonis piisab, et muuta prefiks unikaalseks, vähendades vahemälu tabamuste määra nulliks kõigi järgnevate kihtide puhul. Kõik, mis varieerub, peab minema viimaseks.

Muidugi pead veenduma, et teooria tõlkeb numbriteks. Järgnev monitor loeb igal vastusel input_tokens_details.cached_tokens ja kogub mõõtmisi, andes sulle kasutatava keskmise määra asemel kõhutunde.

class CacheMonitor:
    """Jälgib vihjekätkimise efektiivsust."""

    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 "Kõnesid pole."
        return (
            f"Kõnesid: {len(self.calls)} | "
            f"Keskmine vahemälu määr: {self.average_rate:.1%} | "
            f"Säästetud tokeneid: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Kolm mustrit, mis teevad erinevuse

Esimene muster puudutab töötlemise järjekorda. Kui töötled heterogeensete päringute partiid, vahelduvad prefiksid saabumise järjekorras töötamisel ja takistavad vahemälu soojana püsimist. Probleemi lahendab rühmitamine ühise konteksti järgi: kogu esmalt, käivita hiljem, nii et iga rühm saab kasu oma esimese päringu poolt ettevalmistatud prefiksist.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Rühmitab päringud ühise prefiksi järgi."""
    groups = defaultdict(list)

    for request in requests:
        # Võti = jagatud konteksti räsi
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Töötleb rühmitatud päringuid kätkimise maksimeerimiseks."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # Kõik rühma päringud jagavad sama prefiksi
        for request in group:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=request["shared_context"],
                input=request["question"],
            )
            monitor.record(response.usage)

Teine muster tegeleb külma käivitusega. Seeria esimene päring maksab täishinda, kuna midagi pole veel vahemällu salvestatud; kui see esimene päring tuleb reaalset kasutajalt esmaspäeva hommikul kell 9, kannab nemad latentsust. Enne teenuse avamist saadetud soojenduspäring nihutab selle kulu sinna, kus see kedagi ei häiri. Pane tähele kaitset funktsiooni alguses: alla 1024 tokeni kätkimine ei kehti ja eelsoojendamine oleks puhas kulu.

def warm_up_cache(system_prompt: str):
    """Saadab minimaalse päringu vahemälu ettevalmistamiseks."""
    if len(system_prompt) // 4 < 1024:
        print("Vihje on kätkimiseks liiga lühike (< 1024 tokenit)")
        return

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=system_prompt,
        input="Kinnita, et oled valmis.",
        max_output_tokens=10,
    )

    usage = response.usage
    print(
        f"Vahemälu ette valmistatud: {usage.input_tokens} sisendtokenit, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} vahemällu salvestatud"
    )

Kolmas muster teeb vahemälu kehtetuks tunnistamise nähtavaks. Komma parandamine 5000-tokenises süsteemivihjes tundub tühine, ometi tühjendab see comma vahemälu kõigi jaoks. Sisule sõrmejälje lisamisega tuvastad muudatuse kasutuselevõtul, mitte järgmisel päeval arvel, ja saad kohe jätkata eelsoojendamisega.

import hashlib

class VersionedPrompt:
    """Haldab vihje versioone kätkimise kontrollimiseks."""

    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

# Kui versioon muutub, tunnistatakse vahemälu kehtetuks
prompt_v1 = VersionedPrompt("Juhised v1...")
prompt_v2 = VersionedPrompt("Juhised v2 muudetud...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Hoiatus: vihje muutus, vahemälu tunnistatakse kehtetuks")
    warm_up_cache(prompt_v2.content)

Mida see mahus tähendab

Võtame reaalse juhtumi: 10 000 väljakutset päevas 3000-tokenise süsteemivihjega. Ilma kätkimiseta arvestatakse 10 000 × 3000 ehk 30 miljonit sisendtokenit iga päev. 80% tabamuste määraga jääb 6 miljonit tokenit täishinda ja 24 miljonit langeb poolhinda, tuues säästu sisendtokenitel umbes 40%. Number tundub ühe kõne suhtes tagasihoidlik; tootmises aasta jooksul muudab see rakenduse kulustruktuuri.

Peamised punktid

  • Struktureeri oma vihjed kihtidena kõige stabiilsemast kõige muutuvamani
  • Rühmita päringud ühise konteksti järgi, et hoida vahemälu soojana
  • Soojenda vahemälu enne liikluse tipphetki
  • Jälgi vahemälu määra kasutades input_tokens_details.cached_tokens
  • Versioneeri oma vihjeid, et ennustada vahemälu kehtetuks tunnistamisi