OpenClaw + Ollama: Суверенный вайбкодинг. Полный курс (2026)

Манифест суверенного кодера

Ты держишь в руках не просто курс. Ты держишь альтернативный путь. Путь, где твой код, твои данные, твои мысли — никогда не покидают пределы твоей машины. Где нет подписок, нет облаков, нет чужих серверов, хранящих твои промпты.

Этот курс — о свободе через локальность. О том, как стать хозяином своего инструмента, а не арендатором.

🏠 Локальность

Всё работает на твоём железе. Никаких API-ключей. Никаких облаков. Никаких зависимостей от интернета.

🔒 Приватность

Твои промпты, твой код, твои данные — никогда не покидают твою машину. Даже если ты работаешь с коммерческой тайной.

🛠 Контроль

Ты выбираешь модель. Ты выбираешь квантизацию. Ты выбираешь, когда и как она работает. Ты — хозяин.

💰 Экономия

Никаких $20/мес. Никаких лимитов токенов. Один раз настроил — пользуешься сколько угодно.

Но помни: свобода — это ответственность. Локальные модели слабее облачных. Они требуют больше понимания. Они не прощают ленивых промптов. Готов ли ты платить за суверенитет ценой более глубокого понимания?

Методология курса

Этот курс построен на сократическом методе. Мы не будем «закачивать» в тебя информацию — мы будем извлекать понимание через вопросы, практику и рефлексию.

Каждая глава состоит из трёх частей:

1. Теория (вопрос)

Мы начинаем с вопроса, а не с ответа. Ты думаешь, прежде чем читать.

2. Практика (действие)

Ты делаешь руками. Без действий знание мертво.

3. Осознание (рефлексия)

Ты смотришь на результат и задаёшь себе вопросы. Здесь рождается мудрость.

Заведи журнал. Бумажный или в Obsidian — неважно. Важно, чтобы ты записывал свои ответы на рефлексивные вопросы. Без журнала курс превратится в чтение. С журналом — в трансформацию.

📋 Полный план курса

Ниже — все темы, которые мы пройдём. Каждая раскрывается в соответствующем модуле с практикой и рефлексией.

• Философия локальности: суверенитет vs облако
• Знакомство с OpenClaw и Ollama
• Установка Ollama: первая модель, квантизация
• Установка OpenClaw: подключение к Ollama
• Первая задача: от промпта до кода
• Дисциплина промпта для локальных моделей
• CLAUDE.md как контракт с агентом
• Few-shot промптинг и Chain-of-Thought
• Зоопарк моделей: qwen, deepseek, llama, phi
• Квантизация и VRAM: искусство компромиссов
• Модели под задачи: код, рассуждения, креатив
• MCP-серверы: локальные инструменты
• Суб-агенты и параллельные воркфлоу
• Файнтюн: когда стандартной модели мало
• Оптимизация: выжимаем максимум из железа
• Границы локального: что OpenClaw+Ollama НЕ могут
• Инженерия ПО в эпоху локального ИИ
• Суверенитет как философия
• Бонус: Топ локальных MCP-серверов
• Бонус: 7 способов обойти блокировки
• Бонус: Анатомия папки .openclaw/
• Бонус: 10 slash-команд OpenClaw

Модуль 0. Философия локальности: прежде чем трогать клавиатуру

Глава 0.1. Почему локальность — это не компромисс, а выбор Представь, что у тебя есть два повара. Один — гениальный шеф в мишленовском ресторане, но ты должен приносить ему все свои рецепты, и он может их запомнить и рассказать другим. Второй — похуже, но он готовит у тебя дома, на твоей кухне, и никогда ничего не выносит наружу. Кого ты выберешь, если готовишь семейный секретный рецепт?

В мире LLM есть два пути:

• Облачный путь (Claude, GPT, Gemini): мощь, удобство, но твои данные уходят на чужие серверы. Ты платишь подписку. Ты зависишь от интернета.
• Локальный путь (Ollama + OpenClaw): меньше мощь, больше настройки, но полный контроль. Твои данные — только твои. Один раз настроил — пользуешься вечно.

