Créer un chatbot conversationnel compatible N.L.P à l'aide de Dialogflow de Google

À propos de l'auteur

Nwani Victory travaille en tant qu'ingénieur frontend chez Liferithms.inc de Lagos, Nigeria. Après les heures de bureau, il se double d'un ingénieur cloud à la recherche de moyens de faire du cloud…
En savoir plus sur
Nwani
…

Depuis ELIZA (le premier Natural Language Processing) programme informatique mis en place par Joseph Weizenbaum en 1964) a été créé afin de traiter les entrées des utilisateurs et d'engager des discussions supplémentaires basées sur les phrases précédentes, il y a eu une utilisation accrue de Natural Traitement du langage pour extraire des données clés des interactions humaines. Une application clé du traitement du langage naturel a été la création d'assistants de conversation conversationnels et d'assistants vocaux qui sont utilisés dans les applications mobiles et Web pour agir en tant qu'agents de service client répondant aux besoins virtuels des clients.

En 2019, le L'institut de recherche Capgemini a publié un rapport après avoir mené une enquête sur l'impact des assistants de chat sur les utilisateurs après avoir été intégrés par des organisations au sein de leurs services. Les principales conclusions de cette enquête ont montré que de nombreux clients étaient très satisfaits du niveau d'engagement qu'ils ont obtenu de ces assistants de chat et que le nombre d'utilisateurs qui adoptaient l'utilisation de ces assistants augmentait rapidement!

Pour créer rapidement un chat l'assistant, les développeurs et les organisations exploitent les produits SaaS exécutés sur le cloud tels que Dialogflow de Google, Watson Assistant d'IBM, Azure Bot Service de Microsoft, et aussi Lex d'Amazon pour concevoir le flux de discussion, puis intégrer les chatbots activés par le traitement du langage naturel offerts par ces services dans leur propre service.

Cet article serait utile aux développeurs intéressés par la création d'assistants de discussion conversationnels utilisant Dialogflow car il se concentre sur le Dialogflow lui-même en tant que service et comment les assistants de chat peuvent être créés à l'aide de la console Dialogflow .

Note : Bien que les webhooks personnalisés créés dans cet article soient bien expliqués, une bonne compréhension du langage JavaScript est nécessaire car les webhooks ont été écrits en utilisant JavaScript.

Dialogflow

Dialogflow est une plate-forme qui simplifie le processus de création et de conception d'un assistant de conversation conversationnel de traitement du langage naturel qui peut accepter des données vocales ou textuelles lorsqu'il est utilisé depuis la console Dialogflow ou depuis une application Web intégrée.

Pour comprendre comment Dialogflow simplifie la création d'un assistant de conversation conversationnel, nous l'utiliserons pour créer un agent de service à la clientèle pour un service de livraison de nourriture et voir comment l'assistant de discussion intégré peut être utilisé pour gérer les commandes de nourriture et d'autres demandes du

Avant de commencer la construction, nous devons comprendre certaines des terminologies clés utilisées sur Dialogflow. L'un des objectifs de Dialogflow est d'abstraire les complexités de la construction d'une application de traitement du langage naturel et de fournir une console où les utilisateurs peuvent visuellement créer, concevoir et former un chatbot alimenté par l'IA.

Dialog Flow Terminologies

Voici une liste des terminologies de Dialogflow que nous examinerons dans cet article dans l'ordre suivant:

• Agent
  Un agent sur Dialogflow représente le chatbot créé par un utilisateur pour interagir avec d'autres utilisateurs finaux et effectuer des opérations de traitement de données sur les informations qu'il reçoit . D'autres composants se réunissent pour former un agent et chaque fois qu'un de ces composants est mis à jour, l'agent est immédiatement réentraîné pour que les modifications prennent effet.

  Utilisateur qui souhaite créer un chatbot conversationnel à part entière dans les plus brefs délais possible peut sélectionner un agent parmi les agents prédéfinis qui peuvent être comparés à un modèle qui contient les intentions et les réponses de base nécessaires pour un assistant conversationnel .

  Note: [19659020] Un assistant conversationnel sur Dialogflow sera désormais appelé un «agent» tandis que quelqu'un d'autre à part l'auteur de l'assistant qui interagit avec lui sera appelé un «utilisateur final».

• Intention
  Similaire à sa signification littérale, l'intention est l'objectif final de l'utilisateur dans chaque phrase lorsqu'il interagit avec un agent. Pour un seul agent, plusieurs intentions peuvent être créées pour gérer chaque phrase dans une conversation et elles sont connectées ensemble à l'aide de contextes.

  À partir de l'intention, un agent est capable de comprendre l'objectif final d'une phrase. Par exemple, un agent créé pour traiter les commandes de produits alimentaires des clients serait de reconnaître l'objectif final d'un client de passer une commande pour un repas ou d'obtenir des recommandations sur les repas disponibles à partir d'un menu en utilisant les intentions créées.

