Запускаю Gemma 4 локально в LM Studio: 51 токен/с и Claude Code без интернета

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

Встречайте: Google Gemma 4 26B-A4B. Модель, которая ломает старые правила. Архитектура mixture-of-experts (128 экспертов, 8 активных на токен) позволяет ей работать на скромных 48 ГБ объединённой памяти, выдавая при этом качество, сопоставимое с гигантами вроде Qwen 3.5 на 397B параметров.

А LM Studio 0.4.0 только что сделала локальный запуск таких моделей по-настоящему удобным. Фоновый демон llmster, консольная утилита lms, непрерывный батчинг и – внимание! – эндпойнт, совместимый с Anthropic. Это значит, что вы можете направить Claude Code на свою локальную Gemma 4.

Хотите узнать, как заставить эту связку летать? Как правильно рассчитать память под контекст в 256K токенов и почему спекулятивное декодирование — плохая идея для MoE? А главное — сколько это всё жрёт энергии и греет ли ваш Mac?

Поехали!

Зачем запускать модели локально?

Новая Gemma 4 от Google особенно интересна для домашнего использования благодаря своей архитектуре “группы экспертов” (mixture-of-experts, MoE). Хотя в этой модели 26 млрд параметров, при каждом проходе активируются лишь 4 из них. Это позволяет ей летать на оборудовании, которому полноценный 26-миллиардный гигант оказался бы не по зубам. На моём 14-дюймовом MacBook Pro, с чипом M4 Pro и 48 ГБ объединенной памяти, она чувствует себя вполне вольготно, выдавая около 51 токена в секунду. Правда, по моему опыту, в связке с Claude Code скорость заметно падает.

Кстати: Google Gemma 4 можно запустить локально и через Ollama. О том, как это сделать, читайте в моей следующей статье.

Семейство моделей Gemma 4

Google выпустила Gemma 4 не в виде одной модели, а семейством из четырех вариантов. Линейка подобрана так, чтобы охватить самые разные классы устройств:

Модели с индексом “E” (E2B, E4B) используют послойные эмбеддинги для максимально эффективного развертывания непосредственно на гаджетах; только они умеют работать со звуком (распознавать и переводить речь). Самая мощная в семействе – плотная (dense) модель 31B: её результаты впечатляют – 85,2% в тесте MMLU Pro и 89,2% на AIME 2026.

Почему я выбрал 26B-A4B. Всё дело в архитектуре mixture-of-experts. Здесь задействовано 128 экспертов плюс один общий, но для обработки каждого токена активируются лишь восемь из них (что эквивалентно 3,8 млрд параметров). По негласному правилу качество такой MoE-модели примерно соответствует плотной модели с числом параметров, равным корню из произведения общего количества на активные, – в нашем случае это дает около 10 млрд эффективных параметров. На деле же мы получаем скромные “аппетиты” 4-миллиардной модели при качестве, которое заметно выше её весовой категории. В бенчмарках она набирает 82,6% на MMLU Pro и 88,3% на AIME 2026 – это вплотную приближает её к тяжеловесной 31B (у той 85,2% и 89,2%), зато работает она в разы шустрее.

График ниже наглядно всё объясняет. Здесь показано соотношение рейтинга Эло к общему размеру последних моделей с открытыми весами и поддержкой рассуждений. Нас интересует левый верхний угол (выделен синим): именно там живут модели с высокой производительностью и малым “отпечатком”.

Gemma 4 26B-A4B (с рейтингом Эло около 1441) уверенно держится в этой зоне, выдавая результат, достойный куда более тяжелых систем. Плотная версия на 31B набрала чуть больше (~1451), но всё равно осталась удивительно компактной. Для контекста: таким гигантам, как Qwen 3.5 397B-A17B (~1450 Elo) или GLM-5 (~1457 Elo), требуется от 100 до 600 млрд параметров, чтобы достичь сопоставимых высот. А Kimi-K2.5 (~1457 Elo) и вовсе перевалила за триллион. На этом фоне 26B-A4B творит чудеса: пригоршня параметров дает конкурентный уровень Эло, что на практике означает низкие требования к памяти и молниеносную генерацию.

