Запускаем Claude Code локально с GLM-4.7 Flash: полный гайд с Docker и автовыгрузкой VRAM

Зачем это вообще нужно?

Три причины, почему я перешел с облачных API на локальный сервер:

• Конфиденциальность: весь код остается на моих серверах. Никаких логов в облаке у Anthropic или других провайдеров
• Экономия: после первоначальных вложений в железо месячные расходы — только электричество. Для команды из 5 разработчиков экономия $1000+ в месяц
• Контроль: сам настраиваю параметры генерации, контекст, скорость. Никаких лимитов от провайдера

Железо: что реально нужно в 2026 году

Забудьте про рекомендации "2x A100 80GB". На практике для GLM-4.7-Flash в формате Q4_K_M GGUF хватит:

Лично я использую RTX 4090 для разработки и тестирования. Для продакшена — 2x RTX 3090. Разница в скорости заметна, но для интерактивной работы с кодом даже 20 токенов в секунду достаточно. Если нужно больше — смотрите в сторону vLLM с несколькими картами.

Подготовка: что скачиваем и устанавливаем

1 Скачиваем модель GLM-4.7-Flash-GGUF

На 22.01.2026 самая стабильная версия — от unsloth. Квантование Q4_K_M дает оптимальный баланс качества и размера:

# Создаем директорию для моделей
mkdir -p ~/models/glm-4.7-flash
cd ~/models/glm-4.7-flash

# Скачиваем модель (примерно 8.5 GB)
wget https://huggingface.co/unsloth/GLM-4.7-Flash-GGUF/resolve/main/GLM-4.7-Flash.Q4_K_M.gguf

# Альтернативно через git lfs (если wget тормозит)
git lfs install
git clone https://huggingface.co/unsloth/GLM-4.7-Flash-GGUF

2 Устанавливаем Docker и NVIDIA Container Toolkit

# Для Ubuntu/Debian
sudo apt-get update
sudo apt-get install -y docker.io docker-compose

# Добавляем пользователя в группу docker
sudo usermod -aG docker $USER
newgrp docker

# Устанавливаем NVIDIA Container Toolkit
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

Проверяем, что Docker видит GPU:

docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi

Запускаем llama.cpp server в Docker

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

# Создаем docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  llama-server:
    image: ghcr.io/ggerganov/llama.cpp:server-latest
    container_name: glm-4.7-server
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    volumes:
      - /home/$USER/models/glm-4.7-flash:/models
    ports:
      - "8080:8080"
    command: [
      "--model", "/models/GLM-4.7-Flash.Q4_K_M.gguf",
      "--host", "0.0.0.0",
      "--port", "8080",
      "--ctx-size", "131072",
      "--batch-size", "512",
      "--ubatch-size", "512",
      "--parallel", "1",
      "--cont-batching",
      "--mlock",
      "--n-gpu-layers", "99",
      "--temp", "0.1",
      "--top-p", "0.95",
      "--repeat-penalty", "1.1",
      "--no-display-prompt",
      "--log-format", "json",
      "--sleep-idle-seconds", "300"
    ]
EOF

Теперь запускаем:

docker-compose up -d

# Смотрим логи
docker logs -f glm-4.7-server

Разбираем ключевые параметры

Почему именно такие настройки? Давайте по пунктам:

Автовыгрузка VRAM: как это работает

Параметр --sleep-idle-seconds 300 — главное преимущество этой настройки. После 5 минут без запросов llama.cpp:

1. Выгружает модель из VRAM
2. Освобождает память для других задач (игры, рендеринг, другие модели)
3. При новом запросе — загружает модель обратно (занимает 15-30 секунд)

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

Тестируем API

Сервер запущен на порту 8080. Проверяем:

# Проверка здоровья
curl http://localhost:8080/health

# Простой запрос
curl http://localhost:8080/completion -H "Content-Type: application/json" -d '{
  "prompt": "Напиши функцию на Python для сложения двух чисел",
  "temperature": 0.1,
  "top_p": 0.95,
  "max_tokens": 500
}'

Для совместимости с Claude Code используем OpenAI-совместимый endpoint:

# Chat completion endpoint (OpenAI compatible)
curl http://localhost:8080/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "GLM-4.7-Flash",
  "messages": [
    {"role": "system", "content": "Ты — опытный программист, помогающий писать код."},
    {"role": "user", "content": "Напиши функцию на Python для парсинга JSON файла"}
  ],
  "temperature": 0.1,
  "max_tokens": 1000
}'

Интеграция с Claude Code и другими IDE

В Claude Code (или Cursor, или любом другом редакторе с поддержкой OpenAI API) меняем настройки:

{
  "baseUrl": "http://ваш-сервер:8080/v1",
  "apiKey": "sk-not-needed",
  "model": "GLM-4.7-Flash",
  "temperature": 0.1,
  "maxTokens": 4000
}

Теперь все запросы из IDE идут на ваш локальный сервер. Полная замена Claude API за 0 рублей в месяц.

Частые ошибки и решения

Ошибка: "CUDA out of memory" при запуске

Решение: уменьшаем --n-gpu-layers. Начните с 40, постепенно увеличивайте:

# Проверяем свободную память перед запуском
nvidia-smi

# Если мало памяти, уменьшаем слои на GPU
--n-gpu-layers 40  # вместо 99

Ошибка: медленная загрузка после автовыгрузки

Решение: используйте NVMe SSD для хранения моделей. Разница между HDD и NVMe — 3-5 раз в скорости загрузки. Также помогает --mlock.

Ошибка: "Model failed to load"

Решение: проверьте путь к модели и права доступа. В Docker контейнер должен иметь доступ к файлу:

# Даем права
sudo chmod 644 ~/models/glm-4.7-flash/*.gguf

# Проверяем, что файл существует в контейнере
docker exec glm-4.7-server ls -la /models/

Проблема: модель зацикливается при генерации кода

Решение: увеличиваем --repeat-penalty до 1.2-1.3. Если не помогает — добавляем стоп-токены:

--repeat-penalty 1.3
--repeat-last-n 64
--stop "\n\n\n"  # Три переноса строки как стоп-сигнал

Производительность: что можно улучшить

Если 20-30 токенов в секунду мало:

1. Используйте более агрессивное квантование: Q3_K_S вместо Q4_K_M. Скорость вырастет на 30-40%, качество упадет незначительно
2. Увеличьте batch size: если обрабатываете несколько запросов параллельно, поднимите --batch-size до 1024 или 2048
3. Рассмотрите TensorRT-LLM: для NVIDIA карт дает прирост 2-3x, но сложнее в настройке
4. Добавьте вторую карту: 2x RTX 3090 через NVLink почти удваивает скорость

Мониторинг и логирование

Для продакшена добавьте мониторинг:

# Создаем docker-compose.monitoring.yml
cat > docker-compose.monitoring.yml << 'EOF'
version: '3.8'

services:
  llama-server:
    # ... предыдущая конфигурация ...
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  prometheus-exporter:
    image: ghcr.io/ricoberger/llama.cpp-exporter:latest
    ports:
      - "9091:9091"
    environment:
      - LLAMA_SERVER_URL=http://llama-server:8080
      - SCRAPE_INTERVAL=15s
    depends_on:
      - llama-server
EOF

Теперь у вас есть метрики в Prometheus и можно настраивать алерты на падение сервиса.

Что дальше? Эволюция локальных моделей

На 22.01.2026 мы видим тренд: качество локальных моделей догоняет облачные. GLM-4.7-Flash — не предел. В разработке:

• GLM-5 с контекстом 256k и улучшенным пониманием кода
• Специализированные кодогенераторы на 3-7B параметрах, которые работают быстрее при сравнимом качестве
• Аппаратные ускорители от NVIDIA, AMD и китайских производителей

Мой прогноз: к концу 2026 года локальный запуск моделей уровня GPT-4 будет доступен на картах за $1000. Провайдеры облачных API либо сильно снизят цены, либо умрут.

А пока — настраивайте GLM-4.7-Flash, экономьте тысячи долларов в месяц и не зависьте от капризов облачных провайдеров. Код должен генерироваться там, где он выполняется.