Критерий Облако (Claude Code) Локально (OpenClaw + Ollama) Качество рассуждений⭐⭐⭐⭐⭐⭐⭐⭐ (зависит от модели) Приватность⭐⭐⭐⭐⭐⭐⭐ Стоимость$20-200/месТолько электричество Зависимость от сетиПолнаяНикакой КонтрольМинимальныйПолный Требует железаНетДа (GPU/RAM) Локальный путь — это не «хуже». Это иначе. Ты меняешь часть качества на полный суверенитет. Вопрос не «что лучше», а «что подходит именно тебе и именно сейчас».

Упражнение «Карта суверенитета»

Возьми лист бумаги. Ответь письменно:

1. Какие данные ты обрабатываешь в работе? (Код клиентов? Личные заметки? Коммерческая логика?)
2. Готов ли ты отправлять эти данные в облако? Если да — то в какое? Если нет — почему?
3. Что для тебя важнее: максимальное качество или полный контроль? Где проходит твоя личная граница?
4. Какое железо у тебя есть? (GPU, RAM, диск.) Готов ли ты инвестировать в апгрейд ради локальности?

Осознание результата

• Когда ты писал ответы — что тебя удивило? Какие свои приоритеты ты увидел впервые?
• Есть ли противоречие между тем, что ты хочешь (качество), и тем, что ты готов отдать (контроль)? Как ты будешь это разрешать?
• Готов ли ты принять, что локальные модели будут ошибаться чаще? Что это значит для твоего рабочего процесса?
• Почему ты выбрал этот курс — из любопытства или из убеждения? Разница важна.

Запиши в журнал одну фразу: «Я выбираю локальность, потому что...» Это твоя «точка А». К ней мы вернёмся в конце. Глава 0.2. Знакомство с героями: OpenClaw и Ollama Прежде чем мы начнём — кто наши герои? Ollama — это «двигатель», который запускает LLM на твоём железе. OpenClaw — это «руки», которые дают модели доступ к твоей файловой системе и терминалу. Вместе они — локальный аналог Claude Code. Но что они на самом деле?

Ollama — это open-source runtime для локальных LLM. Он:

• скачивает модели в формате GGUF (квантизированные),
• запускает их на CPU или GPU (NVIDIA, AMD, Apple Silicon),
• предоставляет единый API (совместимый с OpenAI),
• управляет несколькими моделями одновременно,
• работает полностью оффлайн после первой загрузки.

OpenClaw — это open-source CLI-агент для кодинга, вдохновлённый Claude Code. Он:

• читает файлы в твоей директории,
• создаёт и редактирует код,
• исполняет команды в терминале,
• поддерживает MCP-серверы,
• может работать с любым OpenAI-совместимым API — включая Ollama.

Ollama — это мозг. OpenClaw — это тело. Мозг без тела не может действовать. Тело без мозга не может думать. Вместе — они локальный агент. В отличие от облачных аналогов, здесь всё открыто. Ты можешь читать исходный код. Можешь модифицировать. Можешь понять, как всё работает. Это не чёрный ящик — это прозрачная машина.

Исследование репозиториев

1. Открой GitHub-репозиторий Ollama (ollama/ollama). Прочитай README. Найди ответы:
   • Какие модели поддерживаются?
   • Какие системные требования?
   • Как устроена архитектура?
2. Открой репозиторий OpenClaw. Прочитай README. Найди ответы:
   • Чем он отличается от Claude Code?
   • Какие LLM-провайдеры поддерживает?
   • Как настраивается работа с Ollama?
3. Запиши три вещи, которые тебя удивили в каждом проекте.

Осознание результата

• Что тебе понравилось в философии этих проектов? Что — насторожило?
• Понимаешь ли ты теперь, как они связаны? Можешь ли объяснить это другу за минуту?
• Готов ли ты читать исходный код, если что-то пойдёт не так? Или ты ожидаешь «готового продукта»?
• Как чтение документации изменило твои ожидания от курса?

Модуль 1. Установка и первая встреча с локальным агентом

Глава 1.1. Ollama: установка и первая модель Ты устанавливал сотни программ. Но задавал ли ты себе вопрос: что на самом деле происходит, когда ты «скачиваешь модель»? Это не просто файл. Это миллиарды параметров, сжатых в несколько гигабайт. Это — чужой интеллект, упакованный для твоего железа.

