Self-hosting китайских open-source LLM в 2026: Ollama, vLLM и llama.cpp для DeepSeek, Qwen, Kimi, GLM, Yi

Автор: Silvana · Дата: 02.08.2026 · Verified: 01.09.2026 · Reading time: 14 минут · Prerequisite: базовые знания командной строки, Python, что такое open-source LLM.

Self-hosting китайских LLM в 2026 — это запуск DeepSeek, Qwen 3, Kimi K2, GLM и Yi на своём железе через один из трёх runtime: Ollama для быстрого старта, vLLM для production и llama.cpp для CPU и mixed inference. Реалистичный порог: 8 ГБ RAM — 7B в Q4, 24 ГБ VRAM (RTX 4090) — 32B в Q4, A100 80 ГБ — 70B, для полных DeepSeek-V3, R1 или Kimi K2 (671B–1T параметров) нужен кластер из нескольких H100. Quantization Q4_K_M — стандартный компромисс для потребительского железа. LoRA и QLoRA дают fine-tuning на 24 ГБ GPU за часы, а не за недели. Матрица выбора: до 100 миллионов токенов в месяц — API, свыше 1 миллиарда — окупается свой inference.

Кратко

Self-hosting — это запуск LLM на своём железе: своём ноутбуке, домашнем PC с GPU, арендованном сервере или on-premise стойке. Модель работает офлайн, данные не уходят наружу, платить провайдеру не надо.
Три главных runtime для 2026: Ollama (простой запуск на любом железе), vLLM (production-grade сервер с высокой пропускной способностью), llama.cpp (максимальная экономия — CPU, Mac Metal, mixed inference на слабом GPU).
Китайские open-weights модели, которые реально скачать: DeepSeek-R1 и V3, Qwen 3 (все размеры от 0.6B до 235B), GLM от Zhipu AI / z.ai, Yi (01.AI), Kimi K2 от Moonshot AI — веса открыты.
Реалистичное железо: 8 Gb RAM → 7B в Q4; 24 Gb VRAM (RTX 4090) → 32B в Q4; A100 80 Gb → 70B; для полных DeepSeek-V3 / R1 / Kimi K2 (671B–1T параметров) нужен кластер из нескольких H100.
Quantization (Q4, Q5, Q8) уменьшает модель в 2–8 раз, но снижает качество. Q4_K_M — стандартная точка компромисса для потребительского железа.
Из РФ international API-ключи Anthropic и OpenAI не работают напрямую. Self-hosting китайских моделей — легитимный путь: скачал веса с Hugging Face (доступ есть), запустил у себя, никаких международных платежей.
Fine-tuning реален с LoRA и QLoRA: обучить адаптер на 3–10 тысяч примеров можно на одной 24 Gb GPU за часы, а не за недели.
Не self-hosting: если у вас <100 M токенов в месяц и не критична privacy — дешевле и проще API DeepSeek или Qwen через официальный portal. Разбор — статьи про API этих моделей.

Что это и зачем

Self-hosting означает: вы качаете веса модели (тензоры с весами нейросети) на своё железо и запускаете inference локально. Модель полностью подконтрольна вам — можно выключить интернет, отдать её команде через локальную сеть, обучить на своих данных, встроить в закрытый корпоративный контур.

До 2024 self-hosting серьёзной модели требовал стойку с 8 × A100 и профильного ML-инженера. К 2026 картина изменилась радикально по трём причинам:

Китайские лаборатории публикуют веса моделей MoE-архитектуры. DeepSeek-V3 (671B параметров, 37B активированных на токен) и Kimi K2 (1T параметров) доступны для скачивания под открытыми лицензиями. Западные Frontier-модели — GPT-5, Claude Opus 5, Gemini 3 Pro — закрыты.
Инструменты стали дружелюбными. Ollama устанавливается одной командой и запускает модель за 60 секунд после ollama pull. Не нужно понимать torch.compile() и разбирать CUDA-ошибки.
Quantization ушла в народ. GGUF-формат от llama.cpp позволяет ужать 32B-модель до 20 Gb памяти без катастрофической потери качества. Модель, для которой раньше нужен был кластер, теперь бегает на RTX 4090.

Зачем это может понадобиться:

Privacy и compliance. Персональные данные клиентов, медицинские записи, юридические документы не должны уходить в чужие облака. Внутри российского контура — обязательное требование при работе с ПДн (ФЗ-152).
Стоимость на масштабе. При >1 B токенов в месяц self-hosting на арендованных GPU окупает и OpAmp, и работу инженера. При 100 M токенов и меньше — сравните с ценой API официального DeepSeek portal, чаще выгоднее API.
Fine-tuning под свою нишу. Дообученная на 10 тысячах примеров ваших диалогов Qwen 3 8B на своей задаче начинает работать лучше, чем базовый GPT-5. Через API это невозможно.
Работа офлайн. On-premise LLM в цехе, в поле, в самолёте, в изолированном сегменте сети — интернет не нужен.
Из РФ. Открытые веса на Hugging Face скачиваются без проблем. Никаких международных платежей, никаких блокировок аккаунта. Модель у вас на диске — вы не зависите от политики платформы.

Три пути self-hosting: как выбирать

Три инструмента закрывают разные сценарии. Выбор зависит от того, что важнее — скорость старта, throughput под нагрузкой или дешевизна железа.

Ollama — если хотите за 5 минут запустить и попробовать

Ollama — это обёртка над llama.cpp с автоматической установкой, реестром моделей и удобной командной строкой. Проект позиционирует себя как «easiest way to build with open models» и интегрируется с внешними инструментами вроде IDE и агент-фреймворков.

Плюсы:

Установка одной командой на macOS, Linux и Windows.
Одна команда для скачивания и запуска модели: ollama run qwen3:14b.
Автоматически поднимается HTTP API, совместимый с OpenAI (/v1/chat/completions).
Автоматически подхватывает GPU (CUDA на Linux, Metal на Mac) или падает на CPU.
Реестр моделей: DeepSeek-R1, Qwen 3, GLM 4, Yi, Llama, Mistral, Gemma и другие.

Минусы:

Throughput ниже, чем у vLLM: при одновременных запросах будет очередь. Ollama не рассчитана на production-нагрузку в десятки одновременных сессий.
Меньше контроля над деталями: outer batching, tensor parallel, точная quantization — либо доступно упрощённо, либо недоступно вовсе.

Кому нужен: разработчик, который хочет попробовать модель локально; тимлид для внутреннего чата 3–10 человек; блогер для эксперимента.

vLLM — если это production и нужна пропускная способность

vLLM — inference-сервер из UC Berkeley Sky Computing Lab, ныне поддерживаемый сообществом более 2000 контрибьюторов. Его отличительная фишка — алгоритм PagedAttention: KV-кэш управляется как виртуальная память в ОС, что позволяет обслуживать в десятки раз больше одновременных запросов, чем «наивная» реализация.

Плюсы:

State-of-the-art throughput. Один сервер vLLM может обслуживать десятки одновременных сессий без деградации задержки.
Поддержка 200+ архитектур моделей с Hugging Face: Llama, Qwen, DeepSeek (включая V3 MoE), Gemma, Mixtral, мультимодальные (LLaVA, Qwen-VL).
Continuous batching + prefix caching — экономит вычисления на общих префиксах промптов.
Tensor parallel, pipeline parallel, expert parallel — модель размазывается на несколько GPU через флаг --tensor-parallel-size 4.
Множество quantization: FP8, INT4, GPTQ, AWQ, GGUF — можно ужать веса и увеличить throughput.
Hardware plugins: NVIDIA, AMD, Intel GPU, TPU, Intel Gaudi, Apple Silicon, x86/ARM/PowerPC CPU.

Минусы:

Сложнее в эксплуатации: параметры серверу нужно подбирать под свою нагрузку и железо.
CUDA-мир: под Windows требует WSL2 или Docker, под Mac — работает через CPU/Metal, но пик throughput доступен только на NVIDIA/AMD.
Больше памяти под сам сервер (по сравнению с llama.cpp).

Кому нужен: команда, которая ставит LLM для 20+ пользователей одновременно; сервис с API-эндпоинтом для клиентов; ML-инженер, оптимизирующий cost per token.

llama.cpp — если хотите выжать максимум из скромного железа

