Локальный голосовой агент с задержкой 375 мс: Nemotron-4 + Kokoro-82M на bare metal

Почему 375 мс — это не просто цифра, а граница между "говорит" и "общается"

Знаете, что бесит в большинстве голосовых агентов? Эта пауза. Та самая, когда вы закончили фразу, а система молчит две секунды, потом издаёт механическое "Хм..." и ещё через три секунды начинает отвечать. Человеческий мозг воспринимает задержку больше 500 мс как разрыв в диалоге. После 700 мс — это уже не разговор, а обмен аудиосообщениями.

375 мс — это магия. Это время, за которое звук проходит от ваших губ до микрофона (5-10 мс), распознаётся (150 мс), обрабатывается LLM (150 мс), синтезируется в речь (50 мс) и воспроизводится (20 мс). И ещё остаётся запас в 40 мс на всякий случай. На таком уровне задержки мозг перестаёт замечать, что говорит с машиной.

Стек технологий: что внутри этой штуки

Собрать быстрый голосовой агент — это как готовить сложное блюдо. Можно взять самые дорогие ингредиенты (самые большие модели) и получить нечто несъедобное (задержка 5 секунд). А можно взять правильные компоненты и оптимизировать каждый миллисекунд.

Nemotron-4 — это не просто очередная большая модель. NVIDIA специально оптимизировала её для инференса на своих картах. Архитектура Blackwell с тензорными ядрами 4-го поколения обрабатывает 4-bit квантование так, будто это полноценные float16. Чистая магия — или просто 3 года инженерной работы.

Железо: на чём это всё летает

Здесь начинается боль. Можно взять RTX 4090 и упираться в 24 ГБ VRAM. Можно собрать кластер из четырёх RTX 3090 и мучиться с NVLink. А можно сделать правильно.

• GPU: NVIDIA H200 80GB (или две H100 80GB) — 141 ГБ/s пропускной способности памяти, достаточно для Nemotron-4 в 4-bit
• CPU: AMD Threadripper PRO 7995WX — 96 ядер, но нам нужно всего 8-12 для оркестрации
• RAM: 256 ГБ DDR5 6400 MHz — не для моделей, а для кэширования диалогов
• NVMe: Samsung 990 Pro 4TB — модели загружаются за 12 секунд вместо 45
• Сеть: 10 GbE — если планируете несколько агентов, как в многопользовательском AI-чате

Да, это дорого. H200 стоит как подержанная Toyota. Но считайте: аренда GPT-4 Turbo с голосом — $0.06 за минуту разговора. 8-часовой рабочий день — $28.8. За месяц — $576. За год — $6912. H200 окупается за 8 месяцев. А потом вы получаете бесплатные разговоры и полную приватность.

Пошаговый разбор: от коробки до работающего агента

1 Подготовка системы: Linux, драйверы и большие страницы

Устанавливаем Ubuntu 24.04 LTS. Не 22.04, не 25.04 — именно 24.04. В ядре 6.8 есть оптимизации для NVIDIA GPUDirect, которых нет в старых версиях.

# Драйверы CUDA 13.5 (актуально на 16.02.2026)
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update
sudo apt install cuda-toolkit-13-5

# Большие страницы для кэша контекста
echo "vm.nr_hugepages = 1024" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Отключаем swap полностью — модели в VRAM, не в swap
sudo swapoff -a
echo "vm.swappiness=0" | sudo tee -a /etc/sysctl.conf

vm.swappiness=0 — это секретный соус. Linux по умолчанию пытается выгружать неактивные страницы в swap. Для LLM с их 200 ГБ контекста это смерть. Мы говорим ядру: «Держи всё в RAM, даже если придется убить процесс». Но наши процессы — это модели в VRAM, так что RAM хватит.

2 Установка и квантование Nemotron-4

Скачиваем модель с Hugging Face. Весит она 680 ГБ в fp16. Нам нужно квантовать в 4-bit, но не с помощью обычного GPTQ, а через NVIDIA TensorRT-LLM с оптимизациями для Blackwell.

# Установка TensorRT-LLM (версия 0.9.0 на 16.02.2026)
pip install tensorrt_llm==0.9.0 --extra-index-url https://pypi.nvidia.com

# Квантование модели
tensorrt_llm quantize \
  --model_dir ./nemotron-4-340b \
  --output_dir ./nemotron-4-340b-4bit \
  --quant_config awq \
  --calib_size 128 \
  --dtype float16 \
  --use_parallel_embedding \
  --use_paged_context_fmha

Ключевые флаги: --use_parallel_embedding распределяет embedding слой по нескольким GPU ядрам, --use_paged_context_fmHA включает paged attention как в vLLM, но на уровне компиляции. Результат — модель 68 ГБ вместо 680 ГБ, с потерей качества менее 1% на benchmarks.

3 Сборка голосового конвейера на Rust

Python с его GIL для такого конвейера не подходит. Один поток блокирует интерпретатор, остальные ждут. Rust + Tokio даёт настоящую параллельность.

// Cargo.toml зависимость для аудио
[tependencies]
cpal = "0.15" // Capture Playback Audio Library
tokio = { version = "1.40", features = ["full"] }
tokio-util = { version = "0.7", features = ["codec"] }
bytes = "1.5"