Ollama работает с моделями в формате GGUF — это квантизированные версии моделей. Квантизация — это сжатие весов модели с потерей точности, но с выигрышем в размере и скорости.

Основные уровни квантизации:

• Q4_K_M — 4-бит, хорошее соотношение качество/размер. Самый популярный.
• Q5_K_M — 5-бит, чуть лучше, чуть больше.
• Q8_0 — 8-бит, близко к оригиналу, но требует много RAM.
• Q2_K / Q3_K — сильное сжатие, заметно хуже качество.

Выбор квантизации — это компромисс между качеством и ресурсами. Чем меньше бит — тем быстрее и меньше памяти, но тем глупее модель. Нет «правильного» выбора — есть выбор под твои задачи и железо.

Пошаговая установка Ollama

1. Установи Ollama.
   • macOS / Linux: curl -fsSL https://ollama.com/install.sh | sh
   • Windows: скачай установщик с ollama.com/download
2. Проверь, что Ollama работает: ollama --version
3. Скачай первую модель. Начнём с небольшой — qwen2.5-coder:7b (специально для кода, ~4.7 ГБ): ollama pull qwen2.5-coder:7b
4. Запусти модель и пообщайся: ollama run qwen2.5-coder:7b

   Попробуй простой промпт: Напиши функцию на Python, которая считает факториал.

5. Посмотри доступные модели: ollama list
6. Проверь, что Ollama отдаёт API (это важно для OpenClaw): curl http://localhost:11434/api/tags

Если у тебя нет дискретной GPU — модель будет работать на CPU. Это медленно. Для комфортной работы нужны: NVIDIA GPU с 8+ ГБ VRAM, или Apple Silicon с 16+ ГБ unified memory, или AMD GPU с ROCm.

Осознание результата

• Когда модель впервые ответила на твой промпт — что ты почувствовал? Это было «волшебство» или «инженерия»?
• Сравни качество ответа с тем, что дал бы Claude или GPT. Честно: где разница? В чём она?
• Понимаешь ли ты теперь, что такое «квантизация»? Можешь ли объяснить это другу?
• Готов ли ты работать с моделью, которая слабее облачной? Что это значит для твоих ожиданий?

Глава 1.2. OpenClaw: установка и подключение к Ollama У тебя есть мозг (Ollama). Теперь дадим ему тело (OpenClaw). Но прежде чем подключать — спроси себя: доверяешь ли ты этому телу? Оно будет читать твои файлы, писать код, исполнять команды.

OpenClaw — это CLI-агент, который:

• подключается к любому OpenAI-совместимому API (включая Ollama),
• даёт модели инструменты для работы с файловой системой,
• исполняет команды в терминале,
• поддерживает MCP-серверы,
• работает полностью локально.

В облачном Claude Code модель — это данность. В OpenClaw + Ollama модель — это твой выбор. И этот выбор — часть инженерной работы.

Пошаговая установка OpenClaw

1. Убедись, что у тебя Node.js 18+: node --version
2. Установи OpenClaw глобально: npm install -g @openclaw/cli
3. Создай рабочую директорию: mkdir ~/openclaw-lab && cd ~/openclaw-lab
4. Настрой подключение к Ollama. Создай файл .openclaw/config.json: { "provider": "ollama", "baseUrl": "http://localhost:11434/v1", "model": "qwen2.5-coder:7b", "apiKey": "ollama" }
5. Запусти OpenClaw: openclaw
6. Проверь, что всё работает: Привет. Какие файлы есть в этой директории?

Если OpenClaw не видит Ollama — проверь, что Ollama запущен (ollama serve) и что порт 11434 доступен.

Осознание результата

• Когда OpenClaw впервые ответил — что ты почувствовал? Это было «как Claude» или «совсем иначе»?
• Заметил ли ты разницу в скорости ответа по сравнению с облаком?
• Понимаешь ли ты теперь, как OpenClaw подключается к Ollama?
• Что было самым сложным в установке? Что — самым простым?

Запиши в журнал: «Моя локальная установка — это...» (опиши свою конфигурацию: железо, модель, ощущения). Глава 1.3. Первая задача: от промпта до кода Ты установил всё. Теперь — первый настоящий тест. Но прежде чем давать задачу — спроси себя: а что, если локальная модель не справится? Готов ли ты к этому?