• Entity [19659017] Les entités sont un moyen par lequel Dialogflow traite et extrait des données spécifiques à partir de l'entrée d'un utilisateur final. Un exemple de ceci est une entité Car ajoutée à un intent. Les noms des véhicules seraient extraits de chaque entrée de phrase en tant qu'entité Car.

  Par défaut, un agent a des entités système qui ont été prédéfinies lors de sa création. Dialogflow a également la possibilité de définir des entités personnalisées et d'ajouter des valeurs reconnaissables dans cette entité.

• Phrase de formation
  Les phrases de formation sont un moyen majeur permettant à un agent de reconnaître l'intention d'un utilisateur final interagissant avec le agent. Avoir un grand nombre de phrases de formation dans une intention augmente la précision de l'agent pour reconnaître une intention, en fait La documentation de Dialogflow sur les phases de formation recommande d'ajouter «au moins 10-20» phrases de formation à un intent.

  Pour rendre les phrases d'entraînement plus réutilisables, dialogflow donne la possibilité d'annoter des mots spécifiques dans la phrase d'apprentissage. Lorsqu'un mot dans une phrase est annoté, dialogflow le reconnaîtra comme un espace réservé pour les valeurs qui seraient fournies dans l'entrée d'un utilisateur final.

• Contexte
  Les contextes sont des noms de chaîne et ils sont utilisés pour contrôler le flux d'un conversation avec un agent. Sur chaque intention, nous pouvons ajouter plusieurs contextes d'entrée et également plusieurs contextes de sortie. Lorsque l'utilisateur final crée une phrase reconnue par une intention, les contextes de sortie deviennent actifs et l'un d'eux est utilisé pour correspondre à l'intention suivante.

  Pour mieux comprendre les contextes, nous pouvons illustrer le contexte comme la porte d'entrée et de sortie de sécurité , tandis que l'intention comme le bâtiment. Le contexte d'entrée est utilisé lors de l'entrée dans le bâtiment et il accepte les visiteurs qui ont été répertoriés dans l'intention tandis que la porte de sortie est ce qui relie les visiteurs à un autre bâtiment qui est une autre intention.

• Base de connaissances
  Une base de connaissances représente un grand pool d'informations où un agent peut récupérer des données lorsqu'il répond à une intention. Il peut s'agir d'un document dans n'importe quel format tel que txt pdf csv parmi d'autres types de documents pris en charge . Dans l'apprentissage automatique, une base de connaissances pourrait être appelée un ensemble de données de formation .

  Un exemple de scénario dans lequel un agent pourrait faire référence à une base de connaissances serait celui où un agent est utilisé pour obtenir plus de détails sur un service ou une entreprise. Dans ce scénario, un agent peut faire référence aux questions fréquemment posées du service comme base de connaissances.

• Fulfillment
  Dialogflow’s Fulfillment permet à un agent de donner une réponse plus dynamique à une intention reconnue plutôt qu’à une réponse créée de manière statique. Cela peut être en appelant un service défini pour effectuer une action telle que la création ou l'extraction de données à partir d'une base de données.

  La réalisation d'une intention est obtenue grâce à l'utilisation d'un webhook. Une fois activée, une intention correspondante ferait une requête API au webhook configuré pour l'agent dialogflow.

Maintenant que nous comprenons les terminologies utilisées avec Dialogflow, nous pouvons continuer à utiliser la console Dialogflow pour créer et former notre premier agent pour un service de restauration hypothétique.

Utilisation de la console Dialogflow

Remarque: L'utilisation de la console Dialogflow nécessite un compte Google et un projet sur Google Cloud Platform est créé. En cas d'indisponibilité, un utilisateur serait invité à se connecter et à créer un projet lors de la première utilisation.

La console Dialogflow est l'endroit où l'agent est créé, conçu et formé avant de s'intégrer à d'autres services. Dialogflow fournit également des points de terminaison de l'API REST pour les utilisateurs qui ne souhaitent pas utiliser la console lors de la création avec Dialogflow.

Pendant que nous parcourons la console, nous allons progressivement créer l'agent qui agirait comme un agent de service à la clientèle pour un service de livraison de nourriture ayant la capacité de lister les repas disponibles, d'accepter une nouvelle commande et de donner des informations sur un repas demandé.

L'agent que nous allons créer aura le flux de conversation montré dans le diagramme de flux ci-dessous où un utilisateur peut acheter un repas ou obtenir la liste des repas disponibles, puis acheter l'un des repas indiqués.

Création d'un nouvel agent

Dans chaque projet nouvellement créé, Dialogflow inviterait le premier utilisateur à créer un agent qui prendrait les champs suivants:

• Un nom à identifier l'agent.
• Une langue dans laquelle l'agent répondrait. Si elle n'est pas fournie, l'anglais par défaut est utilisé.
• Un projet sur Google Cloud auquel associer l'agent.

Immédiatement après avoir cliqué sur le bouton Créer après avoir ajouté les valeurs des champs ci-dessus, un nouvel agent serait enregistré et l'onglet Intents serait affiché avec les intentions de secours par défaut et de bienvenue par défaut comme les deux seules intentions disponibles qui sont créées par défaut avec chaque agent sur Dialogflow. [19659054] L'onglet Intents avec les deux intentions créées par défaut « />

