Лёгкая LLM на VPS без видеокарты: какую модель выбрать

Лёгкая LLM на VPS без видеокарты: запуск модели на CPU-сервере БЛОГ

⚡️ Кратко: ключевые факты и быстрый ответ

  • Потолок для VPS с 4 vCPU и 4 ГБ RAM без видеокарты — модели класса 3–4B параметров в квантизации Q4. Этого хватает на классификацию обращений, тональность отзывов и короткие ответы по базе знаний.
  • Скорость на CPU определяет не число ядер, а пропускная способность памяти: на дешёвом сервере 3–4B выдаёт примерно 5–12 токенов в секунду, что быстрее, чем человек читает. Модели 7–8B требуют уже 8–16 ГБ RAM и заметно просаживаются.
  • Считайте бюджет памяти как вес модели плюс KV-кеш, контекст и 1–1,5 ГБ на систему: закладывайте запас 30–40% к размеру файла GGUF, иначе сервер уйдёт в своп на длинных запросах.
  • Главная ошибка , брать 16 ГБ «на вырост» под 7B-модель: если задачи не требуют сложных рассуждений, вы платите за гигабайты, которые простаивают 90% времени.

Содержание
  1. Почему на VPS без GPU всё упирается в память, а не в ядра
  2. Сколько RAM нужно модели: считаем бюджет под веса и KV-кеш
  3. Квантизация GGUF и llama.cpp: сколько бит на вес брать
  4. Сравнительная таблица: какие лёгкие модели реально живут на CPU-VPS
  5. LLM на VPS: как выбрать тариф и не переплатить за гигабайты
  6. Производительность на практике: токены в секунду и узкие места
  7. Чем запускать: Ollama, llama.cpp или серверный рантайм
  8. Инженерная безопасность: маскирование данных и контуры изоляции
  9. Часто задаваемые вопросы (FAQ)
  10. Влезет ли LLM на VPS с 4 ГБ RAM без видеокарты, и какой размер модели брать?
  11. llama.cpp с GGUF или Ollama, что ставить на CPU-сервер?
  12. С какой скоростью модель будет отвечать и хватит ли этого для реальной задачи?
  13. Как квантизация влияет на качество — экономить на битах или на памяти?
  14. Что ещё незаметно съедает память и как не платить за лишние гигабайты?
  15. 💡 В сухом остатке: главное

Почему на VPS без GPU всё упирается в память, а не в ядра

При генерации токенов на VPS без видеокарты узкое место , пропускная способность оперативной памяти, а не тактовая частота процессора. Скорость жёстко ограничена тем, сколько гигабайт в секунду сервер способен прокачать через веса модели.

Чтобы выдать один токен, движок вроде llama.cpp должен прогнать вход через все слои сети. На каждом шаге веса читаются из RAM заново — в кэш процессора они просто не помещаются. Модель на 4 ГБ физически не влезет в 32 МБ кэша L3, поэтому каждый токен — это свежее чтение из памяти.

Отсюда простая арифметика. Потолок скорости примерно равен пропускной способности памяти, делённой на размер модели в памяти. Сервер с реальными 20 ГБ/с и моделью на 4 ГБ в квантованном виде упрётся в ~5 токенов/с, и никакие 8 ядер по 3,5 ГГц это не исправят.

💡 Инсайт: при выборе тарифа под LLM смотрите на тип памяти и число каналов, а не на частоту CPU. Два канала DDR5 дают кратный прирост к одному каналу DDR4 — это влияет на скорость генерации сильнее, чем лишние 4 vCPU.

Второй эффект , кэш ключей и значений контекста. Чем длиннее диалог, тем больше памяти съедает служебная структура, и тем меньше остаётся под сами веса. На 4 ГБ RAM это критично: модели до 4B параметров ещё живут, всё что крупнее — уже нет. Детали такого разбора с замерами по бизнес-задачам есть в материале про лёгкие LLM на CPU.

⚠️ Подводный камень: хостинг часто считает память вместе с запасом под систему. Если модель влезает «впритык», ядро уйдёт в подкачку, и генерация просядет с 5 токенов/с до долей токена. Всегда оставляйте 1–1,5 ГБ свободными.

