Local AI Agents — минимальные агенты, OpenClaw, Hermes, Qwen-Agent

Модуль: 13. Профессиональная практика | Время: ~35 мин теории + 30 мин практики

Суть урока

Claude Code — это электричество из сети. Платишь подписку и получаешь свет (актуальные цены и версии: Актуальное сейчас). Удобно, надёжно, но провод у тебя в руках только пока счёт оплачен и интернет есть.

К октябрю 2026 года есть много зрелых фреймворков, которые позволяют запустить agent-системы полностью на твоём собственном компьютере. Без API. Без интернета. С tool use, памятью, MCP-серверами, мультиагентной коллаборацией.

Урок Локальные AI модели — Ollama, LM Studio и приватный AI рассказал про базовые локальные модели (Ollama, LM Studio) — это были "лампочки". Этот урок — про полноценную "электростанцию": когда модель + агентный фреймворк + инструменты работают вместе и решают реальные задачи без отправки байта наружу.

Разберём 8 ключевых фреймворков, примеры моделей для agent-задач, hardware-требования и сделаем честный итог: где local выигрывает, где проигрывает API.

🎨 Образ: Claude API — это электричество из городской сети. Платишь за каждый kWh, всё стабильно, но зависишь от компании. Local agents — солнечные панели на крыше. Один раз установил, дальше генерируешь сам. Хватает на бытовые нужды (90% задач). Но если запускаешь промышленный станок (уровень сильнейших облачных моделей) — переключаешься на городскую сеть. Это не "или-или", это "и-и" для разных задач.

🎯 Decision tree: когда local лучше API

Главный вопрос — не "что круче", а "что подходит твоей задаче":

→ Production B2B с SLA, support, uptime гарантиями?
   → API (Anthropic/OpenAI). Local не для этого.

→ Работа с конфиденциальными данными (медицина, юристика, корпоративный код)?
   → LOCAL обязательно. Юристы и врачи не отправляют данные клиентов наружу.

→ Personal automation без интернета (домашний бот, заметки, переводы)?
   → LOCAL. Нет смысла платить за приватные задачи.

→ Hobby-проекты и эксперименты?
   → LOCAL. Бесплатно и без лимитов.

→ Высокий volume + простые задачи (классификация, перевод тысяч записей)?
   → LOCAL дёшевле. API быстро съест бюджет.

→ Сложный reasoning, ADR, архитектурные решения, complex code?
   → API (сильные облачные модели). Local пока не дотягивает.

→ Российская/китайская юрисдикция, санкции, доступ к API ограничен?
   → LOCAL = независимость. Никто не отключит. (России и Беларуси нет в списках поддерживаемых стран Anthropic и OpenAI на октябрь 2026.)

→ Не уверен — нужна максимальная производительность или экономия?
   → Гибрид. Local для рутины, API для сложного.

🎨 Образ: не выбирай между велосипедом и автомобилем — держи оба. До магазина едешь на велосипеде (local), в другой город — на машине (API). У большинства builders стек смешанный.

Ключевые концепции

• Local agent framework — софт который превращает локальную модель (Llama, Qwen, Mistral) в полноценного агента с tools, memory, planning
• Function calling — способность модели не просто отвечать текстом, а вызывать инструменты с правильными аргументами. Базовая способность agent-моделей
• MCP (Model Context Protocol) — открытый протокол подключения tools к моделям. Изначально от Anthropic, теперь поддерживается локальными фреймворками
• Inference backend — движок исполнения модели: Ollama (простой), vLLM (быстрый, prod), SGLang (max throughput), llama.cpp (минимум зависимостей)
• Quantization — сжатие модели для запуска на меньшем железе. Q4_K_M даёт 70B на 40GB вместо 140GB
• Open weights — модель опубликована с весами (можно скачать и запускать). Не путать с open source (открытый код обучения)
• Tool-native model — модель обученная вызывать функции из коробки. Современные семейства (Qwen3, gpt-oss, Hermes 4) — tool-native. Старые базовые модели без отдельного fine-tune — часто нет
• Hybrid stack — комбинация local + API: рутина локально, сложное через API
• MoE (Mixture of Experts) — архитектура, где из всех параметров на запрос активна только часть. Пример: DeepSeek-V3 — 671B параметров, активны 37B; Qwen3-Coder 30B активирует около 3.3B. Качество большой модели, скорость средней

