Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Kehittynyt kehotevälimuisti

Oppitunti 13 / 20 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Automaattisen välimuistin tuolla puolen
  2. Kehotearkkitehtuuri välimuistin maksimoimiseksi
  3. Kolme mallia, jotka tekevät eron
  4. Mitä tämä tarkoittaa volyymissa
  5. Keskeiset asiat

Automaattisen välimuistin tuolla puolen

Näit kehostevälimuistin perusteet oppitunnilla 3. Siellä välimuisti vaikutti automaattiselta mekanismilta, joka hyödyttää sinua ilman erityisiä ponnisteluja, ja tämä pitää paikkansa niin kauan kuin sovelluksesi lähettää hyvin järjestettyjä pyyntöjä. Tuotantoympäristön todellisuus on sotkuisempi: useat käyttäjät osuvat samaan APIin samanaikaisesti, jokainen omien kansioidensa, dokumenttiensa ja kysymystensä kanssa. Yhteinen etuliite kutistuu tällöin lähes olemattomiin, ja välimuistin osumaprosentti romahtaa kenenkään huomaamatta, sillä mikään ei hajoa – lasku vain kasvaa.

Monikäyttäjä-, monidokumentti- ja käsittelyputket: käymme nämä monimutkaiset skenaariot läpi yksi kerrallaan välimuistin osumaprosentin maksimoimiseksi. Ohjaava periaate mahtuu yhteen lauseeseen: välimuisti ei ole jotain, mitä sinulle tapahtuu; se on jotain, mitä suunnittelet.

Kehotearkkitehtuuri välimuistin maksimoimiseksi

Välimuisti koskee pyyntöjesi pisintä yhteistä etuliitettä. Mitä pidempi ja vakaampi tämä etuliite on, sitä enemmän säästät. Käytännön seuraus on, että kehotte on järjestettävä vakaimmasta muuttuvimpaan, kuin kirja, jonka ensimmäiset sivut eivät koskaan muutu ja vain viimeinen luku kirjoitetaan uudelleen jokaisessa painoksessa.

Alla oleva esimerkki soveltaa tätä periaatetta asianajotoimiston dokumenttianalyysiavustajaan. Kolme kerrosta seuraavat toisiaan: globaalit ohjeet, jotka ovat jäädytettyjä; tietokanta, jota tarkistetaan kerran kuussa; sekä tapausaineisto ja kysymys, jotka muuttuvat jokaisessa kutsussa.

import openai

client = openai.OpenAI()

# Kerrosarkkitehtuuri: vakaimmasta muuttuvimpaan

# Kerros 1: Globaalit ohjeet (eivät koskaan muutu)
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
"""

# Kerros 2: Tietokanta (muuttuu harvoin)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# Kerros 3: Tapauksen konteksti (muuttuu asiakaskohtaisesti)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

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

Klassinen virhe on sijoittaa asiakkaan nimi tai tämän päivän päivämäärä järjestelmäkehotteen alkuun sen “personoimiseksi”. Yksi muuttuva merkki alkupäässä riittää tekemään etuliitteestä ainutlaatuisen, mikä pudottaa välimuistin osumaprosentin nollaan kaikille seuraaville kerroksille. Kaiken, mikä vaihtelee, täytyy mennä viimeiseksi.

Sinun tulee tietenkin varmistaa, että teoria muuttuu numeroiksi. Seuraava monitori lukee input_tokens_details.cached_tokens jokaisesta vastauksesta ja kertyy mittaukset, antaen sinulle käyttökelpoisen keskiarvon pelkän mututuntuman sijaan.

class CacheMonitor:
    """Valvoo kehostevälimuistin tehokkuutta."""

    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 "Ei kutsuja."
        return (
            f"Kutsuja: {len(self.calls)} | "
            f"Keskimääräinen välimuistisuhde: {self.average_rate:.1%} | "
            f"Säästetyt tokenit: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Kolme mallia, jotka tekevät eron

Ensimmäinen malli koskee käsittelyjärjestystä. Kun käsittelet erilaisten pyyntöjen erää, niiden suorittaminen saapumisjärjestyksessä vuorottelee etuliitteitä ja estää välimuistia pysymästä lämpimänä. Ryhmittely yhteisen kontekstin mukaan ratkaisee ongelman: kerää ensin, suorita myöhemmin, jotta jokainen ryhmä hyötyy ensimmäisen pyynnön virittämästä etuliitteestä.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Ryhmittelee pyynnöt yhteisen etuliitteen mukaan."""
    groups = defaultdict(list)

    for request in requests:
        # Avain = jaetun kontekstin tiiviste
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Käsittelee ryhmitellyt pyynnöt välimuistin maksimoimiseksi."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # Kaikki ryhmän pyynnöt jakavat saman etuliitteen
        for request in group:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=request["shared_context"],
                input=request["question"],
            )
            monitor.record(response.usage)

