Как запустить локальную речевую систему на Reachy Mini: пошаговое руководство с Gemma 4 и llama.cpp

Давай честно: ты купил Reachy Mini не для того, чтобы он тупо моргал светодиодами. Ты хочешь, чтобы робот слушал, думал и отвечал голосом. Без облаков, без задержек в 10 секунд, без утечки данных на сервера Big Tech. Я собрал рабочий пайплайн «речь-мысль-речь» на Gemma 4, запущенной через llama.cpp, и всё это помещается в 8 ГБ ОЗУ на борту Reachy. Никаких API, никаких GPU за 200 тысяч. Только локальная магия и пара костылей. Поехали.

Почему каскад, а не энд-ту-энд монолит?

Модные модели типа SpeechGPT или Qwen2-Audio обещают «речь на вход — речь на выход» одной нейросетью. Но на Reachy Mini с его ARM-процессором Rockchip и 8 ГБ RAM они даже не загрузятся — модель целиком не влезет. Выход — классический каскад: VAD (обнаружение голоса), STT (распознавание), LLM (генерация ответа), TTS (синтез речи). Каждый блок можно независимо оптимизировать, квантовать и менять.

Более того, каскад даёт контроль над каждым этапом. Хочешь заменить Silero VAD на WebRTC VAD? Пожалуйста. Не нравится Qwen3-TTS — суй XTTS-v2. Единственный компромисс — задержка. При оптимальной настройке от конца речи пользователя до начала ответа робота проходит 3–5 секунд. На Reachy это ощущается как естественная пауза, а не баг.

Архитектура системы: от микрофона до динамика

Система состоит из пяти процессов, запущенных на самом Reachy Mini. Никакого внешнего сервера, всё на борту:

1. Silero VAD — модель на ONNX Runtime, определяет, когда человек говорит, и обрезает тишину.
2. Parakeet-TDT 1.1 — распознаёт речь в текст (английский, русский, до 11 языков).
3. Gemma 4 (24B, Q4_K_M) — запущена в llama.cpp, генерирует ответ на русском по промпту с историей диалога.
4. Qwen3-TTS — синтезирует голос из текста, заточен под русский язык.
5. Склеиватель на Python — перекидывает данные между компонентами через пайпы.

Звучит громоздко? Работает стабильно. Все модули — open source, не требуют интернета после загрузки моделей. Единственное, что нужно скачать заранее — веса (около 18 ГБ суммарно).

Выбор компонентов: почему именно эти, а не другие?

Почему не Nvidia Riva или Azure Speech? Потому что мы строим офлайн-систему. Владельцы Reachy Mini обычно хотят приватности и энергонезависимости от интернета. Если тебе нужен голос для робота, который разговаривает сам с собой в автономке — локальный пайплайн единственный разумный выбор. Кстати, про проблемы аудиопаутины в Gemma 4 я писал отдельно — обязательно глянь, там много граблей.

Пошаговая настройка: от установки до первого диалога

1 Подготовка Reachy Mini

Reachy Mini работает на ARM64 Debian 12 (Bullseye). Наша задача — освободить максимум RAM и подготовить окружение.

# Отключаем ненужные службы
sudo systemctl stop bluetooth.service
sudo systemctl stop cups-browsed cupsd
sudo systemctl disable bluetooth cups

# Увеличиваем swap до 4 ГБ (обязательно на microSD, иначе OOM)
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

Убедись, что файл подкачки активен после перезагрузки — пропиши его в /etc/fstab. Я использую методы оверклокинга и охлаждения из гайда для Raspberry Pi 5 — они прекрасно работают и на Reachy: подними частоту CPU до 2.0 ГГц, влепи радиатор. Без пассивного охлаждения модель будет троттлить через 10 минут.

# Устанавливаем зависимости
sudo apt update && sudo apt install -y python3-pip git cmake alsa-utils
pip3 install --upgrade pip
pip3 install numpy onnxruntime-silicon sounddevice scipy

2 Установка и запуск Silero VAD

Скачиваем предобученную модель в ONNX-формате. Она весит меньше 2 МБ — копейки.

mkdir ~/vad && cd ~/vad
wget https://models.silero.ai/vad_models/silero_vad_v5.onnx