Теория

Когда local agents лучше API

Local — не замена API. Это другой инструмент с другой экономикой. Три ситуации где local реально выигрывает:

1. Privacy и sovereignty. Медицинские записи, корпоративный код, личные заметки — это данные которые не должны покинуть твой компьютер. Условия обучения на данных у API и у подписок разные, и юристы клиента всё равно могут сказать "нет". Local решает вопрос архитектурно: данные физически не уходят наружу.

2. Cost при высоком volume. Если у тебя десятки тысяч задач классификации текста в месяц, счёт за API растёт вместе с объёмом, а локальная модель класса 7–14B стоит только электричества. Считай по своим объёмам: цены токенов — на странице Актуальное сейчас.

3. Independence. Санкции, отключения, изменения политик. Для части русскоязычных builders это не гипотетический риск: России и Беларуси нет в списках поддерживаемых стран Anthropic и OpenAI (на октябрь 2026), доступ к их API ограничен. Local работает всегда.

Когда local проигрывает: сложный reasoning (сильнейшие облачные модели), multimodal на высоком уровне, длинный контекст (сотни тысяч токенов и больше), новейшие функции (управление компьютером, голос). Здесь облачные модели обычно впереди.

🎨 Образ: local — это твой огород. Помидоры свежие, бесплатные, твои. Но манго на огороде не вырастишь — за манго идёшь в супермаркет (API).

Hardware requirements — что реально нужно

Главный лимит локального AI — железо. Размер модели определяет минимальную RAM/VRAM:

Цены на железо сильно плавают, поэтому в таблице нет сумм: сверяй с продавцами перед покупкой. Конкретные модели видеокарт и чипов меняются каждый год, суть в объёме памяти.

Важные правила:

• Модель на 70B параметров в Q4 квантизации требует ~40GB RAM/VRAM. На 32GB запустится медленно (swap), на 16GB — не запустится
• Mac преимущество: unified memory. M2 Max 64GB ведёт себя как 64GB VRAM. На PC отдельно RAM и GPU VRAM
• Старые GPU (GTX 1080, RTX 2060) работают, но медленно. Для real-time agent нужна видеокарта хотя бы на 12 ГБ памяти
• Электричество: мощная видеокарта на полной нагрузке потребляет 300–450 Вт. При 8 часах работы в день это заметная прибавка к счёту, посчитай по своему тарифу

🎨 Образ: хочешь готовить дома вместо ресторана — нужна плита. Газовая горелка сварит макароны. Индукционная варочная панель — стейк. Профессиональная кухня — банкет на 50 человек. Сначала пойми меню, потом покупай кухню.

8 ключевых local agent-фреймворков (на октябрь 2026)

Разберём по порядку. Каждый со своей нишей.

Framework 1: nanoClaude — учебный minimal agent

Что: Минимальные реализации агента в стиле Claude Code, которые умещаются в небольшой объём кода. Это не один проект, а целый жанр: на GitHub есть несколько независимых community-проектов (например, nanoclaude и nano-claude-code). Идея близка к nanoGPT Карпати. Не путай с NanoClaw: это другой проект, лёгкая контейнерная альтернатива OpenClaw.

Best for: Образование. Понять как работает агент изнутри — без обёрток фреймворка.

Runs on: Обычно Python. Подключаются к облачной модели или к локальной через Ollama (смотри README конкретного проекта).

Cost: $0.

Status: Community-built, качество и поддержка разные. Не для production — это learning tool.

Source: https://github.com/karpathy/nanoGPT (идея), https://github.com/CohleM/nanoclaude (пример учебного агента).

🎨 Образ: Lego-конструктор. Собираешь сам, понимаешь каждый кубик. Не для жилого дома — для понимания "как дома строятся".

Framework 2: OpenClaw — open-source персональный агент

