Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

7. Кэш промпта и агентские нагрузки

Зачем эта глава. Агент, который вызывает инструменты, делает десятки запросов подряд. Каждый следующий запрос — это почти тот же промпт плюс небольшой хвост. Если это не использовать, вы будете платить за обработку одного и того же текста снова и снова. Кэш промпта превращает prefill из главной статьи расходов в почти бесплатную операцию.

За 30 секунд

  • Агент шлёт почти один и тот же промпт много раз подряд; кэш промпта сохраняет KV общего начала и считает prefill только для нового хвоста.
  • Совпадение проверяется по токенам с самого начала: одно изменение в начале — и всё после него считается заново.
  • Отсюда правило: стабильное — в начало, изменчивое — в конец.
  • Кэш ускоряет prefill, но не декод; в агентских нагрузках после включения кэша узким местом становится генерация.

7.1 Как выглядит агентский запрос

Типичный шаг агента:

[ системный промпт ]
[ описания инструментов ]
[ история диалога: 20 предыдущих шагов ]
[ результат последнего инструмента ]
[ инструкция: что делать дальше ]

Следующий шаг — это тот же текст плюс ответ модели и новый результат инструмента. Общий префикс может составлять 95–99% запроса.

Если сервер каждый раз обрабатывает весь промпт, он делает одну и ту же работу заново. Кэш промпта (prompt cache, prefix cache) сохраняет KV-кэш для общего начала и переиспользует его.

7.2 Как это работает

Сервер хранит KV-кэш обработанных токенов. При новом запросе он ищет наибольший общий префикс (longest common prefix, LCP) с тем, что уже есть в кэше. Совпавшая часть берётся готовой, а prefill считается только для хвоста.

запрос:  A B C D E F G
кэш:     A B C D E
итог:    [A B C D E] — из кэша, [F G] — prefill

Выигрыш огромен. Пример: промпт 20 000 токенов, новый хвост 500 токенов, скорость prefill 1000 ток/с.

СценарийОбработано токеновВремя prefill
Без кэша20 00020 с
С кэшем5000,5 с

Это разница между «агент думает полминуты на каждый шаг» и «агент отвечает почти сразу».

7.3 Главное правило: стабильный префикс

Кэш работает по точному совпадению токенов. Если изменить один токен в начале, всё, что после него, перестаёт совпадать.

Warning

Самая частая ловушка — «Сегодня 7 ноября, 14:32» в первой строке системного промпта. Строка меняется на каждом запросе, и кэш не срабатывает ни разу, хотя формально включён. Дату и время передавайте в конце, рядом с вопросом.

Плохие привычки, которые убивают кэш:

  • дата, время или счётчик в начале системного промпта;
  • случайный порядок описаний инструментов;
  • перестановка истории или сжатие середины диалога;
  • добавление уникального идентификатора запроса в системную часть;
  • разные пробелы и переводы строк при каждом запросе.

Хорошая структура:

[ стабильный системный промпт ]
[ стабильные описания инструментов ]
[ растущая история ]
[ новый хвост ]

Всё изменчивое — в конец. Это одновременно улучшает кэш и упрощает отладку.

7.4 Кэш и слоты

В llama.cpp у каждого слота (-np) свой контекст и свой кэш. Когда приходит запрос, сервер выбирает слот по наибольшему совпадению префикса. Поэтому:

  • один слот с длинной историей лучше, чем четыре слота с короткой, если запросы идут последовательно;
  • каждый слот добавляет ещё один KV-объём: N слотов — примерно в N раз больше памяти под KV, а не «чуть больше»; при последовательных запросах лишние слоты не помогают;
  • при параллельных запросах с общим началом кэш может переиспользоваться между слотами, если реализация это поддерживает.

Флаг --cache-prompt включает кэш (в актуальных сборках он включён по умолчанию, выключается --no-cache-prompt). --cache-reuse N позволяет переиспользовать часть KV при изменении в середине, сдвигая кэш; это полезнее для редактирования промпта, чем для агента, который всегда дописывает в конец.

7.5 Продвинутые реализации

  • vLLM поддерживает automatic prefix caching: блоки KV хранятся по хешу токенов и переиспользуются между запросами.
  • SGLang использует RadixAttention: префиксы хранятся в дереве (radix tree), что позволяет эффективно разделять общие начала между многими запросами и ветвями диалога.
  • Prompt Cache (исследование 2023) предлагает модульное переиспользование attention-состояний для повторяющихся частей промпта.

В локальном llama.cpp реализация проще: кэш на слот плюс выбор по LCP. Этого достаточно для последовательного агента, но для сервера с сотнями пользователей нужен движок вроде vLLM или SGLang.

7.6 Где кэш не помогает

  • Первый запрос всегда холодный.
  • Изменение начала сбрасывает всё после него.
  • Разные документы в RAG дают разные префиксы, если документ вставлен в начало. Ставьте стабильные инструкции первыми, документы — после.
  • Смена модели или кванта — другой кэш.
  • Очень длинный хвост (например, вставили новый документ на 50k токенов) всё равно требует prefill этого хвоста.
  • Параллельные разные запросы не делят префикс, если он у них разный.

7.7 RAG как нагрузка

RAG (retrieval-augmented generation) — поиск внешних фрагментов и вставка их в промпт. Для кэша это особая нагрузка:

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

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