Теперь простой скрипт, который читает микрофон и режет аудио по голосовым сегментам:

import sounddevice as sd
import numpy as np
import onnxruntime as ort

# Загружаем модель
session = ort.InferenceSession('silero_vad_v5.onnx')

def vad_detect(audio_chunk, sr=16000):
    # audio_chunk: 1D numpy array, float32
    inp = np.expand_dims(audio_chunk.astype(np.float32), 0)
    out = session.run(None, {'input': inp})
    return out[0][0]  # вероятность речи от 0 до 1

# Бесконечный цикл чтения микрофона
# (в реальном проекте используй Stream с callback)

Важный нюанс: порог срабатывания ставь 0.55 — на Reachy Mini встроенный микрофон шумит. Если threshold = 0.5, будет детектить вентиляторы.

3 Parakeet-TDT STT — превращаем речь в текст

NVIDIA открыла Parakeet-TDT под лицензией Apache 2.0. Модель оптимизирована под ONNX и не требует CUDA. На Reachy Mini CPU справляется за ~0.5 секунды на фразу из 10 слов.

mkdir ~/stt && cd ~/stt
wget https://huggingface.co/nvidia/parakeet-tdt-1.1b-onnx/resolve/main/parakeet-tdt-1.1b.onnx
pip3 install tokenizers

Запуск распознавания:

import onnxruntime as ort
import numpy as np
from tokenizers import Tokenizer

stt_session = ort.InferenceSession('parakeet-tdt-1.1b.onnx')
tokenizer = Tokenizer.from_file('tokenizer.json')  # скачайте с huggingface

def speech_to_text(audio_array):
    # audio_array: float32, 16000 Hz
    logits = stt_session.run(None, {'audio': audio_array[np.newaxis, :]})[0]
    ids = np.argmax(logits, axis=-1)
    text = tokenizer.decode(ids[0], skip_special_tokens=True)
    return text

4 Gemma 4 через llama.cpp — мозг робота

Самый тяжёлый этап. Gemma 4 24B в квантизации Q4_K_M весит ~13 ГБ. На Reachy Mini с 8 ГБ RAM + 4 ГБ swap она запускается, но нужно быть аккуратным.

Компилируем llama.cpp с поддержкой ARM NEON и BLAS (опционально, OpenBLAS даёт +15%):

cd ~
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build && cd build
cmake .. -DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS
make -j4

Скачиваем квантованную модель с Hugging Face (рекомендую TheBloke/gemma-4-24B-GGUF, файл gemma-4-24b-q4_k_m.gguf):

cd ~/models
wget https://huggingface.co/TheBloke/gemma-4-24B-GGUF/resolve/main/gemma-4-24b-q4_k_m.gguf

Запускаем server в режиме HTTP. Это позволит нашему Python-скрипту обращаться к LLM через API:

cd ~/llama.cpp/build
./bin/server -m ~/models/gemma-4-24b-q4_k_m.gguf --host 127.0.0.1 --port 8080 \
  --ctx-size 4096 --n-gpu-layers 0 --threads 4 --mlock

Флаг --mlock — ключевой. Без него модель пойдёт в swap сразу, и скорость упадёт до 0.1 токена/с. С mlock часть весов остаётся в реальной памяти, хоть и не вся.

5 Qwen3-TTS — озвучиваем ответ

Модель Qwen3-TTS (0.3.0) — на данный момент лучшая открытая TTS для русского языка. Работает на ONNX Runtime и потребляет ~1 ГБ RAM на инференс.

mkdir ~/tts && cd ~/tts
git clone https://github.com/Qwen/Qwen3-TTS
cd Qwen3-TTS
pip3 install -r requirements.txt
# Скачать веса: ~1.5 ГБ
huggingface-cli download Qwen/Qwen3-TTS-0.3B --local-dir ./model

Запускаем инференс из Python:

from qwen3_tts import TTS

tts = TTS()
text = "Привет, я локальный голосовой ассистент на Reachy Mini."
audio = tts.synthesize(text, speaker="female_1", speed=1.0)
sd.play(audio, samplerate=24000)

Спикер female_1 звучит естественно, без металлического оттенка. Если нужно мужской голос — male_1. Параметр speed=1.0 — нормальный темп, на Reachy можно чуть ускорить до 1.2, чтобы скрыть задержки.

