SSD Nodes Learn Hosting plans →
Руководства Matt ConnorАвтор: Matt Connor · Обновлено 2026-11-08

Ollama: как увеличить контекст через num_ctx

Ollama обрезает длинный prompt из-за небольшого окна по умолчанию. Настройте num_ctx для запроса или сервера и заранее оцените RAM для KV cache.

За что отвечает num_ctx и почему ваш длинный промпт был обрезан

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

Для Llama 3.1 8B в библиотеке моделей Ollama указано окно контекста 128k. Стандартный сервер не предоставит вам такой объем. В документации самой Ollama на разных страницах указаны разные значения по умолчанию: в FAQ говорится о 4096 токенах, в справочнике Modelfile указано, что num_ctx по умолчанию равно 2048, а на странице о длине контекста сказано, что значение по умолчанию выбирается исходя из доступной VRAM (видеопамяти): 4k при объеме менее 24 GiB, 32k при объеме от 24 GiB до 48 GiB и 256k при 48 GiB и более. Каждое из этих утверждений было верно для определенных сборок. Это расхождение — полезный урок: считывайте значение с вашего собственного работающего сервера, а не доверяйте любой странице, включая эту.

Усечение происходит незаметно, так как модель все равно отвечает, и ответ выглядит связным. Он был составлен на основе конца вашего ввода. Резюме, в котором отсутствует первая половина документа, выглядит как результат работы слабой модели. Обычно причина кроется в малом окне контекста.

Проверьте фактический размер контекста, применённый сервером Ollama

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

sudo apt update && sudo apt install -y jq
LONG=$(python3 -c "print('the quick brown fox jumps over the lazy dog. ' * 2000)")
jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:4096}}' |
  curl -s http://localhost:11434/api/generate -d @- |
  jq '{prompt_eval_count, prompt_eval_duration}'

В этом запросе около 18,000 слов, то есть значительно больше 4096 токенов. prompt_eval_count возвращает значение около 4096, а не значение, близкое к фактическому количеству токенов, поскольку сервер отбросил остаток. Запустите проверку ещё раз с "num_ctx":16384, и значение увеличится. Если ваша сборка возвращает ошибку вместо усечения запроса, это тот же результат, но с более явным сигналом.

ollama ps

В сборках, которые выводят этот столбец, столбец CONTEXT содержит размер контекста, с которым загруженная модель работает сейчас. Соседний столбец PROCESSOR показывает, где выполняется модель. 100% CPU — нормальное значение для VPS без GPU. Разделение, например 30%/70% CPU/GPU, на сервере с GPU означает, что веса модели вместе с cache больше не помещаются в VRAM. Обычно это происходит из-за увеличенного num_ctx.

journalctl -u ollama --no-pager | grep -i n_ctx | tail -n 5

Модуль выполнения inference выводит размер контекста в строке, содержащей n_ctx. Точная формулировка меняется между релизами, поэтому отсутствие этой строки следует считать переименованием, а не доказательством какого-либо вывода.

Четыре места для настройки num_ctx

В запросе. Передайте "options": {"num_ctx": 16384} в /api/generate или /api/chat. Этот параметр имеет приоритет над всеми остальными и действует только для текущего запроса. Если значение отличается от того, с которым запущена загруженная модель, сервер сначала перезагружает модель. Это видно по load_duration в ответе: значение увеличивается почти с нуля до нескольких секунд. Такая же задержка возникает, когда модель достаточно долго простаивает и выгружается. Поэтому после выбора размера контекста стоит оставить модель загруженной с помощью keep_alive.

В интерактивном сеансе. В ollama run введите /set parameter num_ctx 16384. Параметр действует в течение этого сеанса.

В Modelfile. Так значение сохраняется в именованной модели, и каждый клиент получает его без изменений на стороне клиента.

FROM llama3.1:8b
PARAMETER num_ctx 16384
ollama create llama3.1-16k -f ./Modelfile
ollama run llama3.1-16k

На сервере. OLLAMA_CONTEXT_LENGTH задаёт значение по умолчанию для каждого запроса, в котором отсутствует собственный num_ctx. В systemd добавьте drop-in-файл вместо изменения файла юнита.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"
sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama ps

