Приватный перевод кода на локальной LLM: Полный гайд по настройке Ollama + Neovim

Код не должен утекать в облака

Представьте ситуацию: у вас есть legacy-проект на COBOL, который нужно переписать на Python. Или китайский код от подрядчика, который нужно понять. Или просто старый код на Java, который нужно перевести на Go для нового микросервиса.

Первая мысль - скопировать кусок в ChatGPT или GitHub Copilot. И это будет ошибкой.

Решение? Локальная LLM. Но не просто локальная, а настроенная специально для перевода кода. И не через веб-интерфейс, а прямо в редакторе.

Почему translategemma:4b, а не обычная модель

Когда я впервые попробовал переводить код на обычной Llama 3.1, результат был... странным. Модель пыталась объяснить код, пересказать его, добавить комментарии. Но не перевести.

Потом появилась translategemma:4b - специализированная версия Gemma 2B, дообученная именно на переводе кода. Разработчики из Google Research взяли миллионы пар кода на разных языках и научили модель не просто понимать синтаксис, а преобразовывать его.

На февраль 2026 года это самая точная модель для перевода кода среди локальных вариантов. 4 миллиарда параметров - достаточно для понимания контекста, но мало для работы на слабом железе.

Стек, который работает (а не просто выглядит круто)

Я перепробовал десяток комбинаций. LM Studio с расширениями для VS Code, отдельные TUI-приложения, веб-интерфейсы. Все они требуют переключения контекста. Копировать код из редактора, вставлять в другое окно, ждать ответ, копировать обратно.

Это убивает продуктивность.

Идеальный стек выглядит так:

• Ollama - самый стабильный способ запуска локальных моделей в 2026 году. Проще, чем llama.cpp, надежнее, чем vLLM для десктопного использования.
• translategemma:4b - специализированная модель для перевода кода
• Neovim с плагином nvim-llama - потому что все должно работать в одном окне, без переключений

Если вы предпочитаете VS Code, у нас есть отдельный гайд по LMStudio-Ollama. Но Neovim дает больше контроля и работает быстрее.

Шаг за шагом: от нуля до работающего перевода

1 Устанавливаем Ollama

На февраль 2026 года актуальная версия - Ollama 0.5.0. Установка на Linux:

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

На macOS через Homebrew:

brew install ollama

После установки запускаем сервис:

ollama serve &

2 Качаем translategemma:4b

Модель весит около 2.5 ГБ. Скачиваем:

ollama pull translategemma:4b

Ждем. Заварите кофе - на средней скорости интернета займет 10-15 минут.

Проверяем, что модель загрузилась:

ollama list

Должны увидеть что-то вроде:

NAME                ID              SIZE    MODIFIED
translategemma:4b   sha256:...      2.5 GB  2 minutes ago

3 Настраиваем Neovim (версия 0.11+ обязательна)

Если у вас старый Neovim - обновите. Критически важные изменения в API появились в 0.10, а в 0.11 стабилизировались.

Устанавливаем менеджер плагинов. Я использую lazy.nvim, но подойдет любой. В lazy.nvim конфиг выглядит так:

return {
  {
    "james1236/nvim-llama",
    config = function()
      require("nvim-llama").setup({
        model = "translategemma:4b",
        endpoint = "http://localhost:11434",
        context_lines = 10,
        max_tokens = 2048,
      })
    end,
  },
}

Ключевые параметры:

• context_lines: 10 - сколько строк контекста вокруг выделенного кода отправлять модели. Для перевода кода нужно больше контекста, чем для обычных запросов.
• max_tokens: 2048 - максимальная длина ответа. translategemma иногда генерирует много пояснений, этот лимит ее ограничивает.

4 Настраиваем горячие клавиши

Без удобных хоткеев весь смысл теряется. Добавляем в конфиг Neovim:

vim.keymap.set("v", "ct", ":lua require('nvim-llama').translate_code()",
  { desc = "Translate selected code" })

vim.keymap.set("n", "ct", ":lua require('nvim-llama').translate_code()",
  { desc = "Translate current line" })

