Как запустить LLM локально: полное руководство от железа до первого ответа

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

Проблема в том, что инструмент и модель выбирают за вас, не спросив, что у вас за железо. А в локальном запуске железо решает почти всё: объём видеопамяти определяет, какая модель вообще влезет, пропускная способность памяти — с какой скоростью она будет отвечать, а платформа (NVIDIA, AMD, Apple, встроенная графика) — какой бэкенд придётся собирать руками.

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

#Что происходит, когда модель работает локально

Локальный запуск — это не «скачать нейросеть». Это загрузить в память файл с весами модели и прогонять через них ваш текст, токен за токеном, на вашем процессоре или видеокарте.

Отсюда два следствия, которые объясняют почти все дальнейшие ограничения.

Первое: веса должны поместиться в память целиком. Модель на 8 миллиардов параметров в четырёхбитной квантизации — это файл примерно на 4,5–5 ГБ. Он должен лежать в видеопамяти (или в оперативной, если запуск на процессоре) всё время, пока модель отвечает. Не поместился на гигабайт — либо часть слоёв уедет на процессор и скорость упадёт, либо запуск оборвётся с ошибкой.

Второе: скорость генерации упирается в пропускную способность памяти, а не в вычисления. Чтобы выдать один токен, движок читает все веса модели из памяти. Если модель весит 5 ГБ, а память отдаёт 360 ГБ/с, теоретический потолок — 72 токена в секунду. Реально выйдет 50–60% от этого. Именно поэтому видеокарта с медленной памятью не спасает, а Apple Silicon с широкой шиной работает быстрее, чем можно было бы ожидать от «ноутбучного чипа».

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

#Шаг нулевой: узнать своё железо

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

Windows (PowerShell). Если стоит видеокарта NVIDIA, самая честная команда — от драйвера:

nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv

Если nvidia-smi не найдена, драйвер либо не установлен, либо карта не от NVIDIA. Тогда:

Get-CimInstance Win32_VideoController | Select-Object Name, DriverVersion
Get-CimInstance Win32_ComputerSystem | Select-Object TotalPhysicalMemory

Обратите внимание: поле AdapterRAM в Win32_VideoController врёт на картах с объёмом больше 4 ГБ — это старое 32-битное поле, оно переполняется. Объём видеопамяти смотрите в «Диспетчере задач» на вкладке «Производительность» или через nvidia-smi.

Linux:

nvidia-smi --query-gpu=name,memory.total --format=csv
rocm-smi --showproductname --showmeminfo vram
lspci | grep -Ei 'vga|3d|display'
free -g

Первая команда — для NVIDIA, вторая — для AMD с установленным ROCm, третья покажет карту в любом случае, четвёртая — оперативную память в гигабайтах.

macOS:

system_profiler SPHardwareDataType | grep -E "Chip|Memory"

На Apple Silicon отдельной видеопамяти нет: процессор и графика делят один пул. Это одновременно главное преимущество платформы — модели, требующие 30–40 ГБ, запускаются на ноутбуке, — и её ограничение: та же память занята системой и приложениями.

Запишите три числа. Дальше они понадобятся в каждом решении.

#Сколько памяти нужно: пять классов моделей

Практическая формула для веса модели в четырёхбитной квантизации выглядит так:

Размер файла в ГБ ≈ (число параметров в миллиардах) × 0,6

Коэффициент 0,6 — не константа физики, а эмпирика для квантизации Q4_K_M: чистые 4 бита на вес дали бы 0,5, но часть тензоров (эмбеддинги, слои внимания) хранится точнее, поэтому реальный файл получается тяжелее. Для Q8 коэффициент около 1,1, для Q6_K — около 0,85. Подробный разбор уровней и того, где проходит точка перелома, — в статье о квантизации LLM и разнице между Q4, Q5 и Q8.

К весу модели добавляется KV-кэш — память под контекст диалога, и он растёт линейно с длиной контекста. Формулу расчёта и таблицу на двенадцать связок «модель + квант + контекст» разбирает отдельный материал о том, сколько нужно VRAM для локальной LLM.

Сводная таблица по классам. Колонка «вес Q4_K_M» — порядок величины по конкретным популярным моделям на момент написания; конкретный файл может отличаться на 10–15% в любую сторону. Колонка «минимум» — сколько памяти нужно, чтобы модель просто запустилась с контекстом 4096. Колонка «комфорт» — сколько нужно, чтобы держать контекст 16–32k и не думать об этом.

Класс 70B в таблицу не вошёл сознательно: при Q4_K_M это около 40–43 ГБ весов, то есть либо две карты по 24 ГБ, либо Mac с 64 ГБ памяти, либо выгрузка половины слоёв на процессор со скоростью в единицы токенов в секунду. Это не «локальный запуск для начинающих», это отдельный проект.