En explorant l'intention de secours par défaut, nous pouvons voir qu'elle n'a pas de phrase d'entraînement mais contient des phrases telles que "Désolé, pouvez-vous le redire?", "Qu'est-ce que c'était?", «Dites ça encore une fois?» comme réponses pour indiquer que l'agent n'a pas été en mesure de reconnaître une phrase qui a été faite par un utilisateur final. Lors de toutes les conversations avec l'agent, ces réponses ne sont utilisées que lorsque l'agent ne peut pas reconnaître une phrase saisie ou prononcée par un utilisateur.

Bien que les phrases ci-dessus soient suffisantes pour indiquer que l'agent ne comprend pas la dernière phrase tapée, nous aimerions aider l'utilisateur final en lui donnant des informations supplémentaires pour l'indiquer. sur ce que l'agent peut reconnaître. Pour ce faire, nous remplaçons toutes les phrases listées ci-dessus par les suivantes et cliquons sur le bouton Enregistrer pour l'agent à recycler.

 Je n'ai pas compris. Je m'appelle Zara et je peux vous aider à acheter ou à en apprendre davantage sur les repas du service de livraison de nourriture Dialogflow. Qu'est-ce que tu aimerais que je fasse?

J'ai manqué ce que tu as dit. Je m'appelle Zara et je peux vous aider à acheter ou à en apprendre davantage sur les repas du service de livraison de nourriture Dialogflow. Qu'est-ce que tu aimerais que je fasse?

Désolé, je n'ai pas compris. Pouvez-vous le reformuler? Je m'appelle Zara au fait et je peux vous aider à acheter ou à en apprendre davantage sur les repas auprès du service de livraison de nourriture Dialogflow.

Hé, j'ai manqué que je suis Zara et je peux vous aider à acheter ou à en savoir plus sur les repas du service de livraison de nourriture Dialogflow. Que voudriez-vous que je fasse? 

De chacune des quatre phrases ci-dessus, nous pouvons observer que l'agent ne pouvait pas reconnaître ce qu'était la dernière phrase faite et aussi un élément d'information sur ce que l'agent peut faire, laissant ainsi entendre le l'utilisateur sur ce qu'il faut taper ensuite pour continuer la conversation.

En passant à côté de Intention de bienvenue par défaut la première section de la page d'intention est la Section Contexte et en la développant nous pouvons voir que les contextes d'entrée et de sortie sont vides. À partir du flux de conversation de l'agent montré précédemment, nous voulons qu'un utilisateur final passe une commande de repas ou demande une liste de tous les repas disponibles. Cela nécessiterait les deux nouveaux contextes de sortie suivants, ils deviendraient chacun actifs lorsque cette intention est mise en correspondance;

• awaiting_order_request
  Ceci serait utilisé pour faire correspondre les demandes d'ordre de traitement d'intention lorsqu'un utilisateur final le souhaite pour passer une commande pour un repas.

• awaiting_info_request
  Ceci serait utilisé pour faire correspondre l'intention qui récupère les données de tous les repas lorsqu'un utilisateur final souhaite connaître les repas disponibles .

Après la section de contexte se trouvent les événements de l'intention et nous pouvons voir que le type d'événement Bienvenue est ajouté à la liste des événements indiquant que cette intention sera utilisée en premier lorsque le L'agent est chargé.

Viennent ensuite les Phrases d'entraînement pour l'intention. En raison de sa création par défaut, il contient déjà 16 phrases qu'un utilisateur final taperait ou dirait probablement lorsqu'il interagirait avec l'agent pour la première fois.

Grand aperçu )

Lorsqu'un utilisateur final tape ou fait une phrase similaire à celles répertoriées dans les phrases de formation ci-dessus, l'agent répondrait en utilisant une réponse choisie dans la section Liste des réponses ci-dessous: [19659072] Une liste a généré des réponses dans l'intention de bienvenue par défaut. « />

Chacune des réponses ci-dessus est automatiquement générée pour chaque agent sur Dialogflow. Bien qu'ils soient grammaticalement corrects, nous ne les utiliserions pas pour notre agent alimentaire. Étant une intention par défaut qui accueille un utilisateur final auprès de notre agent, une réponse de l'agent devrait indiquer à quelle organisation il appartient et également répertorier ses fonctionnalités dans une seule phrase.

Nous supprimerions toutes les réponses ci-dessus et les remplacerions par ceux ci-dessous pour mieux aider à informer l'utilisateur final sur ce qu'il doit faire ensuite avec l'agent.

 1. Bonjour, je m'appelle Zara et je suis là pour vous aider à acheter ou à vous renseigner sur les repas auprès du service de livraison de nourriture Dialogflow. Qu'est-ce que tu aimerais que je fasse?

