Ukládání promptů LLM do mezipaměti: Snížení nákladů na API o 90 % (všichni 3 poskytovatelé)

Ukládání promptů LLM do mezipaměti: Snížení nákladů na API o 90 % (všichni 3 poskytovatelé)

Ukládání promptů LLM do mezipaměti vám umožňuje znovu používat dříve zpracované tokeny napříč voláními API, čímž snižuje vstupní náklady až o 90 % a zkracuje dobu do prvního tokenu (TTFT) až o 85 %. Pokud posíláte stejný systémový prompt, definice nástrojů nebo few-shot příklady s každým požadavkem, platíte plnou cenu za práci, kterou GPU již odvedlo.

Tento průvodce pokrývá OpenAI, Anthropic a Gemini se stejným chatbotem implementovaným ve všech třech SDK, což žádný jiný průvodce nedělá. Podíváme se také na aktualizaci automatického ukládání do mezipaměti od Anthropic z února 2026, scénáře produkčních nákladů s reálnými částkami v dolarech a anti-vzory, které tiše ničí vaši míru zásahu do mezipaměti (cache hit rate).

Rychlé shrnutí: Všichni tři poskytovatelé na první pohled

Než se ponoříme do detailů implementace, zde je úplné srovnání. Pokud již víte, kterého poskytovatele používáte, přejděte přímo na jeho sekci. Pokud hodnotíte možnosti, tato tabulka vám řekne vše za 10 sekund.

Klíčové zjištění: OpenAI je nejjednodušší (nulová konfigurace, 50 % sleva). Anthropic nabízí nejhlubší slevu (90 %) s největší kontrolou. Gemini nabízí konfigurovatelné TTL a implicitní ukládání do mezipaměti u modelů 2.5+ se slevami srovnatelnými s Anthropic.

Jak funguje ukládání promptů LLM do mezipaměti?

Abyste efektivně využívali ukládání promptů do mezipaměti, nemusíte rozumět vnitřnostem transformerů. Musíte však pochopit jeden koncept: shodu prefixů.

KV Cache za 60 sekund

Když LLM zpracovává váš prompt, vypočítává stavy pozornosti (páry klíč-hodnota) pro každý token. Tyto položky KV cache jsou tou drahou částí – právě ony spotřebovávají paměť GPU a výpočetní čas. Ukládání promptů do mezipaměti tyto vypočítané stavy ukládá, takže další požadavek se stejným prefixem přeskočí celý přepočet.

Klíčovým slovem je prefix. Mezipaměť porovnává od začátku vašeho promptu směrem dopředu. Pokud prvních 2 000 tokenů odpovídá uložené položce, ale token 2 001 se liší, těchto prvních 2 000 tokenů je obslouženo z mezipaměti. Vše po bodě divergence se počítá znovu.

Proto záleží na pořadí promptu. Strukturovejte své prompty takto:

1. Definice nástrojů (nejstatictější)
2. Systémový prompt
3. Statické few-shot příklady
4. Získaný kontext (polodynamický)
5. Historie konverzace (roste s každým kolem)
6. Dotaz uživatele (vždy jiný)

Statický obsah první, dynamický obsah poslední. Čím více tokenů odpovídá uloženému prefixu, tím větší jsou vaše úspory.

Ukládání promptů vs. semantická mezipaměť vs. mezipaměť odpovědí

Tyto tři pojmy se často zaměňují. Ukládání promptů (což pokrývá tento průvodce) znovu využívá vypočítané stavy KV na úrovni GPU pro identické tokenové prefixy, bez ztráty přesnosti, se stejným výstupem jako bez mezipaměti. Semantická mezipaměť využívá podobnost embeddingů k vrácení dříve vygenerovaných odpovědí pro „dostatečně podobné“ dotazy, je rychlejší, ale může vracet špatné odpovědi. Mezipaměť odpovědí ukládá přesné páry vstup-výstup a vrací uloženou odpověď doslovně, funguje pouze pro skutečně identické požadavky.

Ukládání promptů je jediná „bezplatná optimalizace“, která snižuje náklady a latenci bez jakéhokoli kompromisu v přesnosti. Pro hlubší matematické pozadí KV cachingu technický vysvětlující článek Hugging Face naměřil zrychlení ~5,21x na GPU T4.

Jak řeší ukládání promptů OpenAI?