Именно это делает MoE-модели по-настоящему революционными для персонального использования. Больше не нужны серверные кластеры или монструозные GPU-фермы, чтобы тягаться с исполинами на 400+ млрд параметров. Ноутбука с 48 ГБ объединенной памяти вполне достаточно.

Для мака с 48 ГБ памяти это золотая середина. Плотная модель 31B съела бы больше ресурсов и работала медленнее, ведь там в процессе вычислений участвует каждый параметр. Версия E4B легче, но и соображает ощутимо слабее. В случае с 26B-A4B мы получаем всё и сразу: контекст до 256K, поддержку зрения (удобно для анализа скриншотов и диаграмм), нативную работу с инструментами и функциями, а также гибко настраиваемые режимы рассуждений. И всё это на скорости в 51 токен в секунду.

---

Практическая ремарка. Мы замерили 51 токен/с у Gemma 4 на M4 Pro — отлично для локальной модели. Но в облачных API скорости на порядок выше, а главное — вам не нужно думать о memory pressure и swap-файлах. Если ваша цель не в том, чтобы настроить демона, а в том, чтобы быстро и надёжно получить ответ от лучших нейросетей, присмотритесь к BotHub. Здесь собраны все топовые модели, готовые к работе в один клик.

Для доступа не требуется VPN, можно использовать российскую карту.

По ссылке вы можете получить 300 000 бесплатных токенов для первых задач и приступить к работе с нейросетями прямо сейчас!

---

Что нового в LM Studio 0.4.0

LM Studio давно зарекомендовал себя как удобное десктопное приложение для запуска локальных моделей. Однако в версии 0.4.0 архитектуру программы в корне пересмотрели: сердце приложения – движок инференса – выделили в отдельный сервер под названием llmster.

На практике это означает, что теперь LM Studio можно гонять прямо из терминала с помощью консольной утилиты lms. Графический интерфейс больше не нужен. Это развязывает руки при работе на удаленных серверах (headless), в CI/CD-пайплайнах, через SSH-сессии или если вы просто из тех разработчиков, кто предпочитает не покидать консоль.

Ключевые новшества версии 0.4.0:

• Демон llmster: фоновая служба, которая рулит загрузкой моделей и инференсом, не требуя запуска основного приложения.

• Консоль lms: полноценный интерфейс для скачивания, запуска и обслуживания моделей, а также для общения с ними в режиме чата.

• Параллельная обработка запросов: вместо того чтобы выстраивать запросы в очередь, система использует непрерывный батчинг, позволяя нескольким пользователям или процессам обращаться к одной модели одновременно.

• Stateful REST API: новый эндпоинт /v1/chat, который умеет хранить историю переписки между запросами.

• Интеграция с MCP: поддержка протокола Model Context Protocol с разграничением прав доступа по ключам.

Установка

Утилита lms ставится одной командой:

# Linux/Maccurl -fsSL https://lmstudio.ai/install.sh | bash# Windowsirm https://lmstudio.ai/install.ps1 | iex

Затем запускаем фонового демона:

lms daemon up

Если вы на macOS, не забудьте обновить оба движка инференса:

lms runtime update llama.cpplms runtime update mlx

Загрузка Gemma 4

Когда демон в строю, можно качать модель Gemma 4 26B:

lms get google/gemma-4-26b-a4b

Утилита покажет конкретный вариант (по умолчанию это квантованная версия Q4_K_M весом 17,99 ГБ) и попросит подтверждения:

   ↓ To download: model google/gemma-4-26b-a4b - 64.75 KB   └─ ↓ To download: Gemma 4 26B A4B Instruct Q4_K_M [GGUF] - 17.99 GBAbout to download 17.99 GB.? Start download?❯ Yes  No  Change variant selection

Если модель уже есть в вашей библиотеке, консоль любезно сообщит об этом и подскажет команду для её запуска:

✔ Start download? yesModel already downloaded. To use, run: lms load google/gemma-4-26b-a4b

Инвентаризация: что в арсенале?

Список всех скачанных моделей можно вызвать командой:

lms ls

You have 10 models, taking up 118.17 GB of disk space.LLM                                   PARAMS     ARCH             SIZE         DEVICEgemma-3-270m-it-mlx                   270m       gemma3_text      497.80 MB    Localgoogle/gemma-4-26b-a4b (1 variant)    26B-A4B    gemma4           17.99 GB     Localgpt-oss-20b-mlx                       20B        gpt_oss          22.26 GB     Localllama-3.2-1b-instruct                 1B         Llama            712.58 MB    Localnvidia/nemotron-3-nano (1 variant)    30B        nemotron_h       17.79 GB     Localopenai/gpt-oss-20b (1 variant)        20B        gpt-oss          12.11 GB     Localqwen/qwen3.5-35b-a3b (1 variant)      35B-A3B    qwen35moe        22.07 GB     Localqwen2.5-0.5b-instruct-mlx             0.5B       Qwen2            293.99 MB    Localzai-org/glm-4.7-flash (1 variant)     30B        glm4_moe_lite    24.36 GB     LocalEMBEDDING                               PARAMS    ARCH          SIZE        DEVICEtext-embedding-nomic-embed-text-v1.5              Nomic BERT    84.11 MB    Local

Заметьте: многие из этих моделей (Gemma 4, Qwen 3.5, GLM 4.7 Flash) построены на архитектуре группы экспертов. Для локального запуска MoE – это настоящий подарок, ведь при генерации каждого токена просыпается лишь малая часть параметров, что позволяет им прыгать выше своей головы.

Интерактивный чат

Запустим чат с флагом --stats, чтобы в реальном времени видеть показатели производительности:

lms chat google/gemma-4-26b-a4b --stats

 ╭─────────────────────────────────────────────────╮ │ 👾 lms chat                                     │ │ Type exit or Ctrl+C to quit                     │ │                                                 │ │ Chatting with google/gemma-4-26b-a4b            │ │                                                 │ │ Try one of the following commands:              │ │ /model - Load a model (type /model to see list) │ │ /download - Download a model                    │ │ /clear - Clear the chat history                 │ │ /help - Show help information                   │ ╰─────────────────────────────────────────────────╯

Благодаря --stats, после каждого ответа мы получаем подробную метрику:

Prediction Stats:  Stop Reason: eosFound  Tokens/Second: 51.35  Time to First Token: 1.551s  Prompt Tokens: 39  Predicted Tokens: 176  Total Tokens: 215

51 токен в секунду для модели класса 26B на MacBook Pro M4 Pro с 48 ГБ памяти – результат более чем достойный. Время до выдачи первого токена в 1,5 секунды обеспечивает вполне комфортный диалог.

Ревизия памяти и активных моделей

Проверим, что загружено в данный момент:

lms ps

IDENTIFIER                MODEL                     STATUS    SIZE        CONTEXT    PARALLEL    DEVICE    TTLgoogle/gemma-4-26b-a4b    google/gemma-4-26b-a4b    IDLE      17.99 GB    48000      2           Local     60m / 1h

Модель занимает 17,99 ГБ ОЗУ, держит окно контекста в 48K и готова обрабатывать два запроса параллельно. Параметр TTL (time-to-live) здесь крайне полезен: он автоматически выгрузит модель через час бездействия, освобождая память без лишних телодвижений с вашей стороны.

Для любителей покопаться в деталях есть вывод метаданных в JSON (удобно прогнать через jq):

lms ps --json | jq