Что: Open-source самохостящийся персональный AI-агент (лицензия MIT). Живёт на твоём компьютере, общается с тобой через мессенджеры (WhatsApp, Telegram, Discord, Slack и другие), помнит прошлые разговоры, умеет работать с почтой, календарём, браузером и файлами. Работает и с облачными моделями (Claude, GPT), и с локальными. Проект ведёт некоммерческий OpenClaw Foundation, платной версии нет.

Best for: Тем, кто хочет личного агента под своим контролем и не хочет отдавать данные чужому сервису. Для работы в коде лучше подходят Claude Code, Codex и IDE-агенты, а не OpenClaw.

Runs on: Mac, Windows, Linux. Установка скриптом, через npm или настольным приложением. Backend — любая модель, в том числе локальная через Ollama.

Cost: $0 (open source), платишь только за выбранную облачную модель, если используешь её.

Status: Активно развивается; актуальную версию смотри на официальном сайте.

Source: https://openclaw.ai и https://github.com/openclaw/openclaw.

🎨 Образ: личный помощник, который сидит у тебя дома. Пишешь ему в Telegram как живому человеку, а он открывает почту, календарь и файлы на твоём компьютере. Полный контроль, но и ответственность: права доступа выдавай осторожно, по минимуму.

Framework 3: Hermes — Nous Research: модели и агент

Что: Под именем Hermes компания Nous Research выпускает две связанные вещи. Первая: семейство fine-tuned моделей Hermes (актуальная линейка — Hermes 4), обученных на function calling и agent tasks. Вторая: Hermes Agent, open-source агентный фреймворк (лицензия MIT) с постоянной памятью, работой через мессенджеры и делегированием задач субагентам. Агент можно подключить к своей модели или к Nous Portal.

Модели: Hermes 4 на Hugging Face: 14B, 36B (версия 4.3), 70B и 405B (для 405B нужен серверный GPU).

Best for: Function calling без API, multi-step reasoning offline. Когда нужна модель которая правильно вызывает tools из коробки.

Runs on: Ollama / vLLM / TGI. Любой framework, который умеет с моделями соответствующего семейства.

Cost: $0 (модели и агент) + compute electricity.

Source: https://huggingface.co/NousResearch и https://hermes-agent.nousresearch.com.

🎨 Образ: обычная базовая модель — это универсал. Hermes — модель, прошедшая курс "как работать с инструментами". Разница как между новичком и опытным официантом: оба возьмут заказ, но один забудет половину.

Framework 4: Qwen-Agent — Alibaba native framework

Что: Agent framework созданный командой Qwen для своих моделей. Tight integration с моделями Qwen (Qwen3 и новее). Поддерживает function calling, MCP, code interpreter и RAG.

Модели: Qwen3 (от 0.6B до 235B параметров) и Qwen3-Coder (30B и 480B). Более новые поколения Qwen смотри на странице проекта.

Best for: Сложные coding задачи локально, multi-step workflows. Если задача "напиши и протестируй функцию" — Qwen3-Coder подходит для проверки в первую очередь.

Special: Сам фреймворк под лицензией Apache 2.0, у многих моделей Qwen тоже открытые веса и Apache 2.0 — смотри лицензию конкретной модели.

Runs on: Ollama / SGLang / vLLM. Native поддержка.

Cost: $0.

Source: https://github.com/QwenLM/Qwen-Agent.

🎨 Образ: рабочая лошадь — не самая красивая машина, не самые громкие маркетинговые ролики. Но работает там где более красивые конкуренты застрянут. Qwen — workhorse open source AI.

Framework 5: DeepSeek — reasoning model offline

Что: Открытые модели китайской лаборатории DeepSeek. DeepSeek-R1 (начало 2025) — одна из первых reasoning-моделей с открытыми весами. Актуальная линейка на октябрь 2026 — DeepSeek V4: V4.1-Flash вышла 10.09.2026, её веса лежат на Hugging Face.

Модели: V4.1-Flash — крупная MoE-модель, на обычном домашнем железе её, как правило, не запустить, нужен сервер. Для домашнего железа смотри уменьшенные distill-версии R1 (7B, 14B, 32B, 70B) и небольшие модели других семейств.