Практический вывод: сначала считаем бюджет памяти под веса и контекст, потом подбираем квантизацию, и только в конце смотрим на ядра. Сколько потоков реально отдавать модели — вопрос отдельный, и ему посвящён блок про выбор процессора ниже: там разберём, когда 4 vCPU лучше 8 и почему Hyper-Threading в этой задаче почти не помогает.

И ещё один нюанс. Если сценарий требует длинных цепочек рассуждений, локальный сервер на 4 ГБ RAM будет откровенно медленным. В таких случаях дешевле отдать тяжёлую часть облачной модели — мы уже разбирали, как Gemini для агентных задач экономит бюджет за счёт длинных цепочек.

Сколько RAM нужно модели: считаем бюджет под веса и KV-кеш

Модели на 4B параметров в квантизации Q4 нужно около 2,4 ГБ под веса и ещё 0,56 ГБ под KV-кеш при контексте 4 тыс. токенов. С накладными расходами движка получается примерно 3,4 ГБ — то есть сервер на 4 ГБ работает впритык.

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

Веса считаются элементарно: число параметров умножаем на биты квантизации и делим на восемь. Для 4B в Q4_K_M это 4 млрд × 4,8 бита / 8 ≈ 2,4 ГБ. Точное значение всегда указано в карточке модели , ориентируйтесь на размер файла GGUF, а не на заявленное число параметров.

KV-кеш растёт линейно с длиной контекста и считается по формуле:

KV = 2 × L × H_kv × D × C × s

Здесь L , число слоёв, H_kv , количество голов ключей и значений (после группировки их обычно в 4–8 раз меньше, чем голов внимания), D , размерность головы, C , контекст в токенах, s , байт на элемент. Множитель 2 — отдельные тензоры для ключей и значений.

Подставим типичную 4B-модель: 36 слоёв, 8 голов KV, размерность 128, FP16. Один токен контекста съедает 2 × 36 × 8 × 128 × 2 = 147 456 байт, то есть около 144 КБ. На 4096 токенов набегает 576 МБ.

Контекст, токенов KV-кеш, FP16 KV-кеш, Q8_0 Итого с весами и запасом
2048 0,29 ГБ 0,15 ГБ ~3,1 ГБ
4096 0,56 ГБ 0,28 ГБ ~3,4 ГБ
8192 1,13 ГБ 0,56 ГБ ~3,9 ГБ
16384 2,25 ГБ 1,13 ГБ ~5,1 ГБ

⚠️ Подводный камень: как только память заканчивается, ядро начинает выгружать страницы в своп. Веса при этом отображены в память через mmap, и их вытеснение обваливает скорость с десятков токенов в секунду до единиц. Дальше срабатывает OOM-killer: процесс убивается сигналом SIGKILL, а в журнале ядра остаётся запись вида «Out of memory: Killed process». Держите запас 20–25% свободной RAM и не ставьте своп вместо расчёта — он спасает от падения, но не от деградации.

💡 Инсайт: квантизуйте сам кеш внимания. Флаг --cache-type-k q8_0 в llama.cpp режет KV-кеш ровно вдвое: те же 4 тыс. токенов обойдутся в 288 МБ вместо 576 МБ. На классификации и извлечении сущностей разницы в качестве не видно, а в 4 ГБ RAM модель влезает с комфортным запасом.

Что это даёт на практике? Четвёрка параметров уверенно живёт на сервере с 6 ГБ и контекстом 8 тыс. токенов. На 4 ГБ она тоже запустится, но свободного места под страничный кеш и соседние процессы почти не останется.

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

Ключевые этапы внедрения: LLM на VPS

🎯

1. Цель и контекст
Формулирование задачи и метрик

➔
⚙️

2. Выбор стека
Подбор оптимальной архитектуры

➔
🧪

3. Тестовый контур
Пилотный запуск и бенчмаркинг

➔
🚀

4. Ввод в прод
Масштабирование и контроль затрат

💡 Следование этапности гарантирует предсказуемый результат при внедрении решений на базе LLM на VPS.

