Agent d’IA vocale lors des appels téléphoniques en direct : pourquoi asyncio bat les threads, ainsi que trois bugs.
Leçons tirées d’un agent téléphonique en temps réel utilisant la reconnaissance de parole, les grands modèles linguistiques et la synthèse vocale : le passage des threads à asyncio, ainsi que les appels d’outils fuités, les messages en suspens et les transferts obsolètes.
Sources: Building a Production Voice AI Agent: Threading, Async, and the Bugs Nobody Warns You About
Un agent vocal en temps réel qui répond aux appels téléphoniques en direct combine la reconnaissance vocale en texte, un LLM et la synthèse vocale en texte, et s’intègre à un système de téléphonie. Il nécessite également une fonction d’interruption, permettant à un appelant de couper le bot au milieu d’une phrase, ainsi que la possibilité de transférer l’appel à un agent humain et une fermeture propre de la connexion. Ce texte présente les choix de conception et les bugs qui ont le plus appris lors du fonctionnement d’un tel système avec des appels simultanés, en commençant par une erreur qui a failli rester non corrigée.
Un aperçu succinct du processus
Chaque appel fait fonctionner trois composants en chaîne :
Caller audio → STT (Deepgram, streaming) → LLM (Groq, LLaMA 70B) → TTS (Cartesia) → Caller
- La reconnaissance vocale transmet de l’audio via WebSocket et renvoie des transcriptions, avec une détection de fin de phrase basée sur l’activité vocale.
- Le LLM renvoie des tokens qui sont conservés jusqu’à la rencontre d’une limite de phrase (un point, un point d’interrogation, un point d’exclamation ou une nouvelle ligne) avant d’être utilisés pour la synthèse vocale, permettant ainsi à l’assistant de commencer à parler avant que la réponse complète ne soit prête.
- La synthèse vocale envoie de l’audio back vers l’appelant par le même pont téléphonique, au rythme en temps réel grâce à l’envoi de trames toutes les 20 ms selon un calendrier horaire.
Autour de cela se trouvent la détection d’intrusion, qui arrête le bot dès que l’appelant parle dessus, une mémoire qui résume les échanges précédents afin que des appels de 45 minutes restent dans la fenêtre de contexte, ainsi que des outils permettant d’exécuter des actions comme transférer l’appel à une personne ou raccrocher. Aucun composant en particulier n’est le plus intéressant ; ce qui compte, c’est ce qui se passe lorsque de nombreux appels sont gérés en même temps sur du matériel modeste.
Les threads semblaient naturels mais ne l’étaient pas
La première conception attribuait à chaque appel un thread en arrière-plan pour gérer les intrusions. Ce dernier écoutait continuellement l’audio de l’appelant et activait un indicateur dès que le discours commençait ; les autres étapes consultaient cet indicateur pour savoir quand devoir se taire et recommencer à écouter. Chaque appel nécessitant un écoutateur toujours actif, un thread par appel semblait intuitif.
Celui-ci a cessé de fonctionner rapidement. Sur un ordinateur portable doté de 16 GB de RAM et d’un processeur i5 à 8 cœurs, quatre appels simultanés suffisaient pour provoquer des ralentissements généralisés, avec des pertes de frames audio, une détection lente des interruptions et une lecture irrégulière.
La première piste était la taille de la file d’attente : avec une limite de 30 threads, l’appel numéro 50 devait attendre derrière les autres. C’est un véritable problème à grande échelle, mais cela ne pouvait pas expliquer les difficultés avec seulement quatre appels.
La véritable cause était plus fondamentale. La charge de travail est limitée par l’attente et non par le calcul. Même un écouteur léger par appel passe presque tout son temps inactif, en attendant les trames audio depuis le pont de communication ainsi que suffisamment de signal pour distinguer la parole du bruit. Le travail réel, qui consiste à vérifier un indicateur ou à calculer une valeur RMS pour détecter le silence, ne dure que quelques microsecondes entre de longues pauses. Les threads du système d’exploitation ne conviennent pas à cela : chacun comporte une pile mémoire, des coûts liés à l’ordonnancement du noyau et au changement de contexte, et Python ajoute le GIL pour tout ce qui n’est pas purement une attente en I/O. Chaque appel doit supporter ces surcoûts de thread jusqu’à ce que la prochaine trame arrive.
Async/await inverse la situation. Une boucle d’événements peut gérer des milliers de tâches en attente sur le réseau, car une coroutine suspendue ne coûte presque rien : pas de pile mémoire dédiée, pas de changement de contexte au niveau du noyau, simplement une place dans une file d’attente jusqu’à ce que son socket reçoive des données.
Ainsi, l’élément d’écoute en mode intrusif, ainsi que les couches de reconnaissance vocale en texte, des modèles LLM et de synthèse, ont été transférés sur asyncio. La réécriture de cet élément d’écoute en est une bonne illustration. Auparavant, un thread en arrière-plan s’éveillait toutes les 20 ms pour vérifier une file d’attente, à la recherche de données audio et pour déterminer s’il s’agissait bien de parole, ce qui entraînait une attente inutile même en période de silence. Par la suite, le boucle d’envoi des données audio appelle asyncio.wait_for(queue.get(), timeout=...), ce qui suspend complètement la coroutine sans consommer de CPU, jusqu’à l’arrivée d’un nouveau frame ou l’échéance du délai imparti. Le flag de mode intrusif devient alors un état partagé ordinaire lu aux points await, remplaçant ainsi une valeur écrite depuis un autre thread du système d’exploitation à des moments imprévisibles.
Le plafond de concurrence a donc changé. La question n’est plus de savoir combien de threads le système d’exploitation peut planifier, mais plutôt combien de sockets peuvent rester ouverts, quel est le limiteur de débit du fournisseur et quelle est la bande passante réseau disponible, ce qui représente une courbe d’échelle bien plus favorable pour ce type de charge. Il convient d’admettre que l’inquiétude initiale concernant l’épuisement du pool à 50 appels n’était pas infondée, mais il s’agissait d’une préoccupation secondaire liée à l’échelle. La raison principale pour laquelle l’approche asynchrone est supérieure est d’ordre architectural, car les threads constituent une abstraction inadaptée pour des tâches dominées par des attentes I/O, quel que soit la taille du pool.
Trois bugs à connaître
Aucun n’est particulièrement exotique. Tous apparaissent uniquement lorsque du trafic concurrentiel réel interagit avec un fournisseur de LLM réel.
1. Les appels aux outils s’échappent sous forme de texte brut
Certains points de contrôle LLaMA hébergés sur Groq laissent parfois le champ structuré tool_calls vide. Au lieu de cela, ils émettent directement dans le flux de texte une chaîne ressemblant à une appel de fonction, que la synthèse vocale lira ensuite à haute voix.
Rédiger une expression régulière pour chaque forme rencontrée jusqu’à présent est inefficace, car de légères modifications dans l’espacement, l’ordre des touches ou le style des guillemets suffisent à provoquer des erreurs. Une approche plus judicieuse consiste à considérer tout accolade brute ou toute balise suspecte dans le flux comme temporairement dangereuse. Elle est immédiatement retenue avant d’être émise et ne sera libérée que si elle s’avère être l’une de deux choses : une invocation d’outil complète et interprétable (convertie en une véritable exécution et retirée du texte parlé) ou bien rien d’autre qu’un texte ordinaire (renvoyé au flux tel quel). Une valve de sécurité est également utile : si le buffer retenu dépasse une limite de taille sans être résolu, il faut le traiter comme un faux positif, peut-être le nom d’un client contenant un caractère ressemblant à une accolade, et l’éliminer en tant que texte plutôt que de bloquer indéfiniment la réponse. La leçon : lorsque le format de sortie est ambigu, ne listez pas les formes possibles d’échec. Bufferisez et vérifiez.
2. Invocations d’outil en suspens après une interruption
Si un appelant interrompt l’LLM au milieu de l’émission d’une requête vers une outil, l’historique peut contenir un AIMessage contenant des tool_calls qui n’ont jamais reçu de résultat. L’API de Groq rejette cela lors du tour suivant, car l’ordre des messages n’a plus de sens structurel.
Deux mécanismes gèrent ce problème. Tout d’abord, un annulation explicite en cas d’interruption supprime le message AI non finalisé, ses résultats d’outil orphelins ainsi que le message de l’utilisateur qui l’a déclenché. Ensuite, un filtre s’exécute avant chaque appel à l’LLM en tant que dernière ligne de défense, éliminant tous les paires de messages AI et d’outil qui ne correspondent pas. L’annulation doit permettre de détecter le problème, tandis que le filtre garantit qu’aucun bug ailleurs ne puisse corrompre le tour suivant.
3. Un transfert obsolète sur une appel déjà terminé
Le transfert vers un humain et la déconnexion sont deux appels d’outils distincts. En raison du traitement des fuites décrit dans la faille 1, le modèle peut légitimement déclencher les deux en une seule étape : l’un via un appel structuré et l’autre à partir de texte fuité. Si une demande de transfert a été enregistrée précédemment pour une autre raison et que l’appel se termine par déconnexion, un système ultérieur qui demande si l’appel a été escaladé pourrait voir cette entrée obsolète et envoyer un appel déjà terminé dans la file d’attente des humains.
La solution consiste en une règle de priorité appliquée partout où un appel peut se terminer : la déconnexion l’emporte toujours, et tout chemin qui termine un appel en premier efface toute entrée de transfert en attente. Il s’agit d’une règle simple qui n’est devenue évidente qu’après avoir observé concrètement ce phénomène, car deux envois asynchrones d’outils peuvent se terminer dans n’importe quel ordre en fonction de la manière dont le modèle formate sa réponse.
Détails peu reluisants mais importants
Quelques ajustements de production ont modifié la manière dont le bot semble s’exprimer :
- Buffertage aux limites des phrases. Le texte est envoyé à la synthèse par phrases complètes, et non token par token, ce qui rend la parole naturelle plutôt que constituée de fragments hachés.
- Mécanisme de protection au démarrage. La détection des interruptions ignore approximativement les premières une seconde et demie à deux secondes de parole du bot, car certains fournisseurs de synthèse stockent l’intégralité de l’enregistrement avant de le diffuser. Pendant cette période silencieuse, le micro reste activé, et une réponse rapide à la question précédente peut être confondue avec une interruption de celle en cours.
- Ajustement de la sensibilité à l’activité vocale pour le seuil et le délai de fin de phrase. Ces paramètres permettent de distinguer un bot qui coupe les gens au milieu d’une pensée d’un bot qui semble lent ; comme il n’existe pas de valeur universelle, ils sont calibrés à partir d’enregistrements réels d’appels.
Les efforts nécessaires
Tout cela ne nécessitait aucune infrastructure exotique, ni Kubernetes, ni extensions C personnalisées, ni réseaux sur mesure. Il suffisait de asyncio, d’une gestion rigoureuse de l’état et de la volonté de suivre ce qui se passe lorsque deux tâches asynchrones s’affrontent. Des abstractions indépendantes des fournisseurs pour les LLM, la reconnaissance vocale et la synthèse vocale, ainsi qu’une séparation claire entre le moteur de conversation et le transport téléphonique, ont permis de changer de fournisseur, d’ajouter des outils et de corriger ces bugs sans avoir à tout réécrire. Pour quiconque développe quelque chose de similaire, la première question à se poser est de savoir si la charge de travail est limitée par les opérations d’entrée/sortie ou par le processeur avant de recourir aux threads. Cela pourrait éviter une après-midi perdue à observer quatre appels gêner un ordinateur portable performant.