Best for: Reasoning задачи offline. Math problems, complex code logic, multi-step planning.

Special: Веса в open weights. Есть и платный API с низкими ценами (актуальные цены: Актуальное сейчас).

Cost: $0 (local, если хватает железа) или по тарифу API.

Source: https://github.com/deepseek-ai.

🎨 Образ: reasoning model — это калькулятор который показывает работу. Раньше такие модели были только за закрытой подпиской. DeepSeek сказал "вот вам веса, делайте что хотите".

Framework 6: Open WebUI + tools — полный local ChatGPT stack

Что: Web UI похожий на ChatGPT для локальных моделей. Backend — Ollama. Поддерживает tools, RAG, веб-поиск через SearxNG (local), code interpreter, voice (TTS/STT через Whisper), подключение MCP-серверов.

Best for: Chat interface на собственном компьютере. Когда нужен "локальный ChatGPT" с продвинутыми фичами.

Features: Multi-user (можно семья/команда), RAG (загружаешь документы — модель их видит), pipelines (custom logic). Один из самых популярных проектов в этой нише. Смотри лицензию в репозитории: в ней есть условия про сохранение брендинга.

Runs on: Docker (запускается одной командой).

Cost: $0.

Source: https://github.com/open-webui/open-webui.

🎨 Образ: ChatGPT интерфейс — но всё работает у тебя на Mac. Семья пользуется, документы не уходят наружу, счёт за API — ноль.

Framework 7: smolagents — HuggingFace minimal framework

Что: Минималистичный agent framework от HuggingFace. Главная идея: агент пишет код вместо вызова tools через JSON schemas. Меньше overhead, больше capability.

Best for: Experimentation, fast prototyping, education. Когда хочешь понять "что если агент сам пишет Python вместо ограниченного набора tools".

Runs on: Любая модель (local через Ollama / API через провайдеров).

Cost: $0 (framework).

Source: https://github.com/huggingface/smolagents.

🎨 Образ: тонкий клиент. Фреймворк не мешает, модель работает напрямую. Сравни с CrewAI где много обёрток и configuration — smolagents даёт минимум кода между тобой и моделью.

Framework 8: AutoGen Studio + local models

Что: AutoGen — фреймворк от компании Microsoft для multi-agent коллаборации. AutoGen Studio — GUI поверх него. Совместим с local models через OpenAI-compatible API. Важно: на октябрь 2026 AutoGen в режиме поддержки (maintenance mode), новых функций не будет, преемник — Microsoft Agent Framework. AutoGen Studio подходит для прототипов, но не для production.

Best for: Multi-agent коллаборация offline. Когда нужны 3+ агентов которые "разговаривают" между собой для решения задачи.

Runs on: Ollama / LM Studio / любой OpenAI-compatible endpoint. AutoGen Studio даёт визуальный builder.

Cost: $0 (framework).

Source: https://github.com/microsoft/autogen.

🎨 Образ: команда специалистов работающих у тебя в подвале без интернета. Architect, coder, tester — каждый специалист, общаются между собой, решают задачу.

Дополнительно (часто упоминаются):

• Continue.dev — IDE agent для VS Code и JetBrains. Работает с local models. Open source. Альтернатива для тех, кто не хочет SaaS-редактор
• LM Studio — GUI для local model management + базовые agent features. Хорош для новичков
• Jan.ai — open-source ChatGPT alternative. Полностью locally. Простой UI
• CrewAI local — обычный CrewAI с Ollama backend вместо OpenAI

Примеры local моделей для agent-задач (на октябрь 2026)

Модели — это сердце local agent. Без правильной модели даже лучший framework бесполезен:

Размеры скачивания Ollama проверены по страницам моделей на октябрь 2026. Как выбирать: не верь процентам вида "почти как Sonnet" из чужих сравнений. Прогони свою задачу на двух-трёх моделях (см. Шаг 5), и сравнивай результат сам. На сложных архитектурных задачах разрыв с сильными облачными моделями больше.