Ukládání promptů OpenAI je plně automatické. Od října 2024 každé volání API s více než 1 024 vstupními tokeny automaticky těží z ukládání do mezipaměti. Nemusíte se přihlašovat, nepřidáváte hlavičky, neměníte svůj kód.

Jak funguje automatické ukládání do mezipaměti OpenAI

Když odešlete požadavek s alespoň 1 024 tokeny, OpenAI zkontroluje, zda prefix odpovídá nedávnému požadavku z vaší organizace. Zásahy do mezipaměti stojí 50 % standardní ceny vstupního tokenu. Po počátečním prahu 1 024 tokenů se mezipaměť shoduje v krocích po 128 tocenech.

Mezipaměť žije 5–10 minut během běžného používání a může přetrvat až 24 hodin s rozšířeným uchováním během období mimo špičku. Je scopedována podle organizace, takže různé projekty v rámci stejné orgánizace těží ze sdílených mezipamětí.

Podporované modely zahrnují GPT-4o, GPT-4o-mini, GPT-4.1, o1, o3-mini a všechny novější modely.

Příklad v Python SDK OpenAI

from openai import OpenAI

client = OpenAI()

# This system prompt is ~2,000 tokens -- well above the 1,024 minimum
SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

def chat(user_message: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_message},
        ],
    )

    # Check if caching kicked in
    usage = response.usage
    cached = usage.prompt_tokens_details.cached_tokens
    total_input = usage.prompt_tokens
    print(f"Cached: {cached}/{total_input} tokens ({cached/total_input*100:.0f}%)")

    return response.choices[0].message.content

# First call: cache miss (full price)
chat("Review this async function for race conditions...")

# Second call within 5-10 min: cache hit (50% off on cached tokens)
chat("Now optimize the same function for throughput...")

První volání zpracuje vše za plnou cenu a naplní mezipaměť. Druhé volání znovu použije tokeny systémového promptu z mezipaměti za poloviční cenu. Ve výstupu uvidíte něco jako Cached: 1920/2048 tokens (94%).

Verdikt: OpenAI je nejjednodušší na začátek, nulová konfigurace, ukládání do mezipaměti prostě proběhne. Sleva 50 % je nejnižší ze tří poskytovatelů, ale jednoduchost nelze porazit.

Jak řeší ukládání promptů Anthropic/Claude?

Anthropic nabízí dva režimy: automatické ukládání do mezipaměti (ve výchozím nastavení od února 2026) a explicitní ukládání s body přerušení cache_control. Číslo, které stojí za zmínku, je těžké ignorovat – čtení z mezipaměti stojí jen 10 % standardní vstupní ceny, což je 90 % sleva.

Automatické vs. explicitní ukládání do mezipaměti (Aktualizace 2026)

Od 5. února 2026 Anthropic povoluje automatické ukládání do mezipaměti ve výchozím nastavení pro všechny způsobilé prompty. Starou beta hlavičku již nepotřebujete. Systém automaticky určuje optimální body přerušení mezipaměti.

Explicitní ukládání do mezipaměti je stále dostupné, když chcete jemnozrnnou kontrolu. Umístíte cache_control: {"type": "ephemeral"} na specifické bloky obsahu, abyste přesně označili, kde by měla být hranice mezipaměti. To je užitečné, když má váš prompt specifickou strukturu a chcete zajistit uložení určitých sekcí do mezipaměti.

Existují dvě možnosti TTL:

• 5minutová mezipaměť (výchozí): zápisy stojí 1,25x základní vstupní cenu, čtení stojí 0,1x. Vyplatí se po 1 zásahu do mezipaměti.
• 1hodinová mezipaměť: zápisy stojí 2x základní vstupní cenu, čtení stojí 0,1x. Vyplatí se po 2 zásazích do mezipaměti. Dostupné u modelů Claude 4.5+.

Izolace mezipaměti se 5. února 2026 změnila z úrovně organizace na úroveň workspace (pracovního prostoru). To znamená, že různé workspaces v rámci stejné organizace udržují samostatné mezipaměti.

Při práci s ukládáním do mezipaměti Anthropic pomáhá strukturovat váš prompt pro optimální ukládání, umístění statického obsahu před dynamický je zde ještě důležitější, protože platíte prémii za zápis.

Příklad v Python SDK Anthropic

import anthropic

