Премини към основното съдържание
Български— Изберете език
Меню

Разширено кеширане на подкани

Урок 13 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Отвъд автоматичното кеширане
  2. Архитектура на подканите за максимизиране на кеширането
  3. Три модела, които правят разликата
  4. Какво означава това в обем
  5. Ключови изводи

Отвъд автоматичното кеширане

Запознахте се с основите на кеширането на подкани в Урок 3. Там кеширането се появи като автоматичен механизъм, от който се възползвате без специални усилия, и това е вярно, стига приложението Ви да изпраща добре подредени заявки. Реалността в продукционна среда е по-хаотична: множество потребители атакуват едно и също API едновременно, всеки със своята папка, документи и въпроси. Тогава общият префикс се свива до почти нищо, а процентът на попадения в кеша (cache hit rate) се срива, без никой да забележи, тъй като нищо не се чупи – просто сметката нараства.

Многопотребителски среди, многодокументни обработки и конвейери за обработка: ще разгледаме тези сложни сценарии един по един, за да максимизираме процента на попадения в кеша. Ръководният принцип се събира в едно изречение: кеширането не е нещо, което Ви се случва; то е нещо, което проектирате.

Архитектура на подканите за максимизиране на кеширането

Кеширането се прилага към най-дългия общ префикс във Вашите заявки. Колкото по-дълъг и стабилен е този префикс, толкова повече спестявате. Практическото следствие е, че една подкана трябва да бъде организирана от най-стабилната към най-променливата част, като книга, чиито първи страници никога не се променят, а само последната глава се пренаписва с всяко издание.

Примерът по-долу прилага този принцип към асистент за анализ на документи за адвокатска кантора. Три слоя следват един след друг: глобални инструкции, които са замразени; база от знания, която се преразглежда веднъж месечно; и досието на случая и въпросът, които се променят при всяко обаждане.

import openai

client = openai.OpenAI()

# Layered architecture: from most stable to most variable

# Layer 1: Global instructions (never change)
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
"""

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

# Layer 3: Case context (changes per client)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

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

Класическата грешка е поставянето на името на клиента или днешната дата в началото на системната подкана, за да я „персонализирате“. Един единствен променлив символ в началната позиция е достатъчен, за да направи префикса уникален, намалявайки процента на попадения в кеша до нула за всички последващи слоеве. Всичко, което варира, трябва да отиде най-накрая.

Разбира се, трябва да проверите дали теорията се превръща в числа. Следният монитор чете input_tokens_details.cached_tokens при всеки отговор и натрупва измерванията, като Ви дава използваема средна стойност, вместо да разчитате на усещане.

class CacheMonitor:
    """Monitors prompt caching efficiency."""

    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 "No calls."
        return (
            f"Calls: {len(self.calls)} | "
            f"Average cache rate: {self.average_rate:.1%} | "
            f"Tokens saved: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Три модела, които правят разликата

Първият модел се отнася до реда на обработка. Когато обработвате пакет от хетерогенни заявки, изпълнението им в реда на постъпване редува префиксите и пречи на кеша да остане „топъл“. Групирането по споделен контекст решава проблема: първо съберете, после изпълнете, така че всяка група да се възползва от префикса, подготвен от първата ѝ заявка.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Groups requests by common prefix."""
    groups = defaultdict(list)

    for request in requests:
        # Key = hash of shared context
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Processes grouped requests to maximize caching."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # All requests in the group share the same 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)

Вторият модел обработва „студените стартове“. Първата заявка в поредица плаща пълната цена, тъй като все още нищо не е кеширано; ако тази първа заявка идва от реален потребител в понеделник сутрин в 9 ч., той поема латентността. Заявка за загряване, изпратена преди отварянето на услугата, прехвърля тази цена там, където не пречи на никого. Обърнете внимание на проверката в началото на функцията: под 1024 токена кеширането не се прилага, а предварителното загряване би било чист разход.

def warm_up_cache(system_prompt: str):
    """Sends a minimal request to prime the cache."""
    if len(system_prompt) // 4 < 1024:
        print("Prompt too short for caching (< 1,024 tokens)")
        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"Cache primed: {usage.input_tokens} input tokens, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} cached"
    )

Третият модел прави инвалидирането на кеша видимо. Поправянето на запетая в системна подкана от 5000 токена изглежда тривиално, но тази запетая изчиства кеша за всички. Чрез прикрепяне на отпечатък (fingerprint) към съдържанието, откривате промяната при внедряване, а не на следващия ден във фактурата, и можете незабавно да продължите с предварително загряване.

import hashlib

class VersionedPrompt:
    """Manages prompt versions to control caching."""

    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

# If the version changes, the cache will be invalidated
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Warning: prompt changed, cache will be invalidated")
    warm_up_cache(prompt_v2.content)

Какво означава това в обем

Вземете реален случай от 10 000 обаждания на ден със системна подкана от 3000 токена. Без кеширане таксувате 10 000 × 3000, или 30 милиона входни токена всеки ден. При процент на попадения от 80%, 6 милиона токена остават на пълна цена, а 24 милиона падат до половин цена, което носи спестявания от около 40% за входните токени. Фигурата изглежда скромна спрямо едно единствено обаждане; но за една година продукционна работа, тя променя ценовата структура на приложението.

Ключови изводи

  • Структурирайте подканите си на слоеве от най-стабилния към най-променливия
  • Групирайте заявките по споделен контекст, за да поддържате кеша топъл
  • Загрявайте кеша преди пикове в трафика
  • Следете процента на кеширане с input_tokens_details.cached_tokens
  • Версионирайте подканите си, за да предвидите инвалидирания на кеша