Приоритет параметров особенно важен при отладке клиента, которым управляет другой разработчик. Запрос с num_ctx имеет приоритет над значением сервера по умолчанию. Поэтому web-интерфейс чата или агент, который отправляет небольшое значение, может незаметно отменить изменение в systemd. Когда вы подключаете coding agent к серверу Ollama, сначала проверьте, что отправляет клиент, и только потом ищите причину на сервере.

Почему нельзя просто установить num_ctx на максимум модели

Механизм внимания (attention) заставляет каждый токен «смотреть» на все предыдущие токены. Ключи и значения, вычисленные для ранних токенов, сохраняются, чтобы не пересчитывать их для каждого нового токена; это хранилище называется KV cache (кэш ключей/значений). Он выделяется для всего объема num_ctx при загрузке модели, а не по мере роста диалога, поэтому большой контекст потребляет память даже при запросе из одной строки.

Каждый слой хранит один вектор ключа и один вектор значения на каждую голову ключей/значений для каждого токена, поэтому расчеты укладываются в одну формулу:

kv_bytes_per_token = 2 * layers * kv_heads * head_dim * bytes_per_value

Множитель 2 учитывает ключи и значения отдельно. Остальные числа возьмите из характеристик вашей модели.

curl -s http://localhost:11434/api/show -d '{"model":"llama3.1:8b"}' |
  jq '.model_info | {ctx: ."llama.context_length", layers: ."llama.block_count", heads: ."llama.attention.head_count", kv_heads: ."llama.attention.head_count_kv", embed: ."llama.embedding_length"}'

Llama 3.1 8B имеет 32 слоя и 8 голов ключей/значений. Размерность головы — это embed, деленное на heads, то есть 4096 / 32 = 128, некоторые модели публикуют это значение напрямую как llama.attention.key_length. Кэш по умолчанию хранит значения f16, поэтому bytes_per_value равно 2, и выражение 2 32 8 128 2 дает 131 072 байта. Это 128 KiB кэша на каждый отдельный токен контекста. Умножьте это на длину контекста, и стоимость перестанет быть абстрактной.

ГрафикLlama 3.1 8B at f16: KV cache and total RAM by context length, in GiB
Данные, на которых построен график
[
  {
    "label": "4k",
    "kv_cache_gib": 0.5,
    "total_ram_gib": 5.1
  },
  {
    "label": "8k",
    "kv_cache_gib": 1,
    "total_ram_gib": 5.6
  },
  {
    "label": "16k",
    "kv_cache_gib": 2,
    "total_ram_gib": 6.6
  },
  {
    "label": "32k",
    "kv_cache_gib": 4,
    "total_ram_gib": 8.6
  },
  {
    "label": "64k",
    "kv_cache_gib": 8,
    "total_ram_gib": 12.6
  },
  {
    "label": "128k",
    "kv_cache_gib": 16,
    "total_ram_gib": 20.6
  }
]

Эти 6 строк — результат вычислений по формуле выше, а не прямые измерения. Итоговый столбец включает 4.9 GB веса модели, который библиотека Ollama указывала для llama3.1:8b в октябре 2026 года (это 4.6 GiB), и не учитывает вычислительные буферы и сам процесс сервера. Рассматривайте это как минимально возможный порог.

Суть в масштабировании. При 8k кэш занимает 1 GiB, что незначительно по сравнению с весами модели. При полном контексте модели в 128k он занимает 16 GiB — более чем в три раза больше весов, что в сумме дает около 20.6 GiB. Таким образом, VPS с 4 GB памяти не сможет загрузить эту модель с полезным контекстом. VPS с 8 GB комфортно работает на 8k. VPS с 16 GB позволяет использовать 32k, оставляя место для работы остальной системы. Каждый из этих порогов сдвигается вверх вместе с весом модели, поэтому, если вы сравниваете более крупную модель с этой 8B, те же расчеты, выполненные для тега Qwen 27B на VPS без GPU, показывают, как мало места остается для контекста между 8 и 64 GB оперативной памяти.

Что происходит, если KV cache не помещается в память

На VPS без GPU процесс просто увеличивает потребление памяти. Наблюдайте за ним во время загрузки модели и выполнения длинного запроса.

free -m
ps -eo rss,comm --sort=-rss | head -n 5

RSS (resident set size) отображается в килобайтах. Если значение используемого swap в free -m начинает расти, уменьшите размер контекста. Если KV cache находится в swap, генерация каждого токена будет занимать секунды, так как для каждого нового токена системе приходится считывать весь кэш целиком.

