Каждый одинаковый запрос к LLM, отправленный дважды, оплачивается дважды. Кэш ответов сохраняет ответ в первый раз и возвращает его в следующий — без оплаты токенов и без ожидания. Идея проста. Сложность в том, чтобы решить, что делает два запроса «одинаковыми», какие запросы никогда нельзя отдавать из хранилища и достаточно ли часто повторяется ваш трафик, чтобы это имело значение.
В этой статье мы собираем небольшой кэш точных совпадений на Python и SQLite, проверенный на мок-сервере, совместимом с OpenAI, и показываем, как измерить долю попаданий по логам ещё до того, как писать код.
Кэширование ответов — то же самое, что кэширование промптов?
Нет. Они экономят разное, и можно использовать оба.
| Кэширование промптов (провайдер) | Кэширование ответов (вы) | |
|---|---|---|
| Что используется повторно | Повторяющееся начало промпта | Ответ целиком |
| Кто это выполняет | Провайдер API | Ваш код |
| Модель всё равно работает? | Да, пишет новый ответ | Нет |
| Что экономится | Часть стоимости входа | Токены входа, выхода и рассуждений, плюс задержка |
| Когда срабатывает | Общий префикс, разные вопросы | Ровно тот же запрос |
Сторона провайдера разобрана в статье кэшированные входные токены, а как выстроить промпт, чтобы префикс использовался повторно, — в статье структура промпта для кэширования. Стоимость считает калькулятор кэширования промптов. Кэш ответов стоит перед всем этим: при попадании ни один запрос не покидает ваш сервер.
Действительно ли кэш сэкономит вам деньги?
Измерьте, прежде чем строить. Проценты экономии во многих туториалах по кэшированию взяты из чужого трафика. Ваша цифра зависит от одного: как часто тот же запрос приходит снова в пределах срока жизни записей.
Если вы уже логируете каждый вызов, как в статье логирование использования LLM API, добавьте одно поле: request_hash, ключ кэша, описанный ниже. Текст промпта в нём не хранится, так что он подходит и для лога без контента. Затем посчитайте повторы:
import json
from collections import Counter
def potential_hit_rate(log_path: str) -> float:
"""Share of calls whose request_hash was already seen: an upper bound for an exact cache."""
hashes = [json.loads(line)["request_hash"] for line in open(log_path)]
seen, repeats = set(), 0
for h in hashes:
repeats += h in seen
seen.add(h)
print("top repeated requests:", Counter(hashes).most_common(3))
return repeats / len(hashes) if hashes else 0.0
print(f"potential hit rate: {potential_hit_rate('calls.jsonl'):.1%}")
На синтетическом логе из 20 вызовов — один запрос пять раз, другой три раза и двенадцать уникальных — скрипт вывел потенциальную долю попаданий 30,0%. Это верхняя граница: она не учитывает срок жизни и предполагает, что каждый повтор безопасно отдавать из хранилища.
Затем переведите долю в деньги:
monthly saving = hit rate × requests per month
× (input tokens × input price + output tokens × output price) ÷ 1,000,000
То есть месячная экономия = доля попаданий × запросов в месяц × (входные токены × цена входа + выходные токены × цена выхода) ÷ 1 000 000.
Выходные токены включают рассуждения. В документации BroadNet сказано, что DeepSeek V4.1 Flash, GLM 5.3 и Qwen3.8 27B рассуждают перед ответом и что рассуждения входят в max_tokens, так что попадание экономит и те токены, которых вы в ответе не видите. Берите completion_tokens из залогированного usage, а не длину ответа.
Пример в токенах: 100 000 запросов в месяц по 1200 входных и 150 выходных токенов при доле попаданий 30% избавляют от 36 млн входных и 4,5 млн выходных токенов. На DeepSeek V4.1 Flash они оплачиваются по $0.175 и $0.52 за 1 млн соответственно; подставьте свои цифры в калькулятор стоимости LLM API. Если большая часть этого входа и так попадала в кэш провайдера, экономия на входе считается по более низкой цене входа из кэша ($0.0055 за 1 млн на той же модели), так что важнее часто оказывается выходная сторона.
Что входит в ключ кэша?
Всё, что может изменить ответ, и ничего больше.
- Включайте:
model, весь списокmessages(включая системный промпт),temperature,top_p,max_tokens,seed,response_format,tools,tool_choiceиreasoning_effort. - Добавьте версию промпта, которой управляете вы, например
faq-v3. Повышайте её, когда меняете шаблоны промптов, данные для поиска или постобработку, которых не видно в теле запроса. - Не включайте то, что меняется от вызова к вызову, не меняя ответа: ID запросов, метки времени, заголовки трассировки, поле
user, которое вы отправляете только для отслеживания злоупотреблений.
Сериализуйте материал ключа каждый раз одинаково. json.dumps в Python с sort_keys=True и separators=(",", ":") даёт одну каноническую строку независимо от порядка ключей словаря; ensure_ascii=False сохраняет арабский и другой нелатинский текст в UTF-8 вместо escape-последовательностей. Хешируйте результат через SHA-256.
Опасная ошибка — пропущенное поле. Если max_tokens не входит в ключ, ответ, обрезанный по маленькому лимиту, будет отдан запросу, который допускал длинный.
Кэш: SQLite, TTL и правила пропуска
import hashlib, json, sqlite3, time
# Every field that changes the answer belongs in the key.
KEY_FIELDS = ("model", "messages", "temperature", "top_p", "max_tokens", "seed",
"response_format", "tools", "tool_choice", "reasoning_effort")
def cache_key(params: dict, prompt_version: str) -> str:
material = {k: params[k] for k in KEY_FIELDS if k in params}
material["prompt_version"] = prompt_version
canon = json.dumps(material, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return hashlib.sha256(canon.encode("utf-8")).hexdigest()
class ResponseCache:
def __init__(self, path="llm_cache.sqlite", ttl_s=7 * 86400):
self.db, self.ttl = sqlite3.connect(path), ttl_s
self.db.execute("CREATE TABLE IF NOT EXISTS cache (k TEXT PRIMARY KEY, created REAL,"
" body TEXT, prompt_tokens INT, completion_tokens INT)")
self.hits = self.misses = self.skips = self.saved_in = self.saved_out = 0
def create(self, client, prompt_version: str, **params):
if params.get("stream") or params.get("temperature", 1) > 0:
self.skips += 1 # not cacheable: call the model directly
return client.chat.completions.create(**params)
k = cache_key(params, prompt_version)
row = self.db.execute("SELECT body, created, prompt_tokens, completion_tokens"
" FROM cache WHERE k = ?", (k,)).fetchone()
if row and time.time() - row[1] < self.ttl:
self.hits += 1; self.saved_in += row[2]; self.saved_out += row[3]
return json.loads(row[0]) # a plain dict, not an SDK object
self.misses += 1
r = client.chat.completions.create(**params)
choice = r.choices[0]
if choice.finish_reason == "stop" and not choice.message.tool_calls:
self.db.execute("INSERT OR REPLACE INTO cache VALUES (?, ?, ?, ?, ?)",
(k, time.time(), r.model_dump_json(),
r.usage.prompt_tokens, r.usage.completion_tokens))
self.db.commit()
return r.model_dump()
И запуск с ним:
import os
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
cache = ResponseCache("demo.sqlite", ttl_s=86400)
SYSTEM = {"role": "system", "content": "Answer questions about our refund policy in one sentence."}
questions = ["How long do refunds take?", "Can I refund a gift card?",
"How long do refunds take?", "How long do refunds take?", "Can I refund a gift card?"]
for q in questions:
r = cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": q}])
print(r["choices"][0]["message"]["content"])
# a personalised, sampled request is never cached
cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0.7,
messages=[SYSTEM, {"role": "user", "content": "Write me a friendly reminder"}])
# a new prompt version is a new key
cache.create(client, "faq-v4", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": "How long do refunds take?"}])
print(f"hits={cache.hits} misses={cache.misses} skipped={cache.skips} "
f"saved_input={cache.saved_in} saved_output={cache.saved_out}")
Мы запускали это с OpenAI Python SDK 3.51.0 на локальном мок-сервере, который считал вызовы к апстриму и сообщал 1200 токенов промпта и 150 токенов ответа на каждый ответ (без обращения к живому API). Семь запросов дали четыре вызова апстрима. Скрипт вывел hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450. При повторном запуске на том же файле базы все шесть кэшируемых запросов попали в кэш (hits=6 misses=0): SQLite сохраняет кэш между перезапусками. Ключи, собранные из тех же полей в другом порядке, совпали.
Замечания к коду:
max_tokens=1200оставляет место для рассуждений перед ответом. При маленьком лимите модель с рассуждениями может вернуть пустой ответ (почему). Такие ответы не сохраняются, потому чтоfinish_reasonу нихlength, а неstop.- Попадания возвращают dict. Промахи тоже возвращают
model_dump(), так что вызывающий код видит одну форму. Если ваш код ждёт объекты SDK, оберните оба случая. - Отсутствующий
temperatureсчитается сэмплированием. Тогда сервер применяет своё значение по умолчанию, которое может быть выше 0, поэтому обёртка не кэширует, если вы явно не задали 0. - SQLite подходит для одного или нескольких процессов. Для нескольких серверов перенесите ту же логику ключа и TTL в Redis или свою базу данных.
Что никогда нельзя отдавать из кэша?
- Ответы с сэмплированием (temperature выше 0). Вы выбрали разнообразие. Кэш его убирает, и пользователь, нажавший «сгенерировать заново», получит тот же текст.
- Персонализированные ответы, если ID пользователя не входит в ключ. У двух пользователей, отправивших «кратко опиши мой аккаунт», разные аккаунты. Лучше кэшировать только запросы, в сообщениях которых нет данных конкретного пользователя.
- Вызовы инструментов. Вызов инструмента — это команда действовать. Повтор «верни деньги за заказ 1182» из хранилища может повторить побочный эффект, а правильный следующий шаг зависит от текущего состояния. Обёртка отказывается сохранять любой ответ с
tool_calls. - Стриминговые ответы. При
stream=Trueобёртка обходит кэш. Кэшировать стрим — значит буферизовать его, проверять, что он завершился, и воспроизводить, а для чат-интерфейсов это редко того стоит. - Обрезанные или неудачные ответы. Сохраняйте только
finish_reason == "stop". Обрезанный ответ или ошибка, закэшированные на неделю, — это баг, который выглядит как проблема модели. - Ответы, зависящие от времени. «Какой сегодня курс валют?» требует короткого TTL или вообще без кэша.
Что хорошо кэшируется: классификация фиксированного набора входов, извлечение данных из документов, которые вы обрабатываете повторно, ответы на FAQ по фиксированному промпту, тестовые наборы и оценки, которые вы перезапускаете, и циклы разработки, где вы снова и снова отправляете один и тот же запрос.
Когда должны истекать закэшированные ответы?
Используйте три вида инвалидации:
- TTL. Ограничение по времени для каждой записи: дни для стабильных ответов на FAQ, минуты для всего, что читает живые данные.
- Версия в ключе. Меняйте версию промпта, когда меняются системный промпт, поисковый индекс или схема вывода. Старые записи перестают совпадать и постепенно устаревают.
- Модель в ключе. Она там уже есть, так что переход с одной модели на другую начинает кэш с нуля, а это именно то, что нужно, пока вы оцениваете переход.
Удаляйте просроченные строки по расписанию (DELETE FROM cache WHERE created < ?). Иначе файл будет только расти.
Есть и побочная польза. Движки инференса не обещают одинакового вывода на одинаковый вход: в документации vLLM сказано, что он “does not guarantee the reproducibility of the results by default” (перевод: «по умолчанию не гарантирует воспроизводимость результатов»). Кэш даёт каждому пользователю один и тот же ответ на один и тот же вопрос, пока жива запись.
А как насчёт семантического кэширования?
Семантический кэш превращает каждый вопрос в эмбеддинг и возвращает сохранённый ответ, когда новый вопрос достаточно близок, так что «сколько идёт возврат?» может попасть в «сколько времени занимает возврат денег?». Самый известный пример с открытым кодом — GPTCache. В его README сказано, что он использует векторное хранилище для поиска по сходству и оценщик сходства, чтобы решить, было ли попадание, есть предупреждение, что “you may encounter false positives during cache hits and false negatives during cache misses” (перевод: «при попаданиях в кэш возможны ложные срабатывания, а при промахах — ложные промахи»), и отмечено, что без эмбеддингов он превращается в кэш с поиском по ключевым словам.
Два практических момента. Во-первых, ему нужны модель эмбеддингов и векторное хранилище. BroadNet Inference эмбеддинги не предлагает, так что для этого слоя понадобится другой провайдер или локальная модель; варианты оценивает калькулятор стоимости эмбеддингов. Во-вторых, ложное попадание возвращает уверенный ответ на другой вопрос. Используйте строгий порог сходства, проверьте его на реальных парах почти совпадающих вопросов и оставьте семантическое кэширование для ответов, где цена ошибки невелика. В любом случае ставьте кэш точных совпадений первым: проверка бесплатна, и он никогда не ошибается в том, о чём спросили.
Что кэш означает для приватности?
Кэш — это хранилище промптов и ответов. Это меняет то, где живут ваши данные.
Заявление BroadNet о приватности инференса, проверенное 2026-11-15, говорит, что её шлюз не хранит промпты, сообщения, ответы или транскрипты, а записи о трафике и использовании без контента (число токенов, стоимость, время) сохраняются. Контент инференса не хранится. Необходимые метаданные аккаунта, оплаты и безопасности сохраняются так, как описано в этом заявлении. Как только вы добавляете кэш ответов, ваша система хранит тот контент, который не хранит провайдер. Относитесь к нему как к любому другому хранилищу пользовательских данных:
- По возможности кэшируйте только запросы без персональных данных — это заодно повышает долю попаданий.
- Задайте TTL, достаточно короткий для вашей политики хранения, и удаляйте записи по расписанию.
- Шифруйте файл или таблицу при хранении и ограничьте круг тех, кто может их читать.
- Учитывайте кэш в запросах на удаление данных, если в нём может оказаться пользовательский текст.
Остальная часть этого чек-листа — в статье отправка чувствительных данных в LLM API.
Как кэширование сочетается с другими способами контроля расходов?
Кэширование убирает повторные вызовы. На уникальные оно никак не влияет, поэтому стоит рядом с другими мерами, а не заменяет их: более короткими промптами, кэшированием промптов у провайдера, лимитом max_tokens на запрос, бюджетами и лимитами циклов из статьи контроль расходов на LLM API. Для больших разовых задач убирайте дубли входов до отправки; это та же идея, что и кэш, только выполненная один раз. Сторона задачи разобрана в статье обработка большого объёма без Batch API.
На тарифе с фиксированной ценой арифметика другая. У сессий DeepSeek в BroadNet нет счётчика токенов, так что попадание в кэш там денег не экономит. Но экономит время: сессия выполняет один запрос за раз, поэтому каждый пропущенный повтор освобождает сессию для новой работы.
Какое место здесь занимает BroadNet Inference
BroadRouter — собственный сайт BroadNet. BroadNet Inference предоставляет DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B и Gemma 4 VL 26B через OpenAI-совместимый эндпоинт /v1/chat/completions, так что обёртка выше работает с OpenAI Python SDK после смены базового URL. Собственной функции кэширования ответов у BroadNet нет; кэш из этой статьи — ваш. Попадания в кэш на стороне провайдера отражаются в usage.prompt_tokens_details.cached_tokens и оплачиваются по цене входа из кэша, согласно справочнику API. Цены по моделям — на странице цен.