Квантизация GGUF и llama.cpp: сколько бит на вес брать

Для CPU-VPS золотая середина — Q4_K_M: файл выходит примерно вдвое легче Q8_0, а просадка на типовых задачах редко выходит за 1–3 процентных пункта. Q5_K_M берите, когда оперативной памяти с запасом, Q8_0 , только для эталонных прогонов и сверки.

Формат GGUF — это контейнер, внутри которого лежат веса в заданной битности плюс метаданные: шаблон чата, токенизатор, гиперпараметры. Именно поэтому один и тот же файл одинаково понимают llama-server, llama-cli и llama-bench. «Бит на вес» — усреднённая плотность упаковки: у Q4_K_M она около 4,8, у Q5_K_M , примерно 5,7, у Q8_0 , 8,5.

Квантизация Бит на вес Модель 4B Модель 8B Что с качеством
Q8_0 ~8,5 ~4,3 ГБ ~8,5 ГБ Отличия от FP16 в пределах шума замеров
Q5_K_M ~5,7 ~2,9 ГБ ~5,7 ГБ Рост перплексии меньше процента, на глаз не видно
Q4_K_M ~4,8 ~2,5 ГБ ~4,8 ГБ Заметно на длинных рассуждениях, терпимо на извлечении данных и классификации

Логика простая: память и скорость на CPU упираются в объём весов, а не в тактовую частоту. Файл на 8,5 ГБ читается с диска и прогоняется через кеш-линии примерно в 1,7–1,8 раза дольше, чем 4,8 ГБ. То есть Q8_0 на слабом сервере отнимает и память, и терпение.

⚠️ Подводный камень: K-кванты (суффиксы _K_S, _K_M, _K_L) собраны из тензоров разной разрядности и требуют инструкций AVX2. На старых Xeon без AVX2 сборка либо откажется работать, либо уполовинит скорость. Проверьте флаг в /proc/cpuinfo до покупки тарифа.

Запуск на голом CPU: слои на видеокарту не выносим (-ngl 0), потоки ставим по числу ядер, контекст — под реальную длину запросов.

llama-server \
  -m /opt/models/qwen-4b-instruct-q4_k_m.gguf \
  --host 127.0.0.1 --port 8080 \
  -ngl 0 -t 4 -c 4096 -b 512 \
  --n-predict 512

Перед этим полезно снять базовый замер и не гадать:

llama-bench -m /opt/models/qwen-4b-instruct-q4_k_m.gguf -t 4 -p 256 -n 128

💡 Инсайт: Сравнивайте квантизации на своих данных, а не на чужих таблицах. Прогоните 30–50 реальных обращений через Q4_K_M и Q5_K_M и посмотрите, где именно ломается ответ — обычно разница вылезает только на многошаговых инструкциях, а на извлечении реквизитов её нет вовсе.

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

В сухом остатке: Q4_K_M — дефолт для 4–8B на VPS, Q5_K_M , апгрейд за счёт лишнего гигабайта-полутора, Q8_0 на CPU почти никогда не оправдан.

Сравнительная таблица: какие лёгкие модели реально живут на CPU-VPS

Короткий ответ: на CPU-VPS без видеокарты реально живут три класса моделей , 1–2B в Q4 (хватает 2 ГБ RAM, 20–35 ток/с), 3–4B (4 ГБ RAM, 8–15 ток/с) и 7–8B (8–10 ГБ RAM, 3–6 ток/с).

Цифры ниже , ориентир для машины с 4 vCPU, поддержкой AVX2 и обычной серверной DDR4. Разброс между провайдерами приличный: у кого-то ядро новее, у кого-то память быстрее, поэтому воспринимайте значения как порядок величины, а не как паспортные характеристики.

