Intégrer ChatGPT d'OpenAI avec Programmable Voice et Functions de Twilio

Temps de lecture: 13 minutes

March 23, 2023
Rédigé par
Michael Carpenter
Twilion
Révisé par
Dhruv Patel
Twilion

Pourquoi parler à un robot quand vous pouvez parler à trois ?

T-800 du film Terminator 2 : le Jugement dernier expliquant que son processeur est un ordinateur neuronal d'apprentissage et qu'il apprend des humains lorsqu'il est en contact avec eux, tandis que John Connor lui touche le visage, incrédule.

L'utilisation de ChatGPT pour alimenter un chatbot vocal interactif n'est pas une simple curiosité, c'est un moyen d'obtenir des informations de Business Intelligence utiles tout en réservant des agents humains dédiés, coûteux et mono-thread pour les conversations pour lesquelles seuls les humains peuvent aider. Aujourd'hui, nous parlons à des robots, nous les écoutons et nous collaborons avec eux en permanence. Mais vous savez ce qui est encore plus incroyable qu'interagir avec un seul robot ? Interagir avec trois robots !

Dans cet article, nous allons vous montrer comment utiliser la reconnaissance vocale native de Twilio et les fonctionnalités de synthèse vocale neuronale Text to Speech Amazon Polly avec ChatGPT pour créer un chatbot activé par la voix, le tout entièrement hébergé sur l'environnement Functions sans serveur de Twilio. Vous utiliserez également l'API Call Event pour analyser les questions des appelants et afficher les réponses du bot, ce qui nous permettra de déverrouiller les données first-party riches capturées lors de ces interactions et d'envoyer les données aux plateformes d'engagement client telles que Segment, où vous pouvez les utiliser pour construire des profils clients, comprendre les préférences des clients et créer les expériences personnalisées exigées par les clients.

Vous voulez voir une démo avant de vous lancer ? Appelez le 1-989-4OPENAI (467-3624) pour faire un test !

Robot nº 1 : décodage de la voix humaine à l'aide de la reconnaissance vocale

La reconnaissance vocale de Twilio à l'aide du verbe <Gather> TwiML est un outil puissant qui transforme les mots prononcés lors d'un appel téléphonique en texte. Il offre une excellente précision et une faible latence, et prend en charge une multitude de langues et de dialectes. Jusqu'à présent, les développeurs de Twilio ont utilisé la reconnaissance vocale comme moyen de naviguer dans les systèmes de serveur vocal interactif (IVR) et d'autres workflows d'automatisation en libre-service, mais avec l'arrivée de nouveaux modèles de voix expérimentaux, la seule limite est ✨votre imagination ✨.

Robot nº 2 : donner une voix à votre robot avec les voix neuronales Amazon Polly

Avec le verbe <Say> TwiML, Twilio offre une fonction de synthèse vocale Text to Speech (TTS) qui utilise les voix Amazon Polly qui tirent parti du deep learning pour synthétiser la voix humaine. Les voix neuronales de Polly ont un son plus naturel et réaliste, offrant une expérience d'écoute agréable pour les utilisateurs. Grâce à la prise en charge de plusieurs langues, d'un large éventail de voix et de SSML, la synthèse vocale Text to Speech de Twilio vous permet d'adapter la voix de votre chatbot à l'identité de votre marque.

Robot nº 3 : assistant conversationnel ChatGPT d'OpenAI

ChatGPT est un modèle de langage avancé développé par OpenAI, capable de générer du texte de type humain en se basant sur une entrée donnée. Il peut comprendre le contexte, fournir des réponses pertinentes et même réaliser des tâches créatives telles que la rédaction d'histoires ou de poèmes. En tirant parti de l'API OpenAI, les développeurs peuvent intégrer cette IA directement dans leurs applications, offrant ainsi aux utilisateurs une expérience plus interactive et attrayante.

L'ingrédient secret : Twilio Functions

Comment faire pour que ces trois robots communiquent entre eux et avec vos appelants ? En utilisant Twilio Functions. Au-delà de la simple possibilité de mettre en place une preuve de concept sans avoir à exécuter un serveur, Functions offre des capacités d'évolution automatique, une sécurité renforcée et une latence réduite en exécutant votre code dans Twilio. Bien sûr, si vous constatez des bogues sur votre serveur, vous pouvez apporter quelques petites modifications au Javascript, et celui-ci s'exécutera dans votre environnement node.js.

