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

Кеширане на подкани: Повторно използване на изчисления

Урок 3 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Какво представлява кеширането на подкани?
  2. Как работи
  3. Структуриране за максимизиране на кеша
  4. Ключови изводи

Какво представлява кеширането на подкани?

Когато изпращате многократно една и съща префиксна част на подканата – дълго системно указание, подробни инструкции или справочен документ – OpenAI може автоматично да кешира този префикс. Последващите заявки, които споделят този префикс, се възползват от намалено време до първия токен (TTFT) и по-ниски разходи за входните токени. С други думи, работата по обработката на стабилния контекст не се повтаря за всяка заявка.

Кеширането на подкани е автоматично от 2025 г.: не е необходимо да активирате нищо. OpenAI открива идентични префикси и ги кешира. Вашият лост за влияние следователно не е включването или изключването на функцията, а структурирането на подканите така, че механизмът да може да се приложи. Това е въпрос на структура, а не на конфигурация, и именно тук повечето екипи губят потенциални икономии.

Как работи

Кешът се прилага към префиксите на подканата: първите токени трябва да бъдат строго идентични от една заявка до следващата, а съвпадението спира при първия различаващ се символ. Изисква се минимален размер от 1024 токена, за да се задейства кеширането, което веднага изключва кратките системни подсказки. Кешът се споделя в рамките на една организация, което означава, че множество услуги във Вашата компания, извикващи един и същ префикс, си помагат взаимно. Продължителността му варира от няколко минути до няколко часа, без твърда гаранция, а постигнатото намаление е приблизително 50% от цената на кешираните входни токени.

Практическото следствие от правилото за префикса е, че трябва да поставите стабилните елементи в началото на подканата, а променливите – в края. Услуга, която вмъква днешната дата или идентификатор на сесия в началото на системната си подкана, инвалидира кеша си при всяко извикване, без дори да го осъзнае.

import openai

client = openai.OpenAI()

# ✅ Добра структура: стабилни елементи първи
SYSTEM_PROMPT = """Вие сте юридически асистент, специализиран във френското
договорно право. Вие анализирате договорни клаузи съгласно
Гражданския кодекс и съдебната практика. Винаги отговаряте, като
структурирате анализа си: 1) Идентифициране на клаузата,
2) Правен анализ, 3) Потенциални рискове, 4) Препоръки.

Ето референтния договор за анализ:
[Вмъкнете документ от над 2000 токена, който не се променя между извикванията]
"""

def analyze_clause(clause: str) -> str:
    """Всяко извикване повторно използва кеша на системната подкана."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,  # Стабилен префикс = кеширан
        input=f"Анализирай тази клауза: {clause}",  # Променлива част
    )
    return response.output_text

В този пример референтният договор и рамката за анализ съставляват неизменния блок, докато анализираната клауза се променя с всяко извикване. Ако анализирате четиридесет клаузи от един и същ договор, плащате за контекста веднъж на пълна цена.

Проверка на кеша

Оптимизация, която не измервате, е оптимизация, която само си мислите, че имате. API връща информация за използването на кеша в отговора:

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=SYSTEM_PROMPT,
    input="Анализирай клаузата за забрана за конкуренция.",
)

# Проверка на използването на кеша
usage = response.usage
print(f"Входни токени: {usage.input_tokens}")
print(f"Входни токени (кеширани): {usage.input_tokens_details.cached_tokens}")
print(f"Изходни токени: {usage.output_tokens}")

# Ако cached_tokens > 0: кешът е използван
cache_ratio = usage.input_tokens_details.cached_tokens / usage.input_tokens
print(f"Коефициент на кеша: {cache_ratio:.1%}")

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

Структуриране за максимизиране на кеша

Първият подход е умишленото обогатяване на системната подкана. Това може да изглежда контраинтуитивно, когато се опитвате да намалите броя на токените, но се съобразява с правилото за прага: системна подкана от 900 токена никога няма да бъде кеширана, докато същата подкана, обогатена с примери „few-shot“ и справочен документ, преминава границата и преминава към намалената тарифа за кешираната част.

# Обогатете системната подкана, за да максимизирате кеша
ENRICHED_PROMPT = """
[Подробни инструкции - над 500 токена]
[Примери few-shot - над 500 токена]
[Справочен документ - над 1000 токена]
---
Общо > 1024 токена = допустимо за кеширане
"""

В разговор с много завъртания механизмът работи във Ваша полза без допълнителни усилия: натрупаната история формира естествено стабилен префикс, който расте с всяка размяна. Стига винаги да инжектирате съобщенията в един и същи ред, десетият завой се възползва от кеша, изграден от предишните девет.

def conversation_with_cache(history: list[dict], new_message: str):
    """Нарастващата история автоматично максимизира кеша."""
    history.append({"role": "user", "content": new_message})

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,
        input=history,
    )

    history.append({
        "role": "assistant",
        "content": response.output_text,
    })
    return response.output_text

И накрая, тъй като продължителността на кеша се измерва в минути, групирането на заявки, които споделят префикс, става решение за планиране. Обработката на четиридесет клаузи от договор една след друга поддържа кеша „горещ“; разпръскването им през деня, като се редуват с други файлове, позволява той да изтече между извикванията.

import asyncio

async def batch_with_cache(clauses: list[str]) -> list[str]:
    """Изпраща заявки бързо, за да се възползва от кеша."""
    results = []
    for clause in clauses:
        result = analyze_clause(clause)
        results.append(result)
    return results

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

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

  • Кеширането на подкани е автоматично с OpenAI – поставете стабилните елементи в началото на подканата
  • Минимален праг: 1024 идентични токена в префикса
  • Печалба: ~50% за кешираните входни токени + намалено TTFT
  • Проверете usage.input_tokens_details.cached_tokens, за да потвърдите кеширането