2. Bonjour, je m'appelle Zara et je peux vous aider à acheter ou à en apprendre davantage sur les repas grâce au service de livraison de nourriture Dialogflow. Que voulez-vous que je fasse? 

D'après les deux réponses ci-dessus, nous pouvons voir que cela indique à un utilisateur final quel est le nom du bot, les deux choses que l'agent peut faire, et enfin, il pousse la fin – l'utilisateur pour prendre d'autres mesures. Prendre d'autres mesures plus loin de cette intention signifie que nous devons connecter l'intention de bienvenue par défaut à une autre. Ceci est possible sur Dialogflow en utilisant le contexte.

Lorsque nous ajoutons et sauvegardons ces deux phrases ci-dessus, dialogflow réentraînerait immédiatement l'agent afin que je puisse répondre en utilisant l'une d'entre elles.

Ensuite, nous passons à en créer deux. plus l'intention de gérer les fonctionnalités que nous avons ajoutées dans les deux réponses ci-dessus. L'un pour acheter un aliment et le second pour obtenir plus d'informations sur les repas auprès de notre service de restauration.

Création d'une intention de liste-repas:

Cliquez sur l'icône + (ajouter) dans le menu de navigation de gauche pour accéder à la page de créant de nouvelles intentions et nous nommons cette intention list-available-foods .

De là, nous ajoutons un contexte de sortie avec le nom pending-order-request . Ce contexte de sortie serait utilisé pour lier cette intention à la suivante où ils commandent un repas car nous nous attendons à ce qu'un utilisateur final passe une commande pour un repas après avoir obtenu la liste des repas disponibles.

Passons aux phrases de formation section sur la page d'intention, nous ajouterons les phrases suivantes fournies par l'utilisateur final afin de savoir quels repas sont disponibles.

 Hé, j'aimerais connaître les repas disponibles.
Quels sont les éléments de votre menu?
Y a-t-il des repas disponibles?
J'aimerais en savoir plus sur les repas que vous proposez. 

Ensuite, nous ajouterons juste la réponse de secours ci-dessous à la section Réponses:

 Bonjour, la liste de nos repas n'est actuellement pas disponible. Veuillez revenir dans quelques minutes car les éléments de la liste sont régulièrement mis à jour. 

D'après la réponse ci-dessus, nous pouvons constater qu'elle indique que la liste des repas n'est pas disponible ou qu'une erreur s'est produite quelque part. En effet, il s'agit d'une réponse de secours et ne serait utilisée que lorsqu'une erreur se produit lors de la récupération des repas. La réponse principale serait une exécution en utilisant l'option webhooks que nous allons configurer ensuite.

La dernière section de cette page d'intention est la section Fulfillment et elle est utilisée pour fournir des données à l'agent pour être utilisé comme réponse d'une API ou d'une source déployée en externe. Pour l'utiliser, nous activerions l'option Webhook call dans la section Fulfillment et configurer le traitement pour cet agent à partir de l'onglet Traitement.

Managing Fulfillment:

Depuis l'onglet Fulfillment de la console, un développeur a la possibilité d'utiliser un webhook qui donne la possibilité d'utiliser n'importe quelle API déployée via son point de terminaison ou d'utiliser l'éditeur de code en ligne pour créer une application sans serveur à déployer en tant que fonction cloud sur Google Cloud. Si vous souhaitez en savoir plus sur les applications sans serveur, cet article fournit un excellent guide pour démarrer avec les applications sans serveur.

Chaque fois qu'un utilisateur final interagit avec l'agent et que l'intention correspond, une demande POST est adressée au point final. Parmi les différents champs d'objet dans le corps de requête un seul nous concerne, à savoir l'objet queryResult comme indiqué ci-dessous:

 {
  "queryResult": {
    "queryText": "Expression de l'utilisateur final",
    "paramètres": {
      "param-name": "param-value"
    },
  },
} 

Bien qu’il existe d’autres champs dans le queryResult comme un contexte, l’objet parameters est plus important pour nous car il contient le paramètre extrait du texte de l’utilisateur. Ce paramètre serait le repas demandé par l'utilisateur et nous l'utiliserions pour interroger la base de données du service de livraison de nourriture.

Lorsque nous aurons fini de configurer le traitement, notre agent aura la structure et le flux de données suivants:

A partir du diagramme ci-dessus, nous pouvons observer que la fonction cloud agit comme un intermédiaire dans toute la structure. L'agent Dialogflow envoie le paramètre extrait du texte d'un utilisateur final à la fonction cloud dans une charge utile de requête et la fonction cloud, à son tour, interroge la base de données pour le document en utilisant le nom reçu et renvoie les données interrogées dans une charge utile de réponse à l'agent.

Pour démarrer une implémentation du système de conception ci-dessus, nous commencerions par créer la fonction cloud localement dans une machine de développement, puis la connecter à notre agent de flux de dialogue en utilisant l'option webhook personnalisé. Une fois qu'il a été testé, nous pouvons passer à l'utilisation de l'éditeur en ligne dans l'onglet de traitement pour créer et déployer une fonction cloud pour l'utiliser. Nous commençons ce processus en exécutant les commandes suivantes à partir de la ligne de commande:

 # Créer un nouveau projet et (&&) y accéder.