Maintenant que vous avez les ingrédients, examinons la recette en deux versions : CLI et GUI.

Des robots dansent et Herbie Hancock chante dans le clip de la chanson Rockit.

Des prérequis pour éviter beaucoup d'ennuis

Avant de vous plonger dans le processus d'intégration, vous aurez besoin des éléments suivants :

Fonction suivante

Tout d'abord, nous allons mettre notre back-end en ordre. Vous allez commencer par créer un nouveau projet Serverless. Étant donné que vous avez installé l'incroyable kit d'outils Serverless open source, vous pouvez le faire en une seule ligne en transmettant la commande à votre terminal :

twilio serverless:init <project-name>

Remplacez <project-name> par le nom de votre choix. Le mien est three-robot-rhumba.

Fenêtre de terminal affichant l'initialisation d'un projet Twilio Serverless

Maintenant, exécutez cd dans le répertoire de votre projet et mettez à jour le fichier .env de façon à fournir votre token d'authentification Twilio sous la forme AUTH_TOKEN et votre clé API OpenAI sous la forme OPENAI_API_KEY. Le SID de votre compte Twilio devrait se remplir automatiquement. Assurez-vous que votre fichier .env ressemble à ce qui suit (avec les espaces réservés XXXXX remplacés par leurs clés respectives) :

ACCOUNT_SID=XXXXX
AUTH_TOKEN=XXXXX
OPENAI_API_KEY=XXXXX

Puisque les fonctions Twilio Serverless sont de simples applications Node.js, vous pouvez ajouter des dépendances à l'aide de n'importe quel gestionnaire de packages qui écrit dans package.json. Ici, j'utilise npm pour faire simple. Revenez à votre terminal et saisissez les informations suivantes pour installer le package OpenAI NPM :

npm install openai@3.3.0

Maintenant que vos variables d'environnement sont définies et que vos dépendances sont ajoutées, vous pouvez passer aux choses sérieuses. Vous allez créer deux fonctions : une fonction /transcribe qui utilise la reconnaissance vocale Twilio pour transformer vos mots prononcés en texte que ChatGPT peut comprendre à l'aide du verbe <Gather> TwiML, et une fonction /respond qui prend le texte généré par la reconnaissance vocale, l'envoie à l'API OpenAI et transmet la réponse au moteur de synthèse vocale neuronale Text to Speech Amazon Polly de Twilio à l'aide du verbe <Say> TwiML.

Pour créer une nouvelle fonction, ouvrez le dossier functions dans votre répertoire de projet et créez un fichier JavaScript. Créez les fonctions /transcribe et /respond en créant un fichier transcribe.js et un fichier respond.js dans le dossier.

Lost in Transcription

Ouvrez maintenant transcribe.js et ajoutez le code suivant :

exports.handler = function(context, event, callback) {
    // Create a TwiML Voice Response object to build the response
    const twiml = new Twilio.twiml.VoiceResponse();

    // If no previous conversation is present, or if the conversation is empty, start the conversation
    if (!event.request.cookies.convo) {
        // Greet the user with a message using AWS Polly Neural voice
        twiml.say({
                voice: 'Polly.Joanna-Neural',
            },
            "Hey! I'm Joanna, a chatbot created using Twilio and ChatGPT. What would you like to talk about today?"
        );
    }

    // Listen to the user's speech and pass the input to the /respond Function
    twiml.gather({
        speechTimeout: 'auto', // Automatically determine the end of user speech
        speechModel: 'experimental_conversations', // Use the conversation-based speech recognition model
        input: 'speech', // Specify speech as the input type
        action: '/respond', // Send the collected input to /respond 
    });

    // Create a Twilio Response object
    const response = new Twilio.Response();

    // Set the response content type to XML (TwiML)
    response.appendHeader('Content-Type', 'application/xml');

    // Set the response body to the generated TwiML
    response.setBody(twiml.toString());

    // If no conversation cookie is present, set an empty conversation cookie
    if (!event.request.cookies.convo) {
        response.setCookie('convo', '', ['Path=/']); 
    }

    // Return the response to Twilio
    return callback(null, response);
};