llama.cpp — оригинальный проект Георгия Герганова, из которого вырос весь ecosystem GGUF. Написан на чистом C/C++ без зависимостей. Работает буквально везде: от Raspberry Pi до Mac Studio, от старого ноутбука до серверного CPU без GPU.

Плюсы:

Минимальные требования: работает даже на CPU без GPU. С GPU (CUDA, Metal, HIP, Vulkan, SYCL, OpenVINO) — быстрее, но не обязательно.
Все уровни quantization: 1.5, 2, 3, 4, 5, 6, 8 бит. Q4_K_M — стандарт качество/размер.
Mixed CPU+GPU inference: если модель не помещается в VRAM, часть слоёв в GPU, часть в оперативку. Позволяет запустить 70B на 24 Gb GPU с 64 Gb RAM.
Встроенный веб-UI и REST API server.
Vision-language models (VLM) поддерживаются.

Минусы:

Throughput ниже, чем vLLM: llama.cpp не рассчитан на массовое обслуживание, это движок для локального использования.
Веса нужно вручную скачивать в формате GGUF (с Hugging Face либо конвертировать из safetensors).
Настройка backend’а (CUDA vs Metal vs CPU) требует внимания при сборке.

Кому нужен: пользователь Mac (Apple Silicon отлично работает через Metal); желающий поднять модель на старом железе; edge-deployment (Raspberry Pi, встроенные системы).

Ollama — практический гайд

Установка

macOS и Linux одной командой:

curl -fsSL https://ollama.com/install.sh | sh

Windows — установщик с ollama.com/download.

Homebrew для Mac: brew install ollama.

После установки Ollama запускается как фоновый сервис. Проверить: ollama --version.

Скачивание и запуск модели

Одна команда — модель скачивается и запускается в чате:

ollama run qwen3:14b

Или скачать заранее, запустить позже:

ollama pull deepseek-r1:14b
ollama pull glm4:9b
ollama pull yi:9b

Доступные размеры популярных китайских моделей в реестре Ollama:

Qwen 3: 0.6B, 1.7B, 4B, 8B, 14B, 30B, 32B, 235B
DeepSeek-R1: 1.5B, 7B, 8B, 14B, 32B, 70B, 671B (последняя — оригинальный V3-base с R1-тюнингом, требует кластер)
DeepSeek-V3: 671B (37B активированных, MoE)
GLM 4: 9B
Yi: 6B, 9B, 34B

Список сверять на ollama.com/library — реестр пополняется каждую неделю.

Первый запуск скачает веса (7B ≈ 4 Gb, 14B ≈ 8 Gb, 32B ≈ 20 Gb в Q4). Дальше стартует за секунды.

API endpoint

Ollama поднимает HTTP-сервер на http://localhost:11434. Работает две группы эндпоинтов:

Нативные Ollama: /api/generate, /api/chat, /api/embeddings
OpenAI-совместимые: /v1/chat/completions, /v1/completions, /v1/embeddings

Это значит, что любая библиотека, работающая с OpenAI API (openai для Python, openai для Node, LangChain, LlamaIndex, ваш собственный код), сразу заработает, если поменять base_url на http://localhost:11434/v1 и указать любой api_key (Ollama его не проверяет).

Пример на Python:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # игнорируется
)

response = client.chat.completions.create(
    model="qwen3:14b",
    messages=[{"role": "user", "content": "Кратко объясни MoE-архитектуру"}],
)
print(response.choices[0].message.content)

Web UI

Ollama сама по себе — CLI и API. Веб-интерфейс — сторонние проекты, самый популярный Open WebUI (github.com/open-webui/open-webui), устанавливается в Docker и подключается к вашему Ollama.

Какое железо какие модели тянет через Ollama

Ollama по умолчанию использует Q4_K_M-квантизацию (примерно 4.5 бит на параметр). Реальные требования по RAM или VRAM (условно, зависит от контекстного окна):