mkdir dialogflow-food-agent-server && cd dialogflow-food-agent-server

# Créer un nouveau projet Node
fil init -y

# Installer les packages nécessaires
yarn add mongodb @ google-cloud / functions-framework dotenv 

Après avoir installé les packages nécessaires, nous modifions le fichier package.json généré pour inclure deux nouveaux objets qui nous permettent d'exécuter une fonction cloud localement en utilisant le Functions Framework .

 // package.json
{
  "main": "index.js",
  "scripts": {
    "start": "fonctions-framework --target = foodFunction --port = 8000"
  },
}

La commande start dans les scripts ci-dessus indique au Framework functions d'exécuter la foodFunction dans le fichier index.js et lui permet également d'écouter et de servir les connexions via notre hôte local sur le port 8000 .

Vient ensuite le contenu du fichier index.js qui contient la fonction; nous utiliserons le code ci-dessous car il se connecte à une base de données MongoDB et interroge les données à l'aide du paramètre transmis par l'agent Dialogflow.

 require ("dotenv"). config ();

exports.foodFunction = async (req, res) => {
  const {MongoClient} = require ("mongodb");
  const CONNECTION_URI = process.env.MONGODB_URI;

  // initie une connexion au cluster mongodb déployé
  client const = new MongoClient (CONNECTION_URI, {
    useNewUrlParser: vrai,
  });

  client.connect ((err) => {
    if (err) {
      res
        .status (500)
        .send ({status: "MONGODB CONNECTION REFUSED", erreur: err});
    }
    const collection = client.db (process.env.DATABASE_NAME) .collection ("Repas");
    résultat const = [];
    const data = collection.find ({});
    repas const = [
      {
        text: {
          text: [
            `We currently have the following 20 meals on our menu list. Which would you like to request for?`,
          ],
        },
      },
    ];
    result.push (
      data.forEach ((élément) => {
        const {nom, description, prix, image_uri} = article;
        carte const = {
          carte: {
            title: `$ {name} à $$ {price}`,
            sous-titre: description,
            imageUri: image_uri,
          },
        };
        repas.push (carte);
      })
    );

    Promise.all (résultat)
      .then ((_) => {
        réponse const = {
          réalisationMessages: repas,
        };
        res.status (200) .json (réponse);
      })
      .catch ((e) => res.status (400) .send ({erreur: e}));
    client.close ();
  });
};

À partir de l'extrait de code ci-dessus, nous pouvons voir que notre fonction cloud extrait des données d'une base de données MongoDB, mais passons progressivement à travers les opérations impliquées dans l'extraction et le retour de ces données.

• Premièrement, la fonction cloud démarre une connexion à un cluster MongoDB Atlas puis il ouvre la collection stockant les documents de catégorie de repas dans la base de données utilisée pour le service alimentaire sur le cluster.

• Ensuite, en utilisant le paramètre passé dans la requête à partir de l'entrée de l'utilisateur, nous exécutons une méthode find sur la collection pour obtenir qui renvoie ensuite un curseur que nous répétons pour obtenir tous les documents MongoDB dans la collection contenant les données.

• Nous modélisons les données renvoyées par MongoDB dans la structure d'objet Rich response message de Dialogflow qui affiche chacun des plats à l'utilisateur final sous forme de carte avec un imag e, titre et une description.

• Enfin, nous renvoyons l'intégralité des données à l'agent après l'itération dans un corps JSON et terminons l'exécution de la fonction avec un statut 200 code.

Remarque: L'agent Dialogflow attend une réponse après l'envoi d'une requête dans un délai de 5 secondes. Cette période d'attente correspond au moment où l'indicateur de chargement est affiché sur la console et, une fois qu'il s'est écoulé sans obtenir de réponse du webhook, l'agent utilise par défaut l'une des réponses ajoutées dans la page d'intention et renvoie un DEADLINE EXCEEDED Erreur. Cette limitation mérite d'être prise en compte lors de la conception des opérations à exécuter à partir d'un webhook. La section API error retries dans le Dialogflow best practices contient des étapes sur la façon d'implémenter un système de relance.

Maintenant, la dernière chose nécessaire est un .env ] créé dans le répertoire du projet avec les champs suivants pour stocker les variables d'environnement utilisées dans index.js .

 #. env
MONGODB_URI = "MONGODB CONNEXION STRING"
DATABASE_NAME = "" 

À ce stade, nous pouvons démarrer la fonction localement en exécutant yarn start à partir de la ligne de commande dans le répertoire du projet. Pour l'instant, nous ne pouvons toujours pas utiliser la fonction en cours d'exécution car Dialogflow ne prend en charge que les connexions sécurisées avec un certificat SSL, et où Ngrok entre en scène.

