Чемодан без ручки: как я бросил ChatGPT и перетащил AI к себе на компьютер

Вы когда-нибудь задумывались, куда уходят ваши промпты? Тот самый кусок кода с багом, который вы вставили в ChatGPT, или фрагмент внутреннего техзадания на новый фич. Они летят в облако, где их кто-то может прочитать, проанализировать, и — что самое неприятное — использовать. Паранойя? Возможно. Но после истории с Copilot-фишингом я перестал доверять облакам.

Год назад я был типичным пользователем: ChatGPT для общих вопросов, Claude для документов, GitHub Copilot для кода. Потом посчитал стоимость подписок и ужаснулся. Потом представил, что вся моя интеллектуальная собственность плавает где-то в дата-центрах Калифорнии. И решил: хватит.

Цель была простая: перенести весь AI-воркфлоу к себе. На свой компьютер. Без интернета. Без ежемесячных платежей. Без шансов на утечку.

Звучит как маниакальная идея параноика? Может быть. Но после шести месяцев жизни в этом режиме я понял: это не только безопаснее. Это еще и эффективнее.

Почему ChatGPT для кода — это иллюзия

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

В реальности ChatGPT просто угадывает следующие слова. Он не понимает архитектуру, не отлаживает код, не думает о масштабировании. Как мы разбирали в статье про AI-кодинг-агентов, настоящий агент — это система с планированием, памятью и инструментами. ChatGPT — просто болтливый текстовый генератор.

Для локального использования это даже плюс. Нам не нужен супер-интеллект. Нам нужно:

• Дополнять код (как Tabnine)
• Объяснять куски чужого кода
• Генерировать простые функции
• Помогать с документацией
• Отвечать на технические вопросы

Для этого хватит модели размером 7-13 миллиардов параметров. И вот здесь начинается магия локального AI.

Ollama: Docker для языковых моделей

Если бы я попытался установить все модели вручную — скачать веса, настроить преобразования, разобраться с квантованием — я бы сошел с ума через неделю. К счастью, есть Ollama.

Представьте Docker, но для LLM. Одна команда — и у вас работает модель. Еще одна команда — сменили модель. Все веса качаются автоматически, конфигурация создается сама, API сразу готов к работе.

1 Установка и базовая настройка

Все начинается с одной команды. На Linux или macOS:

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

На Windows — скачиваете установщик с сайта. Через 2 минуты у вас работает демон ollama, который слушает на localhost:11434.

Проверяем:

ollama --version
# ollama version 0.1.27

Теперь самое интересное — выбор моделей.

Модели: не гонитесь за размером

Самая частая ошибка новичков — скачать самую большую модель. «Возьму-ка Llama 3 70B, раз уж перехожу на локальный AI». А потом удивляются, почему ответ генерируется 2 минуты, а вентилятор ноутбука взлетает в космос.

Вот мой стек после месяцев экспериментов:

Все модели в q4 формате — это квантование до 4 бит. Потери качества минимальные (1-3%), зато модель занимает в 4 раза меньше памяти. Для локального использования — идеально.

Устанавливаем первую модель:

ollama pull codeqwen:7b

Ollama сам скачает оптимальную версию (обычно q4). Ждем 5-10 минут в зависимости от скорости интернета. Готово? Запускаем:

ollama run codeqwen:7b

Вы в интерактивном чате с моделью! Можно спрашивать что угодно. Но так никто не работает.

2 Интеграция в редактор кода

Писать код в консоли — это прошлый век. Нам нужно, чтобы модель работала прямо в VS Code или любой другой IDE. Есть два пути:

Первый — через расширение Continue. Это open-source аналог Cursor, который умеет работать с локальными моделями.

Устанавливаем расширение в VS Code, открываем конфигурацию (~/.continue/config.json):