client = anthropic.Anthropic()

SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

def chat(user_message: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-5-20250514",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": SYSTEM_PROMPT,
                "cache_control": {"type": "ephemeral"},  # Explicit breakpoint
            }
        ],
        messages=[
            {"role": "user", "content": user_message},
        ],
    )

    # Read cache metrics from the response
    usage = response.usage
    created = usage.cache_creation_input_tokens
    read = usage.cache_read_input_tokens
    standard = usage.input_tokens
    print(f"Cache write: {created}, Cache read: {read}, Standard: {standard}")

    return response.content[0].text

# First call: cache_creation_input_tokens = ~1920 (write at 1.25x)
chat("Review this async function for race conditions...")

# Second call: cache_read_input_tokens = ~1920 (read at 0.1x -- 90% off!)
chat("Now optimize the same function for throughput...")

Porozumění cenám za zápis do mezipaměti vs. čtení z mezipaměti

Zde se cenotvorba Anthropic stává zajímavou. Jako příklad vezměme Claude Sonnet 4.5 (3 $/MTok základní vstup):

• Standardní vstup: 3,00 $ za milion tokenů
• Zápis do mezipaměti (5 min): 3,75 $ za milion tokenů (1,25x), poprvé platíte více
• Čtení z mezipaměti: 0,30 $ za milion tokenů (0,1x) -- o 90 % levnější při každém dalším zásahu

5minutová mezipaměť se vyplatí již po 1 čtení. 1hodinová mezipaměť (zápis 6,00 $/MTok) se vyplatí po 2 čteních. Pokud provádíte více než pár požadavků za minutu se stejným prefixem, matematika je drtivě ve váš prospěch.

Verdikt: Anthropic nabízí nejhlubší slevu (90 %) a největší kontrolu. Nejlepší pro vysoké objemy a workloady citlivé na náklady.

Jak řeší ukládání promptů Google Gemini?

Gemini přistupuje k věci jinak s dvěma odlišnými mechanismy ukládání do mezipaměti: explicitní ukládání kontextu (pojmenované objekty mezipaměti, které vytvoříte a odkazujete na ně) a implicitní ukládání do mezipaměti (automatické, bez konfigurace, přidané v roce 2026 pro modely Gemini 2.5+).

Explicitní ukládání kontextu (Pojmenované mezipaměti)

Na rozdíl od OpenAI a Anthropic, kde je ukládání do mezipaměti transparentní, explicitní ukládání Gemini vyžaduje, abyste nejprve vytvořili pojmenovaný objekt mezipaměti a poté na něj odkazovali v následných požadavcích. Minimální práh tokenů je 1 024 tokenů pro modely Gemini Flash a 4 096 tokenů pro modely Pro. TTL je konfigurovatelné, výchozí je 1 hodina, ale můžete jej nastavit podle potřeby.

Cena za tokeny v mezipaměti u Gemini 2.5 Pro je 0,125 $/MTok oproti standardní vstupní ceně 1,25 $/MTok, což je 90 % sleva. Existuje také náklad na úložiště ve výši 4,50 $ za milion tokenů za hodinu pro Pro a 1,00 $ pro Flash.

Implicitní ukládání do mezipaměti v Gemini 2.5 (2026)

Počínaje Gemini 2.5 Pro a Flash Google přidal implicitní ukládání do mezipaměti, automatické ukládání, které funguje podobně jako přístup OpenAI. Není nutná žádná konfigurace. Umístěte velký, běžný obsah na začátek svého promptu a posílejte požadavky s podobnými prefixy v rychlém sledu. Systém automaticky detekuje obsah způsobilý pro mezipaměť a předává úspory.

Příklad v Python SDK Gemini

from google import genai
from google.genai import types

client = genai.Client()

SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

# Step 1: Create a named cache object
cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        display_name="python-review-guidelines",
        system_instruction=SYSTEM_PROMPT,
        ttl="3600s",  # 1 hour
    ),
)

print(f"Cache created: {cache.name}, expires: {cache.expire_time}")

# Step 2: Use the cache in requests
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Review this async function for race conditions...",
    config=types.GenerateContentConfig(
        cached_content=cache.name,
    ),
)

# Check cache usage in the response
metadata = response.usage_metadata
print(f"Cached tokens: {metadata.cached_content_token_count}")
print(f"Total input tokens: {metadata.prompt_token_count}")