En utilisant Ngrok nous peut créer un tunnel pour exposer le port localhost exécutant la fonction cloud à Internet avec un certificat SSL attaché à la connexion sécurisée en utilisant la commande ci-dessous à partir d'un nouveau terminal;

 ngrok http -bind-tls = true 8000 

Ce démarrerait le tunnel et générerait une URL de transfert qui serait utilisée comme point de terminaison de la fonction exécutée sur une machine locale.

Remarque: Le supplément -bind-tls = true L'argument est ce qui ordonne à Ngrok de créer un tunnel sécurisé plutôt que la connexion non sécurisée qu'il crée par défaut.

Maintenant, nous pouvons copier la chaîne URL en face du texte de transfert dans le terminal et coller dans le champ de saisie URL qui se trouve dans le Webhook

Pour tester tout ce qui a été fait jusqu'à présent, nous ferions une phrase à l'agent Dialogflow demandant la liste des repas disponibles en utilisant le champ de saisie en haut à droite de la console Dialogflow et regardions comment il attend et utilise une réponse envoyée par la fonction en cours d'exécution.

En partant du terminal placé au centre dans l'image ci-dessus, nous pouvons la série de requêtes POST faites à la fonction exécutée localement et sur le côté droit la réponse de données de la fonction formatée en cartes.

Si pour une raison quelconque une demande de webhook échoue, Dialogflow résoudra l'erreur en utilisant l'une des réponses répertoriées. Cependant, nous pouvons découvrir pourquoi la demande a échoué en utilisant l'outil Informations de diagnostic mis à jour dans chaque conversation. Il contient les onglets Raw API response Fulfillment request Fulfillment response et Fulfillment status contenant JSON données formatées. En sélectionnant l'onglet Réponse d'exécution, nous pouvons voir la réponse du webhook qui est la fonction cloud s'exécutant sur notre machine locale.

À ce stade, nous nous attendons à ce qu'un utilisateur poursuive la conversation avec une commande d'un des repas listés. Nous créons le dernier intent de cette démo à côté de la gestion des commandes de repas.

Création de l'intention de demande de repas:

En suivant les mêmes étapes que lors de la création du premier intent, nous créons un nouvel intent à l'aide de la console et le nommons request-meal et ajoutez un contexte d'entrée de awaiting_order_request pour connecter cet intent à partir de l'intention de bienvenue par défaut ou de l'intention de repas disponibles sur la liste.

Dans la section des phrases de formation, nous utilisons des phrases suivantes,

 Bonjour, je suis affamé, puis-je avoir de la nourriture?

Yo, je veux passer une commande pour de la nourriture.

J'ai besoin de manger maintenant.

Mec, j'aimerais acheter 40 $ de nourriture.

Hé, puis-je avoir 2 assiettes de nourriture? 

En lisant les phrases ci-dessus, nous pouvons observer qu'elles indiquent toutes une chose: l'utilisateur veut de la nourriture. Dans toutes les phrases énumérées ci-dessus, le nom ou le type d'aliment n'est pas spécifié, mais ils sont tous spécifiés comme aliment . C'est parce que nous voulons que l'aliment ait une valeur dynamique, si nous devions lister tous les noms d'aliment, nous aurions certainement besoin d'une très grande liste de phrases d'entraînement. Cela s'applique également à la quantité et au prix des aliments commandés, ils seraient annotés et l'agent serait en mesure de les reconnaître comme un espace réservé pour les valeurs réelles dans une entrée.

Pour rendre dynamique une valeur dans une phrase, dialogflow fournit des entités. Les entités représentent des types de données courants, et dans cette intention, nous utilisons des entités pour faire correspondre plusieurs types d'aliments, différents montants de prix et la quantité de la phrase d'un utilisateur final à la demande.

À partir des phrases d'entraînement ci-dessus, dialogflow reconnaîtrait 40 $ sous @ sys.unit-currency qui appartient à la catégorie montants avec unités de la liste d'entités système et 2 sous @number sous la catégorie de numéro de la liste d'entités système . Cependant, nourriture n'est pas une entité système non reconnue . Dans un cas comme celui-ci, dialogflow donne aux développeurs la possibilité de créer une entité personnalisée à utiliser.

Managing Entities

Double-cliquer sur food affichera le dans le menu déroulant des entités, au bas des éléments de la liste déroulante, nous trouvons le bouton Créer une nouvelle entité et en cliquant dessus, vous accédez à l'onglet Entités de la console de dialogue, où nous pouvons gérer toutes les entités pour le agent.

Lorsque dans l'onglet Entités, nous nommons cette nouvelle entité comme food puis dans la liste déroulante des options située dans la barre de navigation supérieure à côté du bouton Enregistrer nous avons la possibilité de basculer l'entrée d'entités dans un mode d'édition brut. Cela nous permettrait d'ajouter plusieurs valeurs d'entité au format json ou csv plutôt que d'avoir à ajouter les valeurs d'entités l'une après l'autre.

Après le mode d'édition a été modifié, nous copierions les données d'exemple JSON ci-dessous dans la boîte de l'éditeur.

 // foods.json