lms ps --json | jq[  {    "type": "llm",    "modelKey": "google/gemma-4-26b-a4b",    "format": "gguf",    "displayName": "Gemma 4 26B A4B",    "publisher": "google",    "path": "google/gemma-4-26b-a4b",    "sizeBytes": 17990911801,    "indexedModelIdentifier": "google/gemma-4-26b-a4b",    "deviceIdentifier": null,    "paramsString": "26B-A4B",    "architecture": "gemma4",    "quantization": {      "name": "Q4_K_M",      "bits": 4    },    "variants": [      "google/gemma-4-26b-a4b@q4_k_m"    ],    "selectedVariant": "google/gemma-4-26b-a4b@q4_k_m",    "identifier": "google/gemma-4-26b-a4b",    "ttlMs": 3600000,    "lastUsedTime": 1775316805638,    "vision": true,    "trainedForToolUse": true,    "maxContextLength": 262144,    "contextLength": 48000,    "status": "idle",    "queued": 0,    "parallel": 2  }]

На что стоит обратить внимание в этом JSON-файле:

• Архитектура (architecture): "gemma4" с квантованием "Q4_K_M".

• Возможности: "vision": true (поддержка компьютерного зрения) и "trainedForToolUse": true (модель обучена использовать внешние инструменты).

• Контекст: максимальный объем (maxContextLength) составляет 262 144 токена, хотя при текущей загрузке выставлено 48 000.

• Параллелизм: "parallel": 2 – благодаря непрерывному батчингу можно слать два запроса одновременно.

---

Расчёт памяти: сколько весит контекст?

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

Сама тушка модели неизменно занимает около 17,6 ГиБ. А вот каждое удвоение длины контекста прибавляет к этому весу ещё примерно 3–4 ГиБ. При стандартном окне в 48K вам потребуется около 21 ГиБ. На моем MacBook Pro с 48 ГБ памяти я могу замахнуться на полный контекст в 256K – это съест 37,48 ГиБ, оставив ещё добрых 10 ГБ под нужды системы и приложений. Даже на маке с 36 ГБ ОЗУ можно с комфортом работать с контекстом в 200K, и ещё останется запас.

Команда для оценки ресурсов предельно проста:

lms load google/gemma-4-26b-a4b --estimate-only --context-length 48000

Model: google/gemma-4-26b-a4bContext Length: 48,000Estimated GPU Memory:   21.05 GiBEstimated Total Memory: 21.05 GiBEstimate: This model may be loaded based on your resource guardrails settings.

Это крайне полезно для планирования ресурсов. Если вы собираетесь гонять Gemma 4 параллельно с другим тяжелым софтом, лучше сначала свериться с прогнозом для нужного вам контекста.

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

#!/usr/bin/env bashmodel="google/gemma-4-26b-a4b"contexts=(4096 8000 16000 24000 32000 48000 64000 96000 128000 200000 256000)table_contexts=()table_gpu=()table_total=()for ctx in "${contexts[@]}"; do  output="$(lms load "$model" --estimate-only --context-length "$ctx" 2>&1)"  parsed_context="$(printf '%s\n' "$output" | awk -F': ' '/^Context Length:/ {print $2; exit}')"  parsed_gpu="$(printf '%s\n' "$output" | awk -F': +' '/^Estimated GPU Memory:/ {print $2; exit}')"  parsed_total="$(printf '%s\n' "$output" | awk -F': +' '/^Estimated Total Memory:/ {print $2; exit}')"  table_contexts+=("${parsed_context:-$ctx}")  table_gpu+=("${parsed_gpu:-N/A}")  table_total+=("${parsed_total:-N/A}")doneprintf '| Model | Context Length | GPU Memory | Total Memory |\n'printf '|---|---:|---:|---:|\n'for i in "${!table_contexts[@]}"; do  printf '| %s | %s | %s | %s |\n' \    "$model" "${table_contexts[$i]}" "${table_gpu[$i]}" "${table_total[$i]}"done

Настройка загрузки под ваше железо

Команды lms load или lms chat по умолчанию используют вполне разумные настройки, но их всегда можно подкрутить под конкретное оборудование и задачи. Вот краткий гид, как выжать максимум из вашей системы.

Длина контекста: соотносим с объемом памяти

Таблица выше – ваша отправная точка. Вычтите из общего объема ОЗУ накладные расходы системы (macOS обычно отъедает 4–6 ГБ) – и вы поймете, какой максимальный контекст вы можете себе позволить.