Si vous ne connaissez pas encore Functions, laissez-moi vous expliquer ce qui se passe ici. La fonction /transcribe crée une réponse vocale TwiML générée à partir de la librairie d'aide Node.js de Twilio, démarre une conversation s'il n'en existe aucune, écoute l'entrée utilisateur et transmet cette entrée avec l'historique de conversation à l'endpoint /respond pour le traitement.

À la ligne 6, l'application vérifie si un cookie appelé convo existe. S'il n'existe pas, ou s'il existe, mais qu'il est vide, vous pouvez supposer que la conversation n'a pas encore commencé. Vous allez donc envoyer un premier message de bienvenue à l'aide du verbe <Say> TwiML.

Ensuite, la méthode twiml.gather est utilisée pour capturer les données saisies par l'utilisateur. Les paramètres pour Gather sont les suivants :

  • speechTimeout: 'auto' : détermine automatiquement quand l'utilisateur a arrêté de parler. Il peut être défini sur un nombre entier positif, mais « auto » est préférable pour ce cas d'usage
  • speechModel: "experimental_conversations": : utilise un modèle de reconnaissance vocale optimisé pour les cas d'usage conversationnels
  • input: 'speech' : définit le type d'entrée sur « speech » et ignore les touches (DTMF)
  • action: '/respond' : transmet l'entrée vocale de l'utilisateur ainsi que l'historique de conversation à l'endpoint /respond

Maintenant, vous devez faire en sorte de créer le cookie convo pour que la fonction /respond dispose d'un emplacement pour stocker l'historique de conversation qui sera transmis entre l'API OpenAI et nos voix neuronales Polly. Cela signifie que l'application doit initialiser un objet Twilio.Response();, et elle le fait à la ligne 25.

Vous ne pouvez pas transmettre à la fois la réponse Twilio.twiml.VoiceResponse(); et la réponse Twilio.Response(); au gestionnaire. Vous devrez donc utiliser la réponse que vous venez de créer pour ajouter un en-tête à nos demandes et définir le TwiML que vous avez généré via <Gather> au corps aux lignes 28 et 31 respectivement.

Une fois cette opération terminée, vous pouvez définir le cookie à l'aide de response.setCookie(); à la ligne 35 avant de renvoyer la réponse au gestionnaire pour exécution par notre infrastructure Serverless à la ligne 39. Enregistrez ce fichier et fermez-le.

Appel et réponse

Ouvrez ensuite respond.js et ajoutez le code suivant :

// Import the OpenAI module
const { OpenAI } = require("openai");