Главный вывод из таблицы — не «берите 24 ГБ», а другой. Скачок качества между классами 3B и 8B огромный, между 8B и 14B — заметный, между 14B и 32B — уже спорный и сильно зависит от задачи. Если вы выбираете железо под локальные модели, целиться в 12–16 ГБ видеопамяти рациональнее, чем в 24: по деньгам за гигабайт это другая лига. Расклад по конкретным картам — в разборе того, какую видеокарту взять под локальные LLM.

#Четыре инструмента: критерий выбора

Инструментов для локального запуска больше четырёх, но практически весь массовый сценарий закрывается этими: llama.cpp, Ollama, LM Studio и Jan. Три из четырёх, к слову, построены поверх llama.cpp — разница не в движке, а в том, сколько он от вас прячет.

Выбирать между ними по принципу «что популярнее» бессмысленно. Работающий критерий — три вопроса подряд.

Вопрос 1. Вам нужен графический интерфейс или терминал приемлем?

Если графический — остаются LM Studio и Jan, переходите к вопросу 2. Если терминал приемлем — Ollama или llama.cpp, переходите к вопросу 3.

Вопрос 2. Что важнее: отполированный интерфейс или открытость исходников?

• Отполированный интерфейс, встроенный поиск моделей, вкладка параметров с подсказками — LM Studio. Ограничение, которое обычно не называют: это закрытое проприетарное приложение со своими условиями использования. Разбор интерфейса и честная заметка о лицензии — в гайде по LM Studio.
• Открытые исходники важнее полировки — Jan. Интерфейс объективно грубее, часть функций появляется позже. Что именно теряется: меньше тонких настроек загрузки модели и более скромный встроенный каталог.

Вопрос 3. Вам нужно управлять параметрами запуска или достаточно «просто работает»?

• Достаточно «просто работает», модель нужна как фоновый сервис для других приложений — Ollama. Устанавливается как обычная программа, поднимает локальный API, сама подбирает, сколько слоёв отдать видеокарте. Маршрут установки и первые команды — в гайде по запуску моделей через Ollama.
• Нужно точно управлять числом слоёв на GPU, типом KV-кэша, размером батча, или запускать модель, которой нет в каталоге Ollama, — llama.cpp напрямую.

Дерево можно свернуть в одну строку: графика → LM Studio (или Jan, если принципиальна открытость); терминал → Ollama (или llama.cpp, если нужен контроль).

Отдельный случай — очень слабое железо: ноутбук со встроенной графикой, 8–16 ГБ оперативной памяти и без дискретной карты. Там инструмент почти не важен, важна модель и реалистичные ожидания по скорости. Честные замеры для этого сценария — в материале о том, что реально работает на ноутбуке без видеокарты.

#Первый запуск: три маршрута

#Маршрут A: Ollama, минимум действий

После установки проверьте, что фоновый сервис поднялся:

ollama --version

Скачайте и запустите модель одной командой. Начинать имеет смысл с класса, который ваша память тянет с запасом, — не с максимального:

ollama run qwen2.5:7b

Первый запуск скачает веса (несколько гигабайт), последующие поднимают модель из локального хранилища. Выход из диалога — /bye.

Посмотреть, что скачано и сколько занимает:

ollama list

Посмотреть, что загружено в память прямо сейчас и куда именно — в GPU или в CPU:

ollama ps

Колонка PROCESSOR в выводе ollama ps — самая полезная диагностика во всём инструменте. Если там 100% GPU, всё хорошо. Если 48%/52% CPU/GPU — половина слоёв работает на процессоре, и скорость будет соответствующая.

#Маршрут B: llama.cpp, полный контроль

Сборка под CUDA (Linux, нужен установленный CUDA toolkit):

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j

Под Apple Silicon Metal включается по умолчанию, флаг не нужен:

cmake -B build
cmake --build build --config Release -j

Запуск с явным указанием числа слоёв на видеокарте и размера контекста:

./build/bin/llama-cli -m models/qwen2.5-7b-instruct-q4_k_m.gguf -ngl 99 -c 8192 -fa

Здесь -ngl 99 означает «выгрузи на GPU все слои, сколько есть», -c 8192 — размер контекста, -fa — Flash Attention. Каждый из этих трёх флагов меняет результат в разы, и подбирать их приходится под конкретную связку модели и карты.

#Маршрут C: графическое приложение

LM Studio и Jan закрывают одинаковый сценарий: установить приложение, найти модель в встроенном каталоге, нажать «загрузить», начать диалог. Никаких команд. Цена — меньше контроля над тем, что происходит под капотом, и необходимость доверять чужому подбору параметров по умолчанию.

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

#Скорость: что считать нормальным

Самая частая ошибка после первого запуска — не понять, нормально работает модель или плохо. Ориентир:

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

Замерять скорость на глаз бессмысленно: первый запуск всегда медленнее из-за загрузки весов с диска, а длина контекста меняет результат в разы. Воспроизводимый замер требует прогрева и фиксированной длины запроса — утилита llama-bench из состава llama.cpp делает и то, и другое.

#Что выбрать из моделей