Загрузить модель с конкретным размером контекста можно так:

lms load google/gemma-4-26b-a4b --context-length 128000

Если сомневаетесь, всегда сначала запускайте команду с флагом --estimate-only – она учтет в расчетах и flash attention, и потребности визуальной модели.

Распределение нагрузки (GPU offloading)

В чипах Apple Silicon используется объединенная память, поэтому CPU и GPU питаются из одного котла. Здесь флаг --gpu скорее определяет, какая доля вычислений ляжет на графические ядра. Режим auto обычно справляется хорошо, но можно заставить систему использовать GPU на полную мощность:

lms load google/gemma-4-26b-a4b --gpu=1.0

Значение --gpu=max выжмет из графики всё возможное. Для систем с дискретными видеокартами (NVIDIA на Windows или Linux) этот параметр куда важнее, так как видеопамять (VRAM) и системная ОЗУ там разделены. Если модель целиком не влезает в видеокарту, частичный перенос (--gpu=0.5) распределит слои между GPU и процессором: скорость упадет, зато вы сможете запустить модель покрупнее.

Параллельные запросы и непрерывный батчинг

LM Studio умеет обрабатывать несколько запросов одновременно с помощью непрерывного батчинга, сшивая их в единый вычислительный поток. Это незаменимо, если к вашей модели обращаются сразу несколько клиентов или вы используете параллельные вызовы инструментов. Фишка работает на движке llama.cpp (v2.0.0+) и пока недоступна для бэкенда MLX.

Настроить это можно через графический интерфейс: в инсталлере моделей включите Manually choose model load parameters, выберите нужную модель, затем в Advanced settings найдите пункт Max concurrent predictions (по умолчанию там стоит 4). В консоли прямого флага для этого пока нет – настройки подтягиваются из десктопного приложения.

Помните: каждый параллельный поток отъедает дополнительную память пропорционально размеру контекста. Если ОЗУ в дефиците, лучше уменьшить число потоков или урезать контекст. Для Gemma 4 на 48 ГБ оптимальный баланс – 2 потока при контексте 48K.

TTL: автовыгрузка простаивающих моделей

Параметр TTL (time-to-live) автоматически выгружает модель, если к ней долго никто не обращался:

lms load google/gemma-4-26b-a4b --ttl 1800

В примере выше установлен таймаут в 1800 секунд (30 минут). По умолчанию стоит один 1 час. Если вы держите сервер, на котором живет зоопарк моделей под разные задачи, короткий TTL поможет им сменять друг друга на посту, освобождая память без вашего участия. Чтобы модель висела в памяти вечно, поставьте 0 или -1.

Предустановки для моделей

Чтобы не вводить параметры каждый раз, сохраните их прямо в приложении. В разделе My models нажмите на иконку шестеренки рядом с моделью и задайте желаемые настройки GPU, контекста и flash attention. Эти дефолты будут применяться везде, даже при запуске через консоль lms load.

Спекулятивное декодирование

LM Studio поддерживает спекулятивное декодирование для плотных моделей: в пару к основной модели ставится “черновая” (поменьше), которая быстро накидывает варианты токенов, а “старшая” их пачками проверяет. Это может ощутимо ускорить генерацию.

Однако с MoE-моделями вроде Gemma 4 26B-A4B этот фокус проходит плохо. При проверке основной модели приходится подгружать всех экспертов, задействованных во всех предложенных токенах. Поскольку разные токены стучатся к разным экспертам, нагрузка на пропускную способность памяти взлетает до небес и всё начинает безбожно тормозить. Тесты Mixtral показали, что при одних и тех же настройках код пишется на 39% быстрее, а математика считается на 54% медленнее – универсального рецепта тут нет. Исследователи сейчас бьются над этой проблемой (варианты вроде MoE-Spec или SP-MoE), но пока мой совет для Gemma 4: забудьте про спекулятивное декодирование и полагайтесь на родную скорость MoE-инференса.

Flash attention