Класс Семейства Вес в Q4_K_M Минимум RAM Скорость, ток/с Типовые задачи
1–2B Qwen (младшие), Gemma (1B), Llama (1B) 0,7–1,4 ГБ 2 ГБ 20–35 Классификация обращений, теги, извлечение полей из письма, чистка опечаток
3–4B Qwen, Gemma, Phi (mini) 2,2–2,8 ГБ 4 ГБ 8–15 Тональность и приоритет заявки, короткий ответ в поддержке, пересказ письма, ответ по 2–3 абзацам базы знаний
7–8B Qwen, Llama, Mistral 4,4–5,2 ГБ 8–10 ГБ 3–6 Черновик ответа клиенту, разбор длинного документа, замечания по небольшому диффу

Столбец «минимум RAM» — это не только веса. Туда уже заложены сам рантайм, страница под кеш контекста и запас, чтобы система не ушла в подкачку на первом же длинном запросе. На 4 ГБ с моделью класса 7–8B вы получите не «медленно», а «никак».

⚠️ Подводный камень: замеры скорости почти всегда делают на короткой подсказке. Стоит подсунуть модели 4–6 тысяч токенов контекста, и 8B на четырёх ядрах просядет в два-три раза, потому что обработка подсказки на CPU идёт заметно медленнее генерации. Считайте бюджет времени по самому длинному запросу, а не по демо из документации.

Класс 3–4B — самая выгодная точка на этой кривой. Он ещё укладывается в VPS за 4 ГБ и при этом держит связный ответ по небольшому фрагменту базы знаний, чего младшие модели уже не умеют.

💡 Инсайт: если задача разбивается на шаги, не тащите её в 8B. Две последовательные прогонки моделью 3–4B на классификацию и извлечение полей дадут тот же результат быстрее и дешевле по памяти, чем один заход тяжёлой модели. На практике в большинстве внутренних сценариев хватает цепочки из младших моделей.

А вот длинные логические цепочки локальные 4B всё равно проваливают: они теряют нить после третьего-четвёртого шага. Такие сценарии дешевле отдавать внешним моделям — мы отдельно разбирали, как считают бюджет на агентных цепочках.

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

LLM на VPS: как выбрать тариф и не переплатить за гигабайты

Выбирать тариф под LLM на VPS нужно по трём жёстким параметрам: объём RAM важнее числа ядер, частота и поддержка AVX2/AVX-512 важнее количества vCPU, а диск нужен быстрый и с запасом 10–15 ГБ под кеш, логи и временные файлы.

Маркетинговая сетка тарифов у массовых провайдеров, и европейских бюджетных, и российских — устроена одинаково: шаг идёт по RAM и диску, а ядра добавляются «в комплекте». В итоге вы платите за гигабайты памяти и место на накопителе, хотя половину ядер модель всё равно не задействует.

Под капотом тут простая логика. При старте движок читает файл весов с диска и раскладывает его в RAM: медленный накопитель удлиняет холодный старт, но на скорость генерации не влияет. А вот если памяти не хватает и процесс уползает в swap, диск мгновенно становится главным тормозом — выигрыш в цене тарифа съедается падением отклика в разы.

Профиль vCPU RAM Диск Что реально тянет
Стартовый 2 2 ГБ 20–30 ГБ SSD микро-модели до 2B: классификация, извлечение сущностей, короткие ответы
Рабочий 4–6 8 ГБ 40–60 ГБ NVMe средние модели 7–8B в кванте Q4 с контекстом 4–8k, суммаризация
Комфортный 8 16 ГБ 80 ГБ NVMe 9–14B без спешки, плюс отдельный процесс под эмбеддинги

Конкретные цены не привожу намеренно: провайдеры переписывают прайс ежемесячно, и любая цифра в тексте устареет раньше, чем вы дочитаете. Ориентируйтесь на порядок: разница между «рабочим» и «комфортным» профилем обычно кратная, а прирост токенов в секунду — далеко не кратный.

💡 Инсайт: два ядра на высокой частоте с AVX-512 нередко обгоняют восемь ядер с низким базовым тактом и burst-кредитами. Перед заказом посмотрите модель процессора в описании тарифа, а не только число vCPU.

Теперь про то, что в тарифной сетке не написано. Разделяемые ядра — это доля физического процессора, и под соседями вы увидите в top приличный %st (steal time). Часть хостеров прямо прописывает в правилах добросовестного использования запрет на длительную загрузку в 100% CPU — инференс как раз попадает под такое ограничение.