// Define the main function for handling requests
exports.handler = async function(context, event, callback) {
  // Set up the OpenAI API with the API key from your environment variables
   const openai = new OpenAI({
    apiKey: context.OPENAI_API_KEY, 
  });


  // Set up the Twilio VoiceResponse object to generate the TwiML
  const twiml = new Twilio.twiml.VoiceResponse();

  // Initiate the Twilio Response object to handle updating the cookie with the chat history
  const response = new Twilio.Response();

  // Parse the cookie value if it exists
  const cookieValue = event.request.cookies.convo;
  const cookieData = cookieValue ? JSON.parse(decodeURIComponent(cookieValue)) : null;

  // Get the user's voice input from the event
  let voiceInput = event.SpeechResult;

  // Create a conversation object to store the dialog and the user's input to the conversation history
  const conversation = cookieData?.conversation || [];
  conversation.push({role: 'user', content: voiceInput});

  // Get the AI's response based on the conversation history
  const aiResponse = await createChatCompletion(conversation);


  // Add the AI's response to the conversation history
  conversation.push(aiResponse);

  // Limit the conversation history to the last 20 messages; you can increase this if you want but keeping things short for this demonstration improves performance
  while (conversation.length > 20) {
      conversation.shift();
  }

  // Generate some <Say> TwiML using the cleaned up AI response
  twiml.say({
          voice: "Polly.Joanna-Neural",
      },
      aiResponse
  );

  // Redirect to the Function where the <Gather> is capturing the caller's speech
  twiml.redirect({
          method: "POST",
      },
      `/transcribe`
  );

  // Since we're using the response object to handle cookies we can't just pass the TwiML straight back to the callback, we need to set the appropriate header and return the TwiML in the body of the response
  response.appendHeader("Content-Type", "application/xml");
  response.setBody(twiml.toString());

  // Update the conversation history cookie with the response from the OpenAI API
  const newCookieValue = encodeURIComponent(JSON.stringify({
      conversation
  }));
  response.setCookie('convo', newCookieValue, ['Path=/']);

  // Return the response to the handler
  return callback(null, response);

  // Function to generate the AI response based on the conversation history
  async function generateAIResponse(conversation) {
      const messages = formatConversation(conversation);
      return await createChatCompletion(messages);
  }

  // Function to create a chat completion using the OpenAI API
  async function createChatCompletion(messages) {
      try {
        // Define system messages to model the AI
        const systemMessages = [{
                role: "system",
                content: 'You are a creative, funny, friendly and amusing AI assistant named Joanna. Please provide engaging but concise responses.'
            },
            {
                role: "user",
                content: 'We are having a casual conversation over the telephone so please provide engaging but concise responses.'
            },
        ];
        messages = systemMessages.concat(messages);

        const chatCompletion = await openai.chat.completions.create({
            messages: messages,
            model: 'gpt-4',
            temperature: 0.8, // Controls the randomness of the generated responses. Higher values (e.g., 1.0) make the output more random and creative, while lower values (e.g., 0.2) make it more focused and deterministic. You can adjust the temperature based on your desired level of creativity and exploration.
              max_tokens: 100, // You can adjust this number to control the length of the generated responses. Keep in mind that setting max_tokens too low might result in responses that are cut off and don't make sense.
              top_p: 0.9, // Set the top_p value to around 0.9 to keep the generated responses focused on the most probable tokens without completely eliminating creativity. Adjust the value based on the desired level of exploration.
              n: 1, // Specifies the number of completions you want the model to generate. Generating multiple completions will increase the time it takes to receive the responses.
        });

          return chatCompletion.choices[0].message.content;

      } catch (error) {
          console.error("Error during OpenAI API request:", error);
          throw error;
      }
  }
}

Comme précédemment, nous allons expliquer pas à pas ce qui se passe exactement dans ce code. Celui-ci commence par importer les modules requis (ligne 2) et par définir la fonction principale pour traiter les demandes (ligne 5).

Les lignes 7 et 8 définissent l'API OpenAI avec la clé API, tandis que la ligne 11 crée l'objet de réponse vocale Twilio qui génère TwiML pour convertir les réponses ChatGPT en voix pour les appelants. La ligne 14 initie l'objet de réponse Twilio pour mettre à jour le cookie d'historique de conversation et définir les en-têtes et le corps de sorte que le TwiML soit transmis dans la réponse.

Les lignes 17 à 20 analysent la valeur du cookie si elle existe, et la ligne 23 récupère l'entrée vocale de l'utilisateur à partir de l'événement SpeechResult reçu de la fonction /transcribe. Les lignes 26 et 27 créent une variable de conversation pour stocker le dialogue et ajoutent l'entrée de l'utilisateur à l'historique de conversation.

La ligne 30 génère la réponse de l'IA en fonction de l'historique des conversations, et la ligne 33 nettoie la réponse de l'IA en supprimant les noms de rôle inutiles (assistant, Joanna, user). La ligne 36 ajoute la réponse de l'IA nettoyée à l'historique des conversations.

Les lignes 39 à 41 limitent l'historique des conversations aux 10 derniers messages afin d'améliorer les performances et de conserver le cookie à une taille raisonnable tout en donnant au chatbot suffisamment de contexte pour fournir des réponses pertinentes. Vous pouvez augmenter (ou diminuer) cette valeur si vous le souhaitez, mais n'oubliez pas que l'historique stocké est transmis à l'API OpenAI à chaque demande, donc plus il est important, plus votre application reçoit de tokens. Les lignes 44 à 48 génèrent le verbe <Say> TwiML à l'aide de la réponse de l'IA nettoyée et les lignes 51 à 55 redirigent l'appel vers la fonction /transcribe où le verbe <Gather> capture la voix de l'appelant.