// Основной цикл обработки аудио
async fn audio_pipeline() -> Result<(), Box> {
    let (tx_stt, rx_stt) = tokio::sync::mpsc::channel(32);
    let (tx_llm, rx_llm) = tokio::sync::mpsc::channel(32);
    let (tx_tts, rx_tts) = tokio::sync::mpsc::channel(32);
    
    // Запускаем три задачи параллельно
    tokio::join!(
        stt_worker(rx_stt, tx_llm),
        llm_worker(rx_llm, tx_tts),
        tts_worker(rx_tts)
    );
    
    // Захват аудио с микрофона
    let stream = cpal_stream()?;
    for chunk in stream.chunks(16000) { // 1 секунда аудио
        tx_stt.send(chunk).await?;
    }
    Ok(())
}

Канал на 32 сообщения — это буфер. Если STT обрабатывает дольше 32 секунд (маловероятно), канал заполнится, и захват аудио приостановится. Так мы избегаем накопления лагов.

4 Интеграция Kokoro-82M v2.1

Kokoro — это не просто TTS. Это диференциальный диффузионный модель, которая генерирует спектрограммы за 3 шага вместо 50. Устанавливаем через pip, но с флагом для CUDA 13.5:

pip install kokoro-tts==2.1.3

# В коде Rust вызываем Python через pyo3
// Rust часть
async fn tts_worker(mut rx: Receiver) {
    let py_tts = Python::with_gil(|py| {
        py.import("kokoro_tts")?.getattr("generate")?.into_py(py)
    });
    
    while let Some(text) = rx.recv().await {
        // Добавляем emotional token
        let text_with_emotion = format!("{} [neutral]", text);
        let audio = py_tts.call1((text_with_emotion, "en", "fast"))?;
        play_audio(audio);
    }
}

Параметр "fast" включает режим с 3 диффузионными шагами вместо 20. Качество немного страдает (оценка MOS 4.1 вместо 4.5), но задержка падает с 200 мс до 50 мс. Для голосового агента скорость важнее идеального звучания.

Оптимизации, которые дают эти 375 мс

Базовая сборка будет работать с задержкой 600-700 мс. Чтобы сжать до 375, нужны хитрости.

• Prefill во время речи: Nemotron-4 начинает генерировать ответ, когда STT распознал первые 3-4 слова. Не ждём конца фразы.
• Кэш прошлых ответов: LRU кэш на 1000 пар «вопрос-ответ». Если похожий вопрос уже был, берём ответ из кэша (10 мс вместо 150).
• Streaming TTS: Kokoro поддерживает streaming — начинает синтез, когда сгенерированы первые 5 токенов ответа.
• Приоритетные CUDA streams: Выделяем отдельный stream для STT, отдельный для LLM, отдельный для TTS. NVIDIA H200 поддерживает 128 concurrent streams.

# Пример prefilled generation в TensorRT-LLM
from tensorrt_llm import LLM

llm = LLM(model_dir="nemotron-4-340b-4bit")

# Запускаем генерацию, пока пользователь ещё говорит
def generate_with_prefix(prefix_text, max_new_tokens=50):
    # prefix_text — то, что уже распознал STT
    output = llm.generate(
        prefix_text,
        streaming=True,
        max_new_tokens=max_new_tokens,
        stop_token_ids=[2],  # EOS token
        temperature=0.7,
        top_p=0.9
    )
    
    for token in output:
        yield token  # Отправляем в TTS по токену

Типичные ошибки (и как их избежать)

Я видел десятки попыток собрать подобные системы. Вот что ломается чаще всего.

1. Память GPU переполняется через час работы — не чистите кэш ключей-значений (KV cache). Устанавливайте sliding window attention на 4096 токенов. Старые токены вытесняются.
2. Фоновая музыка ломает STT — Whisper.cpp tiny.en обучался на чистую речь. Добавьте простой noise gate перед подачей в STT: отсекайте фрагменты тише -30 dB.
3. Задержка растёт с каждым часом — утечка памяти в Python биндингах. Перезапускайте TTS процесс каждые 1000 запросов. Грубо, но работает.
4. Ответы становятся бессвязными — контекст переполняется. Используйте архитектуру с несколькими агентами, где каждый отвечает за свою тему.

Самая коварная ошибка: использовать токенизатор не от той модели. Nemotron-4 использует токенизатор на основе SentencePiece, но с модификациями для кода. Если взять стандартный — получите бессмыслицу.

Что дальше? Full-duplex и эмоциональный интеллект

375 мс — это не предел. Следующий шаг — full-duplex диалог, где агент может перебивать, подтверждать "угу" и задавать уточняющие вопросы, пока вы говорите. NVIDIA уже анонсировала PersonaPlex — модель, специально обученную для таких взаимодействий.

Вторая ветка развития — эмоциональная адаптация. Kokoro-82M v2.1 понимает эмоциональные токены, но не умеет определять эмоцию по голосу. Добавьте Voxtral-Mini 4B Realtime как второй STT, который анализирует не слова, а интонацию. Тогда агент сможет сказать "Я понимаю, что вы расстроены" прежде, чем вы произнесёте слово "расстроен".

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

Главный секрет не в технологиях, а в подходе. Измеряйте каждую миллисекунду. Логируйте задержки каждого компонента. Автоматически переключайтесь на более простые модели, когда система перегружена. И помните: идеальный голосовой агент — не тот, который всегда прав, а тот, которого не замечаешь.