[
    {
        "value": "Fries",
        "synonyms": [
            "Fries",
            "Fried",
            "Fried food"
        ]
    },
 {
        "value": "Bœuf râpé",
        "synonymes": [
            "Shredded Beef",
            "Beef",
            "Shredded Meat"
        ]
    },
    {
        "value": "Poulet râpé",
        "synonymes": [
            "Shredded Chicken",
            "Chicken",
            "Pieced Chicken"
        ]
    },

    {
        "value": "Sauce aigre douce",
        "synonymes": [
            "Sweet Sour Sauce",
            "Sweet Sour",
            "Sauce"
        ]
    },
    {
        "value": "Spring Onion",
        "synonymes": [
            "Spring Onion",
            "Onion",
            "Spring"
        ]
    },
    {
        "value": "Toast",
        "synonymes": [
            "Toast",
            "Toast Bread",
            "Toast Meal"
        ]
    },
    {
        "value": "Sandwich",
        "synonymes": [
            "Sandwich",
            "Sandwich Bread",
            "Sandwich Meal"
        ]
    },
    {
        "value": "Wrap aux œufs et à la saucisse",
        "synonymes": [
            "Eggs Sausage Wrap",
            "Eggs Sausage",
            "Sausage Wrap",
            "Eggs"
        ]
    },
    {
        "value": "Crêpes",
        "synonymes": [
            "Pancakes",
            "Eggs Pancakes",
            "Sausage Pancakes"
        ]
    },
    {
        "value": "Noix de cajou",
        "synonymes": [
            "Cashew Nuts",
            "Nuts",
            "Sausage Cashew"
        ]
    },
    {
        "value": "Sweet Veggies",
        "synonymes": [
            "Sweet Veggies",
            "Veggies",
            "Sweet Vegetables"
        ]
    },
    {
        "value": "Salade de poulet",
        "synonymes": [
            "Chicken Salad",
            "Salad",
            "Sweet Chicken Salad"
        ]
    },
    {
        "value": "Poulet croquant",
        "synonymes": [
            "Crunchy Chicken",
            "Chicken",
            "Crunchy Chickens"
        ]
    },
    {
        "value": "Haricots rouges pomme",
        "synonymes": [
            "Apple Red Kidney Beans",
            "Sweet Apple Red Kidney Beans",
            "Apple Beans Combination"
        ]
    },
] 

À partir des données formatées JSON ci-dessus, nous avons 15 exemples de repas. Chaque objet du tableau a une clé «valeur» qui est le nom du repas et une clé «synonymes» contenant un tableau de noms très similaires à la valeur de l'objet. [19659006]After pasting the json data above, we also check the Fuzzy Matching checkbox as it enables the agent to recognize the annotated value in the intent even when incompletely or slightly misspelled from the end user's text.

After saving the entity values above, the agent would immediately be re-trained using the new values added here and once the training is completed, we can test by typing a text in the input field at the right section.

Responses within this intent would be gotten from our previously created function using the intent’s fulfillment webhook, however, we add the following response to serve as a fallback to be used whenever the webhook is not executed successfully.

I currently can't find your requested meal. Would you like to place an order for another meal?

We would also modify the code of the existing cloud function to fetch a single requested as it now handles requests from two intents.

require("dotenv").config();