⚠️ Подводный камень: сетевые квоты. Скачивание весов — входящий трафик, он почти везде бесплатный, а вот исходящий на ответы, логи и выгрузку отчётов считают по счётчику. На дешёвых тарифах полоса ограничена, и заливка многогигабайтного файла модели может занять десятки минут.

Наш опыт подсказывает простое правило: берите тариф, где RAM покрывает веса с двукратным запасом, а диск — NVMe. Ядра добавляйте последними, если упёрлись в очередь запросов. И держите в уме сценарий, когда собственная модель экономически не оправдана: часть задач дешевле отдать внешнему API — мы разбирали такие расчёты в материале Gemini для агентных задач: как длинные цепочки экономят бюджет.

Производительность на практике: токены в секунду и узкие места

Скорость лёгкой LLM на CPU-VPS измеряется в токенах в секунду, и упирается она в три вещи: длина контекста, число параллельных запросов и отсутствие кеша промпта. Ядра сами по себе вторичны.

Декодирование на процессоре ограничено пропускной способностью памяти, а не арифметикой. Прикидка простая: если веса модели занимают около 2,5 ГБ, а реальная полоса памяти даёт 12–15 ГБ/с, потолок выходит порядка 5–6 токенов в секунду. Всё, что выше, , уже удача, а не заслуга конфигурации.

Дальше начинается самое неприятное , префилл. Обработка длинного входа растёт нелинейно, и система из 1500 токенов на запрос может съедать больше времени, чем сам ответ. На коротких репликах модель бодро выдаёт 8–12 токенов в секунду, но стоит поднять контекст до 8 тысяч, и просадка в два-три раза становится нормой.

⚠️ Подводный камень: увеличение окна контекста в четыре раза раздувает KV-кеш примерно во столько же. Память кончается раньше, чем терпение, а llama.cpp начинает вытеснять данные на диск, и токены в секунду падают в разы.

Второе узкое место — параллельность. Слоты в llama.cpp делят один и тот же контекст и те же ядра: суммарная пропускная способность подрастает, зато задержка каждого отдельного ответа увеличивается. Для чата это плохо, для пакетной обработки , нормально.

Узкое место Как проявляется Что сделать без апгрейда
Длинный системный промпт Каждый запрос стартует медленно Кеш промпта, повторное использование слота
Раздутый контекст Ответы ползут, память забита Сжать историю, ограничить окно, квантовать KV-кеш
Лишние потоки Ядра дерутся за кеш Выставить число потоков по физическим ядрам
Много параллельных задач Растёт задержка ответа Очередь вместо одновременного запуска

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

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

Ещё три рычага: квантование KV-кеша до 8 бит, аккуратный размер батча при префилле и отключение лишних слоёв истории в диалоге. Плюс железное правило , число потоков равно физическим ядрам, а не удвоенному значению с гиперпоточностью.

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

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

Чем запускать: Ollama, llama.cpp или серверный рантайм

Для CPU-VPS есть три пути: Ollama , быстрый старт и готовый HTTP-API, llama.cpp — минимум накладных расходов и полный контроль над памятью, серверные рантаймы вроде vLLM — пропускная способность под нагрузкой, но с оглядкой на GPU.

Начнём с Ollama. Под капотом у него тот же llama.cpp, только завёрнутый в демон с удобной обвязкой: скачивание весов по имени, Modelfile под свои системные подсказки, REST на порту 11434. Одна команда, и модель уже отвечает.

Цена этой простоты — лишний постоянно живущий процесс и политика удержания модели в памяти. Демон не спешит освобождать RAM, а на VPS с небольшим объёмом это прямой путь к тому, что OOM-killer прибьёт что-нибудь нужное. Таймаут простоя настраивается, но про него надо помнить.

Второй вариант — llama-server из состава llama.cpp. Один бинарь, никакой прослойки, предсказуемое потребление: сколько зарезервировали под веса и контекст, столько и занято. Эндпоинт совместим с форматом OpenAI API, так что клиентский код переезжает без правок.

