Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Haladó prompt gyorsítótárazás

13. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. Túl az automatikus gyorsítótárazáson
  2. Prompt architektúra a gyorsítótárazás maximalizálására
  3. Három minta, ami számít
  4. Mit jelent ez mennyiségben?
  5. Főbb megállapítások

Túl az automatikus gyorsítótárazáson

A 3. leckében már láttad a prompt gyorsítótárazás alapjait. Ott a gyorsítótárazás olyan automatikus mechanizmusként jelent meg, amely külön erőfeszítés nélkül segít neked, és ez addig igaz is, amíg az alkalmazásod jól sorrendezett kéréseket küld. A valóság a éles környezetben azonban rendezetlenebb: több felhasználó egyszerre éri el ugyanazt az API-t, mindegyikük saját mappával, dokumentumokkal és kérdésekkel. A közös prefix ezután szinte semmire zsugorodik, a gyorsítótár-találati arány pedig észrevétlenül összeomlik, mivel semmi sem romlik el – csak a számla nő.

Többfelhasználós, többdokumentumos feldolgozási folyamatok: ezeket a komplex forgatókönyveket egyesével vesszük górcső alá, hogy maximalizáljuk a gyorsítótár-találati arányt. A vezérelv egyetlen mondatba foglalható: a gyorsítótárazás nem valami, ami történik veled; hanem valami, amit te tervezel meg.

Prompt architektúra a gyorsítótárazás maximalizálására

A gyorsítótárazás a kéréseid közötti leghosszabb közös prefixre vonatkozik. Minél hosszabb és stabilabb ez a prefix, annál többet spórolsz. A gyakorlati következmény az, hogy a promptot a legstabilabbtól a legváltozékonyabbig kell megszervezni, mint egy könyvet, amelynek első oldalai sosem változnak, és csak az utolsó fejezetet írják át minden kiadásnál.

Az alábbi példa ezt az elvet alkalmazza egy ügyvédi iroda dokumentumelemző asszisztensére. Három réteg követi egymást: globális utasítások, amelyek befagyasztva maradnak; a tudásbázis, amely havonta egyszer frissül; valamint az ügyirat és a kérdés, amelyek minden hívásnál változnak.

import openai

client = openai.OpenAI()

# Réteges architektúra: a legstabilabbtól a legváltozékonyabbig

# 1. réteg: Globális utasítások (sosem változnak)
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
"""

# 2. réteg: Tudásbázis (ritkán változik)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# 3. réteg: Ügy kontextusa (ügyfelenként változik)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

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

A klasszikus hiba, ha az ügyfél nevét vagy a mai dátumot a rendszerprompt elejére helyezed, hogy „személyre szabd“. Egyetlen változó karakter a kezdő pozícióban elég ahhoz, hogy a prefix egyedi legyen, ezzel nullára csökkentve a gyorsítótár-találati arányt az összes ezt követő rétegnél. Mindennek, ami változik, legvégül kell lennie.

Természetesen ellenőrizned kell, hogy az elmélet számokban is megjelenik-e. Az alábbi monitor minden válasznál leolvassa az input_tokens_details.cached_tokens értéket, és felhalmozza a méréseket, így használható átlagos arányt kapsz a hasraütés helyett.

class CacheMonitor:
    """Figyeli a prompt gyorsítótárazás hatékonyságát."""

    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 "Nincsenek hívások."
        return (
            f"Hívások: {len(self.calls)} | "
            f"Átlagos gyorsítótár-arány: {self.average_rate:.1%} | "
            f"Megtakarított tokenek: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Három minta, ami számít

Az első minta a feldolgozási sorrendre vonatkozik. Ha heterogén kérések batchét dolgozol fel, a beérkezési sorrendben történő futtatás felváltja a prefixeket, és megakadályozza, hogy a gyorsítótár melegen maradjon. A közös kontextus szerinti csoportosítás megoldja a problémát: először gyűjts össze, aztán hajts végre, így minden csoport profitál az első kérés által előkészített prefixből.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Csoportosítja a kéréseket közös prefix alapján."""
    groups = defaultdict(list)

    for request in requests:
        # Kulcs = a közös kontextus hash-e
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """A csoportosított kérések feldolgozása a gyorsítótárazás maximalizálására."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # A csoport összes kérése ugyanazt a prefixet osztja meg
        for request in group:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=request["shared_context"],
                input=request["question"],
            )
            monitor.record(response.usage)

A második minta a hideg indításokat kezeli. Egy sorozat első kérése teljes árat fizet, mivel még semmi sincs gyorsítótárazva; ha ez az első kérés egy valódi felhasználótól érkezik hétfő reggel 9 órakor, ő viseli a késleltetés terhét. Egy előmelegítő kérés, amelyet a szolgáltatás megnyitása előtt küldesz el, áthárítja ezt a költséget oda, ahol senkit sem zavar. Figyeld meg a függvény elején lévő védőfeltételt: 1024 token alatt a gyorsítótárazás nem érvényesül, és az előmelegítés tiszta kiadás lenne.

def warm_up_cache(system_prompt: str):
    """Minimális kérést küld a gyorsítótár előkészítésére."""
    if len(system_prompt) // 4 < 1024:
        print("A prompt túl rövid a gyorsítótárazáshoz (< 1024 token)")
        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"Gyorsítótár előkészítve: {usage.input_tokens} bemeneti token, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} gyorsítótárazva"
    )

A harmadik minta láthatóvá teszi a gyorsítótár érvénytelenítését. Egy vessző javítása egy 5000 tokenes rendszerpromptban triviálisnak tűnhet, mégis ez a vessző mindenki számára kiüríti a gyorsítótárat. Ha ujjlenyomatot (fingerprint) csatolsz a tartalomhoz, a változást már a telepítéskor észleled, nem pedig másnap a számlán, és azonnal követheted előmelegítéssel.

import hashlib

class VersionedPrompt:
    """Kezeli a prompt verzióit a gyorsítótárazás szabályozására."""

    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

# Ha a verzió változik, a gyorsítótár érvénytelenné válik
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Figyelem: a prompt megváltozott, a gyorsítótár érvénytelenné válik")
    warm_up_cache(prompt_v2.content)

Mit jelent ez mennyiségben?

Vegyünk egy valós esetet: napi 10 000 hívás egy 3000 tokenes rendszerprompttal. Gyorsítótárazás nélkül napi 10 000 × 3000, azaz 30 millió bemeneti tokent számláznak ki. 80%-os találati arány mellett 6 millió token teljes áron marad, míg 24 millió félárra csökken, ami körülbelül 40%-os megtakarítást eredményez a bemeneti tokeneken. Az összeg egyetlen híváshoz képest szerénynek tűnhet; egy évnyi éles üzemelés során azonban megváltoztatja az alkalmazás költségszerkezetét.

Főbb megállapítások

  • Strukturáld a promptokat rétegekben, a legstabilabbtól a legváltozékonyabbig
  • Csoportosítsd a kéréseket közös kontextus szerint, hogy a gyorsítótár melegen maradjon
  • Melegítsd elő a gyorsítótárat a forgalmi csúcsok előtt
  • Figyeld a gyorsítótár-arányt az input_tokens_details.cached_tokens segítségével
  • Verzionáld a promptjaidat a gyorsítótár érvénytelenítésének előrejelzésére