Модель	Размер	RAM/VRAM для Q4	Комфортно
Qwen 3 0.6B / 1.7B	0.4–1 Gb	4 Gb	любой ноутбук
Qwen 3 4B, GLM 4 9B, Yi 9B	3–6 Gb	8 Gb	MacBook Air M2, IGP-лаптоп
Qwen 3 8B, DeepSeek-R1 8B	5–7 Gb	12 Gb	средний PC / MacBook Pro
Qwen 3 14B, DeepSeek-R1 14B, Yi 34B (Q3)	8–14 Gb	16 Gb	MacBook Pro M3 32 Gb, RTX 3090/4080
Qwen 3 32B, DeepSeek-R1 32B	18–22 Gb	24 Gb	RTX 4090, Mac Studio 32 Gb
Qwen 3 30B (MoE), Qwen 3 32B	18–24 Gb	32 Gb	Mac Studio 64 Gb, 2 × RTX 3090
DeepSeek-R1 70B	40–45 Gb	48 Gb	A6000, 2 × RTX 4090, Mac Studio 96 Gb
DeepSeek-V3 / R1 671B (Q4)	400+ Gb	512 Gb VRAM или big RAM	кластер

Для 671B-моделей Ollama не оптимальна — используйте vLLM или llama.cpp с распределённой загрузкой.

vLLM — практический гайд

Установка

Через pip (нужен Python 3.10+ и CUDA 12.x для NVIDIA):

uv pip install vllm
# или
pip install vllm

Через Docker (проще всего для production):

docker run --gpus all -p 8000:8000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    vllm/vllm-openai:latest \
    --model Qwen/Qwen3-14B

Через uv (свежий Python-менеджер) вариант рекомендован официальной документацией.

Serving модели

Запустить OpenAI-совместимый сервер:

vllm serve Qwen/Qwen3-14B

По умолчанию поднимается на http://localhost:8000. Клиент — любая OpenAI-совместимая библиотека, точно как с Ollama.

Для DeepSeek-V3 (671B MoE) на кластере:

vllm serve deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --pipeline-parallel-size 2 \
    --max-model-len 65536

--tensor-parallel-size N — модель размазывается на N GPU внутри одной ноды. --pipeline-parallel-size M — на M нод в кластере.

Для Qwen 3 14B на одной 24 Gb GPU с квантизацией:

vllm serve Qwen/Qwen3-14B \
    --quantization gptq \
    --max-model-len 32768

Concurrency и throughput

Ключевое отличие vLLM от Ollama — continuous batching и PagedAttention. Одновременные запросы не конкурируют за GPU: они группируются на лету, KV-кэш переиспользуется через prefix caching. На практике одна NVIDIA H100 обслуживает 30–50 одновременных сессий с Qwen 3 14B без деградации задержки первого токена.

Метрики, которые стоит мониторить:

TTFT (time to first token) — задержка первого токена, чувствительна к prefill-фазе
TPOT (time per output token) — задержка каждого следующего токена, чувствительна к decode-фазе
Throughput — токенов в секунду в сумме по всем запросам
GPU utilization — как загружена карта; при <70% лечится увеличением --max-num-seqs

Полная документация по параметрам — на docs.vllm.ai. Для нашей энциклопедии важно понимать концепцию: vLLM — это не «запусти и забудь», это сервер, который нужно настраивать под нагрузку и железо.

llama.cpp — практический гайд

Установка

Homebrew для Mac:

brew install llama.cpp

Из исходников (Linux, Mac, Windows):

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON  # для NVIDIA
# или -DGGML_METAL=ON для Mac Apple Silicon
# или без флагов для CPU-only
cmake --build build --config Release

Docker — есть готовые образы в docs.

Пре-собранные бинарники — на странице releases GitHub.

GGUF-веса

llama.cpp работает с моделями в формате GGUF (Georgi Gerganov Universal Format). Скачать можно двумя путями:

С Hugging Face — искать репозитории с суффиксом -GGUF. Например, Qwen/Qwen3-14B-GGUF, deepseek-ai/DeepSeek-R1-Distill-Qwen-32B-GGUF, bartowski/glm-4-9b-chat-GGUF. Основные квантизации кладут в один репозиторий: Q2_K, Q3_K_M, Q4_K_M, Q5_K_M, Q6_K, Q8_0.
Конвертировать самому из safetensors через скрипт convert_hf_to_gguf.py из репозитория llama.cpp, потом квантизовать llama-quantize. Нужно для свежих моделей, ещё не выложенных в GGUF.