{
  "models": [
    {
      "title": "Local CodeQwen",
      "provider": "ollama",
      "model": "codeqwen:7b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Local Autocomplete",
    "provider": "ollama",
    "model": "codeqwen:7b",
    "apiBase": "http://localhost:11434"
  }
}

Теперь у вас в редакторе работает автодополнение (как в Copilot) и чат с моделью (Ctrl+I). Все локально. Все приватно.

Второй путь — через API. Ollama предоставляет REST API, совместимый с OpenAI. Это значит, что любая тулза, которая умеет в OpenAI API, может работать с вашей локальной моделью.

Пример простого Python-скрипта:

import requests
import json

def ask_llama(prompt):
    response = requests.post(
        'http://localhost:11434/api/generate',
        json={
            'model': 'llama3.2:3b',
            'prompt': prompt,
            'stream': False
        }
    )
    return response.json()['response']

# Использование
answer = ask_llama("Объясни рекурсию на примере Python")
print(answer)

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

Рабочий процесс: как я теперь работаю

Вот типичный день с локальным AI:

1. Утро. Запускаю Ollama демон. Он тихо работает в фоне, потребляя ~200 МБ оперативки.
2. Пишу код. В VS Code работает автодополнение от CodeQwen. Оно менее навязчивое, чем Copilot, но более точное для Python и Go.
3. Встречаю непонятный код. Выделяю, жму Ctrl+I, спрашиваю: «Что делает эта функция?». Модель объясняет прямо в редакторе.
4. Нужно написать документацию. Переключаюсь на модель Qwen 2.5 (у нее лучше с текстом), генерирую описание API.
5. Вечером — разбор почты. Скрипт на Python с использованием Ollama API сортирует письма, выделяет важное, предлагает ответы.

Все. Ни одного запроса в облако. Ни одного промпта, улетевшего в OpenAI.

Где локальные модели проигрывают (и это нормально)

Не будем обманывать себя. Есть задачи, где GPT-4 все еще король:

• Сложный reasoning. Многошаговые логические задачи, где нужно держать в голове десятки переменных.
• Творческое письмо. Романы, длинные статьи, сложные метафоры — у локальных моделей пока не хватает «воображения».
• Специализированные знания. Последние события, свежие исследования — локальные модели заморожены на моменте своего обучения.

Но вот что интересно: для 80% моих рабочих задач хватает локальных моделей. А для остальных 20%... Я просто иду в ChatGPT. Но теперь это осознанный выбор, а не дефолтный вариант.

Как в том исследовании про рабочие привычки в 2025 — люди используют AI выборочно, а не по дефолту.

3 Продвинутые фишки: контекст, темперамент, система

Ollama поддерживает системные промпты — как в ChatGPT, где вы можете задать роль модели. Это мощнейший инструмент.

Создаем файл Modelfile для нашей модели:

FROM codeqwen:7b

# Системный промпт
SYSTEM """
Ты — Senior Python разработчик с 10 годами опыта.
Твой стиль кода: чистый, документированный, с type hints.
Ты всегда предлагаешь несколько вариантов решения.
Ты объясняешь свои решения кратко, но по делу.
Ты не генерируешь небезопасный код.
"""

# Параметры генерации
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

Создаем кастомную модель:

ollama create my-coder -f ./Modelfile
ollama run my-coder

Теперь у вас персональный ассистент, заточенный под ваш стиль. Хотите более креативного? Увеличьте temperature. Нужна точность — уменьшите.

Кстати, про темперамент. В ChatGPT появились настройки Warmth и Enthusiasm, о которых мы писали в отдельном гиде. В Ollama такого нет, но temperature и top_p дают похожий контроль.

А что с железом? Сколько нужно RAM?

Самый частый вопрос. Ответ: меньше, чем вы думаете.

У меня MacBook Pro M1 с 16 ГБ — идеально для 7B моделей. Если у вас слабее железо — начните с Llama 3.2 3B. Она удивительно умная для своего размера.

Для тех, у кого есть видеокарта, Ollama автоматически использует GPU через CUDA (NVIDIA) или Metal (Apple Silicon). Просто установите, все заработает само.

Ошибки, которые сломают ваш workflow

За полгода я наступил на все грабли. Вот топ-5 ошибок, которые совершают все:

1. Ставить самую большую модель. Начинайте с малого. 3B → 7B → 13B. Не прыгайте сразу на 70B.
2. Ждать облачной скорости. Локальные модели медленнее. Привыкайте. Или купите видеокарту.
3. Использовать одну модель для всего. Разные задачи — разные модели. Код, текст, чат — у каждой свои специалисты.
4. Забывать про системные промпты. Без них модель как дикий зверь. С ними — как обученный ассистент.
5. Не настраивать температуру. Temperature 0.1 для кода, 0.7 для креативных задач, 1.0 для мозгового штурма.

Еще одна ошибка — пытаться полностью воспроизвести ChatGPT. Не нужно. Локальные модели — другой инструмент. У них другие сильные стороны.

Что дальше? Будущее локального AI

Через полгода после перехода я понял: это не временный эксперимент. Это новая норма.

Модели становятся лучше с каждым месяцем. Llama 3.2 3B умнее, чем Llama 2 7B год назад. CodeQwen почти догнал CodeLlama по качеству, но в два раза меньше.

Следующий шаг — мультимодальность. Уже сейчас есть LLaVA, которая понимает картинки. Через год, возможно, у нас будут локальные модели, которые анализируют скриншоты интерфейсов и предлагают улучшения.

Но главное — контроль. Когда модель работает у вас, вы решаете, что с ней делать. Обучить на вашем коде? Пожалуйста. Интегрировать с внутренней базой знаний? Да без проблем. Как в том гайде про локального голосового ассистента с n8n, только для кода.

И последнее. После перехода я заметил странный эффект: стал лучше формулировать промпты. Когда знаешь, что модель ограничена, учишься задавать точные вопросы. Это как разговор с младшим разработчиком — нужно объяснять четко, по шагам.

Может, в этом и есть смысл. Не в том, чтобы получить идеальный ответ с первой попытки. А в том, чтобы научиться правильно задавать вопросы. Даже если отвечает не супер-интеллект, а просто полезный инструмент у вас на компьютере.