Серверные рантаймы (vLLM, TGI) раскрываются на GPU: непрерывная пакетная обработка запросов и эффективное управление кешем дают кратный рост пропускной способности. На четырёх ядрах без ускорителя этот выигрыш почти съедается накладными расходами.

Вариант Простота Память Продакшен
Ollama Высокая: одна команда Демон + удержание модели Годится для внутренних задач
llama.cpp (llama-server) Средняя: ручная настройка Минимальная, предсказуемая Хорош как основной сервис
vLLM / TGI Низкая: много параметров Высокая, рассчитана на GPU Оправдан под поток запросов

Дальше, как это удержать живым. В systemd пишем юнит с Restart=always и жёстким лимитом MemoryMax по cgroups: модель физически не сможет выесть RAM у sshd и веб-сервера. Проверенная схема, работает годами.

Docker удобен воспроизводимостью, но образы тяжёлые, а лимиты надо прописывать явно через --memory. Забыли, и контейнер тихо разрастается до предела хоста.

⚠️ Подводный камень: Ollama в контейнере с включённым удержанием модели держит веса в памяти даже когда запросов нет. На тесном VPS это половина бюджета RAM впустую. Ставьте короткий таймаут простоя или запускайте модель через llama.cpp по требованию.

💡 Инсайт: Начинайте с Ollama ради скорости эксперимента, а на боевой VPS переезжайте на llama.cpp под systemd с лимитом памяти. Клиентский код при этом не меняется — оба отдают совместимый API.

Отдельно про окружение: если модель крутится рядом с кодинг-агентом, стоит заранее подумать, кто и как её вызывает — об этом у нас есть разбор про вайбкодинг в продакшн.

Инженерная безопасность: маскирование данных и контуры изоляции

Маскирование данных — это замена чувствительных сущностей (имена, телефоны, адреса, номера счетов) плейсхолдерами вида [PERSON_1] ещё до отправки запроса во внешний API. Контуры изоляции — это ограничение того, куда процесс вообще может обратиться и что записать на диск.

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

Важный нюанс: нумерация плейсхолдеров должна быть стабильной в рамках сессии. Если в первом сообщении «Иван» стал [PERSON_1], а во втором — [PERSON_2], модель начнёт путать людей и отвечать мусором. На практике это проявляется именно так.

⚠️ Подводный камень: регулярки ловят телефоны и почту, но пасуют перед ФИО в косвенных падежах и адресами вида «двушка на Пресне». Для этого на том же VPS держат крошечную NER-модель на 1–2B параметров — она идёт отдельным процессом и наружу не ходит никогда.

С журналами всё жёстче, чем кажется. Соблазн писать полные запросы и ответы в файл ради отладки убивает всю схему маскирования за один вечер. Наш подход: в журнал попадают только метаданные — длина промпта, число токенов, задержка, хеш запроса. Тело сообщения не пишется вообще либо хранится в зашифрованном виде с ключом вне сервера.

Ротация обязательна. Файл на 200 МБ, который никто не чистит полгода, — это уже не журнал, а архив переписки клиентов на диске VPS.

Теперь про изоляцию. Модель и обвязка живут в контейнере без root, с файловой системой только для чтения и отдельной внутренней сетью. Исходящие соединения — по белому списку доменов, ровно один адрес API, ничего больше. Слушает llama.cpp на 127.0.0.1, наружу выставляем через обратный шлюз с авторизацией и ограничением частоты запросов.

💡 Инсайт: самый дешёвый контур изоляции — локальная модель на 3–4B для всех рутинных операций. Что не уходит в сеть, то нечего и маскировать. Внешний API оставляем для сложных случаев, где нужны логические рассуждения посерьёзнее.

Лимиты по памяти и процессору тоже часть защиты: контейнер с жёстким потолком в 4 ГБ не утянет за собой хост, если модель внезапно начнёт раздувать контекст. Профиль безопасности и отключение лишних системных вызовов — база, которую часто пропускают ради быстрого запуска.

Если гоняете через такие контуры код, пригодится наш разбор про безопасность кодинг-агента: там как раз про то, что агент видит и куда может дотянуться.

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