Скачивание примера:

# через huggingface-cli
huggingface-cli download bartowski/Qwen3-14B-GGUF Qwen3-14B-Q4_K_M.gguf --local-dir ./models

Запуск server

./build/bin/llama-server \
    -m models/Qwen3-14B-Q4_K_M.gguf \
    -c 8192 \
    --host 0.0.0.0 \
    --port 8080

-c 8192 — контекстное окно 8192 токена. --n-gpu-layers 99 — все слои на GPU (для Mac Metal или CUDA). --n-gpu-layers 40 — часть слоёв на GPU, остальное CPU (mixed inference).

Endpoint /v1/chat/completions совместим с OpenAI API. Также поднимается веб-UI на порту сервера.

Что теряется при quantization

Квантизация — переход от FP16/BF16 весов (16 бит на параметр) к 4/5/8 бит представлению. Модель становится в 2–4 раза меньше, требует меньше памяти, работает быстрее. Но качество ответов может проседать.

Практические ориентиры на 2026:

Q8_0 — почти неотличимо от FP16, экономия ×2. Идеально, если позволяет память.
Q6_K — небольшая просадка на редких задачах, экономия ×2.5. Хороший компромисс для 70B+ моделей.
Q5_K_M — заметно проседает на длинных reasoning-цепочках, экономия ×3.
Q4_K_M — стандартный компромисс: 30–50% память от FP16, ощутимая просадка на сложных задачах (математика, длинный код), но повседневный chat/RAG работает нормально.
Q3_K_M, Q2_K — только для эксперимента: качество страдает существенно, использовать когда иначе никак.

Правило: не гонитесь за максимальным сжатием. Q4_K_M на 14B-модели в среднем даёт лучшее качество, чем Q8_0 на 8B при том же расходе памяти.

Реалистичная матрица требований по железу

Практические ориентиры для Q4_K_M-квантизации и контекстного окна 8k:

Железо	Тянет комфортно	Возможно с усилием
MacBook Air M2 8 Gb RAM	Qwen 3 1.7B, GLM 4 9B (Q3)	Qwen 3 4B
MacBook Air M2 16 Gb	Qwen 3 4B, Yi 9B, GLM 4 9B	Qwen 3 8B
MacBook Pro M3/M4 32 Gb	Qwen 3 14B, Yi 34B (Q3)	Qwen 3 30B, Yi 34B (Q4)
RTX 3090 / 4090 24 Gb	Qwen 3 32B, DeepSeek-R1-Distill-32B	Qwen 3 30B MoE (mixed)
RTX 5090 32 Gb	Qwen 3 32B, DeepSeek-R1-Distill-32B, R1-Distill-70B (mixed)	—
A100 40 Gb	Qwen 3 32B (FP16), R1-Distill-70B Q5	Yi 34B FP16
A100 80 Gb / H100 80 Gb	DeepSeek-R1-70B, Qwen 3 235B (Q3, mixed)	full-precision 70B
Mac Studio 96 Gb / 192 Gb	DeepSeek-R1-70B, Qwen 3 235B (Q4)	Qwen 3 235B (Q6)
Кластер 8 × H100 640 Gb	DeepSeek-V3 671B (Q4), Kimi K2 1T (Q3)	full-precision 235B, DeepSeek-V3 (Q6)
Кластер 16 × H100	DeepSeek-V3 / R1 671B (Q8), Kimi K2 (Q4)	full BF16 671B

Full precision (BF16/FP16) требует памяти в 2 раза больше от размера модели в гигабайтах (например, 14B ≈ 28 Gb, 70B ≈ 140 Gb). Умножайте на 2–4 для reserve на KV-кэш при длинных контекстах.

MoE-модели (Qwen 3 30B-A3B, DeepSeek-V3) экономят inference-compute, но требуют памяти под все параметры. 30B-A3B — 30 Gb в Q4, а не 3 Gb.

Какую модель выбрать на своё железо

Матрица покрывает выбор runtime. Ниже — конкретная модель по целевой задаче:

