Разширено кеширане на подкани
На тази страница
Отвъд автоматичното кеширане
Запознахте се с основите на кеширането на подкани в Урок 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 - Версионирайте подканите си, за да предвидите инвалидирания на кеша