Два мозга лучше одного: как собрать AI-ассистента с роутером и мозгом на ограниченных ресурсах

Почему один мозг — это тупик

Вы запускаете локального ассистента, как в нашей статье про голосового ассистента на RTX 3090. Qwen2.5-7B загружен, работает. Пользователь спрашивает: "Включи свет в гостиной". Модель начинает философствовать о природе электричества. Или: "Какая погода завтра?". Она генерирует поэму о дожде вместо того, чтобы вызвать API погоды.

Проблема не в модели. Проблема в архитектуре. Одна LLM пытается быть всем: и классификатором, и генератором, и планировщиком. На 7 миллиардах параметров это невозможно. Особенно когда у вас 8 ГБ VRAM, а не 24.

Архитектура: роутер и мозг

Решение простое и элегантное: разделить ответственность. Две модели вместо одной. Меньшая (2-3B) работает как роутер — определяет интент запроса. Большая (7-13B) — как мозг — генерирует сложные ответы.

Магия в том, что они не работают одновременно. Сначала загружаем роутер. Он анализирует запрос. Если это простой интент ("включи свет", "погода") — выполняем действие через API. Если сложный ("объясни квантовую физику") — выгружаем роутер, загружаем мозг. Серийная загрузка вместо параллельной.

Шаг за шагом: собираем систему

1 Выбираем модели (актуально на февраль 2026)

Не берите первое, что найдете на Hugging Face. Критерии выбора:

• Роутер: должен отлично справляться с классификацией. LiquidAI LFM2.5-1.2B-Thinking — наш выбор. Альтернатива: Qwen2.5-1.5B-Instruct, но у нее хуже с reasoning.
• Мозг: нужна балансированная модель. Qwen2.5-7B-Instruct все еще актуальна в 2026. Если есть больше памяти — GLM-4.7B. Обе поддерживают инструменты (function calling).
• Формат: только GGUF. Не связывайтесь с PyTorch-версиями — съедят всю память.

2 Настраиваем окружение

Ollama — наш выбор. Но не стандартный ollama serve, а кастомный скрипт управления.

# Устанавливаем Ollama если еще нет
curl -fsSL https://ollama.ai/install.sh | sh

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

# Скачиваем модели (пример для LiquidAI)
wget https://huggingface.co/liquid-ai/LFM2.5-1.2B-Thinking-GGUF/resolve/main/LFM2.5-1.2B-Thinking-Q4_K_M.gguf

# Создаем Modelfile для роутера
cat > Modelfile.router << 'EOF'
FROM ./LFM2.5-1.2B-Thinking-Q4_K_M.gguf

PARAMETER temperature 0.1
PARAMETER top_p 0.9
PARAMETER num_ctx 2048

SYSTEM """
Ты — классификатор запросов. Определяй интент пользователя.
Возможные интенты:
1. smart_home — управление умным домом (включить/выключить свет, температуру)
2. weather — запрос погоды
3. general_knowledge — общие вопросы (как работает, что такое)
4. creative — творческие задачи (напиши стих, придумай имя)
5. coding — программирование
6. unknown — все остальное

Отвечай ТОЛЬКО названием интента, без пояснений.
"""
EOF

# Создаем модель в Ollama
ollama create router -f Modelfile.router

То же самое для мозга, но с другим SYSTEM prompt.

3 Пишем оркестратор

Вот где начинается магия. Оркестратор — это Python-скрипт, который решает, какую модель когда загружать.

import subprocess
import json
import time
from typing import Literal, Optional

class DualModelOrchestrator:
    def __init__(self):
        self.current_model: Optional[str] = None
        self.router_model = "router"  # Наша 1.2B модель
        self.brain_model = "qwen2.5:7b"  # 7B модель
        
    def _run_ollama_command(self, model: str, prompt: str) -> str:
        """Запускает модель через Ollama API"""
        cmd = [
            "curl", "-s", "http://localhost:11434/api/generate",
            "-H", "Content-Type: application/json",
            "-d", json.dumps({
                "model": model,
                "prompt": prompt,
                "stream": False
            })
        ]
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode != 0:
            raise RuntimeError(f"Ollama error: {result.stderr}")
        
        response = json.loads(result.stdout)
        return response["response"].strip()
    
    def _unload_model(self):
        """Выгружает текущую модель из памяти"""
        if self.current_model:
            subprocess.run(["ollama", "rm", "-f", self.current_model], 
                          capture_output=True)
            self.current_model = None
            time.sleep(1)  # Даем время на освобождение памяти
    
    def classify_intent(self, query: str) -> str:
        """Определяет интент через роутер"""
        # Если загружен не роутер — выгружаем текущую модель
        if self.current_model != self.router_model:
            self._unload_model()
            self.current_model = self.router_model
        
        intent = self._run_ollama_command(self.router_model, query)
        
        # Валидируем ответ
        valid_intents = {"smart_home", "weather", "general_knowledge", 
                        "creative", "coding", "unknown"}
        return intent if intent in valid_intents else "unknown"
    
    def process_query(self, query: str) -> str:
        """Основной метод обработки запроса"""
        # Шаг 1: классификация
        intent = self.classify_intent(query)
        
        # Шаг 2: обработка простых интентов
        if intent == "smart_home":
            return self._handle_smart_home(query)
        elif intent == "weather":
            return self._handle_weather(query)
        
        # Шаг 3: для сложных запросов загружаем мозг
        if self.current_model != self.brain_model:
            self._unload_model()
            self.current_model = self.brain_model
            time.sleep(2)  # Большая модель грузится дольше
        
        # Шаг 4: генерация ответа
        return self._run_ollama_command(self.brain_model, query)
    
    def _handle_smart_home(self, query: str) -> str:
        """Обработка команд умного дома"""
        # Здесь интеграция с Home Assistant или n8n
        # Подробнее в статье про локальный ассистент с n8n
        return "Команда умного дома выполнена"
    
    def _handle_weather(self, query: str) -> str:
        """Запрос погоды через API"""
        # Простой HTTP-запрос вместо LLM
        return "Завтра +15°C, солнечно"