Эта технология оптимизирует работу с кешем (KV cache), позволяя впихнуть в ту же память гораздо больший объем контекста. В настройках LM Studio её можно включить для каждой модели индивидуально. Для Gemma 4 на Apple Silicon это реальный шанс сэкономить драгоценные гигабайты на длинных дистанциях. Флаг --estimate-only учитывает flash attention, так что вы можете сами сравнить цифры до и после.

---

Десктопное приложение LM Studio

Несмотря на то что выше мы налегали на консольные команды, у LM Studio есть и полноценное графическое приложение для macOS. Оно незаменимо, если нужно наглядно следить за состоянием системы или быстро провести эксперимент, прежде чем переходить к автоматизации через CLI.

На скриншоте ниже представлен раздел сервера с загруженной моделью Gemma 4. Вот на что стоит обратить внимание:

• Статус сервера (Server status): горит “Running”. Локальный эндпойнт http://192.168.1.121:1234 доступен любому устройству в вашей сети.

• Загруженные модели (Loaded models): здесь видна активная модель и живая статистика – 29 генераций, 1087 обработанных токенов и честно занятые 17,99 ГБ в памяти.

• Поддерживаемые эндпойнты: приложение понимает форматы API LM Studio, OpenAI и Anthropic (для последнего используется POST /v1/messages).

• Логи разработчика (Developer logs): поток данных о ходе обработки промптов в реальном времени. Это очень удобно, когда модель переваривает длинные куски кода и вы хотите видеть прогресс.

Кстати, в десктопной версии отлично раскрываются визуальные возможности (vision) Gemma 4. На скриншоте ниже модель анализирует картинку с сайта Timezone Scheduler. Она безошибочно считала заголовок, карту мира с цветовой разбивкой по поясам, сетку расписания (сравнение Брисбена, Нью-Йорка и Лондона), значки функций и даже иконки технологий в самом низу. Результат: 504 токена на скорости 54,51 ток/с, причем первый токен появился уже через 3,15 секунды.

А вот работа Claude Code (через алиас claude-lm) – Gemma 4 анализирует мой репозиторий с бенчмарками Timezones Scheduler.

Окна системного монитора на скриншотах наглядно показывают, как локальный инференс нагружает железо. Вот расклад для моего M4 Pro (4 энергоэффективных ядра, 10 производительных, 20 графических):

• Нагрузка на память (Memory pressure): из 48 ГБ физической памяти занято 46,69 ГБ. Из них 38,07 ГБ – “wired”, то есть жестко зарезервированы (в основном под модель и контекст). Файл подкачки (swap) разросся до 27,49 ГБ, но система при этом не тормозит и остается отзывчивой.

• Загрузка GPU: плотные 90% во время работы. Частота P-кластера ядер – 4,50 ГГц, видеоядра – 1,45 ГГц.

• Загрузка CPU: энергоэффективные ядра (E-Cores) загружены на 82,42%, производительные (P-Cores) – на 35,96%.

• Температура: в среднем 91 °C на процессоре и 92,46 °C на графике. Для M4 Pro под длительной нагрузкой это вполне штатный режим.

• Энергопотребление: суммарно около 23,56 Вт на весь чип (CPU 11,06 Вт + GPU 13,32 Вт). Весьма скромная плата за запуск 26-миллиардной модели.

В этом и кроется главный козырь Apple Silicon для работы с нейросетями. Объединенная архитектура памяти (Unified Memory) позволяет процессору и графике использовать одни и те же данные без лишнего копирования между ОЗУ и видеопамятью, как это бывает на дискретных картах. Модель загружается один раз и доступна всем вычислительным ядрам напрямую.

Раздача моделей через API

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

lms server start

Теперь по адресу http://localhost:1234/v1 доступен API, полностью совместимый с OpenAI. Любой инструмент, будь то Continue, Cursor или ваш собственный скрипт, сможет работать с локальной моделью. Кроме того, в LM Studio 0.4.0 появился эндпойнт для протокола Anthropic (POST /v1/messages), так что софт, заточенный под “Клода”, заработает без всяких прослоек. Если порт 1234 уже чем-то занят, его легко сменить: lms server start --port 8080.