Практический выбор:

• Mac 32GB → Qwen3 14B или gpt-oss 20B (fits comfortably)
• Mac 64GB+ или видеокарта на 24GB → Qwen3 30B / Qwen3-Coder 30B / Qwen3 32B (sweet spot quality/speed)
• Mac Studio на 128GB+ или server → gpt-oss 120B, Hermes 4 70B и более крупные модели

Setup walkthrough — быстрый старт за 30 минут

Полный local agent stack ставится одним вечером:

# Step 1: Установи Ollama (Mac/Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Windows — скачай инсталлятор с ollama.com

# Step 2: Скачай модель (один раз, ~19GB)
ollama pull qwen3:30b

# Альтернативы по размеру:
# ollama pull qwen3:14b   # ~9GB, для 16GB RAM
# ollama pull qwen3:8b    # ~5GB, минимум
# Актуальные названия и размеры: ollama.com/library

# Step 3: Установи Open WebUI через Docker
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

# Step 4: Открой http://localhost:3000 — local ChatGPT готов

После setup — у тебя есть:

• Локальный ChatGPT-like интерфейс
• Модель, которая закрывает значительную часть повседневных задач (код, тексты, переводы). Качество проверь на своих задачах
• Tool calling (модель умеет вызывать функции)
• RAG (загружаешь PDF — модель отвечает по содержимому)
• Полная приватность (ни байта наружу)

Real-world cases — что реально работает локально

Не теория — паттерны которые уже работают:

Case 1: Privacy-first переводчик (юрист)

• Stack: Qwen3 14B + Open WebUI
• Use: переводы конфиденциальных документов клиентов RU↔︎EN↔︎ES
• Speed: зависит от железа, замерь на своём компьютере
• Cost: нет платы за токены после initial setup
• Why local: клиентская конфиденциальность исключает сторонние сервисы вроде DeepL или Claude API

Case 2: Code review для proprietary codebase

• Stack: Qwen3-Coder + Continue.dev в VS Code
• Use: code review без отправки proprietary кода в Anthropic API
• Quality: для стандартных review задач хватает, сложные архитектурные проверки лучше отдавать сильной облачной модели
• Cost: нет платы за токены (нужен Mac на 64GB или ПК с видеокартой на 24GB)
• Why local: corporate IP не уходит наружу, NDA не нарушается

Case 3: Personal automation (домашний бот)

• Stack: небольшая модель (Qwen3 8B или Hermes 4 14B) + Open WebUI + custom tools
• Use: умный дом (Home Assistant integration), личные заметки, напоминания
• Privacy: 100% offline
• Hardware: компактный Mac или мини-ПК с 16GB памяти (one-time)
• Cost: без ежемесячной платы

Case 4: Local agent для контента (Telegram-канал)

• Stack: Qwen3 14B + smolagents + RAG over local Obsidian vault
• Use: писать посты в стиле твоих заметок и предыдущих постов
• Cost: без платы за токены после setup
• Trade-off: качество ниже, чем у сильных облачных моделей. Для personal Telegram — норм
• Why local: твои черновики и идеи остаются у тебя

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

Limits и trade-offs — честно

Без розовых очков. Где local реально слабее:

Честный итог на октябрь 2026: для большинства professional tasks API всё ещё выигрывает. Local — для специфичных use cases (privacy / cost / offline / sovereignty). Но разрыв сокращается: открытые модели последних поколений (Qwen3, gpt-oss, DeepSeek V4) закрывают многие повседневные задачи. Сильнейшие облачные модели по-прежнему впереди на сложном рассуждении и длинных задачах.

🎨 Образ: local — это электромобиль первых поколений. Дешевле в эксплуатации, но запас хода меньше, зарядных станций мало. С каждым годом он всё ближе к бензину.

Стоимость setup — one-time vs ongoing

Самый частый вопрос — "когда окупится":

Сравнение с API:

• Подписка на облачного ассистента стоит в год сумму двенадцати месяцев (актуальные цены: Актуальное сейчас)
• Формула окупаемости: цена железа ÷ (месячный счёт за API − электричество). Железо окупается только при большом объёме задач или когда нужна приватность
• Local не заменяет API на 100%. Реально builders используют hybrid: local для рутины, API для сложного
• Hybrid экономика: local забирает массовые простые задачи, а на облачную модель остаётся счёт только за сложное

Anti-patterns — что НЕ делать

Грабли на которые наступают новички:

❌ Использовать local 7B модели для production B2B. Качество не дотягивает. Клиент заметит. Для production — сильные облачные модели, точка.

❌ Запускать 70B модель на 8GB RAM. Будет умирать через swap. Минимум для 70B — 40GB unified memory или 48GB VRAM.

❌ Игнорировать electricity costs. GPU на полной нагрузке много часов в день заметно увеличивает счёт. Для некоторых сценариев это съедает экономию vs API.

❌ Trying to replicate сильнейшие облачные модели locally. Разрыв real. Не насилуй железо.

❌ Skipping security. Local ≠ безопаснее автоматически. Модель из непроверенного репозитория на Hugging Face может нести вредоносный код в скриптах. Качай из проверенных источников и не включай trust_remote_code, не прочитав код.

❌ Один local instance для всей команды без queue management. Bottleneck. Если 5 человек одновременно гоняют запросы — модель встанет. Нужен load balancer (vLLM) или separate instances.

❌ Сравнивать local с API на одной задаче и делать выводы. Local выигрывает на volume и privacy. API выигрывает на сложном reasoning. Сравнивать нужно по конкретному use case.

Audience рейтинг — для кого что

Прогрессия по уровням:

Новичок (только начал):

• Stack: Ollama + Qwen3 14B + Open WebUI
• Покрытие: большая часть personal tasks (переводы, write/edit, research)
• Hardware: компьютер с 16GB памяти

Средний (имеет coding background):

• Stack: + smolagents + Continue.dev в IDE
• Покрытие: agent-style local workflow для разработки
• Hardware: Mac на 32GB или ПК с видеокартой на 16GB

Профессионал (builder, агентство):

• Stack: + AutoGen или Microsoft Agent Framework / Hermes 4 70B + custom MCP servers offline
• Покрытие: full multi-agent local stack для proprietary projects
• Hardware: Mac Studio 64GB+ или ПК с видеокартой на 24GB

Enterprise (команда):

• Stack: vLLM server + load balancer + fine-tuned models + auth
• Покрытие: internal AI platform для всей команды
• Hardware: выделенный сервер с несколькими профессиональными GPU

Тренды — куда движется local AI

То что становится возможным каждые 6 месяцев:

Smaller, faster. То что было frontier пару лет назад, сегодня запускается на ноутбуке. Модели одного и того же качества становятся всё меньше.

Tool-native by default. Новые модели (Qwen3, gpt-oss) обучаются с function calling из коробки — отдельные fine-tunes вроде Hermes нужны реже.

Multimodal local. Локальные модели умеют работать с картинками (например, Qwen3-VL). Audio (Whisper local) — стандарт. Video — догоняет.

Reasoning offline. DeepSeek-R1 показал что reasoning capability возможна в open weights. Сегодня режимы рассуждения есть у gpt-oss, Qwen3 и DeepSeek, и они всё чаще влезают в consumer hardware.

Mobile AI. Малые модели (1–4B) уже запускаются на смартфонах. Следующий шаг — агенты на мобильных без cloud.

MCP standardization. MCP стал стандартом подключения инструментов. Local фреймворки (Open WebUI, smolagents, Qwen-Agent) поддерживают MCP servers — те же tools работают с Claude API и с local моделями.

🎨 Образ: local AI — это ПК в начале пути. Дорого, сложно, не для всех. Со временем он станет проще и ближе, как это было с компьютером и смартфоном.

Практика

Шаг 1: Установка Ollama и первой модели

# Mac/Linux — одной командой
curl -fsSL https://ollama.com/install.sh | sh

# Проверь установку
ollama --version
# Должно показать номер версии

# Скачай Qwen3 14B (хороший баланс для 32GB RAM)
ollama pull qwen3:14b

