Разница между KV cache и prompt cache в LLM
Узнайте ключевые различия между KV cache и prompt cache. Разбираем, почему нехватка KV cache приводит к ошибкам загрузки модели, а prompt cache лишь влияет на стоимость API.
KV cache и prompt cache: краткий ответ
KV cache и prompt cache у провайдера имеют общее слово в названии, но практически ничего общего в остальном. KV cache — это рабочая память для конкретного запроса. Она находится в RAM или VRAM вашего сервера в течение всего времени обработки одного запроса и увеличивается по мере роста длины контекста и количества одновременных запросов. Prompt caching у провайдера — это функция для оптимизации биллинга и задержек. Стабильный префикс вашего промпта сохраняется на серверах провайдера, и при повторной отправке вы платите за него по сниженной цене.
Первое — это память, которую вы покупаете как оборудование. Второе — это память, которую удерживает кто-то другой и берет с вас арендную плату.
Практическая разница важнее определений. У вас может закончиться KV cache, и в этом случае модель откажется загружаться или запрос будет отклонен. У вас не может закончиться prompt cache. Вы можете лишь не попасть в него, и тогда вы просто заплатите полную стоимость.
Что содержит KV cache и зачем он нужен
Трансформер, генерирующий токен номер 500, должен учитывать все 499 предыдущих токенов. Для каждого из этих токенов каждому слою требуются вектор ключа (key vector) и вектор значения (value vector). Повторное вычисление всех этих векторов для каждого нового токена привело бы к тому, что время генерации росло бы пропорционально квадрату длины последовательности, поэтому среда выполнения сохраняет их. Это хранилище называется KV cache (кэш ключей и значений).
Это состояние, специфичное для каждого запроса, так как оно строится на основе точной последовательности токенов конкретного запроса. Два пользователя, отправляющие разные промпты, не могут использовать его совместно, если только среда выполнения не поддерживает prefix caching — отдельную функцию, описанную далее.
Обслуживание запросов происходит в две фазы. Фаза prefill считывает весь ваш промпт и заполняет кэш; её скорость ограничена вычислительной мощностью. Фаза decode генерирует по одному токену за раз и добавляет их в кэш; её скорость ограничена пропускной способностью памяти. Именно из-за этого разделения обработка промпта и генерация токенов показывают разную скорость, когда вы измеряете количество токенов в секунду на своей системе.
Сколько памяти использует KV-кэш?
Не ищите таблицу от производителя. Размер вычисляется арифметически для любой модели:
bytes per token = 2 * layers * kv_heads * head_dim * bytes per elementЦифра 2 учитывает ключ и значение. Все остальные числа берутся из config.json модели, опубликованного на её странице в Hugging Face.
Возьмем Llama 3.1 8B. В её конфигурации указаны num_hidden_layers 32 и num_key_value_heads 8. hidden_size, равный 4096, распределенный по 32 головам внимания, дает размер головы 128. В формате f16 каждый элемент занимает 2 байта:
2 * 32 * 8 * 128 * 2 = 131072 bytes = 128 KiB per tokenУмножьте это на требуемый контекст, а затем на количество одновременных запросов.
Данные, на которых построен график
[
{
"label": "2k context",
"one_request_gib": 0.25,
"four_requests_gib": 1
},
{
"label": "8k context",
"one_request_gib": 1,
"four_requests_gib": 4
},
{
"label": "32k context",
"one_request_gib": 4,
"four_requests_gib": 16
},
{
"label": "128k context",
"one_request_gib": 16,
"four_requests_gib": 64
}
]При контексте 8k кэш составляет 1 ГиБ. При 32k он составляет 4 ГиБ, что находится в том же диапазоне, что и сами 4-битные веса. При полном контексте модели 128k он составляет 16 ГиБ для одного запроса и 64 ГиБ, если четыре запроса заполняют его одновременно. Веса не изменились. Изменился только кэш.
Grouped query attention (GQA) значительно влияет на это число. У Llama 3.1 8B есть 8 голов ключей/значений, обслуживающих 32 головы запросов, поэтому четыре головы запросов совместно используют одну сохраненную пару ключ/значение. Модель, у которой num_key_value_heads равно num_attention_heads, использует в четыре раза больше кэша при том же количестве параметров. Проверьте это поле, прежде чем предполагать, что две модели 8B требуют одинаковых ресурсов для обслуживания.
Почему модель, работавшая с контекстом 2k, не загружается при 32k
Среда выполнения резервирует KV-кэш в момент загрузки модели, исходя из настроенной длины контекста, а не из размера отправляемого промпта. Значение по умолчанию в Ollama больше не является фиксированным числом. Согласно документации от октября 2026 года, длина контекста определяется объемом VRAM: 4k для систем с объемом менее 24 GiB, 32k для систем от 24 до 48 GiB и 256k для 48 GiB и более, в то время как облачные модели по умолчанию используют свой максимум. На VPS без GPU или с маломощной видеокартой значение по умолчанию составляет 4k. Увеличив его до 32k, вы запрашиваете 4 GiB дополнительной памяти еще до обработки первого токена. На карте с 24 GiB значение 32k уже является стандартным, поэтому резервирование происходит независимо от того, запрашивали вы его или нет.
OLLAMA_CONTEXT_LENGTH=32768 ollama serveАналогичная настройка для сессии из интерактивного промпта:
ollama run llama3.1:8b
/set parameter num_ctx 32768Ошибка выглядит по-разному в зависимости от стека. vLLM выполняет расчеты при запуске и отказывается работать:
ValueError: To serve at least one request with the model's max seq len (131072), (16.0 GiB KV cache is needed, which is larger than the available KV cache memory (9.56 GiB). Based on the available memory, the estimated maximum model length is 78336. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.На VPS без GPU, использующем Ollama или llama.cpp, выделение памяти происходит из обычной системной RAM, и нехватка может быть не обнаружена при старте. В этом случае процесс завершается OOM-киллером (out-of-memory killer) ядра, а запись об этом остается в кольцевом буфере ядра:
dmesg -T | grep -i "killed process"Строка с названием вашего процесса обслуживания означает, что системе было обещано больше памяти, чем доступно физически. Решение заключается в уменьшении контекста, а не в увеличении файла подкачки: если KV-кэш выгружается на диск, он считывается при генерации каждого токена, из-за чего скорость генерации падает до неприемлемых значений. Выбор подходящего значения описан в нашем руководстве по num_ctx и длине контекста в Ollama.
Как параллелизм влияет на показатели
Каждый активный запрос использует собственный KV cache. Это тот фактор, который чаще всего упускают при планировании ресурсов. Четырем пользователям, каждый из которых удерживает 32k контекста, требуется 16 GiB памяти, не считая весов модели.
Среды выполнения различаются по строгости этого требования. Ollama и llama.cpp резервируют запрошенный объем контекста при загрузке модели, поэтому память выделяется независимо от того, используется она или нет. vLLM разбивает пул на блоки фиксированного размера и распределяет их по мере роста каждого запроса, поэтому запрос на 500 токенов занимает память только для 500 токенов. В любом случае пул ограничен, и как только он заполняется, новые запросы встают в очередь, а не выполняются. О том, как эта очередь влияет на время отклика, подробно рассказано в сколько одновременных пользователей может обслуживать self-hosted LLM.
Четыре способа уменьшить размер KV-кэша
- Уменьшите длину контекста. Это самый эффективный рычаг, который обычно не требует затрат. Большинство чат-запросов даже близко не приближаются к 32k.
- Квантуйте сам кэш. По умолчанию в Ollama используется
OLLAMA_KV_CACHE_TYPE, что соответствуетf16. Также поддерживаетсяq8_0, который использует около половины памяти, иq4_0, использующий около четверти. Аналоги в llama.cpp — это-ctk q8_0и-ctv q8_0. - Выбирайте модель с меньшим количеством key/value heads или меньшим числом слоев. Ознакомьтесь с
config.json, прежде чем скачивать 40 GB весов. - Обслуживайте меньше запросов одновременно, а остальные ставьте в очередь.
При q4_0 показатель для Llama 3.1 8B снижается со 128 KiB на токен примерно до 32 KiB. Таким образом, 32k контекста занимают около 1 GiB вместо 4 GiB. Эта экономия не дается бесплатно. Ключи и значения хранятся с меньшей точностью, поэтому сравните вывод на своих собственных промптах, прежде чем переходить на этот режим.
Что на самом деле дает кэширование промптов у провайдера
Кэширование промптов у провайдера — это отдельный продукт с другой единицей учета. Вы помечаете стабильный префикс, провайдер сохраняет его, и последующие вызовы, в точности повторяющие этот префикс, тарифицируются по сниженной ставке вместо полной стоимости входных токенов.
Опубликованные Anthropic коэффициенты на октябрь 2026 года: запись в кэш с временем жизни 5 минут стоит в 1.25 раза больше базовой цены входного токена. Запись на 1 час стоит в 2 раза больше, а чтение из кэша для большинства моделей обходится в 0.1 от базовой цены. Новейшие модели читаются еще дешевле: 0.05 от цены для Claude Opus 5.5 и Sonnet 5.5, и 0.025 для Claude Fable 5.1 и Mythos 5.1. Если применить эти стандартные показатели к системному промпту объемом 20,000 токенов, выгода становится очевидной.
Данные, на которых построен график
[
{
"label": "No caching, every call",
"billed_token_equivalents": "20,000"
},
{
"label": "First call, 5 minute cache write",
"billed_token_equivalents": "25,000"
},
{
"label": "First call, 1 hour cache write",
"billed_token_equivalents": "40,000"
},
{
"label": "Every later call, cache hit",
"billed_token_equivalents": "2,000"
}
]Рассматривайте это как арифметическую задачу. Наценка за запись в 5-минутный кэш при первом вызове составляет эквивалент 5,000 токенов: 25,000 против 20,000 при отправке без кэширования. Каждый последующий вызов в течение этого окна тарифицируется как 2,000 вместо 20,000, что дает экономию в 18,000 токенов. Таким образом, 5-минутный кэш становится выгодным начиная со второго вызова.
1-часовой кэш — это другой расчет. При записи он тарифицирует 40,000, что создает наценку в 20,000 токенов, поэтому для выхода в плюс требуется два попадания в кэш в течение часа. Это вопрос вашего паттерна трафика, а не характеристик модели. Полный расчет, включая выбор окна, приведен в математике окупаемости кэширования промптов Claude.
Две детали определяют, попадете ли вы в кэш вообще. Во-первых, префикс короче минимально допустимой длины модели молча не кэшируется: по состоянию на октябрь 2026 года задокументированный минимум составляет 512 токенов для Claude Opus 5, Opus 5.5 и Sonnet 5.5, и 1,024 токена для Claude Sonnet 5; более короткие запросы обрабатываются в обычном режиме без возврата ошибки. Во-вторых, время жизни отсчитывается с момента начала запроса, который записывает или считывает запись, и каждое чтение обновляет его без дополнительных затрат. Таким образом, нагруженный эндпоинт поддерживает 5-минутный кэш активным бесконечно. Эндпоинт, вызываемый раз в десять минут, каждый раз оплачивает наценку за запись и не получает никакой выгоды.
Проверяйте ответ, а не делайте предположений. Объект usage содержит поля cache_creation_input_tokens и cache_read_input_tokens. Если счетчик чтений равен нулю при каждом вызове, значит, вы оплачиваете записи, но не получаете отдачи.
Точка соприкосновения двух типов кэширования
Длинный системный промпт — это место, где они встречаются, и он расходует ресурсы с обеих сторон одновременно.
Локально системный промпт объемом 20,000 токенов занимает около 2.4 GiB KV-кэша на сервере Llama 3.1 8B в формате f16, причем для каждого параллельного запроса, включающего этот промпт, выделяется отдельный объем памяти. Удаленно тот же префикс требует одной записи в кэш, а затем 0.1 от объема входных данных при каждом последующем вызове (или меньше в новейших моделях). Локальные затраты масштабируются вместе с количеством ваших пользователей. Удаленные затраты масштабируются вместе с трафиком и сбрасываются во время простоя.
Существует локальная функция, которую часто путают с кэшированием промптов у провайдеров: кэширование префиксов (prefix caching). В документации vLLM автоматическое кэширование префиксов описывается как кэширование «KV-кэша существующих запросов, чтобы новый запрос мог напрямую повторно использовать KV-кэш, если он имеет тот же префикс, что и один из существующих запросов». В текущих версиях vLLM эта функция включена по умолчанию. Сервер llama.cpp по умолчанию хранит кэш промптов для каждого слота, а --cache-reuse N задает минимальный фрагмент, который система будет пытаться использовать повторно.
Кэширование префиксов экономит вычислительные ресурсы на этапе prefill. Ваш системный промпт из 20,000 токенов обрабатывается один раз, а не при каждом запросе, что значительно сокращает время до получения первого токена (time to first token). В vLLM общие блоки используются повторно, а не дублируются, что также оптимизирует использование памяти. Однако это никак не уменьшает объем кэша, который необходимо удерживать для активных в данный момент токенов. Удержание весов модели в памяти между запросами — это связанный, но отдельный механизм, который описан в поддержании модели Ollama в загруженном состоянии между запросами.
Что измерять на собственном сервере
Загрузите модель с целевым контекстом, а затем ознакомьтесь с реальными показателями вместо того, чтобы доверять оценочным данным.
ollama ps
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
free -gollama ps выводит список загруженных моделей с указанием их размера, контекста, с которым они были запущены, и того, работают ли они на GPU или CPU. В первую очередь проверьте столбец контекста, так как значение по умолчанию теперь зависит от объема вашей VRAM. Если модель, которая должна была полностью разместиться на GPU, показывает распределение на CPU, это означает, что KV-кэш вытеснил часть данных, и скорость генерации соответственно снизится. nvidia-smi показывает точное значение VRAM, а free -g выполняет ту же задачу на VPS, работающем только на CPU. Увеличивайте контекст поэтапно, перезагружайте модель и следите за изменением показателей. Ваши расчеты и отображаемые данные должны быть близки. Если это не так, разница обычно обусловлена собственными вычислительными буферами среды выполнения, а не ошибкой в формуле.
Если эти цифры подталкивают вас к использованию оборудования, которое вы не хотели бы арендовать, сравнение с оплатой за токен приведено в GPU VPS против API токенов.
FAQ
Является ли KV cache тем же самым, что и кэширование промптов (prompt caching)?
Нет. KV cache — это память внутри процесса обслуживания запроса, хранящая векторы ключей и значений для каждого токена в текущем контексте. Она находится в вашей RAM или VRAM и освобождается после завершения запроса. Кэширование промптов у провайдера — это функция биллинга, которая сохраняет стабильный префикс промпта на инфраструктуре провайдера и взимает плату по сниженному тарифу при повторной отправке. Исчерпание KV cache приводит к невозможности загрузки модели. Отсутствие кэша промптов лишь увеличивает ваш счет и время до получения первого токена.
Почему модель загружается с контекстом 2k, но выдает ошибку на 32k?
Потому что среда выполнения выделяет весь объем KV cache во время загрузки, ориентируясь на настроенную длину контекста, а не на размер отправляемого промпта. Для Llama 3.1 8B в формате f16 кэш составляет 128 KiB на токен, поэтому контекст 2k требует 0.25 GiB, а 32k — 4 GiB. Веса модели помещаются в обоих случаях. Ошибка возникает именно при резервировании памяти. vLLM сообщает об этом через ValueError, указывая требуемый объем памяти KV cache в сравнении с доступным, а также оценочную максимальную длину модели, и предлагает увеличить gpu_memory_utilization или уменьшить max_model_len. На серверах только с CPU, использующих Ollama или llama.cpp, процесс может быть принудительно завершен OOM-киллером ядра, что можно подтвердить с помощью dmesg -T | grep -i "killed process".
Как рассчитать размер KV cache для моей модели?
Умножьте 2 на количество слоев, количество голов ключей/значений (key/value heads), размерность головы и количество байт на элемент. Это даст размер в байтах на токен. Затем умножьте на длину контекста и количество одновременных запросов. Количество слоев и голов можно узнать из файла config.json модели. Используйте 2 байта на элемент для f16 или bf16. Кэш q8_0 занимает примерно половину этого объема, а q4_0 — примерно четверть.
Снижает ли кэширование промптов потребление памяти на моем сервере?
Кэширование промптов у провайдера никак не влияет на ваше оборудование, так как хранилище находится на стороне провайдера. Локальным аналогом является кэширование префиксов (prefix caching), предлагаемое vLLM и сервером llama.cpp. Оно повторно использует уже вычисленные векторы ключей и значений для общего префикса, что экономит вычислительные ресурсы на этапе prefill и сокращает время до получения первого токена. В vLLM общие блоки переиспользуются, а не дублируются, поэтому использование памяти также оптимизируется. Ни одна из этих функций не уменьшает объем кэша, необходимый для текущих токенов в обработке, поэтому ваши расчеты контекста и параллелизма по-прежнему определяют минимальные требования.
Стоит ли кэшировать промпт, который я отправляю только один раз?
Нет. Запись в кэш стоит дороже, чем обычный ввод: по состоянию на октябрь 2026 года это 1.25 от базового тарифа для 5-минутного окна, поэтому префикс, который вы не отправляете повторно в течение этого времени, является прямым убытком. Кэширование выгодно, когда один и тот же префикс повторяется, например, длинный системный промпт или документ, по которому вы будете задавать несколько вопросов. Проверяйте cache_read_input_tokens в ответе API, чтобы убедиться, что вы получаете попадания в кэш, а не платите за записи.