Локальные модели (особенно 7B-параметров) имеют особенности:

• Они хуже следуют сложным инструкциям. Нужно формулировать проще и конкретнее.
• Они чаще галлюцинируют. Особенно в незнакомых доменах.
• Они хуже работают с длинным контекстом. После 4-8K качество падает.
• Они медленнее. Особенно на CPU.

Работа с локальной моделью — это не «то же самое, но хуже». Это иначе. Нужно менять стиль промптов, декомпозицию задач, ожидания.

Упражнение «Первый проект»

Создадим: CLI-утилиту для конвертации валют.

1. В директории openclaw-lab запусти OpenClaw.
2. Дай промпт: Создай Python-скрипт currency.py, который конвертирует суммы между USD, EUR и RUB. Курсы захардкодь. Интерфейс — через input(). Обработай ошибки ввода.
3. Прочитай код. Запусти. Проверь.
4. Если что-то не так — попроси исправить конкретно: В функции convert() есть баг: при вводе "abc" программа падает. Добавь обработку ValueError.
5. Когда всё работает — добавь фичу: Добавь возможность загружать курсы из JSON-файла rates.json. Если файла нет — используй захардкоженные значения.

Осознание результата

• Сколько итераций потребовалось, чтобы получить рабочий код?
• Были ли моменты, когда модель «тупила»? Как ты это понял?
• Пришлось ли тебе менять стиль промптов? Что помогло?
• Чувствуешь ли ты разницу между «работой с облаком» и «работой с локальной моделью»?

Модуль 2. Искусство промптинга для локальных моделей

Глава 2.1. Дисциплина промпта: почему локальная модель требует больше внимания Представь двух студентов. Один — гений, которому можно сказать «сделай проект», и он сам разберётся. Второй — способный, но ему нужно чёткое ТЗ. С кем из них ты работаешь, когда используешь локальную модель?

Локальные модели требуют более дисциплинированных промптов. Вот правила:

• Будь конкретным. Не «сделай сайт», а «создай index.html с формой подписки, тёмная тема, vanilla JS».
• Декомпозируй. Одна задача — один промпт.
• Давай примеры. Few-shot промптинг работает лучше длинных объяснений.
• Указывай формат вывода. «Ответь в виде JSON», «Верни только код».
• Избегай двусмысленности. Локальная модель хуже понимает нюансы.
• Используй структуру. Маркированные списки, нумерация, заголовки.

Промпт для локальной модели — это не «пожелание», а техническое задание. Чем точнее ТЗ — тем лучше результат.

Упражнение «Контраст промптов»

