---
title: "Кэширование ответов LLM API на Python и SQLite | BroadRouter"
description: "Проверенный кэш точных совпадений для ответов LLM API на Python: что входит в ключ, что нельзя кэшировать, TTL, приватность и как заранее измерить долю попаданий."
url: https://broadrouter.com/ru/blog/cache-llm-responses-cut-cost/
lang: ru
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Переведено с английского с помощью ИИ. [Читать оригинал на английском](https://broadrouter.com/blog/cache-llm-responses-cut-cost/) (обновлён 2026-11-15).

# Кэширование ответов LLM API: кэш точных совпадений на Python

Команда BroadNet Inference · 8 мин чтения · Опубликовано 2026-11-15

Хешируйте весь запрос (модель, messages, temperature, max\_tokens, response\_format, инструменты, настройки рассуждений и версию промпта) в ключ и храните под ним ответ со сроком жизни. Отдавайте сохранённый ответ только на детерминированные запросы без побочных эффектов. Сначала измерьте по логам, как часто повторяются одинаковые запросы: эта доля — максимум, который может сэкономить кэш точных совпадений.

## Главное

-   Кэш точных совпадений экономит весь вызов, включая токены выхода и рассуждений, но только для побайтово одинаковых запросов. Перефразированные вопросы всегда промахиваются.
-   Включайте в ключ каждый параметр, который меняет ответ, плюс версию промпта. Пропустите один — будете отдавать неверные ответы; добавите шум вроде метки времени — промахнётся каждый запрос.
-   Не кэшируйте ответы с сэмплированием (temperature выше 0), стриминговые ответы, вызовы инструментов и ответы, обрезанные по max\_tokens.
-   Сначала измерьте: хешируйте каждый запрос в логах использования и посчитайте повторы. Опубликованные цифры экономии ничего не говорят о вашем трафике.
-   Кэш хранит промпты и ответы. Если ваш провайдер не хранит контент инференса, теперь этот контент живёт в кэше, так что задайте ему TTL и правила доступа.

**На этой странице**

1.  Кэширование ответов — то же самое, что кэширование промптов?
2.  Действительно ли кэш сэкономит вам деньги?
3.  Что входит в ключ кэша?
4.  Кэш: SQLite, TTL и правила пропуска
5.  Что никогда нельзя отдавать из кэша?
6.  Когда должны истекать закэшированные ответы?
7.  А как насчёт семантического кэширования?
8.  Что кэш означает для приватности?
9.  Как кэширование сочетается с другими способами контроля расходов?
10.  Какое место здесь занимает BroadNet Inference

Каждый одинаковый запрос к LLM, отправленный дважды, оплачивается дважды. Кэш ответов сохраняет ответ в первый раз и возвращает его в следующий — без оплаты токенов и без ожидания. Идея проста. Сложность в том, чтобы решить, что делает два запроса «одинаковыми», какие запросы никогда нельзя отдавать из хранилища и достаточно ли часто повторяется ваш трафик, чтобы это имело значение.

В этой статье мы собираем небольшой кэш точных совпадений на Python и SQLite, проверенный на мок-сервере, совместимом с OpenAI, и показываем, как измерить долю попаданий по логам ещё до того, как писать код.

## Кэширование ответов — то же самое, что кэширование промптов?

Нет. Они экономят разное, и можно использовать оба.

|  | Кэширование промптов (провайдер) | Кэширование ответов (вы) |
| --- | --- | --- |
| Что используется повторно | Повторяющееся начало промпта | Ответ целиком |
| Кто это выполняет | Провайдер API | Ваш код |
| Модель всё равно работает? | Да, пишет новый ответ | Нет |
| Что экономится | Часть стоимости входа | Токены входа, выхода и рассуждений, плюс задержка |
| Когда срабатывает | Общий префикс, разные вопросы | Ровно тот же запрос |

Сторона провайдера разобрана в статье [кэшированные входные токены](https://broadrouter.com/ru/blog/cached-input-tokens-explained/), а как выстроить промпт, чтобы префикс использовался повторно, — в статье [структура промпта для кэширования](https://broadrouter.com/ru/blog/prompt-structure-for-caching/). Стоимость считает [калькулятор кэширования промптов](https://broadrouter.com/tools/prompt-caching-calculator/). Кэш ответов стоит перед всем этим: при попадании ни один запрос не покидает ваш сервер.

## Действительно ли кэш сэкономит вам деньги?

Измерьте, прежде чем строить. Проценты экономии во многих туториалах по кэшированию взяты из чужого трафика. Ваша цифра зависит от одного: как часто тот же запрос приходит снова в пределах срока жизни записей.

Если вы уже логируете каждый вызов, как в статье [логирование использования LLM API](https://broadrouter.com/ru/blog/llm-api-usage-logging/), добавьте одно поле: `request_hash`, ключ кэша, описанный ниже. Текст промпта в нём не хранится, так что он подходит и для лога без контента. Затем посчитайте повторы:

```python
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%. Это верхняя граница: она не учитывает срок жизни и предполагает, что каждый повтор безопасно отдавать из хранилища.

Затем переведите долю в деньги:

```text
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](https://broadrouter.com/ru/models/deepseek-v4.1-flash/) они оплачиваются по $0.175 и $0.52 за 1 млн соответственно; подставьте свои цифры в [калькулятор стоимости LLM API](https://broadrouter.com/tools/llm-api-cost-calculator/). Если большая часть этого входа и так попадала в кэш провайдера, экономия на входе считается по более низкой цене входа из кэша ($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 и правила пропуска

```python
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()
```

И запуск с ним:

```python
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`** оставляет место для рассуждений перед ответом. При маленьком лимите модель с рассуждениями может вернуть пустой ответ ([почему](https://broadrouter.com/ru/guides/reasoning-tokens-empty-response/)). Такие ответы не сохраняются, потому что `finish_reason` у них `length`, а не `stop`.
-   **Попадания возвращают dict.** Промахи тоже возвращают `model_dump()`, так что вызывающий код видит одну форму. Если ваш код ждёт объекты SDK, оберните оба случая.
-   **Отсутствующий `temperature` считается сэмплированием.** Тогда сервер применяет своё значение по умолчанию, которое может быть выше 0, поэтому обёртка не кэширует, если вы явно не задали 0.
-   **SQLite подходит для одного или нескольких процессов.** Для нескольких серверов перенесите ту же логику ключа и TTL в Redis или свою базу данных.

## Что никогда нельзя отдавать из кэша?

-   **Ответы с сэмплированием (temperature выше 0).** Вы выбрали разнообразие. Кэш его убирает, и пользователь, нажавший «сгенерировать заново», получит тот же текст.
-   **Персонализированные ответы**, если ID пользователя не входит в ключ. У двух пользователей, отправивших «кратко опиши мой аккаунт», разные аккаунты. Лучше кэшировать только запросы, в сообщениях которых нет данных конкретного пользователя.
-   **Вызовы инструментов.** [Вызов инструмента](https://broadrouter.com/ru/glossary/tool-calling/) — это команда действовать. Повтор «верни деньги за заказ 1182» из хранилища может повторить побочный эффект, а правильный следующий шаг зависит от текущего состояния. Обёртка отказывается сохранять любой ответ с `tool_calls`.
-   **Стриминговые ответы.** При `stream=True` обёртка обходит кэш. Кэшировать стрим — значит буферизовать его, проверять, что он завершился, и воспроизводить, а для чат-интерфейсов это редко того стоит.
-   **Обрезанные или неудачные ответы.** Сохраняйте только `finish_reason == "stop"`. Обрезанный ответ или ошибка, закэшированные на неделю, — это баг, который выглядит как проблема модели.
-   **Ответы, зависящие от времени.** «Какой сегодня курс валют?» требует короткого TTL или вообще без кэша.

Что хорошо кэшируется: классификация фиксированного набора входов, извлечение данных из документов, которые вы обрабатываете повторно, ответы на FAQ по фиксированному промпту, тестовые наборы и оценки, которые вы перезапускаете, и циклы разработки, где вы снова и снова отправляете один и тот же запрос.

## Когда должны истекать закэшированные ответы?

Используйте три вида инвалидации:

1.  **TTL.** Ограничение по времени для каждой записи: дни для стабильных ответов на FAQ, минуты для всего, что читает живые данные.
2.  **Версия в ключе.** Меняйте версию промпта, когда меняются системный промпт, поисковый индекс или схема вывода. Старые записи перестают совпадать и постепенно устаревают.
3.  **Модель в ключе.** Она там уже есть, так что переход с одной модели на другую начинает кэш с нуля, а это именно то, что нужно, пока вы [оцениваете переход](https://broadrouter.com/ru/blog/evaluate-llm-before-switching/).

Удаляйте просроченные строки по расписанию (`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” (перевод: «при попаданиях в кэш возможны ложные срабатывания, а при промахах — ложные промахи»), и отмечено, что без эмбеддингов он превращается в кэш с поиском по ключевым словам.

Два практических момента. Во-первых, ему нужны модель [эмбеддингов](https://broadrouter.com/ru/glossary/embeddings/) и векторное хранилище. BroadNet Inference эмбеддинги не предлагает, так что для этого слоя понадобится другой провайдер или локальная модель; варианты оценивает [калькулятор стоимости эмбеддингов](https://broadrouter.com/tools/embedding-cost-calculator/). Во-вторых, ложное попадание возвращает уверенный ответ на другой вопрос. Используйте строгий порог сходства, проверьте его на реальных парах почти совпадающих вопросов и оставьте семантическое кэширование для ответов, где цена ошибки невелика. В любом случае ставьте кэш точных совпадений первым: проверка бесплатна, и он никогда не ошибается в том, о чём спросили.

## Что кэш означает для приватности?

Кэш — это хранилище промптов и ответов. Это меняет то, где живут ваши данные.

[Заявление BroadNet о приватности инференса](https://www.broadnet.ai/inference-privacy), проверенное 2026-11-15, говорит, что её шлюз не хранит промпты, сообщения, ответы или транскрипты, а записи о трафике и использовании без контента (число токенов, стоимость, время) сохраняются. Контент инференса не хранится. Необходимые метаданные аккаунта, оплаты и безопасности сохраняются так, как описано в этом заявлении. Как только вы добавляете кэш ответов, ваша система хранит тот контент, который не хранит провайдер. Относитесь к нему как к любому другому хранилищу пользовательских данных:

-   По возможности кэшируйте только запросы без персональных данных — это заодно повышает долю попаданий.
-   Задайте TTL, достаточно короткий для вашей политики хранения, и удаляйте записи по расписанию.
-   Шифруйте файл или таблицу при хранении и ограничьте круг тех, кто может их читать.
-   Учитывайте кэш в запросах на удаление данных, если в нём может оказаться пользовательский текст.

Остальная часть этого чек-листа — в статье [отправка чувствительных данных в LLM API](https://broadrouter.com/ru/blog/llm-api-sensitive-data/).

## Как кэширование сочетается с другими способами контроля расходов?

Кэширование убирает повторные вызовы. На уникальные оно никак не влияет, поэтому стоит рядом с другими мерами, а не заменяет их: [более короткими промптами](https://broadrouter.com/ru/blog/reduce-prompt-tokens/), кэшированием промптов у провайдера, лимитом `max_tokens` на запрос, бюджетами и лимитами циклов из статьи [контроль расходов на LLM API](https://broadrouter.com/ru/blog/llm-api-spend-control/). Для больших разовых задач убирайте дубли входов до отправки; это та же идея, что и кэш, только выполненная один раз. Сторона задачи разобрана в статье [обработка большого объёма без Batch API](https://broadrouter.com/ru/blog/llm-batch-processing-without-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](https://broadrouter.com/ru/guides/openai-python-sdk/) после смены базового URL. Собственной функции кэширования ответов у BroadNet нет; кэш из этой статьи — ваш. Попадания в кэш на стороне провайдера отражаются в `usage.prompt_tokens_details.cached_tokens` и оплачиваются по цене входа из кэша, согласно [справочнику API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-cache-llm-responses-cut-cost&utm_content=body). Цены по моделям — на [странице цен](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-cache-llm-responses-cut-cost&utm_content=body).

Бесплатные инструменты по теме (на английском)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Бесплатные инструменты (на английском)](https://broadrouter.com/tools/)

## Термины в этой статье

[Токен (token)](https://broadrouter.com/ru/glossary/token/)

Токен — это единица текста, которую языковая модель читает и пишет: слово, часть слова, знак препинания или последовательность байтов, которую выдаёт токенизатор модели. LLM API считают, ограничивают и обычно тарифицируют использование в токенах.

[Вход из кэша (cached input tokens)](https://broadrouter.com/ru/glossary/cached-input-tokens/)

Вход из кэша (cached input tokens) — это токены промпта, которые провайдер LLM недавно обработал и может взять из кэша, а не вычислять заново; обычно это повторяющийся префикс, например системный промпт или документ. Провайдеры тарифицируют их дешевле, чем новые входные токены.

[Входные и выходные токены (input and output tokens)](https://broadrouter.com/ru/glossary/input-and-output-tokens/)

Входные токены — это токены, которые языковая модель читает в запросе: системный промпт, история диалога, описания инструментов и изображения. Выходные токены — это токены, которые она генерирует в ответ, включая рассуждения. LLM API обычно тарифицируют их по отдельности, и выход, как правило, дороже.

[Вызов инструментов (tool calling)](https://broadrouter.com/ru/glossary/tool-calling/)

Вызов инструментов (function calling) — это функция LLM API, при которой модель возвращает структурированный запрос на выполнение функции, заданной разработчиком, с аргументами в JSON. Приложение выполняет функцию и отправляет результат обратно; сама модель код никогда не выполняет.

[Эмбеддинги (embeddings)](https://broadrouter.com/ru/glossary/embeddings/)

Эмбеддинги — это списки чисел с плавающей точкой (векторы), которые модель выдаёт для фрагмента текста, изображения или другого входа. Близкие по смыслу входы получают близкие векторы, поэтому расстояние между векторами позволяет ранжировать результаты поиска, группировать документы или находить похожие объекты.

[Векторная база данных (vector database)](https://broadrouter.com/ru/glossary/vector-database/)

Векторная база данных — это хранилище, которое держит векторы эмбеддингов, часто вместе с исходным текстом и метаданными, и отвечает на запросы ближайших соседей: по вектору запроса возвращает самые похожие сохранённые векторы, обычно по косинусному расстоянию, евклидову расстоянию или скалярному произведению.

[Температура (temperature)](https://broadrouter.com/ru/glossary/temperature/)

Температура — это параметр сэмплирования, который определяет, насколько случайным будет ответ языковой модели. Модель делит оценки токенов на температуру, прежде чем превратить их в вероятности: при низких значениях доминирует самый вероятный токен, при высоких распределение выравнивается и менее вероятные токены выбираются чаще.

[Batch API (пакетная обработка запросов)](https://broadrouter.com/ru/glossary/batch-api/)

Batch API — это асинхронный эндпоинт LLM, который принимает сразу много запросов, обычно в виде файла, обрабатывает их не немедленно, а в пределах заданного окна, и возвращает результаты вместе. Такие провайдеры, как OpenAI и Anthropic, берут за пакетные запросы меньше, чем в своих стандартных API.

## Вопросы и ответы

### Чем кэширование промптов отличается от кэширования ответов?

Кэширование промптов выполняет провайдер: повторяющийся префикс промпта оплачивается по сниженной цене входа из кэша, а модель всё равно пишет новый ответ. Кэширование ответов выполняете вы: сохраняете ответ целиком и возвращаете его на идентичный запрос, вообще не вызывая модель.

### Стоит ли кэшировать ответы LLM при temperature 0?

Да, если у запроса нет побочных эффектов и один и тот же ответ подходит всем, кто его отправляет. Temperature 0 в любом случае не гарантирует идентичный вывод от движка инференса, так что кэш заодно делает ответ стабильным. Не кэшируйте, если temperature выше 0 или не задан.

### Сколько экономит кэширование ответов LLM?

Долю запросов, которые точно повторяются в пределах срока жизни записей, умноженную на стоимость этих запросов. Чтобы узнать эту долю, посчитайте повторяющиеся хеши запросов в своих логах. Для свободного чата она может быть близка к нулю, а для фиксированных FAQ или входов классификации — высокой.

### Семантический кэш лучше кэша точных совпадений?

Он попадает чаще, потому что похожие вопросы тоже совпадают, но может вернуть ответ на другой вопрос. Ему также нужны модель эмбеддингов и векторное хранилище. Начните с кэша точных совпадений, а семантический слой добавляйте только там, где ошибочное попадание обходится дёшево.

### Можно ли кэшировать стриминговые ответы?

Не этой простой обёрткой. Пришлось бы собрать весь стрим, проверить, что он завершился нормально, сохранить его и потом воспроизводить как стрим. Большинство команд кэшируют только вызовы без стриминга: классификацию, извлечение данных и ответы на FAQ.

## Читайте также

-   [Кэшированные входные токены: как снизить счёт за LLM API](https://broadrouter.com/ru/blog/cached-input-tokens-explained/)
-   [Как структурировать промпты, чтобы префикс кэшировался](https://broadrouter.com/ru/blog/prompt-structure-for-caching/)
-   [Контроль расходов на LLM API: бюджеты, лимиты ключей, защита от циклов](https://broadrouter.com/ru/blog/llm-api-spend-control/)
-   [Сокращаем токены промпта: замеры для инструкций, инструментов, данных](https://broadrouter.com/ru/blog/reduce-prompt-tokens/)
-   [Логирование LLM API: стоимость по пользователям и функциям без ПДн](https://broadrouter.com/ru/blog/llm-api-usage-logging/)
-   [Пакетная обработка LLM без Batch API: возобновляемый раннер](https://broadrouter.com/ru/blog/llm-batch-processing-without-batch-api/)
-   [GPU-парк и подход к инференсу BroadNet — по описанию самой BroadNet](https://broadrouter.com/ru/blog/broadnet-gpu-fleet-and-serving/)
-   [Ручная проверка в распознавании документов с помощью ИИ](https://broadrouter.com/ru/blog/document-review-queues/)
-   [Руководство: OpenAI Python SDK и BroadNet Inference](https://broadrouter.com/ru/guides/openai-python-sdk/)
-   [Руководство: Почему рассуждающая модель возвращает пустой ответ](https://broadrouter.com/ru/guides/reasoning-tokens-empty-response/)

Проверьте на своей реальной нагрузке. Новые аккаунты получают стартовый грант US$5 на Gemma и распознавание речи. Для DeepSeek, GLM и Qwen3.8 нужно пополнить баланс.

[Начать](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-cache-llm-responses-cut-cost&utm_content=page-cta) ·

**Источники**

-   [Справочник API BroadNet Inference: рассуждения входят в max\_tokens, поля usage для рассуждений и токенов из кэша, лимиты оплаты по факту (проверено 2026-11-15) (на английском)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [Заявление BroadNet о приватности инференса: промпты, сообщения, ответы и транскрипты не хранятся; хранятся записи о трафике и использовании без контента (проверено 2026-11-15) (на английском)](https://www.broadnet.ai/inference-privacy)
-   [GPTCache на GitHub: семантический кэш с эмбеддингами и оценщиком сходства, ложные срабатывания и ложные промахи, режим поиска по ключевым словам без эмбеддингов (проверено 2026-11-15)](https://github.com/zilliztech/GPTCache)
-   [Документация vLLM, Reproducibility: "vLLM does not guarantee the reproducibility of the results by default" (перевод: «vLLM по умолчанию не гарантирует воспроизводимость результатов»; проверено 2026-11-15)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Документация Python, модуль json: sort\_keys, separators и ensure\_ascii в json.dumps (проверено 2026-11-15)](https://docs.python.org/3/library/json.html)
