⚡️ Кратко: ключевые факты и быстрый ответ
- Потолок для 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% времени.
- Почему на VPS без GPU всё упирается в память, а не в ядра
- Сколько RAM нужно модели: считаем бюджет под веса и KV-кеш
- Квантизация GGUF и llama.cpp: сколько бит на вес брать
- Сравнительная таблица: какие лёгкие модели реально живут на CPU-VPS
- LLM на VPS: как выбрать тариф и не переплатить за гигабайты
- Производительность на практике: токены в секунду и узкие места
- Чем запускать: Ollama, llama.cpp или серверный рантайм
- Инженерная безопасность: маскирование данных и контуры изоляции
- Часто задаваемые вопросы (FAQ)
- Влезет ли LLM на VPS с 4 ГБ RAM без видеокарты, и какой размер модели брать?
- llama.cpp с GGUF или Ollama, что ставить на CPU-сервер?
- С какой скоростью модель будет отвечать и хватит ли этого для реальной задачи?
- Как квантизация влияет на качество — экономить на битах или на памяти?
- Что ещё незаметно съедает память и как не платить за лишние гигабайты?
- 💡 В сухом остатке: главное
Почему на 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.
Обсудить материал и поделиться своими бенчмарками можно в комментариях к блогу.