Explicitní přístup má jednu velkou výhodu: přesně kontrolujete TTL. Pokud víte, že vaše batch job běží 4 hodiny, nastavte 4hodinové TTL a vyhněte se vypršení mezipaměti uprostřed zpracování.

Verdikt: Konfigurovatelné TTL Gemini a duální režimy ukládání do mezipaměti (explicitní + implicitní) ho činí všestranným. Minimální práh je nyní srovnatelný s ostatními poskytovateli a 90 % sleva na čtení z mezipaměti odpovídá Anthropic.

Porovnání kódu vedle sebe: Stejný případ použití, všichni 3 poskytovatelé

Zde je stejný chatbot s uloženým systémovým promptem, implementovaný ve všech třech SDK. Porovnejte zkušenost vývojáře přímo.

# --- OpenAI: Zero config, just call the API ---
from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},  # Cached automatically
        {"role": "user", "content": user_message},
    ],
)
cached = response.usage.prompt_tokens_details.cached_tokens

# --- Anthropic: Explicit cache_control breakpoint ---
import anthropic
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"},  # Mark cache boundary
    }],
    messages=[{"role": "user", "content": user_message}],
)
cached = response.usage.cache_read_input_tokens

# --- Gemini: Named cache object ---
from google import genai
from google.genai import types

client = genai.Client()
cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        system_instruction=SYSTEM_PROMPT,
        ttl="3600s",
    ),
)
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=user_message,
    config=types.GenerateContentConfig(cached_content=cache.name),
)
cached = response.usage_metadata.cached_content_token_count

Pokud chcete úspory bez námahy, zvolte OpenAI. Pokud chcete nejhlubší slevu a jemnozrnnou kontrolu, zvolte Anthropic. Pokud potřebujete konfigurovatelnou životnost mezipaměti nebo již jste na Google Cloud, zvolte Gemini.

Kalkulačka produkčních nákladů: Skutečné úspory ve velkém měřítku

Abstraktní procenta neřídí rozhodování. Částky v dolarech ano. Zde jsou tři produkční scénáře s reálnými odhady nákladů pomocí Claude Sonnet 4.5 (3 $/MTok vstup), GPT-4o (2,50 $/MTok vstup) a Gemini 2.5 Pro (1,25 $/MTok vstup).

Ceny ověřeny v březnu 2026. Aktuální sazby najdete v ceníku Anthropic, ceníku OpenAI a ceníku Gemini.

Předpoklady: 80 % míra zásahu do mezipaměti (realistické pro dobře strukturované prompty), výstupní tokeny vyloučeny, protože ukládání do mezipaměti ovlivňuje pouze vstupní náklady.

V úrovni Growth šetří ukládání do mezipaměti Anthropic 576 $/měsíc, přestože má vyšší základní cenu než OpenAI. V enterprise měřítku se díváte na úspory 7 200 $/měsíc s Anthropic, neboli 86 400 $ ročně. To jsou úspory odpovídající platu senior vývojáře díky změně konfigurace.

Vzor je jasný: čím vyšší je váš objem požadavků a delší váš statický prefix, tím více ukládání do mezipaměti šetří. 90 % sleva Anthropic dominuje ve velkém měřítku, ale nižší základní cena Gemini ho činí konkurenceschopným, když započítáte celkové náklady.

Anti-vzory ukládání promptů: Kdy NEukládat do mezipaměti

Ukládání do mezipaměti vypadá jednoduše, dokud vaše míra zásahu do mezipaměti záhadně nestojí na 0 %. Zde jsou chyby, které tiše ničí ukládání promptů do mezipaměti, a jak je opravit.

Chyby ničící mezipaměť (s opravami)

Časová razítka v systémových promptech, Nejčastější chyba. Pokud váš systémový prompt obsahuje datetime.now(), klíč mezipaměti se mění každou sekundu.

# BAD: Cache misses every single request
system_prompt = f"""You are a helpful assistant.
Current time: {datetime.now().isoformat()}
Always be helpful and accurate."""

# GOOD: Move the timestamp to the user message
system_prompt = """You are a helpful assistant.
Always be helpful and accurate."""

user_message = f"[Current time: {datetime.now().isoformat()}]\n{user_query}"