8–16 Gb RAM/VRAM: Qwen 3 4B для общих задач, GLM 4 9B для многоязычия, Yi 9B — сильная база для дообучения.
24 Gb VRAM: Qwen 3 14B и DeepSeek-R1-Distill-Qwen-14B. Distill-версии — Qwen-база, тюненная на trace’ах reasoning от DeepSeek-R1 полной, хорошо решает математику и код.
32–40 Gb: Qwen 3 32B — топ 2026 в open-source на общих задачах. DeepSeek-R1-Distill-32B — если нужен reasoning.
80 Gb+: DeepSeek-R1-Distill-70B (Llama-3.3-70B, дообученная на R1-trace), Yi 34B в full precision.
Кластер: DeepSeek-V3 для универсальных задач, DeepSeek-R1 (full) для reasoning, Kimi K2 — 1T-параметров MoE, лидер по ряду бенчмарков среди open-weights.

Для русскоязычных задач Qwen 3 и DeepSeek дают лучший результат из китайской подборки (GLM тоже неплох). Yi слабее на русском, зато сильна на английском/китайском и как база под fine-tune.

Fine-tuning open-source моделей

Одна из главных причин self-hosting — возможность дообучить модель на своих данных. Три подхода.

LoRA (Low-Rank Adaptation)

Заморозить базовые веса, обучить только маленькие адаптеры (обычно 0.1–1% от размера модели). Результат: файл на десятки-сотни мегабайт, который добавляется к базе при inference. Для 14B-модели — LoRA-адаптер размером 50–200 Mb, обучается на 3–10 тысячах примеров за 2–8 часов на одной RTX 4090.

QLoRA (Quantized LoRA)

LoRA поверх квантизованных весов (обычно 4-бит). Позволяет тюнить 32B–70B-модель на одной 24 Gb GPU. Качество близко к обычной LoRA. Стандарт для потребительского железа в 2026.

Full fine-tuning

Обучение всех весов. Максимальное качество, но требует кластер (для 70B — минимум 8 × H100). Оправдано только когда LoRA не даёт нужного результата и цена ошибки высока.

Инструменты

Unsloth — самый быстрый фреймворк QLoRA/LoRA, поддерживает Qwen, DeepSeek-Distill, Llama, Yi. Обещает ×2 скорость и −70% памяти по сравнению с базовым transformers.
Axolotl — конфиг-first фреймворк, YAML-описание тренировки, интеграция с DeepSpeed и FSDP.
LLaMA-Factory — китайский инструмент под LoRA/QLoRA/full-tune с web-UI. Поддерживает практически все open-weights модели, включая Qwen, DeepSeek, GLM, Yi. Активно развивается.
TRL (от Hugging Face) — библиотека для SFT, DPO, PPO. Ниже уровнем, чем предыдущие, но гибче.

Дообученную модель можно экспортировать в GGUF (для llama.cpp/Ollama) или запускать в оригинальном формате через vLLM. LoRA-адаптеры отдельно грузятся во vLLM и Ollama через параметры конфига.

5 practical use-cases self-hosting

On-premise чат для enterprise. Юротдел, HR, поддержка — всё, что работает с ПДн. Модель за фаерволом, интеграция с внутренним SSO. Ollama или vLLM в закрытом контуре, RAG поверх корпоративного knowledge base.
Custom fine-tuned под domain. Медицинская клиника обучает Qwen 3 14B на 5 тысячах анонимизированных диалогов «пациент-регистратор» → бот перестаёт путать препараты, знает график врачей, соблюдает стилевые нормы.
Edge deployment. Raspberry Pi 5 + llama.cpp + Qwen 3 1.7B → офлайн-ассистент в теплице, в цехе, на выставке. Модель размером с фильм, работает без интернета.
Batch processing больших корпусов. Разметить миллион документов через API дорого (это минимум $1000). Через vLLM на одном арендованном H100 за 12 часов — $30. Экономика self-hosting раскрывается на объёме.
Development и тестирование без API-costs. Разработка агента с сотнями итераций промптов на Qwen 3 8B через Ollama — бесплатно после покупки железа. Финальная версия уже гоняется через API продакшена (или там же).

Сравнение Ollama vs vLLM vs llama.cpp

	Ollama	vLLM	llama.cpp
