Главная / Статьи

Искусственный интеллект для голосовых звонков: почему asyncio превосходит потоки, плюс три ошибки.

Уроки, полученные от реального телефонного агента с функциями STT, LLM и TTS: переход от использования потоков к asyncio, а также проблемы с утечками вызовов инструментов, незавершенными сообщениями и устаревшими передачами данных.

Издатель: REACTAPP.TOP7 мин чтения1538 слов

Источники: Building a Production Voice AI Agent: Threading, Async, and the Bugs Nobody Warns You About

Агент голосового общения в реальном времени, отвечающий на поступающие телефонные звонки, объединяет в себе функции преобразования речи в текст, использование большой языковой модели и преобразования текста обратно в речь, при этом он интегрируется в телефонную сеть. Ему также необходима возможность прерывания разговора — чтобы звонящий мог прервать бота посреди фразы, а также возможность переключения на человеческого оператора и корректного завершения соединения. В этом тексте рассматриваются выборы при проектировании и ошибки, которые принесли наибольший опыт при работе такой системы с одновременными звонками, начиная с ошибки, которую почти не удалось исправить.

Краткое описание процесса

При каждом звонке выполняются три компонента в последовательности:

Caller audio → STT (Deepgram, streaming) → LLM (Groq, LLaMA 70B) → TTS (Cartesia) → Caller
  • Функция «голос в текст» передаёт аудио по протоколу WebSocket и возвращает транскрипцию, с использованием детекции окончания фразы на основе активности голоса.
  • Большая языковая модель возвращает токены, которые хранятся до появления границы предложения (точки, вопросительного знака, восклицательного знака или переноса строки), прежде чем они будут использованы для синтеза речи, что позволяет боту начать говорить ещё до того, как будет полностью сформирован ответ.
  • Синтез речи отправляет аудио обратно вызывающему через тот же телефонный мост, синхронизируя его с реальным временем путём отправки данных каждые 20 мс в строгом временном порядке.

Вокруг этого расположены механизмы обнаружения прерываний, которые останавливают бота сразу, как только звонящий начинает говорить, память, сводящая кратко предыдущие разговоры, чтобы 45-минутный звонок оставался в пределах окна контекста, а также инструменты для выполнения действий, таких как передача звонка человеку или завершение разговора. Ни один из компонентов сам по себе не является самым интересным. Важно то, что происходит, когда одновременно выполняется множество звонков на ограниченном оборудовании.

Потоки казались естественными, но на самом деле таковыми не были

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

Он быстро перестал работать стабильно. На ноутбуке с 16 ГБ ОЗУ и процессором i5 с 8 ядрами уже четыре одновременные вызова приводили к сбоям в работе: пропадали аудиокадры, замедлялось обнаружение прерываний и нарушалась стабильность воспроизведения.

Первой версией проблемы был размер пула задач: при лимите в 30 потоков вызов номер 50 оказывался в очереди после других. Это действительно серьезная проблема при масштабировании, но она не могла объяснить сбои при четырех вызовах.

Настоящая причина была более фундаментальной. Нагрузка обусловлена ожиданием, а не вычислениями. Даже небольшой слушатель для каждого вызова почти всё время находится в состоянии покоя, ожидая аудио-кадры от моста и достаточного уровня сигнала для определения, является ли звук речью или шумом. Фактическая работа по проверке флагов или вычислению значения RMS для обнаружения тишины занимает всего несколько микросекунд во время длительных пауз. Ядровые потоки плохо подходят для этой задачи: каждый из них требует стека памяти, затрат на планирование ядром и смену контекста, а Python добавляет ограничение GIL для всего, что не сводится исключительно к ожиданию операций ввода-вывода. Каждый вызов оплачивает дополнительные затраты потока на ожидание до поступления следующего кадра.

Async/await меняет ситуацию. Один цикл событий может обрабатывать тысячи задач, ожидающих данных с сети, поскольку приостановленная корутина почти не требует ресурсов: нет отдельного стека, нет смены контекста в ядре — просто место в очереди до тех пор, пока сокет не получит данные.

Таким образом, компонент прослушивания в реальном времени наряду с слоями преобразования речи в текст, ИИ-моделями и синтеза был перенесён на asyncio. Переписывание модуля прослушивания является хорошим примером. Ранее фоновый поток пробуждался каждые 20 мс для проверки очереди, выявления наличия аудио и определения того, является ли оно речью; при этом он тратил ресурсы даже во время тишины. После этого цикл передачи аудио вызывает asyncio.wait_for(queue.get(), timeout=...), что полностью приостанавливает корутину без использования CPU до поступления данных или истечения времени ожидания. Флаг вмешательства становится обычным общедоступным состоянием, которое считывается в моментах await, заменяя значение, записываемое из другого потока операционной системы в непредсказуемые моменты.

В результате изменился потолок одновременной обработки. Вопрос теперь не в том, сколько потоков может запланировать ОС, а в том, сколько сокетов может оставаться открытыми, каковы лимиты скорости у провайдера и каков объем сетевой пропускной способности — это гораздо более благоприятная кривая масштабирования для такой нагрузки. Стоит признать: первоначальные опасения по поводу исчерпания ресурсов при 50 запросах были обоснованными, но это была второстепенная проблема, связанная с масштабированием. Основная причина преимуществ асинхронного подхода кроется в архитектуре, поскольку потоки — это неподходящая абстракция для задач, в которых преобладают ожидания ввода-вывода, независимо от размера пула ресурсов.

