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

Настройка OLLAMA_NUM_PARALLEL и OLLAMA_MAX_QUEUE

Узнайте, как работают параметры OLLAMA_NUM_PARALLEL и OLLAMA_MAX_QUEUE. Разбираем, почему очередь вызывает задержки ответов и как каждый параллельный слот увеличивает потребление VRAM.

Что происходит со вторым запросом к Ollama во время генерации первого

Параллелизм Ollama определяется тремя переменными окружения, и по умолчанию одна загруженная модель обслуживает только один запрос за раз. Второй запрос не отклоняется, и он не получает частичный ответ. Он ожидает в очереди, пока слот не освободится, после чего выполняется с обычной скоростью.

Входящий запрос может ожидать один из трех исходов. Он либо сразу запускается в свободном слоте, либо ожидает в очереди, либо сервер отклоняет его с ошибкой HTTP 503, если очередь уже переполнена. Исход определяется переменными OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE и OLLAMA_MAX_LOADED_MODELS. В текущих релизах по состоянию на октябрь 2026 года есть один нюанс. Ошибка 503 применяется только к тем запросам, которые поступают в момент, когда модель еще должна быть загружена. Ollama никогда не отклоняет запрос к уже загруженной модели. Такой запрос будет ждать слота столько, сколько потребуется.

Настройки по умолчанию безопасны, именно поэтому второй пользователь может сообщать, что сервер «завис», хотя на самом деле всё исправно. Добавление слотов требует изменения двух строк конфигурации. Проблема заключается в памяти. Каждому параллельному слоту требуется собственный кэш ключей и значений (KV cache) — блок памяти, в котором модель хранит уже обработанные токены. Если добавить слоты без увеличения объема VRAM (видеопамяти на GPU), медленный ответ превратится в ошибку загрузки. На сервере, использующем только CPU, этот же кэш будет расходовать системную RAM.