Если на сервере полностью заканчивается память, ядро выбирает процесс для завершения (OOM kill), обычно тот, который занимает больше всего оперативной памяти.

sudo dmesg | grep -i "killed process"

Строка с Out of memory: Killed process 1234 (ollama) означает, что ядро выбрало Ollama для завершения, но это не всегда значит, что именно этот процесс исчерпал всю память. Если на сервере Ollama — единственный крупный процесс, причиной обычно является слишком большой контекст. Проверьте, что еще было запущено, прежде чем сокращать num_ctx. Ollama часто отклоняет запрос до того, как происходит принудительное завершение, и запрос завершается с ошибкой, в которой указан объем требуемой памяти в сравнении со свободным объемом.

На сервере с GPU сбой происходит менее заметно. Слои модели вытесняются в системную RAM, ollama ps показывает распределение нагрузки между CPU и GPU, а пропускная способность резко падает. Насколько сильно она упадет, зависит от вашего оборудования, поэтому измерьте количество токенов в секунду на своей системе для каждого значения контекста, вместо того чтобы полагаться на показатели с чужих машин.

Время prefill растёт быстрее, чем длина prompt

Prefill — это обработка входных данных до появления первого токена ответа. Каждый токен prompt учитывает все предшествующие токены, поэтому общий объём работы растёт пропорционально квадрату длины входных данных. При удвоении prompt ожидание первого токена увеличивается более чем вдвое.

Измерение выводится в ответе, поэтому вам не нужно принимать это утверждение на веру.

jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:16384}}' |
  curl -s http://localhost:11434/api/generate -d @- |
  jq '{tokens: .prompt_eval_count, prefill_seconds: (.prompt_eval_duration/1000000000)}'

Запустите это с коротким prompt, затем повторите с длинным и в каждом случае разделите количество tokens на число секунд. На VPS только с CPU prefill обычно занимает больше всего времени при запросах с длинным контекстом, а показатель tokens per second, полученный на коротком prompt, не позволяет спрогнозировать это время. Если prefill длится дольше, чем заданный перед ним timeout, длинный prompt обычно завершается ошибкой превышено время ожидания контекста, а не выдачей ответа. Поэтому сначала выясните, какой слой прекратил ожидание, и только потом сокращайте контекст.

При параллельной обработке это особенно заметно. Для каждого обслуживаемого запроса нужен собственный cache. Поэтому указанное выше потребление памяти относится к одному запросу, а не ко всему серверу. Один длинный запрос может занять сервер, пока короткие запросы стоят в очереди. Настраивайте OLLAMA_NUM_PARALLEL осознанно и ознакомьтесь с материалом о количестве одновременных пользователей, которых может обслуживать self-hosted LLM, прежде чем одновременно увеличивать оба значения.

Возврат контекста за счет уменьшения кэша

bytes_per_value в формуле — это параметр, которым вы управляете. В FAQ по Ollama описан OLLAMA_KV_CACHE_TYPE, где f16 является значением по умолчанию, q8_0 занимает примерно половину памяти от f16, а q4_0 — примерно четверть. Точное значение для q8_0 составляет чуть больше половины: llama.cpp сохраняет каждый блок из 32 значений как 32 однобайтовых значения плюс двухбайтовый масштаб, итого 34 байта там, где для f16 требуется 64. Переход на q8_0 уменьшает строку 32k примерно до 2.1 GiB вместо 4 GiB. Квантование весов высвобождает память с другой стороны того же бюджета, и тег GLM, который действительно помещается на VPS, прорабатывается методом квантования, если вы предпочитаете именно такой компромисс. В том же FAQ указано, что кэш квантуется только при включенном Flash Attention, и приводится OLLAMA_FLASH_ATTENTION=1 для принудительного включения этой функции.

[Service]
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"

Проверяйте факты, а не предполагайте: перезапустите сервис, загрузите модель с тем же num_ctx, что и раньше, и сравните RSS. Поддержка зависит от модели и бэкенда, поэтому если настройка ничего не меняет, значит, ваша комбинация не поддерживается. Тип кэша — это глобальная опция, поэтому все модели на сервере будут работать с ней. Что касается качества, в FAQ сказано, что q8_0 обычно не дает заметного эффекта, в то время как q4_0 приводит к большей потере точности, что наиболее заметно при больших размерах контекста, поэтому протестируйте q4_0 на своих промптах, прежде чем полагаться на него. Если эти настройки — причина, по которой вы здесь, Ollama и llama.cpp предоставляют к ним разный доступ.