Obsah specifický pro uživatele před statickým obsahem, Pokud umístíte session_id nebo uživatelské preference na začátek, každý uživatel získá unikátní prefix.

# BAD: Unique prefix per user = zero cache reuse
messages = [
    {"role": "system", "content": f"User ID: {user_id}\nPreferences: {prefs}\n{GUIDELINES}"},
    {"role": "user", "content": query},
]

# GOOD: Static content first, user context at the end
messages = [
    {"role": "system", "content": GUIDELINES},  # Same for all users -> cached
    {"role": "user", "content": f"Context: User {user_id}, prefs: {prefs}\n{query}"},
]

Kdy ukládání promptů opravdu nepomáhá

Některé scénáře nebudou těžit z ukládání do mezipaměti, i když perfektně strukturováte své prompty:

• Jednorázové prompty: Pokud má každý požadavek zcela unikátní kontext a žádný sdílený prefix, není co ukládat do mezipaměti.
• Velmi krátké prompty: Pod 1 024 tokeny (OpenAI/Anthropic) nebo 4 096 tokeny (Gemini Pro) se ukládání do mezipaměti neaktivuje.
• Řídké požadavky: Pokud jsou požadavky od sebe vzdáleny hodiny, mezipaměť vyprší, než dorazí druhý požadavek. 5–10minutové okno OpenAI a výchozí 5minutové TTL Anthropic znamenají, že potřebujete konzistentní provoz.

Funguje ukládání promptů se streamováním?

Ano. Ukládání promptů do mezipaměti a streamování jsou nezávislé, ukládání do mezipaměti operuje na vstupních tocenech, streamování ovlivňuje dodávání výstupu. Řeší různé problémy v různých fázích životního cyklu požadavku.

Mezipaměť zpracovává fázi prefill (zpracování vašeho vstupního promptu). Streamování zpracovává fázi decode (generování a postupné odesílání výstupních tokenů). Získáte obě výhody současně: rychlejší prefill díky zásahu do mezipaměti plus progresivní dodávání výstupu ze streamování.