Три ошибки, о которых стоит знать

Ни одна из них не является редкой. Все они проявляются только тогда, когда реальный конкурентный трафик попадает на реального провайдера больших языковых моделей.

1. Выход данных из инструментов в виде обычного текста

Некоторые чекпоинты LLaMA, размещенные на Groq, иногда оставляют структурированное поле tool_calls пустым. Вместо этого они вставляют строку, похожую на вызов функции, непосредственно в поток текста, который затем синтезатор речи зачитывает вслух.

Писание регулярных выражений для каждой встреченной до сих пор структуры делает процесс неэффективным, поскольку незначительные изменения в пробелах, порядке клавиш или стиле кавычек могут привести к ошибкам. Лучший подход заключается в том, чтобы считать любые необработанные скобки или подозрительные теги в потоке временно небезопасными. Их сразу же задерживают от отправки и освобождают только тогда, когда становится ясно, что это либо полный, разборчивый вызов инструмента (который преобразуется в реальную команду и удаляется из текста ответа), либо это вовсе не вызов инструмента (тогда его возвращают в поток как обычный текст). Также помогает механизм безопасности: если размер задержанного буфера превышает установленный лимит без решения ситуации, его следует считать ложным сигналом, возможно, это имя клиента, содержащее символ, похожий на скобку, и его следует вывести как текст вместо того, чтобы бесконечно задерживать ответ. Урок: когда формат вывода неоднозначен, не стоит перечислять все возможные формы сбоев. Необходимо использовать буфер и проверять данные.

2. Незавершенные вызовы инструментов после прерывания

Если звонящий прервет процесс, пока LLM находится в процессе отправки запроса к инструменту, история может содержать элемент AIMessage, в котором хранятся tool_calls, так и не получившие результата. API Groq отклоняет такие запросы в следующем этапе, поскольку порядок сообщений больше не имеет структурного смысла.

Для решения этой проблемы используются два механизма. Во-первых, при прерывании происходит явное откатирование, которое удаляет ненужные сообщения ИИ, связанные с инструментами, а также сообщение пользователя, вызвавшее прерывание. Затем перед каждым вызовом LLM запускается фильтр в качестве последней линии защиты, который удаляет все некорректные пары сообщений ИИ и инструментов. Откатирование должно предотвратить возникновение проблемы, а фильтр гарантирует, что ошибки в других частях системы не смогут повлиять на следующий этап обработки.

3. Устаревшая передача данных в уже завершенном вызове

Передача запроса человеку и разрыв соединения — это отдельные вызовы инструментов. Благодаря механизму обработки утечек, описанному в баге 1, модель может закономерно запустить оба этих действия за один ход: одно как структурированный вызов, а другое — на основе текста, утекшего из процесса обработки. Если ранее по другой причине была зарегистрирована просьба о передаче запроса, а затем вызов завершился разрывом соединения, система, проверяющая, был ли вызов передан на более высокий уровень, может увидеть устаревшую запись и отправить уже завершенный вызов в очередь обработки человеком.

Решением является правило приоритета, применяемое во всех случаях, когда вызов может завершиться: разрыв соединения всегда имеет приоритет, и каждый путь, который первым завершает вызов, удаляет любые незавершенные записи о передаче запроса. Это простое правило стало очевидным только после наблюдения за происходящим, поскольку два асинхронных вызова инструментов могут завершиться в любом порядке в зависимости от того, как модель форматирует свой ответ.

Незаметные детали, которые имеют значение

Несколько технических улучшений изменили восприятие общения с ботом:

  • Буферизация по границам предложений. Текст передается на синтез целиком, в виде полных предложений, а не по отдельным токенам, что делает речь более естественной, а не похожей на серию фрагментов.
  • Защитный механизм при внезапном прерывании. Детекция прерываний игнорирует первые полтора–два секунды речи бота, поскольку некоторые сервисы синтеза сначала буферизируют весь фрагмент перед трансляцией. Во время этого периода микрофон уже включен, и быстрый ответ на предыдущий вопрос может быть принят за прерывание текущего разговора.
  • Регулировка порогов и временных ограничений в зависимости от активности голоса. Эти параметры позволяют отличить бота, прерывающего человека на полуслове, от бота, кажущегося медлительным; универсальных значений не существует, поэтому они настраиваются на основе реальных записей разговоров.

Что потребовалось

Для всего этого не требовалась экзотическая инфраструктура — ни Kubernetes, ни пользовательские расширения на C, ни специальные сетевые решения. Достаточно было библиотеки asyncio, тщательного управления состоянием и готовности отслеживать происходящее при одновременном выполнении двух асинхронных задач. Абстракции, не зависящие от конкретного поставщика услуг, для работы с большими языками моделирования, преобразованием речи в текст и его синтезом, а также четкое разделение между движком общения и телефонным транспортом позволили заменять поставщиков, добавлять инструменты и исправлять ошибки без необходимости переписывать всё заново. Для тех, кто создаёт что-то подобное, первый вопрос заключается в том, ограничен ли объём работы вводом-выводом или процессором, прежде чем начинать использовать потоки. Это может сэкономить много времени, избавив от бесполезных попыток разобраться, почему четыре вызова замедляют работоспособный ноутбук.