Comme pour /transcribe, nous devons utiliser la réponse pour fournir le TwiML et les lignes 58 et 59 définissent l'en-tête approprié et renvoient le TwiML dans le corps de la réponse. Les lignes 62 à 67 mettent à jour le cookie d'historique des conversations avec la réponse de l'API OpenAI et la ligne 70 renvoie la réponse au gestionnaire.

La fonction generateAIResponse (lignes 73 à 76) formate la conversation et crée une fin de conversation à l'aide de l'API OpenAI. La fonction createChatCompletion (lignes 81 à 88) envoie une demande à l'API OpenAI pour générer une réponse à l'aide du modèle GPT-3.5-turbo et des paramètres spécifiés. Si nous obtenons un 500 à partir de l'API OpenAI, nous n'allons pas simplement laisser la conversation comme cela. Nous allons donc gérer une erreur de l'API avec <Say> et rediriger la conversation vers la fonction /transcribe aux lignes 90 à 107.

Il est également possible que la demande à l'OpenAI arrive simplement à expiration, c'est pourquoi une instruction catch a été ajoutée entre les lignes 109 et 131 pour bien gérer les délais d'expiration et rediriger vers /transcribe pour lancer une nouvelle tentative.

Enfin, la fonction formatConversation (lignes 136 à 158) formate l'historique des conversations dans un format que l'API OpenAI peut comprendre en alternant les rôles assistant et user.

Maintenant que votre code est mis à jour, que vos dépendances sont définies et que vos variables d'environnement sont configurées, vous pouvez commencer à déployer. Avec Twilio Serverless, rien de plus simple… une seule commande suffit !

twilio serverless:deploy

Une fois le déploiement terminé, vous pouvez utiliser les fonctions que vous avez créées pour capturer les entrées vocales d'un appelant, les convertir en texte envoyé à l'API ChatGPT et lire la réponse à l'appelant sous forme de discours généré par IA. Trois robots qui travaillent ensemble, rien que pour vous !

Groupe de musique électronique Kraftwerk en concert

Le modèle

L'exemple ci-dessus utilise le modèle gpt-3.5-turbo d'OpenAI. C'est un bon modèle (et peu coûteux !) pour le développement et les preuves de concept, mais vous constaterez peut-être que d'autres modèles conviennent mieux à des cas d'usage spécifiques. GPT-4 vient d'être commercialisé en version bêta limitée, et même ici, chez Twilio, nous n'avons pas encore eu l'occasion de vraiment le tester. Mais d'après la vidéo live du développeur publiée en même temps que l'annonce, il semble que cette mise à niveau présente de nombreux changements par rapport à la version 3.5 et qu'elle impressionne le public depuis deux mois.

Autre fait important, GPT-3 est remplacé par la version 3.5 (et bien sûr, la version 4), mais les modèles de GPT-3 présentent des capacités de réglage précis que les modèles plus avancés ne possèdent pas à l'heure actuelle. Par exemple, même si les données d'entraînement sont plus anciennes, vous pouvez obtenir des réponses plus rapides avec curie et utiliser des éléments tels que l'analyse des sentiments et les styles de réponse. Choisissez votre propre aventure.

Rikki Don't Lose That Number

Maintenant que votre fonction est déployée et prête à être utilisée, vous pouvez la tester en effectuant un appel. Mais pour utiliser les fonctions que vous venez de créer, vous devez d'abord configurer un numéro de téléphone, et la CLI permet de le faire facilement et rapidement. Saisissez ce qui suit dans votre terminal pour répertorier les numéros de téléphone sur votre compte (nous supposons que vous avez suivi les prérequis et que vous avez obtenu un numéro au préalable).

twilio phone-numbers:list

Vous recevrez une liste des SID de numéros de téléphone, des numéros de téléphone et des noms conviviaux sur votre compte. Vous pouvez utiliser le SID ou le numéro de téléphone complet au format E.164 pour votre demande :

twilio phone-numbers:update <PN SID> –voice-url=<The URL for the /transcribe Function>

Ooey-GUI

Obi-wan Kenobi, du film Star Wars, dit qu'il n'a jamais utilisé d'interface de ligne de commande et R2-D2 répond par des bips tristes.