За что отвечают параметры OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE и OLLAMA_MAX_LOADED_MODELS

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

  • OLLAMA_NUM_PARALLEL определяет, сколько запросов одновременно обрабатывает одна загруженная модель. Значение по умолчанию — 1, поэтому запросы обслуживаются последовательно.
  • OLLAMA_MAX_LOADED_MODELS определяет, сколько различных моделей могут одновременно находиться в оперативной памяти. Значение по умолчанию — 0, что означает автоматический выбор Ollama: три модели на один GPU или три модели на машине без GPU.
  • OLLAMA_MAX_QUEUE определяет, сколько запросов могут ожидать в очереди на планирование, что на практике означает ожидание загрузки модели. Значение по умолчанию — 512. Запрос, поступивший при заполненной очереди, отклоняется немедленно. Запросы к уже загруженной модели пропускают эту очередь и ожидают свободного слота, причем время такого ожидания не ограничено. Разработчики Ollama отслеживают это как запрос на доработку (issue #7758), который оставался открытым в октябре 2026 года.

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

Почему каждый параллельный слот потребляет VRAM

Когда Ollama загружает модель, она запускает отдельный процесс-исполнитель (runner). Здесь важны два аргумента: -c — это общий контекст, для которого исполнитель выделяет KV-кэш, и -np — количество параллельных последовательностей. Ollama устанавливает -c как произведение длины контекста на один запрос и количества слотов. Затем исполнитель равномерно распределяет этот объем между слотами, чтобы каждый запрос получал запрошенную вами длину контекста.

Это единственное ограничение, и именно поэтому параллелизм не бесплатен. Переход от одного слота к четырем требует в четыре раза больше KV-кэша при той же длине контекста на запрос. Между слотами ничего не разделяется, и доля простаивающего слота не передается занятому, так как распределение фиксируется при запуске исполнителя. На GPU эта память является VRAM. На сервере только с CPU это системная оперативная память, и применяется то же самое умножение.

Вы можете увидеть реальные значения вместо тех, которые планировали установить:

journalctl -u ollama --no-pager -n 500 | grep "starting llama-server"

Эта строка содержит полную командную строку исполнителя, включая -c и -np. Если после установки переменной -np равно 1, возможны две причины. Первая — сама модель. Ollama ограничивает некоторые архитектуры моделей одним слотом независимо от ваших настроек и записывает model architecture does not currently support parallel requests в логи, когда это происходит. По состоянию на октябрь 2026 года в этот список входят семейства Qwen 3.5, Qwen3-VL, Qwen3-Next, LFM2 и Nemotron-H, а модели для эмбеддингов всегда получают только один слот. Запустите journalctl -u ollama --no-pager | grep "does not currently support parallel" для проверки. Если этого предупреждения нет, значит, настройка не доходит до сервера, и следующий раздел объясняет, почему.

Если веса модели вместе с KV-кэшем не помещаются в VRAM, Ollama перемещает часть слоев в системную оперативную память, и эти слои выполняются на CPU. Слои на CPU работают значительно медленнее, чем на GPU, поэтому это замедляет каждый запрос, включая тот единственный, с которого вы начали. Таким образом, увеличение параллелизма может снизить пропускную способность вместо её повышения. При достаточно большом размере модели веса сами по себе решают вопрос еще до начала вычислений со слотами, поэтому самостоятельный хостинг моделей размером с Kimi K3 — это разговор о количестве ваших видеокарт, а не о количестве настроенных слотов.

ollama ps

Столбец PROCESSOR показывает 100% GPU, когда всё помещается в память. Разделение вида 35%/65% CPU/GPU означает, что часть модели выполняется на CPU. Столбец SIZE включает KV-кэш, поэтому он увеличивается при повышении количества слотов и перезагрузке модели. Увеличьте OLLAMA_NUM_PARALLEL, перезапустите, отправьте один запрос и снова выполните ollama ps: это и есть стоимость вашего изменения в памяти, измеренная, а не предполагаемая. Если это измерение показывает, что модель больше не помещается, помните, что веса — это вторая половина того же бюджета, и переход с fp16 на сборку q8 или q4 часто освобождает больше VRAM, чем стоит слот, который вы пытались добавить.

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

Как настроить эти переменные, чтобы они сохранялись после перезагрузки

В Linux Ollama работает как systemd-сервис. Выполнение export OLLAMA_NUM_PARALLEL=4 в вашей оболочке ничего не меняет, так как systemd запускает сервис в собственном окружении и не видит вашу оболочку. Используйте drop-in файл.

sudo systemctl edit ollama.service

Добавьте следующее в открывшемся редакторе:

[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_MAX_QUEUE=32"

Затем выполните перезагрузку конфигурации и перезапуск:

sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment

systemctl show выводит переменные, которые systemd передаст процессу. Если вашей переменной там нет, значит, drop-in файл не был сохранен или вы пропустили daemon-reload. Проверьте это также со стороны самого сервера:

journalctl -u ollama --no-pager | grep "server config" | tail -1

Ollama записывает всё свое окружение при запуске в строке с сообщением server config. Этот список показывает именно то, что считал сервер, и это самый быстрый способ разрешить спор о том, вступила ли переменная в силу. Он показывает установленное вами значение, а не количество слотов, которое фактически получил конкретный экземпляр модели. Чтобы узнать это, прочитайте значение -np в строке runner выше.

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

Как выглядят состояния served, queued и refused со стороны клиента

Отправьте несколько запросов одновременно и замерьте время их выполнения. Следующая команда запускает восемь потоковых запросов параллельно и выводит статус и время для каждого из них:

for i in $(seq 1 8); do
  curl -s -o /dev/null \
    -w "req$i http=%{http_code} ttfb=%{time_starttransfer}s total=%{time_total}s\n" \
    http://127.0.0.1:11434/api/generate \
    -d '{"model":"llama3.2:3b","prompt":"Explain what a KV cache is.","stream":true}' &
done
wait

ttfb — это время до получения первого байта потока. Оно близко к времени до первого токена (TTFT), так как первый фрагмент потока содержит первый токен.

Served (обработано) параллельно. Каждый запрос показывает схожее значение ttfb, а total увеличивается для всех них одновременно. GPU распределяется между активными слотами, поэтому каждый ответ генерируется медленнее, чем при одиночном запросе, но общее количество завершенных запросов в минуту растет. Именно этот режим вы получаете, увеличивая OLLAMA_NUM_PARALLEL.

Queued (в очереди). Первые запросы отвечают быстро, а последующие показывают большое значение ttfb, за которым следует нормальная генерация. Ожидание происходит в очереди, а не в модели. Пользователь в окне чата видит долгую паузу, после которой текст появляется на полной скорости. Такая картина — медленный старт и быстрая генерация — является признаком очереди, а не перегруженного GPU.

Refused (отклонено). Клиент почти мгновенно получает http=503, а тело ответа выглядит так:

{"error":"server busy, please try again.  maximum pending requests exceeded"}

Это сообщение означает, что очередь планировщика была заполнена в момент поступления запроса. Оно не относится к VRAM или самой модели. В текущих релизах эта очередь содержит только запросы, чья модель еще не была загружена. Если модель уже находится в памяти при запуске цикла выше, ожидайте, что каждый запрос вернет 200, независимо от того, насколько низким вы установите OLLAMA_MAX_QUEUE. Переполнение в этом случае проявится как увеличение ttfb.

Важное ограничение: Ollama не публикует глубину очереди. ollama ps и эндпоинт /api/ps сообщают о загруженных моделях, а не о запросах, ожидающих в очереди. Поэтому измеряйте очередь со стороны клиента, отслеживая время до первого байта, либо подсчитывайте ответы 503 на уровне прокси-сервера, стоящего перед Ollama.

Почему меньшее значение MAX_QUEUE часто является более предпочтительным

Очередь из 512 запросов звучит внушительно, но для одного слота она практически бесполезна. Запрос 300 будет ждать завершения 299 генераций. В лучшем случае это займет минуты. Любой HTTP-клиент сдастся гораздо раньше, поэтому вызывающая сторона получит таймаут на стороне клиента, который не даст информации о причине и не позволит системе мониторинга зафиксировать проблему.

Меньший размер очереди превращает переполнение в немедленный ответ 503, но только для тех запросов, которые ожидают загрузки модели, например, при всплеске трафика после перезапуска или во время смены моделей. По состоянию на октябрь 2026 года запросы к уже загруженной модели обходят OLLAMA_MAX_QUEUE и ожидают свободного слота без ограничений. Таким образом, уменьшение очереди не сократит время ожидания на нагруженном сервере с одной резидентной моделью. Чтобы получить быстрый отказ в такой ситуации, ограничьте параллелизм перед Ollama, как описано в следующем разделе. Ответ 503 полезен: reverse proxy может повторить запрос, клиент может увеличить интервал ожидания, панель мониторинга может учесть этот отказ, а администратор может его увидеть. Рассчитайте лимит на основе собственных измерений. Если генерация занимает около десяти секунд, а ваш клиент ожидает шестьдесят, то в этом окне успеют обработаться около шести запросов на слот, а ожидание большего количества приведет лишь к таймаутам.

Когда перед Ollama нужно ставить очередь

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

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

Легкий вариант — использование reverse proxy. В nginx limit_conn ограничивает количество одновременных соединений, а limit_req ограничивает скорость поступления запросов на клиента, поэтому переполнение отклоняется на прокси и не доходит до Ollama. Тяжелый вариант — очередь задач с базой данных перед воркером, который вызывает Ollama; это необходимо, когда запросы должны пережить перезапуск процесса. Расчет параметров для реального трафика — отдельная задача: в планировании self-hosted LLM для одновременных пользователей приведены расчеты, а в запуске Ollama на VPS описана базовая установка, на которую опираются эти переменные.

Когда честный ответ — другой сервер

Существует предел, который нельзя преодолеть настройками. При загрузке модели Ollama разделяет KV cache на равные фиксированные слоты. Память простаивающего слота нельзя использовать для занятого, а количество слотов нельзя изменить без выгрузки модели. Такая архитектура хорошо подходит для одного человека, небольшой команды или агента для написания кода.

Серверы, созданные для большого количества одновременных пользователей, работают иначе. Они выделяют KV cache небольшими страницами по требованию и добавляют поступающие запросы в уже выполняющийся пакет, поэтому потребление памяти соответствует реальной нагрузке, а не фиксированному разделению. Если ваша цель — большое количество одновременных пользователей на одном GPU, это архитектурное различие важнее любого значения OLLAMA_NUM_PARALLEL. Сравнение Ollama и vLLM поможет принять решение. Если вместо этого вы думаете разделить одну видеокарту между несколькими виртуальными машинами, по экземпляру Ollama на каждую, сравнение vGPU, MIG и проброса PCI объясняет, почему для LLM чаще выигрывает одна VM с общим сервером моделей. Однако не переходите на другое решение только из принципа: другой сервер сложнее в эксплуатации, и если ваш трафик — это несколько человек, встроенное поведение является верным ответом. Если же вопрос в том, стоит ли вообще запускать сервер моделей самостоятельно, сравнение частного AI-сервера с арендой GPU поможет взвесить решение, включая случаи, когда выгоднее использовать API.

Измерение собственной пропускной способности и времени до первого токена

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

Ollama возвращает временные показатели в финальном JSON-объекте каждого ответа. eval_count — это количество сгенерированных токенов, а eval_duration — время, затраченное на их генерацию, в наносекундах.

sudo apt install -y jq
curl -s http://127.0.0.1:11434/api/generate \
  -d '{"model":"llama3.2:3b","prompt":"Explain what a KV cache is.","stream":false}' \
  | jq '{prompt_eval_count, eval_count, eval_duration, tokens_per_second: (.eval_count / (.eval_duration / 1000000000))}'

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

Публичная точка доступа с большой очередью — цель для отказа в обслуживании

Установка OLLAMA_HOST=0.0.0.0:11434 открывает API на всех интерфейсах, а в Ollama нет встроенной аутентификации. С очередью по умолчанию открытая точка доступа примет до 512 запросов в ожидании загрузки модели от любого, кто ее найдет. Для уже загруженной модели она будет удерживать каждое подключившееся соединение без ограничений. Загрузка сервера таким способом почти ничего не стоит атакующему: длинные промпты, отсутствие входа, отсутствие лимитов, отсутствие оплаты. Ваши пользователи в итоге получают 503 ошибки или долгое ожидание, а машина все это время занята.

Оставьте слушающий порт на loopback и обращайтесь к нему через SSH-туннель или частную сеть, либо установите перед ним аутентификацию и ограничение частоты запросов. Защита API-точки доступа Ollama охватывает оба варианта. Настраивайте очередь после выполнения этих мер, так как размер очереди — это параметр производительности, а не средство защиты.

FAQ

Почему мой второй запрос к Ollama ожидает завершения первого?

Потому что OLLAMA_NUM_PARALLEL по умолчанию равно 1, поэтому загруженная модель обрабатывает запросы по очереди, а остальные ожидают в порядке очереди. Ожидающий запрос удерживает HTTP-соединение открытым и не передает данные, пока не освободится слот, что со стороны клиента выглядит как медленная работа модели. Признаком очереди является характер задержки: долгая пауза, а затем вывод текста на полной скорости — это очередь, тогда как медленное появление токенов с самого начала означает медленную работу модели. Увеличьте количество слотов через drop-in файл systemd и перезапустите службу. Затем проверьте значение -np в строке запуска, так как некоторые архитектуры моделей ограничены одним слотом независимо от ваших настроек.

Что означает ошибка "server busy, please try again. maximum pending requests exceeded"?

Это ошибка переполнения очереди Ollama, возвращаемая с HTTP-статусом 503. Количество запросов, ожидающих планирования (то есть ожидающих загрузки своей модели), достигло OLLAMA_MAX_QUEUE, значение которого по умолчанию равно 512, поэтому новый запрос был отклонен вместо постановки в очередь. Запросы к уже загруженной модели не учитываются в этом лимите. Вы будете видеть эту ошибку в основном при всплесках нагрузки во время запуска или при смене моделей. Это не ошибка памяти и не ошибка модели. Увеличение очереди лишь заставит вызывающие стороны дольше ждать перед тем же отказом, поэтому реальными решениями являются увеличение количества слотов (если у вас достаточно VRAM), снижение входящей нагрузки или использование очереди перед Ollama, которая может выполнять повторные попытки и приоритизацию.

Ускоряет ли Ollama увеличение OLLAMA_NUM_PARALLEL?

Нет. Это позволяет выполнять больше запросов одновременно, и каждый из них будет медленнее, чем при выполнении в одиночку, так как они делят один GPU. Это также увеличивает KV-кэш, поскольку Ollama запускает процесс обработки с общим контекстом, равным произведению длины вашего контекста на количество слотов. Если результат перестает помещаться в VRAM, Ollama вытесняет слои в CPU, и каждый запрос замедляется, включая одиночный запрос без конкуренции. Проверьте ollama ps после внесения изменений и убедитесь, что в столбце PROCESSOR по-прежнему указано 100% GPU.

Нужно ли перезапускать Ollama после изменения этих переменных?

Да. Сервер считывает их при запуске, а запущенная модель сохраняет количество слотов, которое было зафиксировано в процессе обработки при его старте. Отредактируйте drop-in файл с помощью sudo systemctl edit ollama.service, затем выполните sudo systemctl daemon-reload и sudo systemctl restart ollama. Подтвердите изменения командой systemctl show ollama --property=Environment, а затем проверьте строку server config в journalctl -u ollama, где перечислено окружение, которое фактически загрузил сервер.

Сколько параллельных слотов следует установить?

Начните с 1 и увеличивайте значение пошагово. После каждого шага перезапускайте Ollama, отправляйте один запрос для загрузки модели и выполняйте ollama ps. Остановитесь на последнем значении, при котором в PROCESSOR по-прежнему указано 100% GPU, а столбец SIZE оставляет запас для самого длинного контекста, который вы обслуживаете. Затем измерьте время до первого токена и количество токенов в секунду при этой настройке в условиях вашей реальной нагрузки, и вернитесь на шаг назад, если скорость обработки запросов упала ниже допустимой для ваших пользователей.

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

#ollama#concurrency#vram#queueing#self-hosted-llm