4 Тонкая настройка промптов

Промпт роутера — это 80% успеха. Вот как НЕ надо делать:

# ПЛОХО: слишком многословно
Ты — умный ассистент. Пользователь задает вопрос. Определи, о чем он: 
о погоде, об умном доме, или общих знаниях. Будь вежливым.

Роутер начнет генерировать: "Это вопрос о погоде, пользователь хочет узнать..." А нам нужно одно слово.

Вот рабочий промпт:

SYSTEM """
Классификатор запросов. 
Возможные категории: weather, smart_home, general, creative, coding, other.

Правила:
1. "какая погода" → weather
2. "включи свет" → smart_home  
3. "объясни квантовую физику" → general
4. "напиши стих" → creative
5. "как отсортировать массив" → coding
6. Все остальное → other

Формат ответа: ТОЛЬКО категория, без точек, без пояснений.
Пример: weather
"""

Для мозга промпт другой — там нужен контекст, personality, инструкции по формату.

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

1. Неправильный quantization

Берете Q2 для роутера — точность падает до 60%. Берете Q8 для мозга — не влезает в память. Q4_K_M для роутера, Q5_K_M для мозга. Проверено на десятках моделей.

2. Игнорирование контекста переключения

Пользователь: "Объясни релятивизм". Мозг отвечает. Следующий запрос: "А теперь включи свет". Система должна снова переключиться на роутер. Многие забывают этот кейс.

# В оркестраторе добавляем
class SmartOrchestrator(DualModelOrchestrator):
    def process_query(self, query: str) -> str:
        # Всегда начинаем с роутера
        intent = self.classify_intent(query)
        
        # Если предыдущий запрос был сложным, а этот простой
        # нужно выгрузить мозг
        if self.current_model == self.brain_model \
           and intent in ["smart_home", "weather"]:
            self._unload_model()
            return self._handle_simple_intent(intent, query)
        
        # ... остальная логика

3. Отсутствие fallback-механизмов

Роутер вернул "unknown", но запрос явно требует мозга. Или роутер сломался. Нужны цепочки fallback:

• Роутер не ответил за 3 секунды → грузим мозг
• Роутер вернул "unknown", но в запросе есть ключевые слова ("объясни", "почему") → мозг
• Мозг не грузится из-за нехватки памяти → lightweight fallback модель (например, Phi-3-mini)

Производительность: цифры на февраль 2026

Тестировал на RTX 4060 Ti 16GB (потому что не у всех есть 3090):

Видите парадокс? Для сложных запросов наша система медленнее на 1.5-2 секунды (переключение моделей). Но 80% запросов к ассистенту — простые команды. Там выигрыш 4-5 раз.

Что делать, если все равно не влезает в память

У вас 4 ГБ VRAM? 6 ГБ? Все еще можно.

1. CPU offloading: часть слоев на CPU. В Ollama: OLLAMA_NUM_GPU=50 — 50% слоев на GPU, остальные на CPU. Медленнее, но работает.
2. Еще меньшие модели: для роутера — Phi-3-mini (3.8B, но в Q4 занимает 2.3 ГБ). Для мозга — Qwen2.5-3B (удивительно умная для своих размеров).
3. Кэширование: если пользователь трижды спрашивает погоду — не запускать роутер каждый раз. Кэшируйте интенты на 5 минут.

Самый экстремальный вариант — запускать на CPU. С современными процессорами (Ryzen 7 7800X3D) инференс 3B модели занимает 3-5 секунд. Медленно, но работает без видеокарты вообще.

Интеграция в полную систему

Этот дуэт моделей — только ядро. В реальном ассистенте, как в нашем AI-монстре, вокруг еще слои:

• STT (Whisper.cpp или Parakeet) превращает голос в текст
• Наш оркестратор с двумя моделями обрабатывает текст
• Для smart_home интентов — интеграция с Home Assistant
• Для creative — возможно, вызов Stable Diffusion
• TTS (Piper или Qwen3 TTS) превращает ответ обратно в речь

Каждый слой можно включать/выключать. Нет видеокарты? Отключаем Stable Diffusion. Нет микрофона? Работаем через текст.

Что будет дальше?

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

Но пока — на февраль 2026 — разделение на роутер и мозг остается самым эффективным способом заставить AI-ассистента работать на ограниченном железе. Особенно если у вас не топовая видеокарта, а что-то вроде 3060 или 4060.

Собирайте. Тестируйте. Особое внимание — на промпты для роутера. Один неверно составленный промпт снижает точность классификации на 30%. И не забывайте про fallback-механизмы — они спасут, когда что-то пойдет не так.

А если соберете — напишите в комментариях, какие модели используете и какую точность получили. Интересно, кто сможет побить 92% на классификации с моделью меньше 2B параметров.