Toinen malli käsittelee kylmiä käynnistyksiä. Sarjan ensimmäinen pyyntö maksaa täyden hinnan, sillä mitään ei ole vielä välimuistissa; jos tämä ensimmäinen pyyntö tulee oikealta käyttäjältä maanantaiaamuna klo 9, hän kantaa viiveen kustannuksen. Lämmityspyyntö, joka lähetetään ennen palvelun avaamista, siirtää tämän kustannuksen sinne, missä se ei haittaa ketään. Huomaa suojaus funktion alussa: alle 1 024 tokenin välimuisti ei toimi, ja esilämmitys olisi puhdasta kulua.

def warm_up_cache(system_prompt: str):
    """Lähettää minimaalisen pyynnön välimuistin virittämiseksi."""
    if len(system_prompt) // 4 < 1024:
        print("Kehote liian lyhyt välimuistille (< 1 024 tokenia)")
        return

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=system_prompt,
        input="Vahvista, että olet valmis.",
        max_output_tokens=10,
    )

    usage = response.usage
    print(
        f"Välimuisti viritetty: {usage.input_tokens} syöttötokenia, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} välimuistissa"
    )

Kolmas malli tekee välimuistin mitätöinnistä näkyvää. Pilkun korjaaminen 5 000 tokenin järjestelmäkehotteessa vaikuttaa triviaalilta, mutta tuo pilkku tyhjentää välimuistin kaikilta. Kiinnittämällä sisältöön sormenjälki havaitset muutoksen käyttöönoton yhteydessä etkä vasta seuraavana päivänä laskulla, ja voit heti seurata sitä esilämmityksellä.

import hashlib

class VersionedPrompt:
    """Hallinnoi kehotteiden versioita välimuistin hallitsemiseksi."""

    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

# Jos versio muuttuu, välimuisti mitätöityy
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Varoitus: kehotte muuttunut, välimuisti mitätöityy")
    warm_up_cache(prompt_v2.content)

Mitä tämä tarkoittaa volyymissa

Ota todellinen tapaus: 10 000 kutsua päivässä 3 000 tokenin järjestelmäkehotteella. Ilman välimuistia laskutat 10 000 × 3 000, eli 30 miljoonaa syöttötokenia joka päivä. 80 %:n osumaprosentilla 6 miljoonaa tokenia jää täyden hinnan piiriin ja 24 miljoonaa putoaa puoleen hintaan, tuoden säästöt noin 40 %:iin syöttötokeneista. Luku vaikuttaa vaatimattomalta yksittäiseen kutsuun verrattuna; vuoden tuotantokäytön aikana se muuttaa sovelluksen kustannusrakennetta.

Keskeiset asiat

  • Järjestä kehotteesi kerroksittain vakaimmasta muuttuvimpaan
  • Ryhmittele pyynnöt jaetun kontekstin mukaan välimuistin lämpimänä pitämiseksi
  • Lämmitä välimuisti ennen liikennehuippuja
  • Valvo välimuistisuhdetta käyttämällä input_tokens_details.cached_tokens
  • Versioi kehotteesi ennakoidaksesi välimuistin mitätöinnit