Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Pokročilé ukládání promptů do mezipaměti

Lekce 13 z 20 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Za hranicemi automatického ukládání do mezipaměti
  2. Architektura promptů pro maximalizaci ukládání do mezipaměti
  3. Tři vzory, které dělají rozdíl
  4. Co to znamená v objemu
  5. Klíčové poznatky

Za hranicemi automatického ukládání do mezipaměti

Základy ukládání promptů do mezipaměti jsi viděl v lekci 3. Tam se caching jevil jako automatický mechanismus, který ti přináší výhody bez jakékoli speciální námahy, a to platí, pokud tvoje aplikace odesílá dobře uspořádané požadavky. Produkční realita je však chaotičtější: více uživatelů současně zasahuje stejné API, každý s vlastní složkou, dokumenty a otázkami. Společná prefixová část se pak smrskne téměř na nulu a míra zásahu mezipaměti (cache hit rate) se zhroutí, aniž by si toho někdo všiml, protože se nic nerozbije – jen narůstá účet.

Scénáře s více uživateli, více dokumenty a zpracovatelskými pipeline vyřešíme jeden po druhém, abychom maximalizovali míru zásahu mezipaměti. Řídící princip se vejde do jedné věty: ukládání do mezipaměti není něco, co se ti děje; je to něco, co navrhuješ.

Architektura promptů pro maximalizaci ukládání do mezipaměti

Ukládání do mezipaměti se vztahuje na nejdelší společný prefix napříč tvými požadavky. Čím je tento prefix delší a stabilnější, tím více ušetříš. Praktickým důsledkem je, že prompt musí být organizován od nejstabilnějších po nejproměnlivější části, jako kniha, jejíž první stránky se nikdy nemění a pouze závěrečná kapitola se přepisuje s každým vydáním.

Níže uvedený příklad aplikuje tento princip na asistenta pro analýzu dokumentů pro advokátní kancelář. Následují tři vrstvy: globální instrukce, které jsou neměnné; znalostní báze, revidovaná jednou měsíčně; a spis případu s otázkou, které se mění při každém volání.

import openai

client = openai.OpenAI()

# Vrstvená architektura: od nejstabilnější po nejproměnlivější

# Vrstva 1: Globální instrukce (nikdy se nemění)
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
"""

# Vrstva 2: Znalostní báze (mění se zřídka)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# Vrstva 3: Kontext případu (mění se pro každého klienta)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

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

Klasickou chybou je umístit jméno klienta nebo dnešní datum na začátek systémového promptu, aby byl „personalizovaný“. Jediný proměnný znak na počáteční pozici stačí k tomu, aby se prefix stal unikátním, čímž se míra zásahu mezipaměti pro všechny následující vrstvy sníží na nulu. Vše, co se mění, musí přijít až nakonec.

Samozřejmě musíš ověřit, že teorie odpovídá číslům. Následující monitor čte input_tokens_details.cached_tokens u každé odpovědi a akumuluje měření, což ti poskytne použitelnou průměrnou míru místo pouhého odhadu.

class CacheMonitor:
    """Monitoruje efektivitu ukládání promptů do mezipaměti."""

    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 "Žádná volání."
        return (
            f"Volání: {len(self.calls)} | "
            f"Průměrná míra cache: {self.average_rate:.1%} | "
            f"Ušetřené tokeny: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Tři vzory, které dělají rozdíl

První vzor se týká pořadí zpracování. Když zpracováváš dávku heterogenních požadavků, jejich spouštění v pořadí příchodu střídá prefixy a brání mezipaměti zůstat „zahřátá“. Seskupení podle sdíleného kontextu problém řeší: nejprve shromáždi, poté execute, aby každá skupina využila prefix připravený svým prvním požadavkem.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Seskupí požadavky podle společného prefixu."""
    groups = defaultdict(list)

    for request in requests:
        # Klíč = hash sdíleného kontextu
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Zpracovává seskupené požadavky pro maximalizaci ukládání do mezipaměti."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # Všechny požadavky ve skupině sdílejí stejný prefix
        for request in group:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=request["shared_context"],
                input=request["question"],
            )
            monitor.record(response.usage)

Druhý vzor řeší studené starty. První požadavek v sérii platí plnou cenu, protože zatím nic není v mezipaměti; pokud tento první požadavek pochází od skutečného uživatele v pondělí ráno v 9 hodin, nese latenci on. Požadavek na zahřátí odeslaný před spuštěním služby přesune tyto náklady tam, kde nikoho netrápí. Všimni si ochrany na začátku funkce: pod 1 024 tokenů se ukládání do mezipaměti neaplikuje a předběžné zahřívání by bylo čistým výdajem.

def warm_up_cache(system_prompt: str):
    """Odešle minimální požadavek pro zahřátí mezipaměti."""
    if len(system_prompt) // 4 < 1024:
        print("Prompt je příliš krátký pro ukládání do mezipaměti (< 1 024 tokenů)")
        return

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=system_prompt,
        input="Potvrďte, že jste připraveni.",
        max_output_tokens=10,
    )

    usage = response.usage
    print(
        f"Mezipaměť zahřáta: {usage.input_tokens} vstupních tokenů, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} uloženo v cache"
    )

Třetí vzor činí invalidaci mezipaměti viditelnou. Oprava čárky v systémovém promptu o 5 000 tokenech se zdá triviální, přesto tato čárka vymaže mezipaměť pro všechny. Připojením otisku (fingerprint) k obsahu detekuješ změnu při nasazení, nikoliv až druhý den na faktuře, a můžeš okamžitě navázat předběžným zahřátím.

import hashlib

class VersionedPrompt:
    """Spravuje verze promptů pro řízení ukládání do mezipaměti."""

    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

# Pokud se verze změní, mezipaměť bude zneplatněna
prompt_v1 = VersionedPrompt("Instrukce v1...")
prompt_v2 = VersionedPrompt("Instrukce v2 upraveno...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Upozornění: prompt změněn, mezipaměť bude zneplatněna")
    warm_up_cache(prompt_v2.content)

Co to znamená v objemu

Vezmi si reálný případ 10 000 volání denně se systémovým promptem o 3 000 tokenech. Bez ukládání do mezipaměti účtuješ 10 000 × 3 000, tedy 30 milionů vstupních tokenů každý den. S 80% mírou zásahu zůstane 6 milionů tokenů za plnou cenu a 24 milionů klesne na poloviční cenu, což přináší úspory přibližně 40 % u vstupních tokenů. Číslo se může zdát skromné vzhledem k jednomu volání; během roku provozu to však změní nákladovou strukturu aplikace.

Klíčové poznatky

  • Strukturoj své prompty do vrstev od nejstabilnějších po nejproměnlivější
  • Seskupuj požadavky podle sdíleného kontextu, aby mezipaměť zůstala zahřátá
  • Zahřej mezipaměť před špičkami provozu
  • Sleduj míru ukládání do mezipaměti pomocí input_tokens_details.cached_tokens
  • Verzi své prompty, abys anticipoval invalidace mezipaměti