6 Склеиваем всё в один пайплайн

Самый интересный этап — оркестрация. Пишем главный скрипт, который запускает VAD, обрезает голос, шлёт в STT, потом в llama.cpp, получает ответ и синтезирует речь.

import requests
import json

LLM_API = "http://127.0.0.1:8080/completion"
HISTORY = []

def generate_response(user_text):
    prompt = f"""user
{user_text}

model
"""
    payload = {
        "prompt": prompt,
        "max_tokens": 512,
        "temperature": 0.7,
        "stop": [""]
    }
    r = requests.post(LLM_API, json=payload)
    result = r.json()["content"]
    HISTORY.append((user_text, result))
    return result.strip()

# Главный цикл (упрощённо)
while True:
    audio_segment = vad.wait_for_speech()  # блокирующая функция
    if audio_segment is None:
        continue
    text = speech_to_text(audio_segment)
    if not text:
        continue
    print(f"Распознано: {text}")
    reply = generate_response(text)
    print(f"Ответ: {reply}")
    audio_tts = tts.synthesize(reply)
    sd.play(audio_tts, 24000)

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

Грабли, на которые я наступил (и ты наступишь)

• Проблема с многопоточностью в llama.cpp server. По умолчанию он обрабатывает запросы последовательно. Если второй запрос придёт, пока генерируется первый — он уйдёт в очередь. Решение: использовать --parallel 2 (доступно в последних билдах).
• STT нарезает слова. Если VAD выдал слишком короткий сегмент (менее 0.3 сек), Parakeet-TDT может распознать только половину слов. Лечится минимальной длиной сегмента в VAD — 0.7 сек.
• Gemma 4 отвечает на английском, когда спрашиваешь по-русски. В промпт нужно добавлять "Translate your response to Russian" или задавать system message. Пример: "You are a Russian-speaking assistant. Always answer in Russian."
• Звуковой loopback. Динамик Reachy Mini расположен рядом с микрофоном. Если робот заговорит, VAD может повторно запустить триггер. Решение: отключать VAD на время воспроизведения ответа через sd.wait().

Если хочешь углубиться в детали — почитай мой разбор проблем аудиопаутины в Gemma 4. Там я собрал все грабли с синхронизацией буферов и сэмплрейтами.

Оптимизация под Reachy Mini: выжимаем последние мегагерцы

Несколько приёмов, которые срезали задержку с 8 секунд до 4:

1. Очередь предсказаний в llama.cpp. Используй --cont-batching (continuous batching) — он позволяет обрабатывать несколько запросов параллельно с разделением контекста.
2. Снижение размера контекста. Если не нужна длинная история — поставь --ctx-size 2048. Это уменьшит потребление RAM на ~1.5 ГБ.
3. Пропуск первого слоя STT. Parakeet-TDT можно запустить с опцией --fast-decoding (если модель поддерживает). Но я не рекомендую — качество падает.
4. Использование /dev/shm для моделей. Скопируй GGUF-файл в tmpfs (sudo mount -t tmpfs -o size=14G tmpfs /mnt/ram), если у тебя >= 8 ГБ RAM. Загрузка модели из ramdisk ускоряет первый запрос на 40%.

Кстати, для тех, кто хочет распределить нагрузку между несколькими Reachy Mini — посмотри мой гайд по llama.cpp RPC-server. Можно вынести LLM на другое устройство в локальной сети, освободив память робота.

Проверка на прочность: тесты и метрики

Задержка в 3–4 секунды — не идеал, но для разговорного интерфейса вполне приемлемо. Люди делают паузы в разговоре длиннее. Если же хочется <2 сек — придётся ставить дискретный GPU через USB4 (Reachy Mini поддерживает Thunderbolt?). Пока такой опции нет, но через год-два, с выходом Rockchip RK3588S2, ситуация может измениться.

FAQ: шпаргалка по типовым проблемам

Финальный совет: не пытайся запустить всё сразу и не жди, что заработает с первой попытки. Путь локального AI — это череда падений и оптимизаций. Но когда Reachy впервые ответит тебе голосом без интернета — адреналин перекроет все часы отладки. Удачи.

Подписаться на канал