Types de nœuds ============== Chaque action dans un flux conversationnel est un nœud. Les nœuds sont reliés par des arêtes qui définissent l'ordre d'exécution. Il existe 5 types de nœuds principaux : deux points d'entrée qui démarrent chaque appel, un nœud agent conversationnel, et deux nœuds terminaux qui terminent l'appel ou le transfèrent. Welcome entry Point d'entrée standard entrant/sortant Chatbot entry Entrée chatbot propulsé par RAG (fournisseur CHATBOT) Agent agent Tours LLM conversationnels avec routes de sortie Transfer system Transfère l'appel vers un numéro par pont audio Hangup system Terminer l'appel avec message d'au revoir optionnel Interpolation de variables -------------------------- N'importe quel champ texte dans n'importe quel nœud supporte l'interpolation de variables. Utilisez les doubles accolades : ``` Bonjour {{caller_name}}, votre commande {{order_number}} est en route. ``` À l'exécution, le moteur remplace chaque placeholder par la valeur actuelle de cette variable. Si la variable n'a pas encore été définie, le placeholder est résolu en chaîne vide. Tapez `{{` (pour une substitution) ou `[[` (pour une référence) dans n'importe quel champ texte de l'éditeur de flux pour ouvrir une liste déroulante d'autocomplétion de toutes les variables disponibles. Taper `@@` fonctionne toujours comme alias hérité. Sur les champs multiligne (prompts, messages, corps de requête), un bouton **+ variable** se trouve en haut à droite du champ comme alternative visible aux déclencheurs à taper, il ouvre le même sélecteur et insère `@{{nom}}` à la position du curseur. --- Nœuds d'entrée -------------- Les nœuds d'entrée sont le premier nœud exécuté quand un appel se connecte. Chaque flux doit avoir exactement un nœud d'entrée, il ne peut pas être supprimé ni dupliqué. Faites glisser un nœud **Welcome** ou **Chatbot** depuis la palette pour remplacer l'entrée par défaut. ### Nœud Welcome Le point d'entrée standard pour les appels **entrants et sortants**. Il prononce un message d'accueil configurable, puis entre soit en mode LLM conversationnel (quand des routes de sortie sont configurées), soit avance automatiquement vers le nœud suivant connecté. **Comportement :** - **Avec routes de sortie**, prononce le message d'accueil, attend le premier énoncé de l'appelant, et l'évalue contre les routes configurées. Les routes conversationnelles sont classifiées par un LLM qui s'exécute en parallèle du modèle principal, économisant ~250 ms par rapport à une approche séquentielle ; les routes basées sur une règle sont vérifiées instantanément, sans aucun appel LLM. Voir [Routes de sortie basées sur des règles](#rule-based-exits). - **Sans routes de sortie**, prononce le message d'accueil et avance immédiatement vers le nœud suivant (utile comme annonce pure avant un Transfer ou un Hangup). PropriétéDéfautDescription **Message d'accueil**-Texte que l'agent **prononce, puis attend la réponse de l'appelant** : aucun message LLM automatique ne le suit. Prononcé via TTS quand l'appel se connecte. Supporte `{{variable}}`. Laissez vide pour le silence. **Routes de sortie**aucuneRoutes nommées qui transitent vers la branche correspondante, soit **conversationnelles** (le LLM classifie le premier énoncé de l'appelant contre une description en langue naturelle), soit **basées sur une règle** (une condition déterministe sur un résultat d'outil ou une variable, vérifiée instantanément sans classificateur). Voir [Routes de sortie basées sur des règles](#rule-based-exits). **Prompt système**-Prompt système LLM utilisé quand le nœud est en mode conversationnel (routes de sortie présentes). **Interruptible**-Si activé, l'appelant peut interrompre le message d'accueil en parlant par-dessus. **Fournisseurs propres au nœud**valeurs agentConfigure un fournisseur LLM, STT ou TTS différent de celui de l'agent, pour ce nœud uniquement. #### Paramètres sortants Quand l'agent passe des appels sortants, le nœud Welcome contrôle le comportement entre le décrochage et le premier énoncé : ParamètreDéfautDescription `waitForFirstWord``true`Attendre que le destinataire parle avant de jouer le message d'accueil. Quand `false`, l'agent parle immédiatement après la connexion. `waitTimeout``4 s`Durée d'attente du premier mot du destinataire quand `waitForFirstWord` est `true`. Après ce délai, `timeoutAction` est déclenché. `timeoutAction``hangup``hangup`, terminer l'appel silencieusement si aucune parole n'est détectée. `speak`, jouer quand même le message d'accueil (pour la messagerie vocale). `speakDelay``1 s`S'applique uniquement quand `waitForFirstWord` est `false`. Délai supplémentaire avant de parler, compense les bips de connexion des opérateurs. **Messagerie vocale :** Définissez `waitForFirstWord: false` et `timeoutAction: speak`. L'agent jouera son message après `speakDelay` secondes, qu'un humain ou une messagerie vocale réponde. ### Nœud Chatbot Point d'entrée pour les appels chatbot propulsés par RAG. Contrairement aux nœuds Welcome/Agent qui utilisent le fournisseur LLM standard, le nœud Chatbot utilise un **fournisseur CHATBOT** dédié (configuré dans la section Connexions du compte propriétaire de l'agent). Il prononce un message d'accueil optionnel puis entre en mode conversationnel continu jusqu'à ce que l'appelant raccroche. PropriétéDéfautDescription **Fournisseur chatbot**-Le fournisseur de type CHATBOT qui gère la conversation. Doit être configuré par un administrateur dans la section Connexions du compte propriétaire de l'agent. Le fournisseur est lié à la création du nœud et affiché en **lecture seule** dans la boîte de dialogue : pour utiliser un autre fournisseur, ajoutez un nouveau nœud Chatbot. **Message d'accueil**-Message TTS optionnel joué avant le premier énoncé utilisateur. Supporte `{{variable}}`. **Routes de sortie**aucuneRoutes nommées. Quand une route correspond, le flux transite hors du nœud Chatbot vers la branche connectée. Les routes de sortie du Chatbot sont toujours **conversationnelles**, classifiées à partir de la réponse du chatbot ; les routes basées sur une règle (voir [ci-dessous](#rule-based-exits)) ne sont disponibles que sur les nœuds Welcome et Agent. **Réglages STT / TTS du nœud**valeurs agentConfigure des fournisseurs STT et TTS différents de ceux de l'agent, pour ce nœud uniquement. --- Nœud Agent ---------- ### Nœud Agent Le nœud conversationnel principal. Entre en **mode conversation LLM libre** avec un prompt système personnalisé. L'appelant parle, le STT transcrit, le LLM génère une réponse en streaming, le TTS joue l'audio. Ce cycle se répète jusqu'à ce que le LLM transite via une route de sortie, ou que l'appelant raccroche. PropriétéDéfautDescription **Prompt système**-Instructions pour le LLM. Supporte `{{variable}}`. Définissez ici la personnalité, les objectifs, le ton et les contraintes de l'agent. **Routes de sortie**aucuneRoutes nommées, soit **conversationnelles** (un classificateur parallèle vérifie chaque énoncé utilisateur contre une description en langue naturelle ; en cas de correspondance, l'appel LLM principal est annulé, ~250 ms économisés), soit **basées sur une règle** (une condition déterministe sur un résultat d'outil ou une variable, vérifiée instantanément sans classificateur). Chaque route peut porter un court **message de transition** (voir ci-dessous). Voir [Routes de sortie basées sur des règles](#rule-based-exits). **Message d'accueil (à l'entrée depuis un autre nœud)**-Phrase scriptée prononcée à l'entrée du nœud via une route. L'agent la prononce puis **attend l'appelant** : aucun tour LLM et aucun RAG ne s'exécutent ensuite. Laissez *vide* pour déclencher à la place un **tour d'entrée proactif** (voir ci-dessous). Supporte `{{variable}}`. **Fournisseurs propres au nœud**valeurs agentConfigure le fournisseur/modèle/température LLM, le fournisseur/voix/langue TTS et le fournisseur/langue STT, pour ce nœud uniquement. **Mots-clés STT**valeurs agentMots-clés au niveau du nœud, saisis sous forme d'étiquettes, qui améliorent la précision de reconnaissance pour ce nœud uniquement. Une fois définis, un sélecteur de mode apparaît : **Ajouter aux mots-clés du workflow** (par défaut) les fusionne avec la liste au niveau agent, **Remplacer les mots-clés du workflow** n'utilise que la liste du nœud. Voir [Configuration de l'agent → Reconnaissance vocale](https://www.manivox.ai/docs/agents/configuration#stt). **Web Services**valeurs agentQuels comptes Web Service sont disponibles comme outils LLM dans ce nœud. Remplace la liste de l'agent pour ce nœud uniquement. **Base de connaissances**valeurs agentActive la recherche RAG sur les bases de connaissances sélectionnées pour les réponses LLM de ce nœud. Le bouton **Filtrer les résultats peu pertinents** définit un seuil de pertinence par nœud (stocké sous `minScore`) qui écarte les correspondances faibles avant qu'elles n'atteignent le contexte du LLM. **Message de transition des routes de sortie** : chaque route de sortie peut avoir une courte phrase de passation (ex : "Permettez-moi de vérifier cela…") prononcée quand cette route se déclenche. Elle est jouée *en parallèle* avec le démarrage du nœud de destination, récupération RAG, construction du prompt et message d'accueil s'exécutent pendant que le message est prononcé, masquant ainsi la latence plutôt que de l'ajouter. L'audio du nœud de destination est mis en file d'attente derrière lui, garantissant l'ordre. **Tour d'entrée proactif** : quand un nœud Agent est atteint depuis un autre nœud et que son *message d'accueil est vide*, l'agent déclenche un tour immédiatement à l'entrée au lieu d'attendre que l'appelant parle. Ce tour d'entrée diffuse un message **avec les outils du nœud activés** et exécute l'**auto-RAG à l'entrée**, si bien que le nœud peut répondre tout de suite à la question routée ou appeler un outil (par exemple récupérer un planning) dès qu'il prend la main, plutôt que d'annoncer « je vérifie… » et de rester bloqué jusqu'à ce que l'appelant le relance. Si vous renseignez au contraire le message d'accueil, l'agent prononce simplement cette phrase scriptée et attend, sans appel LLM d'entrée ni RAG, utile lorsque l'ouverture est une question à laquelle vous voulez que l'appelant réponde. **Historique de conversation** : l'historique complet de conversation inter-nœuds est conservé comme une liste de messages unique. Chaque tour assistant porte un `agent_label` pour que les nœuds suivants puissent lire une transcription claire par locuteur dans le contexte LLM. ``` // Exemple de route de sortie [Welcome : "Merci d'appeler. Comment puis-je vous aider ?"] routes de sortie : billing, support, cancel → billing: [Agent : prompt système = instructions spécialiste facturation] → support: [Agent : prompt système = instructions support technique] → cancel: [Agent : prompt système = instructions spécialiste rétention] // Le classificateur s'exécute en parallèle à chaque tour utilisateur. // Quand l'utilisateur dit "Je voudrais annuler" : // → le classificateur correspond à la route "cancel" // → l'appel LLM principal est annulé // → le flux transite immédiatement vers la branche cancel ``` ### Routes de sortie basées sur des règles ![Configuration d'une route de sortie basée sur une règle](/docs/exit-routes-dark.gif) Chaque route de sortie d'un nœud Welcome ou Agent est de l'un de ces deux types, choisi via un sélecteur dans l'onglet **Routes de sortie** du dialogue du nœud : TypeLibellé dans l'éditeurMode d'évaluation **Conversationnelle**« L'appelant dit quelque chose » *(L'agent interprète — un instant de réflexion)*Une description en texte libre lue par le LLM classificateur en fonction de la conversation. Flexible, mais ajoute un léger délai de routage et ne peut pas observer de manière fiable ce que l'agent ne peut pas voir, comme le fait qu'un appel d'outil se soit réellement exécuté. **Basée sur une règle**« Une règle est remplie » *(Instantané et exact)*Une condition structurée vérifiée par le moteur de flux lui-même, sans classificateur, sans appel LLM, sans attente. L'appel avance dès que la condition devient vraie. Préférez une règle chaque fois que la transition dépend réellement de quelque chose que le flux connaît déjà de manière déterministe, « l'outil a réussi », « cette variable est définie », plutôt que de ce que l'appelant a dit. Cela referme un vrai mode d'échec : une description conversationnelle du type « quand le dossier a été créé » dépend de l'exécution effective d'un outil, mais le classificateur ne peut juger que la conversation, pas le résultat de l'outil, il peut donc se déclencher trop tôt et abandonner l'appel d'outil en cours. L'éditeur détecte ce cas : une description conversationnelle qui nomme un outil avec une formulation évoquant son exécution (« créé », « soumis », « renvoyé »…) affiche un avertissement ambre avec un bouton **Convertir en règle** en un clic. Une route basée sur une règle porte une seule condition, construite à partir d'un sélecteur en forme de phrase (*« Quand »*) : ConditionOpérateurVérifie Un outil réussit / un outil échoue-L'outil nommé s'est exécuté à ce tour et a renvoyé un succès ou un échec. Les outils disponibles sont les actions Web Service et les actions Composio activées sur le nœud. Une variable…`is_set`La variable contient une valeur non vide. Une variable…`equals` / `not_equals`Comparaison de chaîne insensible à la casse avec une valeur (qui peut elle-même contenir `{{variable}}`). Une variable…`contains`Correspondance de sous-chaîne insensible à la casse. Les nœuds avec des outils activés préconfigurent les nouvelles routes de sortie sur une règle liée au premier outil, le schéma le moins susceptible d'abandonner un appel d'outil. Les nœuds sans outil restent en conversationnel par défaut, comme auparavant. #### Tester ces routes Le panneau **Tester ces routes** en bas de l'onglet Routes de sortie permet de simuler à sec les routes d'un nœud sans passer d'appel. Définissez des valeurs hypothétiques pour les variables du nœud et un résultat hypothétique pour chaque outil (réussi / échoué / non exécuté), le panneau évalue alors chaque route basée sur une règle exactement comme le ferait le runtime, et marque la première qui correspond comme la route que l'appel emprunterait, instantanément. Les routes conversationnelles ne peuvent pas être simulées ainsi, les évaluer est le travail du classificateur au moment de l'appel : le panneau les étiquette donc *en direct* et, quand leur description référence une variable, prévisualise la description avec vos valeurs hypothétiques substituées, à titre indicatif. --- Nœuds système ------------- ### Nœud Transfer Transfère l'appel en **plaçant un appel sortant vers la cible et en pontant les deux branches**. En cas de succès, la branche agent se déconnecte et le flux s'arrête, l'appelant continue avec la destination du transfert. PropriétéDéfautDescription **Numéro cible**-Destination au format E.164. Supporte `{{variable}}` pour le routage dynamique, ex : `{{support_queue_number}}` défini par un nœud précédent. **Message avant transfert**-Prononcé à l'appelant avant le déclenchement du transfert. Supporte `{{variable}}`. Gardez-le en dessous de 2 secondes. **Identifiant appelant personnalisé**appelant originalLe numéro affiché à la destination du transfert. Laissez vide pour transmettre le numéro original de l'appelant. **Délai d'attente**30 sDurée de sonnerie de la cible avant de déclarer l'échec. Plage : 5–120 s. **Navigation IVR — séquence DTMF**-Optionnel. Chiffres envoyés automatiquement *après* le décroché de la cible, pour naviguer dans un menu IVR (SVI), ex : `1w3` (appuie sur 1, pause, appuie sur 3). Caractères autorisés : `0-9`, `*`, `#`, `A-D`, et `w` (pause de 0,5 s). Supporte `{{variable}}`, ex : un poste collecté. Laissez vide pour un transfert normal. **Attente avant envoi**`0` sAffiché uniquement si une séquence DTMF est définie. Secondes laissées au message d'accueil du SVI après le décroché, avant l'envoi des chiffres. Plage : 0–30 s. Un délai sans séquence n'envoie rien. **Handles de sortie** : le nœud Transfer possède un handle de sortie `failure`. Si le transfert échoue (délai d'attente, occupé, erreur réseau), l'exécution suit l'arête `failure`. Si aucune arête d'échec n'est connectée et que le transfert échoue, l'appel se termine. ``` Transfer (vers : +33142000000, message: "Je vous transfère vers la facturation.") ↓ success → le flux s'arrête (appel transféré) ↓ failure → Hangup ("Transfert échoué. Veuillez nous rappeler.") ``` Après un Transfer réussi, la session agent se termine. La transcription, les variables collectées et les événements d'appel sont tous conservés dans l'enregistrement d'appel jusqu'au point de transfert. #### Naviguer dans un IVR après transfert (DTMF) Lorsque la cible du transfert est un menu automatisé (IVR / SVI) plutôt qu'une personne, renseignez la **séquence DTMF** pour atteindre automatiquement la bonne option. Après le décroché de la cible, Manivox attend le délai **Attente avant envoi**, puis compose les chiffres ; chaque `w` ajoute une pause de 0,5 s entre les tonalités. Pendant toute la navigation, l'appelant continue d'entendre la sonnerie, sans invite de menu ni bip, et n'est ponté sur la ligne qu'une fois la séquence terminée. ``` Numéro cible : +33142000000 Séquence DTMF : 2w{{ticket_id}}# Attente avant envoi : 4 s ``` Après le décroché, cela attend 4 s le message d'accueil, appuie sur `2`, marque une pause, compose le `ticket_id` collecté, puis `#`. Les chiffres ne sont envoyés qu'après le décroché de la destination : le handle `failure` se déclenche donc normalement en cas de non-réponse ou d'occupation. Comme les menus IVR varient, **passez un appel de test réel contre le vrai IVR** avant de mettre un transfert DTMF en production. ### Nœud Hangup Termine l'appel. Prononce le message d'au revoir (si configuré), puis signale la session pour terminer. Chaque chemin de flux devrait se terminer par un nœud Hangup, ne laissez jamais de branches sans point de terminaison. PropriétéDéfautDescription **Message d'au revoir**-Texte prononcé avant la déconnexion. Supporte `{{variable}}`. Laissez vide pour un raccrochage silencieux. **Raison**`completed`Stockée dans le champ de raison de raccrochage de l'enregistrement d'appel. Valeurs : `completed`, `transferred`, `error`, `user_hangup`. --- Nœuds de flux (optionnels) -------------------------- Au-delà des types de nœuds principaux, la plateforme propose un ensemble de **nœuds de flux** pour un contrôle déterministe et scripté de la conversation. Ils sont **désactivés par défaut** : un administrateur d'organisation les active par organisation, et ils n'apparaissent dans la palette que des organisations qui les ont activés. Les nœuds de flux optionnels sont **Branch**, **Speak**, **Listen**, **Router**, **API Call**, **Condition** et **Variable**. Si vous ne les voyez pas dans la palette, demandez à votre administrateur de les activer pour votre organisation. ### Nœud Branch Aiguille le flux de manière **déterministe** selon la valeur d'une variable, sans faire intervenir le LLM. À utiliser quand l'étape suivante dépend uniquement de données déjà collectées (un code de statut, une réponse oui/non, un niveau d'abonnement) plutôt que de l'interprétation de ce qu'a dit l'appelant. PropriétéDéfautDescription **Variable**-La variable dont la valeur décide de la route. Elle doit déjà être définie par un nœud précédent, le nœud Branch ne la collecte pas. **Cas**2 cas videsUne liste de cas, chacun avec une **valeur** à comparer. Chaque cas produit son propre handle de sortie, connectez une branche différente à chacun. **Default**toujours présentUn handle de sortie fixe emprunté quand la variable ne correspond à aucun cas. Connectez-le à une branche de repli. **Correspondance** : le nœud compare la valeur de la variable à chaque valeur de cas via une **correspondance de chaîne exacte insensible à la casse** (les espaces de début et de fin sont ignorés). Le **premier** cas correspondant l'emporte ; si aucun cas ne correspond, le flux suit le handle `default`. Le nœud se déclenche **immédiatement et de manière déterministe** à l'entrée, il n'attend pas que l'appelant parle, la variable de routage doit donc déjà contenir une valeur. ``` Branch (variable : {{membership_tier}}) → "gold": [Agent : prompt support prioritaire] → "silver": [Agent : prompt support standard] → default: [Agent : prompt qui demande à l'appelant de confirmer son niveau] ``` ### Nœud API Call Appelle un endpoint HTTP externe en cours de flux, sans aucun LLM impliqué, et mappe la réponse sur des variables. Comme les autres nœuds de flux, il est désactivé par défaut et n'apparaît qu'une fois qu'un administrateur l'active pour votre organisation. PropriétéDéfautDescription **Mode**API brute**API brute** construit la requête à la main (méthode, URL, en-têtes, corps). **Service Web** réutilise un compte Web Service déjà configuré dans Connexions, exposé sous forme de deux listes déroulantes plutôt que de champs bruts. **Service web / Action** *(mode Service Web)*-Deux listes déroulantes, alimentées par les Web Services configurés pour votre organisation : choisissez un service, puis une de ses actions. Changer de service réinitialise l'action ; les paramètres requis par l'action sont saisis en JSON. **Méthode / URL / En-têtes / Corps de la requête** *(mode API brute)*GETChamps de requête HTTP standards. L'URL, les valeurs d'en-tête et le corps JSON supportent tous l'interpolation `{{variable}}`, et la zone de texte du corps dispose du même bouton d'insertion **+ variable** que les prompts et messages. **Variable de sortie / Mappage de reponse**-La variable de sortie contient la réponse brute ; le mappage de réponse extrait en plus des champs spécifiques vers leurs propres variables via JSONPath (ex : `$.data[0].email`). **Délai d'attente**30000 msDurée d'attente de la réponse avant de considérer l'appel comme échoué. **En cas d'erreur**`continue``continue` (*Continuer*), ignore l'échec et poursuit. `stop` (*Arrêter*), termine l'appel. `fallback` (*Message de secours*), prononce un message configuré avant de poursuivre. --- Modèles courants ---------------- ### Flux entrant sur un seul sujet ``` [Welcome : "Merci d'appeler le support. Comment puis-je vous aider ?"] routes de sortie : human_requested, resolved → human_requested: [Transfer : +33142000000, message: "Je vous mets en relation."] ↓ failure [Hangup : "Aucun agent disponible. Veuillez rappeler."] → resolved: [Hangup : "Heureux d'avoir pu vous aider. Bonne journée !"] ``` ### Flux entrant multi-sujet ``` [Welcome : "Bienvenue ! Dites facturation, support ou commercial."] routes de sortie : billing, support, sales → billing: [Agent : spécialiste facturation, prompt système = contexte facturation] route de sortie : transfer_human [Transfer : {{billing_queue}}] ↓ failure [Hangup : "Notre équipe est injoignable. Réessayez plus tard."] → support: [Agent : spécialiste support] route de sortie : transfer_human [Transfer : {{support_queue}}] ↓ failure [Hangup : "Notre équipe est injoignable. Réessayez plus tard."] → sales: [Agent : spécialiste commercial] [Hangup : "Merci de votre intérêt !"] ``` ### Appel sortant ``` [Welcome : sortant, waitForFirstWord=true, waitTimeout=4s, timeoutAction=hangup] routes de sortie : interested, callback, not_interested → interested: [Agent : agent de qualification, prompt système = contexte commercial] route de sortie : transfer_sales [Transfer : {{sales_rep_number}}] ↓ failure [Hangup : "Notre équipe vous contactera par e-mail."] → callback: [Agent : "Quand souhaitez-vous que nous vous rappelions ?"] route de sortie : date_confirmed [Hangup : "Parfait, nous vous appellerons le {{callback_date}}."] → not_interested: [Hangup : "Pas de problème. Bonne journée !"] ```