exports.foodFunction = async (req, res) => {
  const { MongoClient } = require("mongodb");
  const CONNECTION_URI = process.env.MONGODB_URI;

  const client = new MongoClient(CONNECTION_URI, {
    useNewUrlParser: true,
  });

  // initate a connection to the deployed mongodb cluster
  client.connect((err) => {
    if (err) {
      res
        .status(500)
        .send({ status: "MONGODB CONNECTION REFUSED", error: err });
    }

    const collection = client.db(process.env.DATABASE_NAME).collection("Meals");
    const { displayName } = req.body.queryResult.intent;
    const result = [];

    switch (displayName) {
      case "list-available-meals":
        const data = collection.find({});
        const meals = [
          {
            text: {
              text: [
                `We currently have the following 20 meals on our menu list. Which would you like to request for?`,
              ],
            },
          },
        ];
        result.push(
          data.forEach((item) => {
            const {
              name,
              description,
              price,
              availableUnits,
              image_uri,
            } = item;
            const card = {
              card: {
                title: `${name} at $${price}`,
                subtitle: description,
                imageUri: image_uri,
              },
            };
            meals.push(card);
          })
        );
        return Promise.all(result)
          .then((_) => {
            const response = {
              fulfillmentMessages: meals,
            };
            res.status(200).json(response);
          })
          .catch((e) => res.status(400).send({ error: e }));

      case "request-meal":
        const { food } = req.body.queryResult.parameters;

        collection.findOne({ name: food }, (err, data) => {
          if (err) {
            res.status(400).send({ error: err });
          }
          const { name, price, description, image_uri } = data;
          const singleCard = [
            {
              text: {
                text: [`The ${name} is currently priced at $${price}.`],
              },
            },
            {
              card: {
                title: `${name} at $${price}`,
                subtitle: description,
                imageUri: image_uri,
                buttons: [
                  {
                    text: "Pay For Meal",
                    postback: "htts://google.com",
                  },
                ],
              },
            },
          ];
          res.status(200).json(singleCard);

      default:
        break;
    }

    client.close();
  });
};

From the highlighted parts above, we can see the following new use cases that the function has now been modified to handle:

• Multiple intents
  the cloud function now uses a switch statement with the intent’s name being used as cases. In each request payload made to a webhook, Dialogflow includes details about the intent making the request; this is where the intent name is being pulled from to match the cases within the switch statement.
• Fetch a single meal
  the Meals collection is now queried using the value extracted as a parameter from the user’s input.
• A call-to-action button is now being added to the card which a user can use to pay for the requested meal and clicking it opens a tab in the browser. In a functioning chat assistant, this button’s postback URL should point to a checkout page probably using a configured third-party service such as Stripe checkout.

To test this function again, we restart the function for the new changes in the index.js file to take effect and run the function again from the terminal by running yarn start.

Note: You don’t have to restart the terminal running the Ngrok tunnel for the new changes to take place. Ngrok would still forward requests to the updated function when the webhook is called.

Making a test sentence to the agent from the dialogflow console to order a specific meal, we can see the request-meal case within the cloud function being used and a single card getting returned as a response to be displayed.

At this point, we can be assured that the cloud function works as expected. We can now move forward to deploy the local function to the Google Cloud Functions using the following command;

gcloud functions deploy "foodFunction" --runtime nodejs10 --trigger-http --entry-point=foodFunction --set-env-vars=[MONGODB_URI="MONGODB_CONNECTION_URL", DATABASE_NAME="DATABASE_NAME"] --allow-unauthenticated

Using the command above deploys the function to the Google Cloud with the flags explained below attached to it and logs out a generated URL endpoint of deployed cloud function to the terminal.

• NAME
  This is the name given to a cloud function when deploying it and is it required. In our use case, the name of the cloud function when deployed would be foodFunction.

• trigger-http
  This selects HTTP as the function’s trigger type. Les fonctions cloud avec un déclencheur HTTP seraient appelées à l'aide de leur point de terminaison URL généré. The generated URLs are secured and use the https protocol.

• entry-point
  This the specific exported module to be deployed from the file where the functions were written.

• set-env-vars
  These are the environment variables available to the cloud function at runtime. In our cloud function, we only access our MONGODB_URI and DATABASE_NAME values from the environment variables.

  The MongoDB connection string is gotten from a created MongoDB cluster on Atlas. If you need some help on creating a cluster, the MongoDB Getting started section provides great help.

• allow-authenticated
  This allows the function to be invoked outside the Google Cloud through the Internet using its generated endpoint without checking if the caller is authenticated.

Dialogflow Integrations

Dialogflow gives developers the feature to integrate a built agent into several conversational platforms including social media platforms such as Facebook Messenger, Slack, and Telegram. Asides from the two integration platforms which we used for our built agent, the Dialogflow documentation lists the available types of integrations and platforms within each integration type.

Integrating With Google Actions

Being a product from Google’s ecosystem, agents on Dialogflow integrate seamlessly with Google Assistant in very few steps. From the Integrations tab, Google Assistant is displayed as the primary integration option of a dialogflow agent. Clicking the Google Assistant option would open the Assistant modal from which we click on the test app option. From there the Actions console would be opened with the agent from Dialogflow launched in a test mode for testing using either the voice or text input option.

Integrating a dialogflow agent with the Google Assistant is a huge way to make the agent accessible to millions of Google Users from their Smartphones, Watches, Laptops, and several other connected devices. To publish the agent to the Google Assistant, the developers docs provides a detailed explanation of the process involved in the deployment.

Integrating With A Web Demo

The Web Demo which is located in the Text-based sections of the Integrations Tab in the Dialogflow console allows for the use of the built agent in a web application by using it in an iframe window. Selecting the web Demo option would generate a URL to a page with a chat window that simulates a real-world chat application.

Note: Dialogflow’s web demo only supports text responses and does not support the display of Rich messages and images. This worth noting when using a webhook that responds with data in the Rich response format.

Conclusion

From several surveys, we can see the effect of chat assistants on customer satisfaction when incorporated by organizations into their services. These positive metrics are expected to grow up in the next coming years thus placing greater importance on the use of these chat assistants.

In this article, we have learned about Dialogflow and how it is providing a platform for organizations and developers to build Natural Language processing conversational chat assistants for use in their services. We also moved further to learn about its terminologies and how these terminologies apply when building a chat assistant by building a demo chat assistant using the Dialogflow console.

If a chat assistant is being built to be used at a production level, it is highly recommended that the developer(s) go through the Dialogflow best practices section of the documentation as it contains standard design guidelines and solutions to common pitfalls encountered while building a chat assistant.

The source code to the JavaScript webhook built within this article has been pushed to GitHub and can be accessed from this repository.

References

(ks, ra, yk, il)