Часто задаваемые вопросы (FAQ)

Влезет ли LLM на VPS с 4 ГБ RAM без видеокарты, и какой размер модели брать?

Ориентир простой: на 4 ГБ оперативной памяти реально живут модели до 4B параметров в четырёхбитной квантизации. Считается на пальцах: 4 млрд параметров при ~4,5 бита на вес — это примерно 2–2,5 ГБ файла весов.

Остаток съедают KV-кэш, буферы рантайма и сама операционная система (обычно 300–500 МБ). То есть 4 ГБ — это впритык, а 8 ГБ дают спокойный запас на контекст и параллельные запросы. На тарифе с 2 ГБ вариант один — модели класса до 1B либо выгрузка в swap, которая убивает скорость.

llama.cpp с GGUF или Ollama, что ставить на CPU-сервер?

llama.cpp напрямую с моделями в формате GGUF — минимальный оверхед и полный контроль над числом потоков, размером контекста и батчем. Ollama удобнее для быстрого старта: сама скачает модель, поднимет локальный сервис с API, даст управлять версиями.

Рабочая схема: гипотезу проверяете на Ollama, а в продакшн выносите llama.cpp, когда начинаете считать каждый мегабайт и каждый токен в секунду. Тяжёлые серверные движки вроде vLLM рассчитаны в первую очередь на видеокарты — на четырёх vCPU они вам ничего не дадут.

С какой скоростью модель будет отвечать и хватит ли этого для реальной задачи?

На 4 vCPU ждите порядок нескольких токенов в секунду при генерации — на практике чаще 3–10 для модели 3–4B в четырёхбитной квантизации. Точные цифры сильно зависят от конкретного процессора и соседей по гипервизору, поэтому не верьте обзорам — замеряйте на своём сервере: llama.cpp в логах сам показывает скорость обработки и генерации.

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

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

Как квантизация влияет на качество — экономить на битах или на памяти?

Рабочая точка по умолчанию — четырёхбитная квантизация среднего уровня (маркировка вида Q4_K_M). Веса сжимаются в 3–4 раза по сравнению с полной точностью, а деградация на коротких прикладных задачах обычно остаётся в пределах разброса между запусками.

Пяти- и шестибитные варианты берите, если критична точность на длинных логических рассуждениях и память позволяет. Сжатие до двух-трёх бит экономит гигабайт, но даёт заметные провалы — модель начинает путать форматы и терять инструкции. И да, проверять надо не на бенчмарках из интернета, а на своей выборке из 50–100 живых примеров.

Что ещё незаметно съедает память и как не платить за лишние гигабайты?

Главный скрытый едок — длина контекста. KV-кэш растёт линейно: модель может поддерживать 32k токенов, но если ваши запросы укладываются в 2–4k, ограничьте контекст явно в настройках запуска. То же с параллельными запросами — каждый активный слот резервирует свою память.

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

💡 Инсайт: самый дешёвый апгрейд — не новый тариф, а урезание контекста и отказ от лишних параллельных слотов. Часто это освобождает больше памяти, чем разница между тарифами на 4 и 8 ГБ.

💡 В сухом остатке: главное

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

Чек-лист для внедрения на практике:

  • ✅ Замерьте реальные задачи: соберите 20–30 типовых запросов команды и прогоните их через модель 3–4B в Q4_K_M, если качество устраивает, апгрейд тарифа не нужен.
  • ✅ Посчитайте бюджет памяти по формуле «вес GGUF + KV-кеш + 1,5 ГБ системы» и только потом выбирайте тариф VPS с запасом 30–40%.
  • ✅ Разверните llama.cpp или Ollama в контейнере, ограничьте контекст 2–4 тыс. токенов и включите кеширование промпта — это дешевле, чем лишние ядра.
  • ✅ Настройте маскирование персональных данных на входе в модель и храните журналы диалогов на своём сервере, не отправляя их во внешние API.

Обсудить материал и поделиться своими бенчмарками можно в комментариях к блогу.


Редактор
Оцените автора
Добавить комментарий

Отправляя данную форму вы соглашаетесь с политикой конфиденциальности сайта