# Если меньше памяти — стартуй с 8B
ollama pull qwen3:8b

# Проверь модель
ollama run qwen3:14b "Привет, как ты?"
# Должен ответить на русском

Шаг 2: Тест function calling через Python

# test_function_calling.py — проверяем что модель умеет вызывать tools
import ollama

# Описываем tool как функцию
def get_weather(city: str) -> str:
    """Возвращает погоду для города (заглушка)"""
    weather_db = {
        "Москва": "−5°C, снег",
        "Куэнка": "+18°C, солнечно",
        "город_x": "+15°C, туман"
    }
    return weather_db.get(city, "Нет данных")

# Описание tool для модели
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Получить текущую погоду для указанного города",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Название города"
                }
            },
            "required": ["city"]
        }
    }
}]

# Отправляем запрос
response = ollama.chat(
    model='qwen3:14b',
    messages=[{
        'role': 'user',
        'content': 'Какая погода в Куэнке?'
    }],
    tools=tools
)

# Смотрим результат
print(response['message'])
# Должно содержать tool_calls с вызовом get_weather(city="Куэнка")

# Симулируем выполнение tool
if response['message'].get('tool_calls'):
    for tool_call in response['message']['tool_calls']:
        if tool_call['function']['name'] == 'get_weather':
            city = tool_call['function']['arguments']['city']
            result = get_weather(city)
            print(f"Tool result: {result}")

Шаг 3: Установка Open WebUI через Docker

# Убедись что Docker установлен
docker --version

# Запусти Open WebUI
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

# Подожди ~30 секунд, потом открой
open http://localhost:3000

# При первом запуске:
# 1. Создай admin account (локальный, никуда не уходит)
# 2. В Settings → Connections → Ollama должно подхватить автоматически
# 3. В Chat выбери модель qwen3:14b
# 4. Начни диалог

Шаг 4: Простой local agent через smolagents

# local_agent.py — minimal agent с smolagents и Ollama
from smolagents import CodeAgent, OpenAIModel, tool

# Подключаем Ollama через OpenAI-compatible endpoint
# (в старых версиях smolagents этот класс назывался OpenAIServerModel)
model = OpenAIModel(
    model_id="qwen3:14b",
    api_base="http://localhost:11434/v1",
    api_key="ollama"  # Ollama игнорирует ключ, но требует строку
)

# Создаём custom tool
@tool
def calculate_compound_interest(principal: float, rate: float, years: int) -> float:
    """
    Рассчитать сложные проценты.
    
    Args:
        principal: начальная сумма
        rate: годовая ставка (например 0.05 для 5%)
        years: количество лет
    """
    return principal * ((1 + rate) ** years)


@tool  
def read_file(path: str) -> str:
    """
    Прочитать файл с диска.
    
    Args:
        path: путь к файлу
    """
    with open(path, 'r', encoding='utf-8') as f:
        return f.read()


# Создаём агента
agent = CodeAgent(
    tools=[calculate_compound_interest, read_file],
    model=model,
    add_base_tools=True  # Добавит python_interpreter и др.
)

# Запускаем
result = agent.run(
    "Если положить $1000 под 7% годовых на 10 лет, "
    "сколько будет в конце? Объясни расчёт."
)

print("\n" + "="*50)
print("РЕЗУЛЬТАТ:")
print("="*50)
print(result)

# Установка
pip install smolagents

# Запуск
python local_agent.py

# Агент должен:
# 1. Понять задачу
# 2. Вызвать calculate_compound_interest(1000, 0.07, 10)
# 3. Получить ~1967.15
# 4. Объяснить расчёт на русском

Шаг 5: Сравнение local vs API на твоей задаче

# compare_local_vs_api.py — честное сравнение на одной задаче
import time
import ollama
from anthropic import Anthropic  # pip install anthropic

# Твоя задача — выбери что-то реальное
prompt = """Напиши функцию на Python которая:
1. Принимает список чисел
2. Возвращает топ-3 наибольших значений
3. Включает type hints
4. Имеет docstring с примером
5. Обрабатывает edge cases (пустой список, < 3 элементов)"""