Zde je příklad streamování s povoleným ukládáním do mezipaměti:

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"},
    }],
    messages=[{"role": "user", "content": "Explain Python's GIL..."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    # After streaming completes, check cache metrics
    usage = stream.get_final_message().usage
    print(f"\nCache read: {usage.cache_read_input_tokens} tokens")

Zlepšení TTFT z ukládání do mezipaměti je ve skutečnosti nejvíce patrné právě se streamováním. Bez ukládání do mezipaměti čekáte na úplný prefill, než se začne streamovat první token. S ukládáním do mezipaměti je prefill téměř okamžitý, takže tokeny začnou proudit téměř ihned.

Jak monitorovat míru zásahu do mezipaměti v produkci

Nastavení ukládání do mezipaměti je polovina bitvy. Vědět, zda to skutečně funguje, je ta druhá. Pokud vaše míra zásahu do mezipaměti klesne pod 50 %, něco se změnilo ve struktuře vašeho promptu a necháváte peníze na stole.

Metriky mezipaměti specifické pro poskytovatele

Jednoduchý logger míry zásahu do mezipaměti

Zde je utility funkce, kterou můžete vložit do jakéhokoli projektu pro sledování míry zásahu do mezipaměti prostřednictvím polí odpovědi API:

import logging

logger = logging.getLogger("cache_monitor")

def log_cache_metrics(provider: str, usage: dict) -> float:
    """Extract and log cache metrics from any provider's response. Returns hit rate."""

    if provider == "openai":
        cached = getattr(usage.prompt_tokens_details, "cached_tokens", 0)
        total = usage.prompt_tokens
    elif provider == "anthropic":
        cached = usage.cache_read_input_tokens
        created = usage.cache_creation_input_tokens
        total = cached + created + usage.input_tokens
    elif provider == "gemini":
        cached = getattr(usage, "cached_content_token_count", 0)
        total = usage.prompt_token_count
    else:
        raise ValueError(f"Unknown provider: {provider}")

    hit_rate = (cached / total * 100) if total > 0 else 0
    logger.info(f"[{provider}] Cache hit rate: {hit_rate:.1f}% ({cached}/{total} tokens)")

    if hit_rate < 50:
        logger.warning(f"[{provider}] Low cache hit rate! Check prompt structure.")

    return hit_rate

Zdravý produkční systém by měl udržovat 70–90 % míru zásahu do mezipaměti. Pokud jste pod 50 %, vraťte se k sekci anti-vzorů. Můžete také integrovat toto s automatizovanými evaluačními metrikami pro zachycení regresí ve vašem pipeline promptů.

Ukládání promptů do mezipaměti v reálných případech použití

Výše uvedené příklady chatbotů ilustrují mechaniku, ale ukládání promptů do mezipaměti skutečně vyniká ve specifických architektonických vzorech.

RAG Pipelines

V nastavení RAG jsou váš systémový prompt a few-shot příklady statické napříč všemi dotazy. Získané dokumenty se mění pokaždé. Strukturovejte svůj prompt tak, abyste maximalizovali uložený prefix:

1. Systémový prompt (uloženo)
2. Few-shot příklady (uloženo)
3. Získané dokumenty (dynamické, jdou poslední)
4. Dotaz uživatele (vždy unikátní)

S 5 000tokenovým systémovým promptem a 3 000 tokeny few-shot příkladů je to 8 000 tokenů uložených v mezipaměti při každém požadavku. Při 1 000 požadavcích/den na Anthropic byste ušetřili zhruba 6,50 $/den jen na uloženém prefixu. Když získáváte a ukládáte bloky kontextu, ujistěte se, že výstup získání přijde za statickým prefixem.

Vícekolové chatboty

Vícekolové konverzace jsou sladkým místem pro ukládání promptů do mezipaměti. Každé kolo přidává do historie konverzace, ale celá předchozí konverzace je již uložena v mezipaměti z předchozích kol. Výhoda mezipaměti se násobí, v 10. kole můžete mít 15 000 tokenů uložené historie s pouze 200 čerstvými tokeny z nejnovější zprávy uživatele.

Agentní systémy a definice nástrojů MCP

Pokud stavíte agenty s použitím nástrojů, vaše definice nástrojů jsou statická JSON schémata opakovaná při každém jednotlivém volání API. Typický agent může mít 20+ nástrojů totaling 3 000–5 000 tokenů definic. To je prvotřídní materiál pro ukládání do mezipaměti.

To je obzvláště relevantní pro architektury založené na MCP, kde definice nástrojů serveru jsou posílány při každém volání. S explicitním cache_control Anthropic můžete označit pole tools pro ukládání do mezipaměti a zaručit, že tyto tokeny budou znovu použity.

Kterého poskytovatele byste si měli vybrat?

Pokud již používáte jednoho poskytovatele, začněte tam, ukládání promptů do mezipaměti nevyžaduje přechod. LiteLLM funguje jako proxy vrstva, která normalizuje parametry ukládání do mezipaměti napříč poskytovateli, což je užitečné, pokud směrujete požadavky na více modelů.

FAQ: Ukládání promptů LLM do mezipaměti

Co je ukládání promptů do mezipaměti v LLM?

Ukládání promptů do mezipaměti ukládá vypočítané stavy pozornosti (KV cache) z dříve zpracovaných prefixů promptů. Když následný požadavek začíná stejnou sekvencí tokenů, poskytovatel znovu použije tyto uložené stavy místo jejich přepočítání, čímž sníží náklady i latenci bez jakéhokoli dopadu na kvalitu výstupu.

Kolik ušetří ukládání promptů do mezipaměti na nákladech API?

Úspory se pohybují od 50 % do 90 % v závislosti na poskytovateli. OpenAI nabízí 50 % slevu na uložené vstupní tokeny. Anthropic nabízí až 90 % slevu (čtení z mezipaměti za 0,1x základní ceny). Gemini nabízí zhruba 90 % slevu na čtení z mezipaměti. Skutečné úspory závisí na vaší míře zásahu do mezipaměti, délce promptu a frekvenci požadavků.

Probíhá ukládání promptů OpenAI automaticky?

Ano, od října 2024. Jakékoli volání API s více než 1 024 vstupními tokeny automaticky těží z ukládání do mezipaměti. Žádné přihlášení, žádné hlavičky, žádné změny kódu nejsou vyžadovány. Mezipaměť porovnává tokenové prefixy od začátku promptu.

Jaký je rozdíl mezi ukládáním promptů a semantickou mezipamětí?

Ukládání promptů porovnává přesné tokenové prefixy na úrovni GPU, nedochází ke ztrátě přesnosti a výstupy jsou identické s požadavky bez mezipaměti. Semantická mezipaměť využívá podobnost embeddingů k nalezení „dostatečně blízkých“ předchozích dotazů a vrací uložené odpovědi, je rychlejší, ale může vracet nesprávné nebo zastaralé odpovědi. Řeší zásadně odlišné problémy.

Jak dlouho vydrží mezipaměť promptů?

Liší se podle poskytovatele. OpenAI: 5–10 minut (až 24 hodin s rozšířeným uchováním). Anthropic: 5 minut (výchozí) nebo 1 hodina (dostupné u modelů Claude 4.5+, stojí 2x zápis). Gemini: konfigurovatelné, výchozí je 1 hodina pro explicitní mezipaměti. TTL implicitního ukládání do mezipaměti spravuje Google automaticky.

Jaká je minimální délka tokenů pro ukládání promptů do mezipaměti?

OpenAI: 1 024 tokenů. Anthropic: 1 024 tokenů pro většinu aktuálních modelů. Gemini: 1 024 tokenů pro modely Flash, 4 096 pro modely Pro. Prompty pod těmito prahy neaktivují ukládání do mezipaměti, toto je nejčastější past typu „ono to nefunguje“.

Funguje ukládání promptů do mezipaměti se streamovanými odpověďmi?

Ano. Ukládání do mezipaměti a streamování operují v různých fázích požadavku. Ukládání do mezipaměti zrychluje fázi prefill vstupu; streamování dodává výstupní tokeny postupně. Obojí funguje současně a zlepšení TTFT si ve skutečnosti více všimnete s povoleným streamováním.

Kdy bych NEMĚL používat ukládání promptů do mezipaměti?

Vyhněte se spoléhání na ukládání do mezipaměti, když jsou vaše prompty pod minimálním prahem tokenů, když zahrnujete časová razítka nebo ID relací do systémového promptu, když rotujete few-shot příklady mezi voláními, nebo když jsou požadavky příliš řídké na to, aby zasáhly mezipaměť před jejím vypršením (5–10minutové okno pro OpenAI/Anthropic).

Mohu používat ukládání promptů do mezipaměti s LangChain nebo LiteLLM?

Ano. LangChain předává parametry ukládání do mezipaměti specifické pro poskytovatele prostřednictvím svých API wrapperů. LiteLLM poskytuje unifikovanou syntaxi ukládání do mezipaměti, která normalizuje cache_control napříč Anthropic, OpenAI, Gemini, Vertex AI a Bedrock, což je obzvláště užitečné pro nastavení s více poskytovateli.

Co je zásah do mezipaměti vs. neúspěch mezipaměti?

Zásah do mezipaměti znamená, že poskytovatel našel odpovídající prefix v paměti a znovu použil uložené stavy KV, platíte sníženou cenu za tokeny z mezipaměti a získáte rychlejší TTFT. Neúspěch mezipaměti znamená, že nebyla nalezena žádná shoda, takže celý prompt je zpracován od začátku za standardní cenu. Zkontrolujte pole cached_tokens (OpenAI), cache_read_input_tokens (Anthropic) nebo cachedContentTokenCount (Gemini) v odpovědi API, abyste viděli, co nastalo.

Finální verdikt

Ukládání promptů do mezipaměti je optimalizace s nejnižším úsilím a nejvyšším návratem v stacku API pro LLM. Neměníte svůj model, neobětujete kvalitu a implementace sahá od „nedělat nic“ (OpenAI) přes „přidat jedno pole“ (Anthropic) až po „vytvořit objekt mezipaměti“ (Gemini).

Začněte s automatickým ukládáním do mezipaměti vašeho současného poskytovatele. Změřte svou míru zásahu do mezipaměti pomocí výše uvedeného logging utility. Pokud jste pod 70 %, restrukturalizujte své prompty (statické první, dynamické poslední) a eliminujte anti-vzory. Většina týmů vidí 50–80 % snížení nákladů během jednoho dne od implementace těchto změn.

Zdroje

• Dokumentace ukládání promptů Anthropic
• Průvodce ukládáním promptů OpenAI
• Dokumentace ukládání kontextu Gemini
• Ceník modelů Anthropic
• Ceník API Gemini
• Vysvětleno KV Caching, Blog Hugging Face
• Dokumentace ukládání promptů LiteLLM