Как выбрать значение num_ctx

  1. Считайте максимальный размер контекста модели, количество её слоёв и количество голов key/value из /api/show.
  2. Рассчитайте количество байт на токен по формуле, затем умножьте результат на нужный размер контекста.
  3. Прибавьте размер весов, сравните итог с доступным объёмом RAM и оставьте не менее 1 GiB для остальных задач сервера.
  4. Задайте значение, загрузите модель и проверьте применённые параметры с помощью ollama ps и prompt_eval_count.
  5. Запустите рабочую нагрузку и следите за free -m. Если swap начинает использоваться, уменьшите размер контекста вдвое.

Для большинства задач требуется меньший контекст, чем обычно задают. Для суммаризации длинного отчёта достаточно 16k. Интерфейс поиска, который передаёт модели пять фрагментов документов, редко использует более 8k. Агент для работы с кодом, который читает файлы целиком, действительно может требовать 64k или больше. В этом случае размер сервера следует рассчитывать исходя из размера контекста, а не наоборот. Если вы работаете из России и думаете переложить такой контекст на Ollama Cloud, сначала разберитесь, что из Ollama работает без оплаты, а что упирается в Stripe, потому что локальные модели на собственном VPS от этого ограничения не зависят. Если сервер ещё не настроен, начните с рабочей установки Ollama на VPS и настройте контекст после того, как модели начнут корректно загружаться.

FAQ

Какова длина контекста по умолчанию в Ollama?

Она зависит от сборки и аппаратного обеспечения, поэтому проверяйте значение, а не полагайтесь на предположения. В FAQ Ollama указано 4096 токенов, в справочнике Modelfile задокументировано num_ctx значение по умолчанию 2048, а на странице о длине контекста описан выбор значения на основе доступной VRAM: 4k при объеме менее 24 GiB, 32k при объеме от 24 GiB до 48 GiB и 256k при 48 GiB и выше. VPS, работающий только на CPU, попадает в категорию с минимальным значением. ollama ps выводит примененный контекст в сборках, поддерживающих этот столбец, а prompt_eval_count в ответе API подтверждает его для любой сборки.

Почему Ollama игнорирует начало моего длинного промпта?

Потому что промпт оказался длиннее окна контекста, поэтому сервер обрезал его до того, как модель получила данные, при этом ошибка не была возвращена. Отправьте тот же промпт еще раз с большим значением num_ctx и следите за тем, как растет prompt_eval_count в ответе. Если это число не меняется, значит, что-то между вами и сервером самостоятельно устанавливает num_ctx, что часто встречается в чат-интерфейсах и агентских фреймворках.

Сколько дополнительной оперативной памяти требуется для большего num_ctx?

Умножьте длину контекста на стоимость кэша в расчете на один токен, которая составляет 2 * layers * kv_heads * head_dim * bytes_per_value. Для Llama 3.1 8B в формате f16 это 128 KiB на токен, поэтому 32k токенов потребуют 4 GiB, а полные 128k — 16 GiB сверх весов модели. Кэш выделяется при загрузке модели, поэтому большой num_ctx занимает этот объем памяти, даже если ваши промпты остаются короткими.

Делает ли большее окно контекста работу Ollama медленнее?

Да, по двум причинам. Время префилла (prefill) растет пропорционально квадрату длины промпта, поэтому длинный ввод задерживает появление первого токена на время, превышающее простое ожидание по длине. Увеличенный кэш также конкурирует за память: на GPU-сервере это вытесняет слои в системную RAM, а на CPU-сервере приближает систему к использованию swap. Большой num_ctx, который вы никогда не заполняете полностью, все равно занимает память, хотя и не увеличивает время префилла.

Можно ли установить num_ctx постоянно для одной модели?

Да. Создайте Modelfile, содержащий FROM llama3.1:8b и PARAMETER num_ctx 16384, затем выполните ollama create llama3.1-16k -f ./Modelfile. Каждый клиент, запрашивающий llama3.1-16k, получит этот контекст без необходимости отправки дополнительных параметров. Запрос, содержащий собственный num_ctx, все равно будет иметь приоритет, поэтому данная настройка задает значение по умолчанию, а не жесткий лимит.

Была ли эта статья полезной?