Сервер также поддерживает динамическую загрузку (JIT, just-in-time). Если клиент запрашивает модель, которой прямо сейчас нет в памяти, LM Studio сама подгрузит её на лету, а после истечения таймаута (TTL) выгрузит обратно. Можно пользоваться целой пачкой моделей, не забивая память всеми сразу.

Чтобы следить за происходящим в реальном времени, запустите стриминг логов:

lms log stream --source model --stats

Вы увидите каждый запрос, ответ, скорость генерации и задержки. Нужен формат для автоматического анализа? Добавьте флаг --json. А если интересуют только системные события (запуск, обращения к эндпойнтам), используйте --source server.

В связке с фоновым демоном вы можете выделить под это дело отдельную машину и раздавать мощности на всю локальную сеть. Сервер будет доступен по локальному IP (например, http://192.168.1.121:1234). Если же вы опасаетесь за безопасность, включите в настройках Require authentication (обязательная авторизация) и создайте API-токены с нужными правами. Тогда для доступа придется передавать стандартный заголовок Authorization: Bearer $LM_API_TOKEN.

---

Gemma 4 на службе Claude Code: настраиваем бэкенд

Наличие эндпойнта, совместимого с Anthropic, открывает захватывающую перспективу: теперь Claude Code можно запустить не через облако, а на базе вашей локальной модели. На выходе мы получаем бесплатного ИИ-помощника, который работает без интернета.

Чтобы всё залетало, я прописал в файле ~/.zshrc функцию под названием claude-lm(). Она задает все нужные переменные окружения и натравливает Claude Code на локальный сервер LM Studio:

claude-lm() {    export ANTHROPIC_BASE_URL=http://localhost:1234    export ANTHROPIC_AUTH_TOKEN=lmstudio    export CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY="2"    export CLAUDE_CODE_NO_FLICKER="0"    export ANTHROPIC_MODEL="gemma-4-26b-a4b"    export CLAUDE_CODE_AUTO_COMPACT_WINDOW="48000"    export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE="90"    export ANTHROPIC_DEFAULT_OPUS_MODEL="google/gemma-4-26b-a4b"    export ANTHROPIC_DEFAULT_SONNET_MODEL="google/gemma-4-26b-a4b"    export ANTHROPIC_DEFAULT_HAIKU_MODEL="google/gemma-4-26b-a4b"    export CLAUDE_CODE_SUBAGENT_MODEL="google/gemma-4-26b-a4b"    export API_TIMEOUT_MS="30000000"    export BASH_DEFAULT_TIMEOUT_MS="2400000"    export BASH_MAX_TIMEOUT_MS="2500000"    export CLAUDE_CODE_MAX_OUTPUT_TOKENS="8000"    export CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS="8000"    export CLAUDE_CODE_ATTRIBUTION_HEADER="0"    export CLAUDE_CODE_DISABLE_1M_CONTEXT="1"    export CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING="1"    claude "$@"}

Разберем, за что отвечают ключевые переменные:

• ANTHROPIC_BASE_URL и ANTHROPIC_AUTH_TOKEN перенаправляют Claude Code на наш локальный сервер LM Studio. Значение lmstudio в токене – это просто заглушка, так как по умолчанию сервер авторизации не требует.

• ANTHROPIC_MODEL и три переменные DEFAULT_*_MODEL заставляют Claude Code использовать Gemma 4 вместо привычных Opus, Sonnet или Haiku. Без этого инструмент попытался бы вызвать родные модели Anthropic, о которых LM Studio ничего не знает.

• CLAUDE_CODE_SUBAGENT_MODEL гарантирует, что даже дочерние агенты, которые Claude Code любит плодить для подзадач, будут работать через нашу локальную модель.

• CLAUDE_CODE_AUTO_COMPACT_WINDOW и CLAUDE_AUTOCOMPACT_PCT_OVERRIDE управляют механизмом сжатия контекста. При окне в 48K очистка триггерится на отметке 90%, чтобы мы не уперлись в лимит в самый ответственный момент.

• API_TIMEOUT_MS выставлен с огромным запасом (около 8 часов), поскольку локальный инференс всё же медленнее облака и сложным задачам нужно время, чтобы прогрузиться.

• BASH_DEFAULT_TIMEOUT_MS и BASH_MAX_TIMEOUT_MS увеличивают время ожидания для команд оболочки до 40–42 минут – на случай долгих операций.

• CLAUDE_CODE_MAX_OUTPUT_TOKENS ограничивает ответ модели 8 тысячами токенов, что помогает держать время генерации в рамках разумного.

• CLAUDE_CODE_DISABLE_1M_CONTEXT и CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING отключают фишки оригинального API, которые наша локальная модель пока не поддерживает.

После того как добавите этот блок в ~/.zshrc и примените изменения командой source ~/.zshrc, локальную сессию можно будет запустить простой командой:

claude-lm

Всё работает в точности как в оригинале, но с одной важной поправкой: ни один байт не покидает ваш компьютер. Конечно, 51 ток/с – это не облачные скорости и при генерации огромных кусков кода придется немного подождать. Зато для код-ревью, точечных правок и исследования проекта это идеальный вариант.

---

Что я вынес из этого опыта

Архитектура MoE – идеальный выбор для локального запуска. Gemma 4 26B-A4B (26 млрд параметров всего, 4 млрд активных) выдает качество плотной 10-миллиардной модели при затратах ресурсов как у 4-миллиардной. Если ищете, что запустить у себя, присматривайтесь в первую очередь к подобным группам экспертов.

Консольный демон в корне меняет рабочий процесс. До версии 0.4.0 LM Studio требовала постоянно открытого окна приложения. Теперь же lms daemon up тихо работает в фоне, а вы общаетесь с системой исключительно через консоль или API. Это открывает дорогу к развертыванию на серверах и работе через SSH.

Длина контекста – главный рычаг управления памятью. Сама модель стабильно съедает около 17,6 ГиБ. Вес контекста растет линейно, так что вы можете математически точно выбрать баланс между объемом памяти и глубиной памяти модели.

Флаг --estimate-only бережет нервы. Всегда проверяйте аппетиты модели перед загрузкой, особенно если замахиваетесь на большой контекст. Это секундное дело спасет вас от внезапного падения системы из-за нехватки памяти (OOM).

Эндпойнт, совместимый с Anthropic, – это прорыв. Возможность подсунуть Claude Code локальную модель через простой алиас позволяет мгновенно переключаться между облаком и собственным сервером. Приватное код-ревью, работа в самолете или просто экономия на API – плюсы очевидны.

С чем возникли сложности

Gemma 4 не узнает себя в лицо через lms chat. На вопрос “Кто ты?” она скромно отвечает, что она – “ИИ-помощник”. Это ограничение системных промптов в LM Studio, а не вина самой модели; проблему можно решить, прописав кастомный системный промпт.

Стандартный контекст в 48K выглядит слишком осторожным для модели, которая тянет 256K. Если оперативная память позволяет, лучше сразу выставлять значения повыше, особенно для анализа увесистой документации или целых репозиториев.

Локальный Claude Code пока не может стать полноценной заменой облачному API. Сложные многоходовые задачи, требующие глубоких раздумий или гигантского контекста, со временем упираются в потолок возможностей локальной архитектуры. Такая связка лучше всего подходит для локальных, четко очерченных задач.

Нагрузка на 48-гигабайтный мак при запущенной Gemma 4 ощущается физически. Во время тестов система выедала 46,69 ГБ из 48 ГБ, активно задействуя еще 27 ГБ в файле подкачки. Если планируете параллельно работать в других тяжелых программах, готовьтесь к тому, что своп будет похрустывать. Для комфортной жизни в таком режиме лучше смотреть в сторону моделей с 64 ГБ ОЗУ и выше.