Сложность старта	5 минут	30 минут — 2 часа	15–60 минут
Скорость 1 запроса	Высокая	Высокая	Средняя
Concurrency	Низкая (очередь)	Максимальная (десятки одновременно)	Низкая (очередь)
Требования к железу	Любое	GPU обязателен для throughput	Любое, вплоть до CPU-only
API OpenAI-совместим	Да	Да	Да (через server)
Multi-GPU	Ограниченно	Tensor/pipeline parallel	Ограниченно
Quantization	Автоматическая Q4	FP8/INT4/GPTQ/AWQ/GGUF	Все от Q2 до Q8, F16, F32
Fine-tuning	Через сторонние инструменты	Через сторонние инструменты	Через сторонние инструменты
Backends	CUDA, Metal, CPU	CUDA, ROCm, Intel, TPU, Apple, CPU	CUDA, Metal, HIP, Vulkan, SYCL, OpenVINO, CPU
Продакшен для 20+ users	Не тянет	Тянет	Не тянет
Mac Apple Silicon	Отлично	Работает, но не максимум	Отлично
Стороннее ПО (SGLang)	—	—	—

Отдельно про SGLang — это ещё один production-runtime, сравнимый с vLLM по throughput, местами быстрее за счёт RadixAttention (структурный prefix-caching). Если vLLM показал недостаточную скорость на конкретной модели — стоит попробовать SGLang. Ставится через pip install sglang, поддерживает те же модели (Qwen, DeepSeek, Yi), запускается похоже. В 2026 два runtime сосуществуют, выбор зависит от workload.

FAQ

В: Нужен ли мне GPU для self-hosting?

Не обязательно. Ollama и llama.cpp запускают модели до 7B на любом ноутбуке с 8 Gb RAM. Модели до 32B — на Apple Silicon Mac или PC с 24 Gb VRAM. Только для DeepSeek-V3 671B и Kimi K2 нужен кластер.

В: Какая модель — универсальная точка старта в 2026?

Для 24 Gb VRAM — Qwen 3 14B в Ollama. Она сильна в русском, английском, коде, следовании инструкциям. Для более сильного reasoning — DeepSeek-R1-Distill-Qwen-14B.

В: Legal ли использовать китайские open-weights модели в РФ?

Да. Веса открыты под лицензиями, разрешающими коммерческое использование (уточните конкретную по каждой модели — большинство под Apache 2.0 или MIT). Скачивание с Hugging Face из РФ работает.

В: Что дешевле — self-hosting или API?

Зависит от объёма. До ~100 M токенов в месяц API китайских провайдеров (DeepSeek, Qwen) обычно дешевле self-hosting. Свыше 1 B токенов в месяц self-hosting на арендованном H100 обгоняет API. В диапазоне 100 M — 1 B — считайте руками, зависит от модели и региона.

В: Могу ли я запустить DeepSeek-R1 «full» (671B) дома?

Нет, если под «домом» не понимается кластер на 8 × H100. На потребительском железе доступны Distill-версии (R1-Distill-Qwen-14B, R1-Distill-Llama-70B) — они дают 80–90% качества оригинала при доступных требованиях.

В: Как обновлять модель, когда выходит новая версия?

Ollama — ollama pull qwen3:14b подтянет новую версию. vLLM — перезапустить сервер с новой моделью. llama.cpp — скачать свежий GGUF с Hugging Face.

В: Что с логами и мониторингом?

Ollama пишет в stdout (journalctl -u ollama на Linux). vLLM экспортирует Prometheus-метрики (RPS, TTFT, TPOT, GPU util, cache hit rate) — стандартная интеграция с Grafana. llama.cpp — базовые логи в stdout.

В: Как встроить RAG?

Runtime отвечает только за inference. RAG (retrieval-augmented generation) — отдельный слой: векторная БД (Qdrant, Weaviate, pgvector), embeddings (тот же Qwen 3 через vLLM или отдельная модель BGE-M3), оркестратор (LangChain, LlamaIndex, свой код). Runtime вызывается на финальном шаге с уже собранным prompt’ом.

В: Что с multi-turn conversation и memory?

Все три runtime работают чат-стилем: клиент присылает историю сообщений на каждый запрос. Долгосрочная memory (запоминание между сессиями) — это application layer, не runtime. Реализуется через сохранение summary в БД и подкладывание в системный prompt.