Теперь выделяете код в визуальном режиме, жмете \ct (leader + c + t) и получаете перевод.

Как это выглядит на практике

Допустим, у вас есть старый код на Python 2:

# legacy_code.py
import urllib2

def fetch_data(url):
    try:
        response = urllib2.urlopen(url)
        data = response.read()
        return data
    except urllib2.URLError as e:
        print "Error fetching URL:", e
        return None

Выделяете весь файл, жмете \ct. Через 5-10 секунд (зависит от железа) получаете:

# legacy_code.py - translated to Python 3
import urllib.request
import urllib.error

def fetch_data(url):
    try:
        response = urllib.request.urlopen(url)
        data = response.read()
        return data
    except urllib.error.URLError as e:
        print(f"Error fetching URL: {e}")
        return None

Модель не просто заменила импорты. Она:

1. Добавила недостающий импорт urllib.error
2. Заменила urllib2.URLError на urllib.error.URLError
3. Преобразовала старый print в f-строку (Python 3.6+)
4. Сохранила комментарий, добавив пометку о переводе

Где translategemma спотыкается (и как помочь)

Модель не идеальна. Особенно страдает с:

Самая частая ошибка - пытаться перевести сразу 500 строк кода. Модель теряет контекст, начинает галлюцинировать. Оптимальный размер - 50-100 строк за раз.

Производительность: что нужно для комфортной работы

translategemma:4b - не самая тяжелая модель, но и не легкая. Минимальные требования:

• 16 ГБ ОЗУ (модель займет ~3 ГБ, плюс нужно место для контекста)
• 4-ядерный CPU (желательно с поддержкой AVX2)
• SSD (модель загружается с диска при первом запросе)

С такой конфигурацией перевод 50 строк кода занимает 5-15 секунд. Если нужно быстрее - можно попробовать квантованную версию модели (например, через llama.cpp), но точность упадет на 10-15%.

Альтернативы: когда translategemma не подходит

Иногда нужно не просто перевести код, а полностью переписать его с изменением архитектуры. Например, перевести монолит на микросервисы.

Здесь translategemma бесполезна. Нужна модель, которая понимает архитектурные паттерны. Я пробовал:

• CodeLlama 13B - понимает структуру лучше, но медленнее и требует больше памяти
• DeepSeek-Coder 6.7B - хорош для рефакторинга, но слабее в переводе между языками
• Qwen2.5-Coder 7B - баланс между скоростью и качеством

Для сложных задач я держу несколько моделей в Ollama и переключаюсь между ними. Настройка nvim-llama позволяет указать модель прямо в запросе:

:lua require('nvim-llama').ask("Translate this to Rust", {model = "codellama:13b"})

Безопасность: что на самом деле остается локальным

Главный вопрос: а точно ли все локально? Проверяем:

1. Ollama по умолчанию слушает только localhost (порт 11434)
2. Модели скачиваются с официального репозитория, можно проверить хэши
3. Никаких телеметрии в базовой версии (в отличие от некоторых коммерческих решений)
4. Весь код обрабатывается в памяти, на диск не пишется

Но есть нюанс: если вы используете облачный Neovim (например, через SSH на удаленный сервер), то код передается по сети. Убедитесь, что соединение зашифровано.

Что будет дальше: прогноз на 2027

Сейчас мы в ранней стадии локализации AI для разработки. К концу 2026-началу 2027 я ожидаю:

• Специализированные модели для перевода между конкретными парами языков (Python→Rust, Java→Go)
• Встроенную поддержку перевода кода в основных IDE без плагинов
• Модели размером 1-2B с качеством сегодняшних 7B-моделей (благодаря улучшениям в архитектуре)
• Автоматическое определение контекста - модель будет сама понимать, какой фрагмент кода нужно перевести целиком

Но главный тренд - не в улучшении моделей, а в упрощении workflow. Сейчас нужно слишком много шагов. В идеале должно быть: открыл файл, выделил код, получил перевод. Без установки, без настройки, без ожидания.

Пока этого нет, наш стек - лучшее, что есть на рынке. Не идеальное, но работающее. И что важно - приватное.

Код остается вашим. Всегда.