Инструмент — это половина решения, вторая половина — какую модель в него загрузить. Общее правило для первого раза: возьмите модель на класс ниже, чем позволяет ваша память. Модель 7B, работающая целиком на видеокарте, полезнее модели 14B, половина которой уехала в оперативную память.

Второе правило: инструкционная версия (instruct, it, chat в имени) для диалога, базовая — почти никогда. Базовые модели не обучены отвечать на вопросы, они продолжают текст.

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

#Три ошибки первого дня

Они повторяются достаточно часто, чтобы назвать их отдельно.

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

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

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

#Мифы и заблуждения

«Локальная модель заменит облачную». Не заменит по качеству рассуждений, и это надо признать прямо. Модель на 7–14 миллиардов параметров, работающая на домашней видеокарте, объективно слабее топовых облачных моделей в сложных многошаговых задачах, в длинном коде, в редких языках. Локальный запуск выигрывает в другом: данные остаются на вашей машине, нет платы за токены, нет лимитов и нет зависимости от чужого сервиса. Это разные плоскости, и подменять одну другой нечестно.

«Нужна топовая видеокарта». Нет. Нужен достаточный объём видеопамяти, а это разные вещи. Карта на 12 ГБ с умеренной скоростью запустит модель, которую карта на 8 ГБ не запустит вообще, — при том что вторая может быть дороже.

«Больше параметров — всегда лучше». До определённого предела да, но модель 14B в жёсткой квантизации Q2, где качество уже поехало, часто уступает модели 8B в честном Q4_K_M того же размера на диске. Число параметров без указания квантизации ничего не значит.

«Если модель влезла в видеопамять, всё в порядке». Влезли веса — это ещё не всё. Контекст занимает память отдельно, и растёт по мере диалога. Модель, спокойно запустившаяся с контекстом 2048, может упасть на контексте 32768.

«Локальный запуск бесплатный». Веса бесплатны, электричество — нет. При интенсивном использовании счёт за свет становится заметной величиной, и в некоторых сценариях те же запросы через API обходятся дешевле. Расчёт по режимам — отдельная тема.

#Порядок действий

1. Соберите три числа: объём видеопамяти, объём оперативной памяти, модель GPU. Команды — в разделе про железо выше.
2. Определите свой класс модели по таблице требований. Берите класс, который влезает с запасом минимум в 2 ГБ.
3. Выберите инструмент по трём вопросам дерева: интерфейс или терминал, полировка или открытость, «просто работает» или контроль.
4. Запустите модель класса ниже целевого. Убедитесь, что всё работает, и только потом поднимайтесь.
5. Проверьте, что модель на GPU целиком — через ollama ps или по логу llama.cpp, где видно число выгруженных слоёв.
6. Замерьте скорость по методике, а не на глаз. Запишите результат — он понадобится, когда вы будете что-то менять.
7. Увеличивайте контекст постепенно, следя за расходом памяти. Прыгать сразу на максимум — верный способ получить ошибку нехватки памяти на середине диалога.

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

#Частые вопросы

#Можно ли запустить LLM без видеокарты вообще?

Да, на процессоре. Скорость будет заметно ниже: для моделей класса 7B на обычном настольном процессоре это обычно единицы токенов в секунду, а не десятки. Модели класса 1–4B на CPU работают приемлемо. Главный ограничитель — не число ядер, а пропускная способность оперативной памяти.

#Сколько места на диске занимают локальные модели?

От примерно гигабайта у самых компактных до сорока с лишним у 70B в четырёхбитной квантизации. Практически: если вы собираетесь пробовать несколько моделей, закладывайте 50–100 ГБ свободного места. Скачанные веса не удаляются автоматически.

#Нужен ли интернет после установки?

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

#Какая модель лучше для русского языка?

Модели, у которых в обучающих данных много многоязычных текстов, — линейки Qwen, Gemma, Mistral — обычно отвечают по-русски связнее, чем модели, оптимизированные под английский. Но по-русски все локальные модели работают хуже, чем по-английски: русский текст занимает в 1,5–2 раза больше токенов, и качество рассуждений на нём ниже. Проверять нужно на своих задачах.

#Что делать, если модель не влезает в память?

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

#Ollama или llama.cpp — что ставить новичку?

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

#Насколько локальная модель хуже облачной?

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

#Вывод

Локальный запуск LLM — не единая процедура, а последовательность из трёх решений, и каждое зависит от предыдущего: сколько у вас памяти → какой класс модели в неё помещается → какой инструмент удобен под ваш стиль работы.

Если у вас 8 ГБ видеопамяти или меньше и терминал не пугает — берите Ollama и модель класса 7B в Q4_K_M, это лучшее соотношение усилий и результата. Если видеопамяти 12–16 ГБ и хочется контроля — llama.cpp с явными флагами даст на тех же весах больше скорости. Если терминал неприемлем — LM Studio, помня, что это закрытое приложение, или Jan, если открытость важнее удобства. А если дискретной видеокарты нет вовсе — начинайте с моделей класса 3B и заранее посмотрите честные замеры скорости, чтобы не разочароваться на первом же длинном ответе.