7.8 Кэш и качество

Кэш не меняет ответ: это те же KV-векторы, которые были бы вычислены заново. Но есть нюансы:

  • KV, посчитанный одним большим батчем, и KV, накопленный по кускам, могут отличаться в последних битах: другие формы матриц — другой порядок сложения чисел с плавающей точкой (подробнее про детерминизм — §10.4); на длинной генерации это иногда меняет выбор токена;
  • при сдвиге кэша (--cache-reuse) позиционные кодировки должны быть скорректированы, иначе модель «увидит» не те позиции;
  • разные реализации могут по-разному обрабатывать границы блоков.

Для детерминированных задач (температура 0) кэш обычно безопасен. Для тонких проверок стоит сравнить ответы с кэшем и без.

7.9 Агентская нагрузка в цифрах

Пусть агент делает 60 шагов, каждый шаг добавляет 300 токенов, контекст растёт с 8k до 26k, prefill 1200 ток/с, декод 40 ток/с, ответ 150 токенов.

Без кэша:

средний промпт ~17k → 14 с prefill + 3,75 с декод на шаг
≈ 18 с × 60 = 18 минут

С кэшем (обрабатывается только хвост ~300 токенов):

0,25 с prefill + 3,75 с декод ≈ 4 с на шаг
≈ 4 минуты

Цифры условные, но соотношение типичное: время шага сократилось в 4,5 раза, и теперь почти всё оно — декод (3,75 с из 4). Вывод: кэш промпта убирает prefill из критического пути, и дальше время определяется декодом. Именно поэтому в агентских нагрузках оптимизация генерации важнее оптимизации prefill.

Посчитай сам. Тот же агент из 60 шагов, но в первой строке системного промпта стоит текущее время с секундами. Кэш включён. Сколько теперь займёт задача?

Решение

Время меняется на каждом запросе, поэтому общий префикс заканчивается уже на первой строке и кэш не срабатывает ни разу. Получаем сценарий «без кэша»: около 18 с на шаг и ~18 минут на задачу вместо ~4. Одна строка в начале промпта сделала агента в 4,5 раза медленнее.

7.10 Практические правила

  1. Держите системный промпт и инструменты неизменными. Версия, дата, счётчик — в конец или в отдельное поле.
  2. Не сжимайте историю в середине без необходимости. Это ломает префикс.
  3. Ставьте самые стабильные части первыми. Инструкции → примеры → документы → вопрос.
  4. Меряйте, сколько токенов реально обрабатывается. В логах сервера видно prompt eval и размер кэша.

Tip

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

  1. Не держите лишние слоты. Каждый слот — это KV-память.
  2. Для мультипользовательского сервера смотрите в сторону vLLM/SGLang, а не только llama.cpp.

Ключевые идеи

  • Кэш промпта переиспользует KV для общего префикса и пересчитывает только хвост.
  • Любое изменение в начале промпта обнуляет кэш после этого места.
  • В агентских нагрузках кэш убирает prefill из критического пути, оставляя декод главным узким местом.
  • Стабильный префикс — это архитектурное решение, а не флаг сервера.
  • Для многих пользователей нужны движки с разделяемым кэшем (vLLM, SGLang).

Проверь себя

  1. Почему дата в начале системного промпта может замедлить агента в разы?
  2. Промпт 30k токенов, хвост 400, prefill 1000 ток/с. Во сколько раз кэш ускоряет prefill?
  3. Чем кэш на слот отличается от разделяемого кэша в vLLM/SGLang?
  4. Почему сжатие истории в середине диалога может быть вредным для скорости?
  5. Кэш промпта ускоряет декод?

Ответы

  1. Каждый день (или каждый запрос) дата меняется, поэтому общий префикс с прошлым запросом заканчивается на ней. Всё, что после, пересчитывается заново, и агент платит полный prefill на каждом шаге.
  2. Без кэша 30 000 / 1000 = 30 с; с кэшем 400 / 1000 = 0,4 с. Ускорение prefill в 75 раз.
  3. Кэш на слот привязан к конкретному слоту и его контексту; разделяемый кэш хранит блоки по хешу токенов и может переиспользовать их между разными запросами и слотами.
  4. Сжатие переписывает середину промпта, поэтому общий префикс с предыдущим запросом обрывается раньше. Агенту приходится заново обрабатывать большой кусок.
  5. Нет. Декод по-прежнему генерирует по одному токену и читает веса на каждом шаге. Кэш ускоряет только prefill.

Источники главы

  • Gim et al., «Prompt Cache: Modular Attention Reuse for Low-Latency Inference» (2023) — arXiv:2311.04934. Идея модульного переиспользования частей промпта.
  • Zheng et al., «SGLang: Efficient Execution of Structured Language Model Programs» (2023) — arXiv:2312.07104. RadixAttention и разделяемый кэш префиксов.
  • vLLM, «Automatic Prefix Caching» — docs.vllm.ai. Как это устроено в vLLM.
  • vLLM blog, «Easy, Fast, and Cheap LLM Serving with PagedAttention» (2023) — blog.vllm.ai. Контекст: PagedAttention и управление KV.
  • llama.cpp, tools/server/README.md — GitHub. --cache-prompt, --cache-reuse, слоты.
  • Databricks, «LLM Inference Performance Engineering» — блог. Метрики TTFT/ITL и влияние кэша в продакшене.