1. Плохой промпт: Сделай мне игру
2. Хороший промпт: Создай игру "Змейка" в одном файле snake.html. Требования: - Поле 20x20 клеток - Управление стрелками - Еда появляется случайно - Счёт увеличивается при поедании - Game over при столкновении со стеной или собой - Рестарт по пробелу Стиль: - Тёмный фон (#1a1a1a) - Зелёная змея (#4ade80) - Красная еда (#f87171) Технологии: - Только HTML + CSS + vanilla JS - Canvas для отрисовки
3. Сравни результаты. Запиши, что изменилось.

Осознание результата

• Насколько сильно отличались два результата?
• Какие детали во втором промпте оказались самыми важными?
• Заметил ли ты, что локальная модель требует больше конкретики? Почему?
• Готов ли ты писать такие промпты для своих задач?

Запиши свой «шаблон промпта для локальной модели»: [Что создать] + [Технические детали] + [Стиль] + [Ограничения] + [Формат вывода]. Глава 2.2. CLAUDE.md: как научить модель твоим правилам Облачная модель уже «знает» много. Локальная — знает меньше. Но ты можешь научить её твоим правилам. Через CLAUDE.md. Но прежде чем учить — какие у тебя правила?

OpenClaw автоматически читает файл CLAUDE.md в корне проекта и добавляет его в системный промпт. Это — контракт между тобой и моделью.

Что писать:

• Описание проекта — что это, зачем, для кого.
• Архитектура — структура файлов, модули.
• Стиль кода — соглашения, линтеры.
• Технологии — что можно, что нельзя.
• Тестирование — как проверять изменения.
• Запреты — что модель не должна делать.

CLAUDE.md — это не «документация». Это инструкция для агента. Пиши так, будто объясняешь стажёру, который видит проект впервые.

Упражнение «Создание CLAUDE.md»

1. Создай файл CLAUDE.md в директории проекта.
2. Напиши туда: # Currency Converter CLI ## Описание CLI-утилита для конвертации валют на Python. ## Архитектура - `currency.py` — точка входа - `rates.json` — курсы (опционально) ## Стиль кода - Python 3.10+, типизация обязательна - Docstrings для всех функций ## Запреты - Не используй внешние библиотеки - Не добавляй сетевые запросы
3. Запусти новую сессию OpenClaw. Спроси: Прочитай CLAUDE.md и расскажи, что ты понял о проекте.

Осознание результата

• Как изменилось поведение модели после CLAUDE.md?
• Какие пункты оказались самыми полезными? Избыточными?
• Заметил ли ты, что локальная модель «забывает» инструкции чаще облачной?
• Готов ли ты вести CLAUDE.md для всех проектов?

Глава 2.3. Few-shot и Chain-of-Thought Локальная модель не всегда понимает с первого раза. Но она отлично учится на примерах. Можешь ли ты показать модели, что делать, вместо того чтобы объяснять?

Few-shot промптинг — даёшь модели несколько примеров «вход → выход» перед задачей. Работает особенно хорошо для локальных моделей.

Chain-of-Thought (CoT) — просишь модель «думать вслух». Улучшает качество рассуждений.

Для локальных моделей примеры важнее инструкций. Если можешь показать — показывай.

Упражнение «Few-shot и CoT»

1. Без примеров: Напиши функцию, которая валидирует email.
2. С примерами (few-shot): Примеры валидации email: "user@example.com" → True "invalid-email" → False "user@.com" → False "user.name+tag@example.co.uk" → True Напиши функцию validate_email(email: str) -> bool.
3. С CoT: Напиши функцию проверки палиндрома. Думай шаг за шагом: 1. Какие случаи учесть? 2. Как обрабатывать регистр и пробелы? 3. Какой алгоритм? 4. Напиши код. 5. Приведи примеры.
4. Сравни результаты.

Осознание результата

• Какой подход дал лучший результат? Почему?
• Помог ли CoT? Или модель «прыгнула» к коду без рассуждений?
• В каких реальных задачах ты будешь использовать эти техники?

Модуль 3. Выбор модели: искусство подбора инструмента

Глава 3.1. Зоопарк моделей: что запустить в Ollama В Ollama можно запустить десятки моделей. Но какую выбрать? Это не вопрос «что лучше» — это вопрос «что лучше для этой задачи, на этом железе».

Основные семейства моделей для кодинга (на 2026 год):

Модель Размер Когда использовать qwen2.5-coder7B / 14B / 32BУниверсальный выбор для кода deepseek-coder-v216B / 236BСложные задачи, рефакторинг codellama7B / 13B / 34BКлассика, стабильность llama3.18B / 70BОбщие задачи mistral-nemo12BБаланс качества и скорости phi-3.53.8BСлабое железо, быстрые задачи

Правило большого пальца:

• 8 ГБ VRAM → 7B модель (Q4_K_M)
• 16 ГБ VRAM → 14B модель (Q4_K_M)
• 24 ГБ VRAM → 32B модель (Q4_K_M)
• 48+ ГБ VRAM → 70B модель (Q4_K_M)

Упражнение «Тест-драйв моделей»

1. Скачай 3 модели разного размера: ollama pull qwen2.5-coder:7b ollama pull qwen2.5-coder:14b ollama pull phi3.5:3.8b
2. Для каждой дай одинаковую задачу: Напиши на Python функцию, которая читает CSV, группирует по "category" и считает сумму по "amount". Обработай ошибки.
3. Сравни: корректность, обработка ошибок, стиль, скорость, использование памяти.

Осознание результата

• Какая модель дала лучший результат? Ожидал ли ты этого?
• Была ли разница между 7B и 14B существенной?
• Какую модель ты будешь использовать по умолчанию?

Запиши свою «карту моделей»: какая модель для какой задачи. Глава 3.2. Квантизация и VRAM: искусство компромиссов У тебя 12 ГБ VRAM. Модель 14B в Q4_K_M — ~9 ГБ. В Q5_K_M — ~11 ГБ. В Q8_0 — ~15 ГБ (не влезет). Что ты выберешь? И почему?

Квантизация — это компромисс между качеством и ресурсами:

• Q2_K — экстремальное сжатие. Только для простых задач.
• Q3_K_M — сильное сжатие. Заметная потеря качества.
• Q4_K_M — «золотая середина». Самый популярный выбор.
• Q5_K_M — чуть лучше Q4, но больше памяти.
• Q6_K — близко к оригиналу.
• Q8_0 — почти без потерь. Много памяти.

Формула расчёта памяти:

Память (ГБ) ≈ (параметры в млрд × бит квантизации / 8) + 2 ГБ на контекст Пример: 14B модель, Q4_K_M (4.5 бит) = (14 × 4.5 / 8) + 2 ≈ 10 ГБ

Упражнение «Подбор квантизации»

1. Посмотри, сколько у тебя VRAM: nvidia-smi
2. Рассчитай, какие квантизации влезут для выбранной модели.
3. Скачай и запусти две квантизации. Дай одинаковую задачу. Сравни.
4. Сделай выбор: какую квантизацию будешь использовать по умолчанию.

Осознание результата

• Заметил ли ты разницу в качестве между Q4 и Q5? В скорости?
• Стоила ли разница в качестве разницы в скорости?
• Понимаешь ли ты теперь, как выбирать квантизацию?

Глава 3.3. Модели для разных задач Не все модели одинаковы. Некоторые лучше пишут код. Некоторые — рассуждают. Как подобрать модель под задачу?

Категории моделей:

• Код-модели (qwen2.5-coder, deepseek-coder): оптимизированы для кода, хуже в общих рассуждениях.
• Универсальные (llama3.1, mistral-nemo): хороши во всём понемногу.
• Reasoning-модели (deepseek-r1): «думают вслух», лучше в сложных задачах, медленнее.
• Миниатюрные (phi-3.5): для слабого железа, быстрые, ограниченные.

В OpenClaw ты можешь переключать модели на лету. Используй код-модель для кода, универсальную для планирования, reasoning для сложных задач.

Упражнение «Специализация моделей»

1. Скачай 3 модели разного типа: ollama pull qwen2.5-coder:7b # код ollama pull llama3.1:8b # универсальная ollama pull deepseek-r1:7b # рассуждения
2. Дай каждой три задачи:
   • Код: «Напиши функцию сортировки на Python»
   • Универсальная: «Объясни, как работает HTTPS»
   • Рассуждение: «Все розы — цветы. Некоторые цветы вянут быстро. Все ли розы вянут быстро?»
3. Сравни результаты.

Осознание результата

• Соответствуют ли результаты ожиданиям?
• Заметил ли ты, что reasoning-модель «думает» дольше, но точнее?
• Составь «маршрутную карту»: какая модель для какой задачи.

Модуль 4. Продвинутые техники: MCP, агенты, файнтюн

Глава 4.1. MCP-серверы: даём локальному агенту руки Локальный агент работает в вакууме. Но что, если нужно работать с БД? С API? Как дать ему доступ к внешнему миру — не нарушая приватности?

MCP (Model Context Protocol) работает и локально. MCP-серверы могут быть полностью локальными:

• filesystem — расширенная работа с файлами,
• sqlite — локальная база данных,
• memory — персистентная память,
• obsidian — работа с локальными заметками.

MCP + локальная модель = полностью приватная автоматизация. Твои данные не покидают машину.

Упражнение «Локальный MCP-сервер»

Создадим MCP-сервер для SQLite.

1. Создай директорию: mkdir ~/mcp-sqlite && cd ~/mcp-sqlite
2. Создай server.py: from mcp.server.fastmcp import FastMCP import sqlite3 from pathlib import Path mcp = FastMCP("sqlite") DB_FILE = Path("data.db") def get_conn(): return sqlite3.connect(DB_FILE) @mcp.tool() def init_db() -> str: """Инициализировать БД""" conn = get_conn() conn.execute("""CREATE TABLE IF NOT EXISTS tasks ( id INTEGER PRIMARY KEY, title TEXT NOT NULL, done BOOLEAN DEFAULT 0 )""") conn.commit() conn.close() return "База инициализирована" @mcp.tool() def add_task(title: str) -> str: """Добавить задачу""" conn = get_conn() conn.execute("INSERT INTO tasks (title) VALUES (?)", (title,)) conn.commit() conn.close() return f"Задача '{title}' добавлена" @mcp.tool() def list_tasks() -> str: """Показать все задачи""" conn = get_conn() cur = conn.execute("SELECT id, title, done FROM tasks") tasks = cur.fetchall() conn.close() if not tasks: return "Задач нет" return "\n".join(f"{t[0]}. [{('x' if t[2] else ' ')}] {t[1]}" for t in tasks) if __name__ == "__main__": mcp.run()
3. Установи зависимости: pip install mcp
4. Добавь в .openclaw/config.json: { "mcpServers": { "sqlite": { "command": "python", "args": ["/путь/к/mcp-sqlite/server.py"] } } }
5. Перезапусти OpenClaw. Проверь: Инициализируй БД и добавь три задачи

Осознание результата

• Что ты почувствовал, когда агент впервые вызвал твой MCP-инструмент?
• Какие ещё локальные MCP-серверы ты мог бы создать?
• Как это меняет твоё представление о приватности?

Глава 4.2. Файнтюн: когда стандартной модели недостаточно Стандартная модель знает много. Но она не знает тебя. Можно ли научить модель быть «твоей»?

Файнтюн — дообучение модели на твоих данных. Позволяет:

• научить модель твоему стилю кода,
• добавить знания о специфическом домене,
• улучшить качество в узкой задаче.

Но это сложно и ресурсоёмко:

• нужно много VRAM (24+ ГБ),
• нужно много данных,
• нужно понимание (LoRA, QLoRA, PEFT),
• результат не гарантирован.

Файнтюн — это не для начинающих. Сначала научись работать со стандартными моделями. Файнтюн — это высшая форма суверенитета. Ты не просто используешь модель — ты создаёшь свою.

Упражнение «Знакомство с файнтюном»

1. Изучи документацию Unsloth (github.com/unslothai/unsloth).
2. Прочитай про LoRA (Low-Rank Adaptation).
3. Посмотри примеры датасетов на HuggingFace.
4. Ответь письменно:
   • Для какой задачи тебе мог бы понадобиться файнтюн?
   • Какие данные у тебя есть?
   • Какое железо нужно?
   • Готов ли ты инвестировать время?

Осознание результата

• Понимаешь ли ты теперь, что такое файнтюн?
• Готов ли ты когда-нибудь попробовать? Для какой задачи?
• Как понимание файнтюна изменило твоё отношение к локальным моделям?

Глава 4.3. Оптимизация: максимум из железа Локальная модель работает на твоём железе. Но использует ли она его на 100%? Как выжать максимум?

Направления оптимизации:

• GPU-ускорение: NVIDIA (CUDA), AMD (ROCm), Apple Silicon (Metal).
• Параллельные запросы: OLLAMA_NUM_PARALLEL=4
• Кэширование KV: ускоряет повторные запросы.
• Flash Attention: для длинного контекста.
• Оптимизация промптов: короче → быстрее.

Упражнение «Оптимизация Ollama»

1. Проверь GPU: ollama ps
2. Настрой параллелизм: export OLLAMA_NUM_PARALLEL=4 export OLLAMA_MAX_LOADED_MODELS=2
3. Измерь скорость: дай задачу, посмотри токены/сек.
4. Сравни разные квантизации по скорости.
5. Оптимизируй промпты — сравни длинный и короткий.

Осознание результата

• Насколько удалось ускорить? Что дало наибольший эффект?
• Где ты готов жертвовать качеством ради скорости?
• Понимаешь ли ты, как работает GPU-ускорение?

Модуль 5. Зрелость: границы, осознанность, суверенитет

Глава 5.1. Границы локального: что OpenClaw + Ollama НЕ могут Ты знаешь, что инструмент может. Но знаешь ли ты, чего он не может? Можно ли мастерски использовать то, границы чего ты не осознаёшь?

Локальная связка не может:

• Догнать топовые облачные модели по качеству рассуждений.
• Эффективно работать с очень длинным контекстом.
• Быстро генерировать большой объём кода.
• Работать без настройки.
• Гарантировать качество.
• Заменять инженерное мышление.

Мастерство в локальном вайбкодинге — это искусство работать в условиях ограничений. Это искусство компромиссов.

Упражнение «Карта границ»

1. Возьми свой текущий проект.
2. Дай задачу на грани возможностей:
   • «Перепиши весь проект на другом языке»
   • «Найди все баги»
   • «Оптимизируй в 10 раз»
   • «Сделай production-ready»
3. Наблюдай, где агент «ломается».
4. Зафиксируй эти моменты.

Осознание результата

• Где именно агент «сломался»?
• Как ты будешь использовать эту карту границ?
• Изменилось ли твоё отношение к локальным моделям?

Глава 5.2. Суверенитет как философия Ты прошёл курс. Настроил связку. Научился работать с ограничениями. Но что это значит для тебя — не как для кодера, а как для человека?

Локальный вайбкодинг — это философия:

• Суверенитет данных. Твои данные — только твои.
• Независимость от корпораций. Ты не зависишь от политик Anthropic, OpenAI.
• Понимание инструмента. Ты не можешь использовать локальную модель «на автомате».
• Сообщество, а не клиент. Ты часть open-source.
• Устойчивость. Система работает без интернета и подписок.

Быть локальным кодером — это не «отказаться от прогресса». Это выбрать другой путь прогресса. Путь, где ты — хозяин.

Упражнение «Манифест суверенитета»

Напиши свой личный манифест. Ответь письменно:

1. Почему я выбрал локальность? Не «потому что модно», а по-настоящему.
2. От чего я готов отказаться? Качество? Скорость? Удобство?
3. Что я готов дать сообществу? Контрибьютить? Делиться опытом?
4. Как локальность изменит мою работу? Не технически — философски.

Осознание результата

• Когда ты писал манифест — что тебя удивило?
• Есть ли противоречие между тем, что ты хочешь, и тем, что выбрал?
• Готов ли ты быть «локальным кодером» философски, а не только технически?
• Как курс изменил твоё представление о том, что значит «быть программистом»?

Запиши «точку Б» — фразу, описывающую твоё текущее состояние. Сравни с «точкой А».

Финал. Возвращение к себе

Большая рефлексия: кто ты теперь?

В начале курса ты записал в журнал «точку А». Найди эту запись. Прочитай её сейчас.

А теперь ответь — честно, без спешки, письменно:

• Что ты знаешь сейчас, чего не знал тогда? Не о OpenClaw и Ollama — о себе, о процессе, о природе суверенитета.
• Какие из твоих ожиданий подтвердились? А какие — оказались иллюзиями?
• Что ты сделал такого, чего не сделал бы месяц назад?
• Где ты всё ещё слаб? Не для самобичевания — для карты роста.
• Как изменилось твоё определение «программиста»? Нужно ли уметь писать код руками в 2026 году?
• Что ты скажешь человеку, который только начинает этот курс?
• Что для тебя значит «суверенитет»? Не технически — а по-человечески.

Запиши теперь «точку Б». Сравни с точкой А.

Это и есть результат курса. Не код. Не проекты. Не модели. А изменение в твоём мышлении. Переход от арендатора к хозяину. От потребителя к создателю. От зависимого к суверенному.

«Свобода — это не отсутствие ограничений. Это возможность выбирать свои ограничения»

Дорожная карта: что дальше?

Курс закончен. Но путь — нет. Направления:

• Углубление в модели: попробуй 32B, 70B. Найди «свою» модель.
• MCP-экосистема: создай 3-5 собственных MCP-серверов.
• Файнтюн: попробуй LoRA-файнтюн на своих данных.
• Специализация: выбери область и стань экспертом.
• Сообщество: контрибьють в OpenClaw, Ollama.
• Преподавание: найди ментори и проведи его через путь.
• Исследование границ: тестируй, документируй.

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