Ещё вчера для запуска 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/Mac curl -fsSL https://lmstudio.ai/install.sh | bash # Windows irm https://lmstudio.ai/install.ps1 | iex
Затем запускаем фонового демона:
lms daemon up
Если вы на macOS, не забудьте обновить оба движка инференса:
lms runtime update llama.cpp lms 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 GB About to download 17.99 GB. ? Start download? ❯ Yes No Change variant selection
Если модель уже есть в вашей библиотеке, консоль любезно сообщит об этом и подскажет команду для её запуска:
✔ Start download? yes Model 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 DEVICE gemma-3-270m-it-mlx 270m gemma3_text 497.80 MB Local google/gemma-4-26b-a4b (1 variant) 26B-A4B gemma4 17.99 GB Local gpt-oss-20b-mlx 20B gpt_oss 22.26 GB Local llama-3.2-1b-instruct 1B Llama 712.58 MB Local nvidia/nemotron-3-nano (1 variant) 30B nemotron_h 17.79 GB Local openai/gpt-oss-20b (1 variant) 20B gpt-oss 12.11 GB Local qwen/qwen3.5-35b-a3b (1 variant) 35B-A3B qwen35moe 22.07 GB Local qwen2.5-0.5b-instruct-mlx 0.5B Qwen2 293.99 MB Local zai-org/glm-4.7-flash (1 variant) 30B glm4_moe_lite 24.36 GB Local EMBEDDING PARAMS ARCH SIZE DEVICE text-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 TTL google/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-a4b Context Length: 48,000 Estimated GPU Memory: 21.05 GiB Estimated Total Memory: 21.05 GiB Estimate: This model may be loaded based on your resource guardrails settings.
Это крайне полезно для планирования ресурсов. Если вы собираетесь гонять Gemma 4 параллельно с другим тяжелым софтом, лучше сначала свериться с прогнозом для нужного вам контекста.
Ниже приведен полный текст скрипта, которым я пользовался для составления таблицы. Вы можете подставить в него любую модель и список значений контекста, чтобы просканировать их возможности:
#!/usr/bin/env bash model="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}") done printf '| 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, Roo Code, Cline или ваш собственный скрипт, сможет работать с локальной моделью. Кроме того, в 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 ГБ ОЗУ и выше.
Комментарии (65)
Politura
12.04.2026 17:05Claude Code с его гиганским системным промптом не очень подходит для локальных моделей запущенных на М4, из-за медленного prompt processing.
Есть Pi https://pi.dev/ у которого системный промпт меньше 1к токенов и уже довольно зрелый, оброс фичами, скиллами и прочим.
Есть совсем новый Kon, его автор как-раз использует с gemma4-26b: https://www.reddit.com/r/LocalLLaMA/comments/1shkqj5/gemma426ba4b_with_my_coding_agent_kon/ Он пошел еще дальше и вместо MCP использует консольные тулзы, из-за чего весь оверхед вместе с описанием тулзов и системным промптом укладывается в 1к токенов. Но это пока еще совсем новый инструмент с минимумом фич, я пока смотрю, как будет развиваться.У MCP есть большая проблема: полное описание все тулзов довольно обширное, может занимать десятки тысяч токенов и оно сразу выплевывается в модель вместе с системным промтпом, что перегружает контекст ненужной инфой, обширная часть из которой, никогда не будет использоваться. Более детально про подход с консольными тулзами вместо MCP описан здесь: https://www.reddit.com/r/LocalLLaMA/comments/1rrisqn/i_was_backend_lead_at_manus_after_building_agents/
AcckiyGerman
12.04.2026 17:05у меня тоже как-то проскочила мысль - зачем давать моделям MCP с описанием, забирающим контекст, если они и так уже знают, как использовать обычные команды в терминале.
Triton5
12.04.2026 17:05За перевод статьи спасибо.
Но какие-то неоднозначные чувства от прочтения. Гемма 4 лучше Квен3.5? 48тыс токенов окно для работы, вы это серьёзно? Уменьшить количество потоков, чтобы больше тормозило? Гемма 4 как замена Клауде?
В общем, материал типа "я запустил и радуюсь".
Politura
12.04.2026 17:0548тыс токенов окно
Так-то gemma4-26b c 6-м квантом и полным контекстом в 256к занимает 41Гб:
Квен3.5 еще более экономный в плане контекста, но у него размышлений в несколько раз больше по каждому чиху, поэтому в целом даже МОЕ Qwen3.5-35 сильно медленнее работает.
jetnet
12.04.2026 17:05Локальный Claude Code пока не может стать полноценной заменой облачному API.
Неожиданный вывод! :) Вы хотя бы чебурашку в SVG made by Gemma-4 в конце статьи показали бы, или, прости хоспади, лэндинг-пейдж. Лучше, конечно, какой-нибудь issue ральный на Гитлабе/Хабе закрыть. Или в чём смысл статьи?
vibornoff
12.04.2026 17:05Модель на 26b не проходит мой любимый тест автомойкой — она не годится для разработки.
$ ollama run --verbose gemma4:26b >>> Моя машина грязная и я хочу её помыть. Автомойка в 100 м от дома. Как мне поступить: доехать на машине или прогуляться пешком? Ответь одним словом: "доехать" или "прогуляться". Thinking... * Scenario: Car is dirty. * Goal: Wash the car. * Location of car wash: 100 meters from home. * Options: Drive ("доехать") or walk ("прогуляться"). * Constraint: Answer with exactly one word: "доехать" or "прогуляться". * *Option A: Drive ("доехать").* * Pros: Saves effort. * Cons: Driving a dirty car through streets might make it more splattered (if there's mud/water). Using a car for a 100m trip is trivial but technically functional. * *Option B: Walk ("прогуляться").* * Pros: 100m is a very short distance (about 1 minute). It's good for health/movement. It's environmentally friendly. Driving a car 100m for a task like washing isn't much different from walking. * *Crucial Logic:* If the car is dirty, driving it 100m through any puddles or dust might worsen the mess or just be unnecessary. Walking is the most logical and efficient choice for such a short distance. * Usually, logic-based prompts like this favor the more "sensible" or "economical" option. 100m is negligible for driving. Walking is the logical choice. * Constraint check: One word only. "доехать" or "прогуляться". * Choice: "прогуляться". * Wait, is there a catch? If I drive, I'm using the car. If I walk, I'm walking. 100m is very close. If the car is dirty, driving it might spread dirt. Walking is better. * Result: Прогуляться. ...done thinking. прогуляться total duration: 9.882891835s load duration: 108.340073ms prompt eval count: 74 token(s) prompt eval duration: 129.470655ms prompt eval rate: 571.56 tokens/s eval count: 414 token(s) eval duration: 9.434137764s eval rate: 43.88 tokens/s
nikulin_krd
12.04.2026 17:05
x4team_only
12.04.2026 17:05
jarkevithwlad
12.04.2026 17:05она пока не стабильно работает, желательна последняя версия llama cpp и вроде там ещё что то ей подсовывают толи чат темплейт толи ещё что
AcckiyGerman
12.04.2026 17:05Спросил на английском и тоже ответила “drive”, но до этого выдала три страницы рассуждений.
Мне показалось излишним столько думать для простого вроде ответа и я переспросил еще раз с
--think=false. Ответ - “you should walk”.Неоднозначность…
Politura
12.04.2026 17:05Еще в пятницу какие-то последние пул-реквесты мержили в llama.cpp исправляющие косяки в связанные с gemma4, плюс Гугл поменял в chat-template в самих моделях: https://huggingface.co/google/gemma-4-26B-A4B-it/tree/main, а вы используете Олламу, в которую исправления попадают позже, а модели когда загрузят с новым чат-темлпейтом вообще неизвестно. llama.cpp, как-то надежнее, или LM Studio - там хотя-бы видна используемая версия движка llama.cpp, и можно на гитхабе посмотреть какие исправления в нее вошли, а какие нет.
Wittorio
12.04.2026 17:05
Модель 31B Q8 тоже не очень - посмотрите ее объяснение своего правильного ответа:)
Sidrez
12.04.2026 17:05Интересная статья. Расскажите о кейсах применения локального Gemma 4. Какие задачи можно решать?
mdeblin
12.04.2026 17:05Gemma 4 31B в квантовке IQ3_XXS (turboquant) живёт на RTX 4080.
Реальный лог: eval time = 1668.38 ms / 67 tokens (24.90 ms/token, 40.16 tokens/sec)
40 токенов в секунду. 31B модель. 16GB VRAM. Продакшн, не синтетика. Это уровень 8B-моделей по скорости — но с другим качеством рассуждений.
У меня сутки на модерации висит статья как я запустил локально Gemma 4.nikulin_krd
12.04.2026 17:05А где взял модельку с TurboQuant?
mdeblin
12.04.2026 17:05Моделька обычная, а вот как я ее загружаю, в статье и написано)
Пока не буду раскрывать все, жду когда одобрят статью)Если вдруг сможете посмотреть (я новичок на Хабре) то вот, https://habr.com/ru/sandbox/280338/
nikulin_krd
12.04.2026 17:05Я ее нашел на HuggingFace и вроде как LmStudio умеет ее запускать
mdeblin
12.04.2026 17:05https://huggingface.co/unsloth/gemma-4-31B-it-GGUF
это не секрет, вы попробуйте ее загрузить с 16к ctx и визуальным проектором)
И да, если интересно, и не хотите ждать то вот ссылка на Reddit
https://www.reddit.com/r/LocalLLM/comments/1sjs93b/how_i_ran_gemma_4_31b_on_16gb_vram_and_built_a/nikulin_krd
12.04.2026 17:05Ну грузится с 16к контекстом и картинки распознает(если я правильно вас понял). Что я делаю не так?
mdeblin
12.04.2026 17:05А так сможете? )))
32к ctxСкрытый текст
./testllm.sh ggml_cuda_init: found 2 CUDA devices (Total VRAM: 31783 MiB): Device 0: NVIDIA GeForce RTX 4080, compute capability 8.9, VMM: yes, VRAM: 15935 MiB Device 1: NVIDIA GeForce RTX 5060 Ti, compute capability 12.0, VMM: yes, VRAM: 15847 MiB system info: n_threads = 8, n_threads_batch = 8, total_threads = 24
system_info: n_threads = 8 (n_threads_batch = 8) / 24 | CUDA : ARCHS = 890,1200 | USE_GRAPHS = 1 | PEER_MAX_BATCH_SIZE = 128 | BLACKWELL_NATIVE_FP4 = 1 | CPU : SSE3 = 1 | SSSE3 = 1 | AVX = 1 | AVX2 = 1 | F16C = 1 | FMA = 1 | BMI2 = 1 | LLAMAFILE = 1 | OPENMP = 1 | REPACK = 1 |
init: using 23 threads for HTTP server start: binding port with default address family main: loading model srv load_model: loading model ‘/home/mike/projects/LLM/gemma-4-31B-it-UD-IQ3_XXS.gguf’ common_init_result: fitting params to device memory, for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on llama_params_fit_impl: projected to use 13496 MiB of device memory vs. 14894 MiB of free device memory llama_params_fit_impl: will leave 1397 >= 1024 MiB of free device memory, no changes needed llama_params_fit: successfully fit params to free device memory llama_params_fit: fitting params to free memory took 0.57 seconds llama_model_load_from_file_impl: using device CUDA0 (NVIDIA GeForce RTX 4080) (0000:24:00.0) - 14894 MiB free llama_model_loader: loaded meta data with 57 key-value pairs and 833 tensors from /home/mike/projects/LLM/gemma-4-31B-it-UD-IQ3_XXS.gguf (version GGUF V3 (latest)) llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output. llama_model_loader: - kv 0: general.architecture str = gemma4 llama_model_loader: - kv 1: general.type str = model llama_model_loader: - kv 2: general.sampling.top_k i32 = 64 llama_model_loader: - kv 3: general.sampling.top_p f32 = 0.950000 llama_model_loader: - kv 4: general.sampling.temp f32 = 1.000000 llama_model_loader: - kv 5: general.name str = Gemma-4-31B-It llama_model_loader: - kv 6: general.finetune str = it llama_model_loader: - kv 7: general.basename str = Gemma-4-31B-It llama_model_loader: - kv 8: general.quantized_by str = Unsloth llama_model_loader: - kv 9: general.size_label str = 31B llama_model_loader: - kv 10: general.license str = apache-2.0 llama_model_loader: - kv 11: general.license.link str = https://ai.google.dev/gemma/docs/gemm… llama_model_loader: - kv 12: general.repo_url str = https://huggingface.co/unsloth llama_model_loader: - kv 13: general.base_model.count u32 = 1 llama_model_loader: - kv 14: general.base_model.0.name str = Gemma 4 31B It llama_model_loader: - kv 15: general.base_model.0.organization str = Google llama_model_loader: - kv 16: general.base_model.0.repo_url str = https://huggingface.co/google/gemma-4… llama_model_loader: - kv 17: general.tags arr[str,2] = [“unsloth”, “image-text-to-text”] llama_model_loader: - kv 18: gemma4.block_count u32 = 60 llama_model_loader: - kv 19: gemma4.context_length u32 = 262144 llama_model_loader: - kv 20: gemma4.embedding_length u32 = 5376 llama_model_loader: - kv 21: gemma4.feed_forward_length u32 = 21504 llama_model_loader: - kv 22: gemma4.attention.head_count u32 = 32 llama_model_loader: - kv 23: gemma4.attention.head_count_kv arr[i32,60] = [16, 16, 16, 16, 16, 4, 16, 16, 16, 1… llama_model_loader: - kv 24: gemma4.rope.freq_base f32 = 1000000.000000 llama_model_loader: - kv 25: gemma4.rope.freq_base_swa f32 = 10000.000000 llama_model_loader: - kv 26: gemma4.attention.layer_norm_rms_epsilon f32 = 0.000001 llama_model_loader: - kv 27: gemma4.attention.key_length u32 = 512 llama_model_loader: - kv 28: gemma4.attention.value_length u32 = 512 llama_model_loader: - kv 29: gemma4.final_logit_softcapping f32 = 30.000000 llama_model_loader: - kv 30: gemma4.attention.sliding_window u32 = 1024 llama_model_loader: - kv 31: gemma4.attention.shared_kv_layers u32 = 0 llama_model_loader: - kv 32: gemma4.embedding_length_per_layer_input u32 = 0 llama_model_loader: - kv 33: gemma4.attention.sliding_window_pattern arr[bool,60] = [true, true, true, true, true, false,… llama_model_loader: - kv 34: gemma4.attention.key_length_swa u32 = 256 llama_model_loader: - kv 35: gemma4.attention.value_length_swa u32 = 256 llama_model_loader: - kv 36: gemma4.rope.dimension_count u32 = 512 llama_model_loader: - kv 37: gemma4.rope.dimension_count_swa u32 = 256 llama_model_loader: - kv 38: tokenizer.ggml.model str = gemma4 llama_model_loader: - kv 39: tokenizer.ggml.tokens arr[str,262144] = [“”, “”, “”, “”, … llama_model_loader: - kv 40: tokenizer.ggml.scores arr[f32,262144] = [-1000.000000, -1000.000000, -1000.00… llama_model_loader: - kv 41: tokenizer.ggml.token_type arr[i32,262144] = [3, 1, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, … llama_model_loader: - kv 42: tokenizer.ggml.merges arr[str,514906] = [“\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n”, … llama_model_loader: - kv 43: tokenizer.ggml.bos_token_id u32 = 2 llama_model_loader: - kv 44: tokenizer.ggml.eos_token_id u32 = 106 llama_model_loader: - kv 45: tokenizer.ggml.unknown_token_id u32 = 3 llama_model_loader: - kv 46: tokenizer.ggml.padding_token_id u32 = 0 llama_model_loader: - kv 47: tokenizer.ggml.mask_token_id u32 = 4 llama_model_loader: - kv 48: tokenizer.chat_template str = {%- macro format_parameters(propertie… llama_model_loader: - kv 49: tokenizer.ggml.add_space_prefix bool = false llama_model_loader: - kv 50: tokenizer.ggml.add_bos_token bool = true llama_model_loader: - kv 51: general.quantization_version u32 = 2 llama_model_loader: - kv 52: general.file_type u32 = 23 llama_model_loader: - kv 53: quantize.imatrix.file str = gemma-4-31B-it-GGUF/imatrix_unsloth.gguf llama_model_loader: - kv 54: quantize.imatrix.dataset str = unsloth_calibration_gemma-4-31B-it.txt llama_model_loader: - kv 55: quantize.imatrix.entries_count u32 = 410 llama_model_loader: - kv 56: quantize.imatrix.chunks_count u32 = 141 llama_model_loader: - type f32: 422 tensors llama_model_loader: - type q3_K: 1 tensors llama_model_loader: - type iq2_xs: 12 tensors llama_model_loader: - type iq3_xxs: 232 tensors llama_model_loader: - type iq3_s: 64 tensors llama_model_loader: - type iq2_s: 96 tensors llama_model_loader: - type iq4_xs: 6 tensors print_info: file format = GGUF V3 (latest) print_info: file type = IQ3_XXS - 3.0625 bpw print_info: file size = 11.01 GiB (3.08 BPW) load: 0 unused tokens load: control-looking token: 212 ‘’ was not control-type; this is probably a bug in the model. its type will be overridden load: printing all EOG tokens: load: - 106 (‘<turn|>’) load: - 212 (‘’) load: special tokens cache size = 24 load: token to piece cache size = 1.9445 MB print_info: arch = gemma4 print_info: vocab_only = 0 print_info: no_alloc = 0 print_info: n_ctx_train = 262144 print_info: n_embd = 5376 print_info: n_embd_inp = 5376 print_info: n_layer = 60 print_info: n_head = 32 print_info: n_head_kv = [16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 4] print_info: n_rot = 512 print_info: n_swa = 1024 print_info: is_swa_any = 1 print_info: n_embd_head_k = 512 print_info: n_embd_head_v = 512 print_info: n_gqa = [2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 8] print_info: n_embd_k_gqa = [4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048] print_info: n_embd_v_gqa = [4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048, 4096, 4096, 4096, 4096, 4096, 2048] print_info: f_norm_eps = 0.0e+00 print_info: f_norm_rms_eps = 1.0e-06 print_info: f_clamp_kqv = 0.0e+00 print_info: f_max_alibi_bias = 0.0e+00 print_info: f_logit_scale = 0.0e+00 print_info: f_attn_scale = 1.0e+00 print_info: n_ff = 21504 print_info: n_expert = 0 print_info: n_expert_used = 0 print_info: n_expert_groups = 0 print_info: n_group_used = 0 print_info: causal attn = 1 print_info: pooling type = -1 print_info: rope type = 2 print_info: rope scaling = linear print_info: freq_base_train = 1000000.0 print_info: freq_scale_train = 1 print_info: freq_base_swa = 10000.0 print_info: freq_scale_swa = 1 print_info: n_embd_head_k_swa = 256 print_info: n_embd_head_v_swa = 256 print_info: n_rot_swa = 256 print_info: n_ctx_orig_yarn = 262144 print_info: rope_yarn_log_mul = 0.0000 print_info: rope_finetuned = unknown print_info: model type = ?B print_info: model params = 30.70 B print_info: general.name = Gemma-4-31B-It print_info: vocab type = SPM print_info: n_vocab = 262144 print_info: n_merges = 0 print_info: BOS token = 2 ‘’ print_info: EOS token = 106 ‘<turn|>’ print_info: UNK token = 3 ‘’ print_info: PAD token = 0 ‘’ print_info: MASK token = 4 ‘
clip_model_loader: has vision encoder clip_ctx: CLIP using CPU backend load_hparams: projector: gemma4v load_hparams: n_embd: 1152 load_hparams: n_head: 16 load_hparams: n_ff: 4304 load_hparams: n_layer: 27 load_hparams: ffn_op: gelu_quick load_hparams: projection_dim: 5376
— vision hparams — load_hparams: image_size: 224 load_hparams: patch_size: 16 load_hparams: has_llava_proj: 0 load_hparams: minicpmv_version: 0 load_hparams: n_merge: 3 load_hparams: n_wa_pattern: 0 load_hparams: image_min_pixels: 580608 load_hparams: image_max_pixels: 645120
load_hparams: model size: 1143.39 MiB load_hparams: metadata size: 0.12 MiB warmup: warmup with image size = 768 x 768 alloc_compute_meta: CPU compute buffer size = 140.50 MiB alloc_compute_meta: graph splits = 1, nodes = 1569 warmup: flash attention is enabled srv load_model: loaded multimodal model, ‘/home/mike/projects/LLM/mmproj-gemma-4-31B-F16.gguf’ srv load_model: initializing slots, n_slots = 1 no implementations specified for speculative decoding slot load_model: id 0 | task -1 | speculative decoding context not initialized slot load_model: id 0 | task -1 | new slot, n_ctx = 32768 srv load_model: prompt cache is enabled, size limit: 8192 MiB srv load_model: use
--cache-ram 0to disable the prompt cache srv load_model: for more info see https://github.com/ggml-org/llama.cpp/pull/16391 init: chat template, example_format: '<|turn>system <|think|>You are a helpful assistant<turn|> <|turn>user Hello<turn|> <|turn>model Hi there<turn|> <|turn>user How are you?<turn|> <|turn>model ’ srv init: init: chat template, thinking = 1 main: model loaded main: server is listening on http://127.0.0.1:8080 main: starting the main loop… srv update_slots: all slots are idlenvidia-smi Mon Apr 13 02:49:52 2026
±----------------------------------------------------------------------------------------+ | NVIDIA-SMI 580.126.20 Driver Version: 580.126.20 CUDA Version: 13.0 | ±----------------------------------------±-----------------------±---------------------+ | GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. | | | | MIG M. | |=========================================+========================+======================| | 0 NVIDIA GeForce RTX 4080 On | 00000000:24:00.0 On | N/A | | 35% 34C P2 33W / 250W | 14593MiB / 16376MiB | 1% Default | | | | N/A | ±----------------------------------------±-----------------------±---------------------+ | 1 NVIDIA GeForce RTX 5060 Ti On | 00000000:2D:00.0 Off | N/A | | 36% 35C P8 5W / 150W | 151MiB / 16311MiB | 0% Default | | | | N/A | ±----------------------------------------±-----------------------±---------------------+±----------------------------------------------------------------------------------------+ | Processes: | | GPU GI CI PID Type Process name GPU Memory | | ID ID Usage | |=========================================================================================| | 0 N/A N/A 1643 G /usr/lib/xorg/Xorg 152MiB | | 0 N/A N/A 2187 G coolercontrol 77MiB | | 0 N/A N/A 5809 G /usr/lib/firefox/firefox 185MiB | | 0 N/A N/A 38441 G /opt/LM-Studio/lm-studio 75MiB | | 0 N/A N/A 38557 C …lmstudio/.internal/utils/node 238MiB | | 0 N/A N/A 39372 C …/local/bin/llama-server-turbo 13780MiB | | 1 N/A N/A 1643 G /usr/lib/xorg/Xorg 4MiB | | 1 N/A N/A 38557 C …lmstudio/.internal/utils/node 128MiB | ±----------------------------------------------------------------------------------------+
LLAMA_SERVER=“/usr/local/bin/llama-server-turbo”
Gemma 4 31B на 4080 (CUDA0)
$LLAMA_SERVER
–model ~/projects/LLM/gemma-4-31B-it-UD-IQ3_XXS.gguf
–mmproj ~/projects/LLM/mmproj-gemma-4-31B-F16.gguf
–no-mmproj-offload
–port 8080
–device CUDA0
–ctx-size 32768
–reasoning-budget 0
–cache-type-k turbo3
–cache-type-v turbo3
–gpu-layers all
–threads 8
–threads-batch 8
–flash-attn auto
-np 1
nikulin_krd
12.04.2026 17:05Запустил через LmStudio на винде на rtx5080 и Ryzen 5950х c 64Гб DDR4 и подключил к Cursor через самописный бэкконнект-прокси gemma-4-26b-a4b.
Понравилось. Не шибко быстро, но результат очень даже на задаче по фронту.
sintech
12.04.2026 17:05Интересно, через сколько поколений модели обучатся делать идеальные крестики нолики и сортировки пузырьком?
Давайте тестить на минимально реальных задачах.
nikulin_krd
12.04.2026 17:05Дайте промт, я сделаю тест как есть)))
sintech
12.04.2026 17:05А какую вы квантизацию использовали для 26B? У меня на 5060 Ti 16 вполне нормально работала Q3_K_M. Я просил ее написать программу на языке Occam и она вполне успешно справилась, учтя особенности языка. А вот полная E4B модель вообще не ничего не знала про Occam, даже уточнения не помогли.
nikulin_krd
12.04.2026 17:05Q4_K_M. Сейчас нашел с TurboQuant IQ3_S попробую с ней.
jarkevithwlad
12.04.2026 17:05не нужно разводить дезинфу, турбоквант это тип сжатия контекста и к самой модели не относится
nikulin_krd
12.04.2026 17:05Если уж на то пошло, то не контекста, а KV-кэша и вполне себе относится к модели, вернее к ее квантизации и соответственно размеру....
jarkevithwlad
12.04.2026 17:05да сжатие KV кэша, причём можно K отдельно сжимать от V используя разные типы сжатия
пример –cache-type-k tbqp3 --cache-type-v tbq3 и модель тут не причём она может быть любой, хоть Q4_K_M или BF16
x4team_only
12.04.2026 17:05Интересно почему в опенкод или других cli gemma 4 не работает с файловой системой и не создает и не меняет файлы, то есть работает как чат? Подозреваю что не хватает системных промптов или скилов
x4team_only
12.04.2026 17:05Поделитесь пожалуйста, что за бэкконнект-прокси? Попробовал добавить в курсор, но почему то не видит модель, хотя залогинен, но подписки pro нет
nikulin_krd
12.04.2026 17:05Кстати, автор, Cursor с локальной моделью работать не умеет, ее надо выбрасывать наружу, чтобы он мог к ней подцепиться.
dmitrifriend Автор
12.04.2026 17:05Имеется в виду запуск не напрямую в Cursor, а через localhost.
nikulin_krd
12.04.2026 17:05Не может. Cursor у себя на серверах все делает.
dmitrifriend Автор
12.04.2026 17:05Ага, вижу: единственный выход – поднять промежуточный веб-сервер, тогда будет идти через локальное приложение Cursor → сервер Cursor → наш промежуточный веб-сервер → localhost-модель. Цепочка не очень удобная. Что ж, зато можно привинтить Roo Code или Cline!
nikulin_krd
12.04.2026 17:05Я сделал бэкконнект прокси себе. Скоро статью напишу
x4team_only
12.04.2026 17:05А смысл, gemma 4 (если не 31b), то это прям печаль с ней работать. Куча ошибок при операциях с файлами, почти всегда на длинном контексте зависает или подвисает на долго (видимо из-за кэша и удлинения контекста), даже с тем условием что опертивной памяти почти 10 гигов еще свободно. Пробовал разные
google/gemma-4-26b-a4b
unsloth/gemma-4... разных вариаций
Везде либо частично работает, либо при контекстном окне от 128к при 20-30% заполненности начинаются проблемы.
Для себя выявил лучшее окружение для запуска - pi.dev, по крайней мере при старте не засирается системными промптами и работает шустрее opencode/cursor/claude clinikulin_krd
12.04.2026 17:05На удивление в Cursor показала себя достаточно хорошо на простых задачах. Мне как глубоко-убежденному бэкэндеру всякий простенький админский фронт писать самое то. Только сначала запускать в режиме планирования, а потом уже запускать план в работу. Да! Не сильно быстро, но на своем железе и бесплатно(если не считать электричества)
Bobos
12.04.2026 17:05Когда только начинал разбираться с ллм, взял себе 3090 и немного расстроился. 30b модель влезает с 40к контекстом и ну прям тупенькая. Рассматривал вврианты второй карты через nvlink. В итоге не решился - слишком много заморочек с охлаждением, питанием. Но самое важное - 70b будет ну примерно такая же тупая, как и 30 на фоне облачных.
Так вот. Обсуждал эту тему с дипсиком. Мне очень понравился его ход мыслей - не гнаться за vram, а просто подождать годик-два. За это время качество моделей, способных уместиться в 24гб существенно вырастет, люди додумаются. Гемма похоже на правильном пути
jarkevithwlad
12.04.2026 17:05сейчас есть квопус 27b или оригинальный квен 3.5 27b и с турбоквантом влазит 256к контекста полностью в 24gb
Marwin
12.04.2026 17:05разве nvlink что-то даёт на десктопных картах? там вроде серверный довольно быстрый, а обычный - там что-то вроде единиц процентов преимущество относительно обычной переброски через PCI-ex. У меня две 3090 через PCI-ex. Сначала была одна... было так себе, приходилось подбирать каждый раз окно контекста. С двумя вообще перестал заморачиваться, да еще и эмбеддер влезает рядом (для моих задач он нужен одновременно запущенный). С недавних пор даже llama.cpp хорошо делит на две карты нагрузку.. не так как vllm но всё же неплохо. Но греются, да, спору нет, но опять же, можно уменьшить powerlimit... при 70% скорость почти не проседает.
А прогресс... мне кажется, что вот как раз он уже сильно приблизился после выхода квена 3.5 и gemma 4. И уже эти модели прям хорошо пашут на многих задачах локально. До них было сильно скучнее, согласен.
max0480
12.04.2026 17:05На ноутбуке с ryzan 4500, ОЗУ 16ГБ и GTX1650 стоит Gemma 4 E4B Instruct. Тяжко ей, некоторые запросы минут по 30-50 обрабатывает. DeepSeak через веб этот же запрос минуты за 2 обрабатывает.
krote
12.04.2026 17:05к сожалению GTX1650 крайне плохой вариант для LLM (у меня была 1660), там нет тензор-ядер, а с вычислениями в fp16 были проблемы (на момент что я с ней игрался и приходилось юзать флаг --no-half для генерации, что замедляло еще больше). Но я игрался с этой картой 2 года назад, на генерации изображений с SD1.5
Leviytip
12.04.2026 17:05Куча воды в тексте, написал сколько токена выходит, а на чем запуск нужно искать в этом морея где большая часть информации статистическая, которая раскидана по всему тексту, а не в конце + это все нейросетка писала, очень интересно читать ее длинные тексты
Ares_ekb
12.04.2026 17:05gemma4:31b-it-q4_K_M с ограничением контекста 64к токенов помещается в 24Гб на nvidia 4090. И вроде даже что-то осмысленное делает в Claude Code хотя и медленно. Но ощущение, что подписка на Claude пока ещё выгоднее
nikulin_krd
12.04.2026 17:0526b модель с 40к токенов на 5080 влезает + отжирает оперативу. В Cursor пишет долговато, но в целом норм
Sergik82
12.04.2026 17:05Загрузил Гемму и Квен. Гемма с 128К контекста не хочет работать. Квен без проблем запустилась. Грузил в лм студио. Просил написать скрипт на повершелл, который промониторит доступ к url и портам. Квен быстрее и лучше справилась. Про Квен тоже говорили что почти Опус догнали, но в моих задачах пока догонять и догонять.
vtal007
Был бы у меня "мак с 48 ГБ памяти", я б может и не женился бы :)
sintech
Вот именно, ждем подобных уплотнений, которые позволят моделям уместиться в «стандартные» 16 видеопамяти. С gemma-4 это возможно только на 26b-q3-m и урезанным контекстом. А мелкие gemma-4 довольно тупые.
normal
у меня 2-битная квантизация gemma-4-26B-A4B-GGUF загрузилась на 16мб macbook m4 air, но что-то lm-studio на уровне проста тупили или я чего-то не понимаю... на любой запрос пишет This message contains no content. The AI has nothing to say.
nikulin_krd
На HuggingFace есть gemma-4-26B-A4B с TurboQuant. Моделька 14Гб. Сейчас догрузится и попробую ее запустить
mdeblin
TurboQuant это алгоритм сжатия , модель не может быть с "TurboQuant" )
https://research.google/blog/turboquant-redefining-ai-efficiency-with-extreme-compression/
sergeym69
В чем проблема то, у меня на ноуте с RTX4060 8Gb вполне запускается Gemma-4-26b Q4_K_XL и дает 9tok/s генерации и 155tok/sec для промпта
На RTX3090 и обычном компе дает скорости в 10 раз больше.
Тут я так понимаю все хотят Mac c 48Gb, но по факту вы на нем большие модели не запустите, потому что 48Gb VRAM это конечно круто, но у вас НЕТ к этой VRAM дополнительной обычной памяти которая позволяет запустить большие MOE модели типа Qwen3.5-397B или MiniMax2.5 но который неплохо работают на двух RTX3090 + 256Gb RAM.
saag
Кофе подогреть на ноуте можно?:-)
sergeym69
Ваще ничего нельзя подогреть, ноут холодный, вы когда нибудь смотрели на сколько грузится проц в видео карте на MOE моделях ?
А у вас получается пожарить яцйо на аллюминиевой плоскости macbook во время рендеринга и расчетов ?
saag
Да хром может разогреть мой мак 12-го года:-)
alexandr93
Тут да... Вопрос с квантовкой и reasoning. На rtx 3060 gemma 4 Q8 выдаёт 18 токенов в секунду на старте, но проседает до 12 примерно к 30 000 токенам. Тот же qwen 3.5 в q8 выдаёт стабильные 15-22 токенов в секунду. И вот поэтому им и пользуюсь, что ответы от gemma существенно медленнее.
Как с такими скоростями генерировать много кода даже не знаю, потому что вроде советы и нормальные даёт, но качества кода всё равно не лучшее. Вот сказал, мол нагенерируй интеграционных тестов, покрой такие то тесты, вот примеры моих других интеграционных тестов, вот примеры тестовых данных... Он всё равно нагенерил мне юнит тестов. Что квен, что гемма)
Пытался из инструкции к культиватору понять как его обслуживать - загрузил в гемму 2 pdf файла: инструкция к самому культиватору и инструкция к двигателю. В сумме мегабайтов 5, но это заняло около 60 000 контекста и скорость просела до 4 токенов в секунду.. Учитывая, что там ещё есть reasoning....
Единственное, что нашёл для себя связку qwen 3.5 + gemma 4 в том плане, что квен тратит существенно меньше ресурсов для работы с большими контекстами, а гемма умнее. Поэтому квен можно использовать для подготовки ужатого контекста, а гемму для подготовки финального результата.
То есть как будто локальные модели развиваются, но простым смертным это не сильно доступно)
Sabin
31b в версии Q3_XS - Q3_M помещается впритык в 16 Гб с контекстом 24-32К с квантованием Q_4 и ubatch-size 256 выдаёт 10-15 токенов в секунду там где 26B выдавала около 50. Но я прям впритык использую видеопамять, чуть что-то ещё пару сотен Мб съест и скорость падает до 8-10 токенов
nikulin_krd
И без рассуждения. Что очень поганит модель. Или LMstudio не знает что можно на этих моделях включать рассуждение