# Вариант 1: Local через Ollama
print("=" * 50)
print("LOCAL: Qwen3 14B")
print("=" * 50)
start = time.time()
local_response = ollama.chat(
    model='qwen3:14b',
    messages=[{'role': 'user', 'content': prompt}]
)
local_time = time.time() - start
print(local_response['message']['content'])
print(f"\nВремя: {local_time:.1f}s | Стоимость: $0")

# Вариант 2: API через Anthropic
print("\n" + "=" * 50)
print("API: Claude Sonnet 5.5")
print("=" * 50)
client = Anthropic()  # Требует ANTHROPIC_API_KEY в env
start = time.time()
api_response = client.messages.create(
    model="claude-sonnet-5-5",  # актуальные идентификаторы моделей: документация Anthropic
    max_tokens=1000,
    messages=[{"role": "user", "content": prompt}]
)
api_time = time.time() - start
input_tokens = api_response.usage.input_tokens
output_tokens = api_response.usage.output_tokens
# Цены за 1 млн токенов: Sonnet 5.5 — $2 на вход, $10 на выход (на октябрь 2026).
# Актуальные цены: страница «Актуальное сейчас» на сайте Академии
PRICE_IN, PRICE_OUT = 2, 10
cost = (input_tokens * PRICE_IN + output_tokens * PRICE_OUT) / 1_000_000
print("".join(b.text for b in api_response.content if b.type == "text"))
print(f"\nВремя: {api_time:.1f}s | Стоимость: ${cost:.4f}")

# Итоги
print("\n" + "=" * 50)
print("СРАВНЕНИЕ:")
print("=" * 50)
print(f"Local: {local_time:.1f}s, $0")
print(f"API:   {api_time:.1f}s, ${cost:.4f}")
print(f"\nЕсли 1000 таких задач в месяц:")
print(f"Local: $0 + электричество")
print(f"API:   ${cost * 1000:.2f}")

Что покажет этот тест:

• На простых coding задачах local часто сопоставим по качеству
• Latency local обычно выше, чем у API
• При большом объёме задач local начинает выигрывать экономически (подставь свой объём в расчёт)
• Качество финального кода — оценишь сам, читая оба ответа

Инструменты и ресурсы

• Ollama — самый простой backend для local моделей. Mac/Linux/Windows
• Open WebUI — ChatGPT-like UI для local моделей
• Hermes (Nous Research) — tool-native модели Hermes 4
• Hermes Agent — open-source агент от Nous Research
• OpenClaw — open-source персональный агент в мессенджерах
• Qwen Team — главная страница Qwen models и frameworks
• Qwen-Agent — agent framework для Qwen
• smolagents (HuggingFace) — minimal Python agent framework
• DeepSeek — модели DeepSeek с открытыми весами
• AutoGen — фреймворк Microsoft для multi-agent (режим поддержки, преемник — Microsoft Agent Framework)
• Continue.dev — open source IDE agent
• LM Studio — GUI для local model management
• Jan.ai — open-source ChatGPT alternative locally
• vLLM — production-grade inference engine
• SGLang — max throughput inference framework
• Karpathy nanoGPT — образовательная основа для nano-агентов
• Цены и версии: Актуальное сейчас

Ключевые выводы

Local agents — это не замена API, это другой инструмент с другой экономикой. Privacy, cost при volume, offline, independence — четыре причины когда local реально выигрывает. Для всего остального API всё ещё впереди.

Hardware = бутылочное горлышко. Компьютер с 16–32GB памяти запустит модель класса 8–14B и закроет многие personal tasks. Mac Studio или ПК с видеокартой на 24GB+ — для серьёзной работы с моделями 30B и больше. Электричество тоже считается.

Реалистичный путь — hybrid stack. Local для рутины (классификация, переводы, simple coding, RAG над личными документами), API для сложного (architecture, complex reasoning, multimodal). Не выбирай одно — комбинируй.

Что дальше

→ Self-hosted AI Enterprise Stack — vLLM, SGLang, Docker — как собрать внутреннюю AI-платформу для команды, когда одного компьютера уже мало