Si les CLI ne passent pas la vibe check, vous pouvez effectuer toutes les opérations décrites ci-dessus directement dans la console Twilio. Tout d'abord, dans la barre de navigation de gauche de l'onglet Develop (Développer), accédez à la section Functions and Assets (Fonctions et ressources), puis cliquez sur Services. Cliquez sur Create Service (Créer un service).

Démonstration de création de service Twilio Voice ChatGPT

Donnez un nom à votre service. Je vais appeler le mien voice-chatgpt-demo et cliquer sur Next (Suivant).

Démonstration de nomination de service Twilio Voice ChatGPT

La vue Console de votre Service s'affiche, avec les fonctions (Functions), les actifs (Assets), les variables d'environnement (Environment Variables) et les dépendances (Dependencies) dans la navigation de gauche, ainsi qu'un éditeur de texte et une console pour modifier votre code et suivre les journaux. Vous devez commencer par configurer vos variables d'environnement. Cliquez sur Environment Variables (Variables d'environnement) en bas à droite.

Démonstration de configuration de service Twilio Voice ChatGPT

Votre SID de compte Twilio et votre token d'authentification sont pré-remplis en tant que variables env. Il vous suffit donc d'ajouter votre clé API OpenAI ; l'exemple de code y fait référence sous la forme OPENAI_API_KEY, donc si vous souhaitez faire un copier/coller sans modification, assurez-vous de le nommer de la même manière. Cliquez sur Add (Ajouter) lorsque vous avez terminé.

Démonstration d'ajout de variables d'environnement Twilio Voice ChatGPT

Maintenant, vous devez mettre à jour nos dépendances pour inclure le module npm OpenAI afin de pouvoir envoyer des demandes à l'API OpenAPI. Cliquez sur Dependencies (Dépendances), puis saisissez openai dans la zone de texte Module et 3.3.0 dans la zone de texte Version. N'oubliez pas de cliquer sur Add (Ajouter).

Vous pouvez maintenant créer vos fonctions. Vous allez en créer deux : /transcribe, qui fait le gros du travail du point de vue de la reconnaissance vocale, et /respond, qui transmet le texte transcrit à l'API ChatGPT et lit la réponse à l'appelant à l'aide d'une voix de synthèse vocale neuronale Text to Speech Amazon Polly.

Cliquez sur le bouton Add (Ajouter) et sélectionnez Add Function (Ajouter une fonction) dans la liste déroulante pour créer une nouvelle fonction, et nommez-la /transcribe.

Démonstration d'ajout de fonction Twilio Voice ChatGPT

Remplacez le contenu de la nouvelle fonction par cet extrait de code et cliquez sur Save (Enregistrer). Une fois l'opération terminée, votre toute nouvelle fonction devrait ressembler à ceci :

Démonstration de transcription de fonction Twilio Voice ChatGPT

Maintenant, créez une autre fonction et appelez-la /respond. Remplacez le contenu de cette nouvelle fonction par cet extrait de code et cliquez à nouveau sur Save (Enregistrer). Si vous souhaitez une explication pas-à-pas de ce qui se passe précisément dans ces exemples, consultez la section CLI de cet article, où nous parcourons le code en détail.

Cliquez ensuite sur le bouton Deploy (Déployer). Vos fonctions enregistrées seront déployées et peuvent désormais être utilisées dans la configuration de votre numéro de téléphone entrant. Cliquez sur les trois points verticaux en regard de /transcribe, puis sur Copy URL (Copier l'URL). Nous en aurons besoin dans une seconde.

Démonstration de configuration de numéro de téléphone Twilio Voice ChatGPT

Dans l'onglet Develop (Développer), accédez à la section Phone Numbers (Numéros de téléphone), puis sélectionnez Manage (Gérer) et Active Numbers (Numéros actifs). Une fois que vous avez trouvé le numéro que vous souhaitez utiliser, faites défiler jusqu'à la section Voice & Fax (Voix et fax). Sous A call comes in (Un appel arrive), sélectionnez Function. Pour Service, sélectionnez le service de fonction que vous venez de créer, que nous avons nommé voice-chatgpt-demo. Choisissez ensuite ui pour Environment (Environnement) et enfin /transcribe pour Function Path (Chemin de fonction), car c'est là que votre appel téléphonique doit être acheminé en premier.

Appelez maintenant votre nouveau numéro de téléphone pour tout tester !

Pas démonter

Johnny Five, du film Short Circuit, dit « Pas démonter » et s'en va, désespéré

Ce qui est particulièrement intéressant avec cette intégration, c'est que les entrées et les réponses sont à votre disposition en tant que développeur ; le texte de reconnaissance vocale de la personne en tant que paramètre SpeechResult qui est transmis à la fonction /respond, et les réponses dérivées de ChatGPT en tant que verbe <Say> TwiML qui est exécuté sur les appels. Cela signifie que ces conversations ne sont pas des boîtes fermées de Business Intelligence, et même si ces fonctions s'exécutent dans l'environnement Twilio Serverless, vous pouvez toujours avoir la main sur le contenu de la conversation grâce à l'API Call Events. Voici comment récupérer les détails à l'aide de la CLI Twilio :

twilio api:core:calls:events:list --call-sid <The call SID you are interested in> -o json

Grâce à cette API, vous pouvez récupérer les demandes, les réponses et les paramètres associés et les transférer directement dans vos systèmes internes pour fournir aux agents des informations sur les questions que l'appelant a posées avant qu'il ne soit connecté. Vous pouvez également utiliser les données pour enrichir vos profils clients dans une plateforme de données client comme Segment.

Robot Rock

Daft Punk jouant de la basse et de la batterie dans le clip de la chanson Get Lucky

Des acteurs comme McKinsey ou Forbes se sont déjà exprimés sur la façon dont les technologies d'IA génératives telles que ChatGPT peuvent être utilisées pour résoudre les problèmes d'entreprise. Maintenant que vous avez trois robots qui travaillent pour vous, qu'allez-vous faire avec une intégration comme celle-ci ? Que dites-vous d'un agent de support pour les postes de travail IT de première ligne ? Demandez à ChatGPT d'effectuer des recherches sur Google pour que votre service IT coûteux n'ait pas à le faire. Si votre appelant et ChatGPT n'y arrivent pas, connectez l'appel à vos agents. Les temps d'attente pour vos spécialistes de la santé sont longs ? Au lieu de faire écouter du jazz à vos appelants, offrez-leur la sagesse de ChatGPT pour résoudre les problèmes courants non critiques pendant qu'ils attendent.

Conclusion

Et voilà : grâce à la reconnaissance vocale de Twilio, aux fonctions Twilio, aux voix neuronales Amazon Polly et à l'API OpenAI, vous avez créé votre propre chatbot vocal interactif. Revenez ici de temps en temps pour connaître les nouveautés en matière d'IA conversationnelle et de capacités de chatbot à exploiter avec Twilio.

Michael Carpenter (ou MC) est un adepte des API de télécommunications qui utilise des logiciels depuis 2001 pour faire sonner les téléphones. Il est Product Manager for Programmable Voice chez Twilio, et manifeste un grand intérêt pour les API, SIP, WebRTC et SDK mobiles. Il est également un grand fan de Depeche Mode. Contactez-le sur mc@twilio.com ou LinkedIn.

Un très grand merci à l'article positivement prémonitoire de Dhruv Patel sur la façon d'appeler un ami IA avec GPT-3 à l'aide de Twilio Voice et de Functions. Dhruv a passé en revue le code dans cet article. Dhruv Patel est développeur au sein de l'équipe Developer Voices de Twilio. Vous pouvez le retrouver autour d'un bon café glacé, ou le contacter à l'adresse dhrpatel@twilio.com ou sur LinkedIn.

Articles associés

Ressources connexes

A newspaper article

Twilio Docs

Des API aux SDK en passant par les exemples d'applications

Documentation de référence sur l'API, SDK, bibliothèques d'assistance, démarrages rapides et didacticiels pour votre langage et votre plateforme.
An Open book

Centre de ressources

Les derniers ebooks, rapports de l'industrie et webinaires

Apprenez des experts en engagement client pour améliorer votre propre communication.
User group reactions

Ahoy

Le hub de la communauté des développeurs de Twilio

Meilleures pratiques, exemples de code et inspiration pour créer des expériences de communication et d'engagement numérique.