В: Как быть с обновлением safety-фильтров?

Open-source модели идут «как есть», встроенной модерации нет. Safety-слой — это ваша ответственность. Простое решение: prompt-инжиниринг + классификатор входа/выхода (тоже маленькая LLM или специализированная модель). Для enterprise — интеграция с Presidio, LLM Guard.

В: Что делать при GPU OOM?

Три варианта: (1) уменьшить контекстное окно (--max-model-len в vLLM, -c в llama.cpp); (2) более сильная quantization (Q5 → Q4 → Q3); (3) уменьшить размер модели.

В: Стоит ли выбрать SGLang вместо vLLM?

Если vLLM показывает нужный throughput и знакомый — оставайтесь. SGLang имеет смысл при: (1) сложные структурированные ответы (JSON schema, constrained decoding); (2) множественные общие префиксы в промптах (агент с одним system prompt на тысячи запросов); (3) специфические ML-workflows. Экосистема и документация vLLM пока больше.

В: Как перенести модель между машинами?

Ollama — файлы в ~/.ollama/models. llama.cpp — GGUF-файлы, копируются целиком. vLLM — Hugging Face cache в ~/.cache/huggingface.

В: Что с Kimi K2 в Ollama?

По состоянию на 02.08.2026 официальный образ Kimi K2 (1T параметров) в реестре Ollama отсутствует из-за размера (даже в Q4 требует 300+ Gb памяти). Kimi K2 практически запускается через vLLM или llama.cpp на кластере. Веса открыты в huggingface.co/moonshotai/Kimi-K2-Instruct. Меньшая Kimi-VL-A3B (16B, мультимодальная) — реалистична на потребительском железе.

В: Что читать дальше по теме?

Обязательно — статьи про API DeepSeek и Qwen (когда self-hosting нецелесообразен), про RAG-архитектуру, про embeddings, про AI-агенты и tool-use. По fine-tuning — гайды Unsloth и LLaMA-Factory на GitHub — практический материал уровня «сделал сам».

Actualnost

Актуально на 02.08.2026. Модели, runtime, GGUF-квантизации и цены на облачные GPU меняются ежемесячно. За 2025–2026 ландшафт open-weights LLM пересобирался несколько раз (DeepSeek-V3, Qwen 3, GLM 5.x, Kimi K2 — все выпущены в этот период). Перед бизнес-решением всегда сверяйся с первоисточником — все ссылки в разделе Sources ниже.

Sources

Ollama — official website: https://ollama.com/ (verified 02.08.2026)
Ollama — models library: https://ollama.com/library (verified 02.08.2026)
vLLM — official documentation: https://docs.vllm.ai/ (verified 02.08.2026)
vLLM — GitHub repository: https://github.com/vllm-project/vllm (verified 02.08.2026)
llama.cpp — GitHub repository: https://github.com/ggml-org/llama.cpp (verified 02.08.2026)
SGLang — GitHub repository: https://github.com/sgl-project/sglang (verified 02.08.2026)
DeepSeek — Hugging Face organization: https://huggingface.co/deepseek-ai (verified 02.08.2026)
Qwen (Alibaba Cloud) — Hugging Face organization: https://huggingface.co/Qwen (verified 02.08.2026)
Zhipu AI / GLM — Hugging Face organization: https://huggingface.co/zai-org (verified 02.08.2026)
01.AI Yi — Hugging Face organization: https://huggingface.co/01-ai (verified 02.08.2026)
Moonshot AI Kimi — Hugging Face organization: https://huggingface.co/moonshotai (verified 02.08.2026)
Unsloth (fine-tuning framework) — GitHub: https://github.com/unslothai/unsloth (verified 02.08.2026)
Axolotl (fine-tuning framework) — GitHub: https://github.com/axolotl-ai-cloud/axolotl (verified 02.08.2026)
LLaMA-Factory (fine-tuning framework) — GitHub: https://github.com/hiyouga/LLaMA-Factory (verified 02.08.2026)

Русские пересказы (vc.ru, habr, retail.ru) в этой статье не использовались согласно правилу primary sources only для library (LR-12).