Integration von ChatGPT von OpenAI mit Twilio Programmable Voice und Functions

Lesezeit: 12 Minuten

March 23, 2023
Autor:in:
Michael Carpenter
Twilion
Prüfer:in:
Dhruv Patel
Twilion

Warum mit einem Roboter sprechen, wenn Sie mit drei sprechen können?

T-800 aus dem Film Terminator 2: Tag der Abrechnung erklärt, dass seine CPU ein neuronaler Netzprozessor ist, ein lernender Computer, und dass er von Menschen lernt, wenn er mit ihnen in Kontakt kommt, während John Connor ungläubig sein Gesicht berührt.

Die Verwendung von ChatGPT zum Betrieb eines interaktiven Voice-Chatbots stellt nicht nur eine Neuheit, sondern auch eine Möglichkeit dar, nützliche Business Intelligence-Informationen zu erhalten. Gleichzeitig wird dadurch dediziertes, teures und auf einen einzigen Thread beschränktes menschliche Personal für Gespräche reserviert, bei denen nur Menschen helfen können. Heutzutage sprechen Menschen ständig mit Robotern, hören ihnen zu und arbeiten mit ihnen zusammen. Aber wissen Sie, was noch cooler ist als die Interaktion mit einem Roboter? Die Interaktion mit drei Robotern!

In diesem Beitrag zeigen wir Ihnen, wie Sie die systemeigene Spracherkennung von Twilio und die neuronalen Text-to-Speech-Funktionen von Amazon Polly mit ChatGPT nutzen können, um einen Chatbot mit Sprachaktivierung zu erstellen, der vollständig auf der serverlosen Funktionsumgebung von Twilio gehostet wird. Mit der Call-Event-API werden Sie die Fragen der Anrufenden analysieren und die Antworten des Bots anzeigen. So können Sie die umfangreichen First-Party-Daten, die bei diesen Interaktionen erfasst werden, freischalten und an Customer-Engagement-Plattformen wie Segment senden. Dort können Sie diese Daten nutzen, um Kundenprofile zu erstellen, Kundenpräferenzen zu verstehen und personalisierte Erfahrungen zu schaffen, die sich Kund:innen wünschen.

Möchten Sie das erst einmal ausprobieren, bevor Sie loslegen? Rufen Sie dafür 1-989-4OPENAI (467-3624) an.

Roboter 1: Entschlüsseln der menschlichen Stimme durch Spracherkennung

Die Spracherkennung von Twilio mit dem TwiML-Verb <Gather> ist ein leistungsstarkes Tool, das das gesprochene Wort am Telefon in Text umwandelt. Es zeichnet sich durch hervorragende Genauigkeit, geringe Latenz und Unterstützung zahlreicher Sprachen und Dialekte aus. In der Vergangenheit haben Entwickler von Twilio mit Spracherkennung interaktive Sprachantworten (Interactive Voice Response, IVR) und andere Workflows mit Self-Service-Automatisierung gesteuert. Seit der Einführung neuer experimenteller Sprachmodelle sind der ✨Fantasie allerdings keine Grenzen mehr gesetzt ✨.

Roboter 2: Ihrem Roboter mit Amazon Polly Neural Voices eine Stimme geben

Mit dem TwiML-Verb <Say> bietet Twilio eine Text-to-Speech-Funktion (TTS), die Stimmen von Amazon Polly verwendet. Diese synthetisieren mithilfe von Deep Learning menschenähnliche Sprache. Die neuronalen Stimmen von Polly haben einen natürlicheren und realistischeren Klang und bieten ein fesselndes Hörerlebnis. Dank Unterstützung mehrerer Sprachen, einer großen Auswahl an Stimmen und SSML-Unterstützung können Sie die Stimme Ihres Chatbots mit Twilio Text-to-Speech an die Identität Ihrer Marke anpassen.

Roboter 3: ChatGPT von OpenAI als Gesprächsbegleiter

ChatGPT ist ein fortschrittliches Sprachmodell, das von OpenAI entwickelt wurde und nach bestimmter Eingabe menschenähnlichen Text erzeugen kann. Es kann Zusammenhänge verstehen, sachdienliche Antworten geben und sogar kreative Aufgaben wie das Schreiben von Geschichten oder Gedichten übernehmen. Durch die Nutzung der OpenAI-API können Entwickler diese KI direkt in ihre Anwendungen integrieren und Nutzer:innen ein interaktives und ansprechendes Erlebnis bieten.

Geheimzutat: Twilio Functions

Wie bringen Sie diese drei Roboter dazu, miteinander und mit Ihren Anrufer:innen zu sprechen? Mit Twilio Functions. Neben der Möglichkeit, einen Proof-of-Concept zum Laufen zu bringen, ohne einen eigenen Server hochfahren zu müssen, bieten Functions automatische Skalierungsmöglichkeiten, verbesserte Sicherheit und geringere Latenzzeiten, da Ihr Code innerhalb von Twilio ausgeführt wird. Natürlich können Sie, wenn Sie einen eigenen Server haben, mit ein paar kleinen Änderungen am Javascript-Code diesen auch in Ihrer Node.js-Umgebung zum Laufen bringen.

Jetzt, da Sie die Zutaten haben, können Sie das Rezept in zwei Geschmacksrichtungen ausprobieren: CLI und GUI.

Tanzende Roboter und der Gesang von Herbie Hancock aus dem Musikvideo zum Song Rockit.

Vorbereitung ist die halbe Miete

Bevor Sie mit der Integration beginnen, benötigen Sie Folgendes:

Fortschrittliche Functions

Zunächst müssen Sie das Back-End in Ordnung bringen. Sie beginnen mit der Erstellung eines neuen Serverless-Projekts. Da Sie das großartige Open-Source-Serverless Toolkit installiert haben, können Sie dies in einer Zeile tun, indem Sie den Befehl in Ihr Terminal eingeben:

twilio serverless:init <project-name>

Ersetzen Sie <project-name> durch einen Namen Ihrer Wahl. Ich nenne mein Projekt three-robot-rhumba.

Terminal-Fenster, das die Initialisierung eines Twilio Serverless-Projekts zeigt

Fahren Sie fort und fügen Sie cd in das Verzeichnis Ihres Projekts ein. Aktualisieren Sie die Datei .env, um Ihr Twilio-Authentifizierungstoken als AUTH_TOKEN und Ihren OpenAI-API-Schlüssel als OPENAI_API_KEY anzugeben. Die SID Ihres Twilio-Kontos sollte automatisch ausgefüllt werden. Vergewissern Sie sich, dass die Datei .env wie folgt aussieht (wobei die Platzhalter XXXXX durch die entsprechenden Schlüssel ersetzt werden):

ACCOUNT_SID=XXXXX
AUTH_TOKEN=XXXXX
OPENAI_API_KEY=XXXXX

Da Twilio Serverless Functions nur Node.js-Apps sind, können Sie Abhängigkeiten mit einem beliebigen Paketmanager hinzufügen, der in package.json schreibt. Der Einfachheit halber verwende ich npm. Navigieren Sie zurück zu Ihrem Terminal und geben Sie Folgendes ein, um das OpenAI-NPM-Paket zu installieren:

npm install openai@3.3.0

Wenn Sie Ihre Umgebungsvariablen festgelegt und Ihre Abhängigkeiten hinzugefügt haben, können Sie sich an die Arbeit machen. Sie werden zwei Functions erstellen: eine /transcribe Function, die mit der Twilio-Spracherkennung Ihre gesprochenen Worte in Text umwandelt, den ChatGPT mit dem TwiML-Verb <Gather> verstehen kann. Und eine /respond Function, die den von der Spracherkennung erzeugten Text an die OpenAI-API sendet und die Antwort mit dem TwiML-Verb <Say> an die von Amazon Polly Neural betriebene Text-to-Speech-Engine von Twilio weitergibt.

Um eine neue Function zu erstellen, öffnen Sie den Ordner functions in Ihrem Projektverzeichnis und erstellen Sie eine JavaScript-Datei. Erstellen Sie die Functions /transcribe und /respond, indem Sie die Dateien transcribe.js und respond.js im Ordner erstellen.

Lost in Transkription

Öffnen Sie jetzt transcribe.js und fügen Sie den folgenden Code hinzu:

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);
};

Wenn Sie Functions zum ersten Mal verwenden, erkläre ich Ihnen, was passiert. Die Function /transcribe erstellt eine TwiML-generierte Sprachantwort, die auf der Node.js-Hilfsbibliothek von Twilio basiert, startet ein Gespräch, falls keines vorhanden ist, wartet auf Nutzereingaben und übergibt diese Eingaben mit dem Gesprächsverlauf zur weiteren Verarbeitung an den Endpunkt /respond.

In Zeile 6 prüft die Anwendung, ob ein Cookie namens convo vorhanden ist. Ist dies nicht der Fall, oder ist es zwar vorhanden, aber leer, können Sie davon ausgehen, dass das Gespräch noch nicht begonnen hat. Mit dem TwiML-Verb <Say> können Sie mit einer ersten Begrüßung beginnen.

Als Nächstes werden mit der Methode twiml.gather Nutzereingaben erfasst. Die Parameter für „gather“ sind:

  • speechTimeout: 'auto': Stellt automatisch fest, wann Nutzer:innen nicht mehr sprechen; kann auf eine positive Ganzzahl gesetzt werden, aber „auto“ ist für diesen Anwendungsfall am besten geeignet
  • speechModel: "experimental_conversations": Verwendet ein Spracherkennungsmodell, das für Gespräche optimiert ist
  • input: 'speech': Stellt den Eingabetyp auf Sprache ein und ignoriert Tastendrücke (Mehrfrequenzwähltöne)
  • action: '/respond': Übergibt die Spracheingabe mit dem Gesprächsverlauf an den Endpunkt /respond

Jetzt müssen Sie eine Möglichkeit schaffen, das Gesprächs-Cookie zu erstellen, damit die Function /respond den Gesprächsverlauf speichern kann, der zwischen der OpenAI-API und unseren Polly Neural Voices weitergegeben wird. Das bedeutet, dass die App ein Twilio.Response();-Objekt initialisieren muss. Das geschieht in Zeile 25.

Sie können nicht beide Objekte, Twilio.twiml.VoiceResponse(); und Twilio.Response();, an den Handler zurückgeben. Daher müssen Sie die soeben erstellte Antwort verwenden, um Ihren Anfragen in Zeile 28 einen Header hinzuzufügen und das mit <Gather> erzeugte TwiML in Zeile 31 an den Text anzuhängen.

Anschließend können Sie das Cookie mit response.setCookie(); in Zeile 35 setzen, bevor Sie die Antwort in Zeile 39 zur Ausführung durch die Serverless-Infrastruktur an den Handler zurückgeben. Speichern und schließen Sie die Datei.

Anruf und Antwort

Öffnen Sie jetzt respond.js und fügen den folgenden Code hinzu:

// 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;
      }
  }
}

Ähnlich wie oben werfen wir nun einen genaueren Blick darauf, was genau in diesem Code vor sich geht. Zunächst werden die erforderlichen Module (Zeile 2) importiert und die Hauptfunktion zur Bearbeitung von Anfragen (Zeile 5) wird definiert.

In den Zeilen 7–8 wird die OpenAI-API mit dem API-Schlüssel eingerichtet. In Zeile 11 wird das Response-Objekt von Twilio Voice erstellt, das TwiML generiert, um die ChatGPT-Antworten für Anrufende in Sprache umzuwandeln. Zeile 14 initiiert das Twilio-Response-Objekt, um das Cookie für den Gesprächsverlauf zu aktualisieren und die Header und den Text so einzustellen, dass TwiML in der Antwort weitergegeben wird.

In den Zeilen 17–20 wird der Cookie-Wert analysiert, sofern vorhanden. In Zeile 23 wird die Spracheingabe aus dem Ereignis SpeechResult abgerufen, das von der Function /transcribe empfangen wurde. In den Zeilen 26–27 wird eine Gesprächsvariable erstellt, um den Dialog zu speichern und die Nutzereingaben in den Gesprächsverlauf aufzunehmen.

Die KI-Antwort auf Grundlage des Gesprächsverlaufs wird in Zeile 30 erstellt und in Zeile 33 bereinigt. Dabei werden alle unnötigen Rollennamen (Assistent, Joanna, Nutzer) entfernt. In Zeile 36 wird die bereinigte KI-Antwort zum Gesprächsverlauf hinzugefügt.

In den Zeilen 39–41 wird der Gesprächsverlauf auf die letzten 10 Nachrichten beschränkt, um die Leistung zu verbessern und das Cookie nicht unnötig zu vergrößern. Der Chatbot verfügt trotzdem über ausreichend Kontext, um hilfreich zu antworten. Sie können diesen Wert bei Bedarf erhöhen (oder verringern). Bedenken Sie aber, dass der gespeicherte Verlauf bei jeder Anfrage an die OpenAI-API weitergegeben wird. Je größer dieser Wert ist, desto mehr Token verbraucht Ihre Anwendung. In den Zeilen 44–48 wird TwiML <Say> unter Verwendung der bereinigten KI-Antwort generiert. In den Zeilen 51–55 wird der Anruf an die Function /transcribe weitergeleitet, wo <Gather> die Anrufersprache erfasst.

Wie bei /transcribe müssen Sie TwiML mit „response“ übermitteln. In den Zeilen 58–59 werden die entsprechenden Header festgelegt und TwiML im Hauptteil der Antwort zurückgegeben. Das Cookie für den Gesprächsverlauf wird in den Zeilen 62–67 mit der Antwort von der OpenAI-API aktualisiert. Zeile 70 gibt die Antwort an den Handler zurück.

Die Function generateAIResponse (Zeilen 73–76) formatiert das Gespräch und erstellt mit der OpenAI-API einen Chatabschluss. Die Function createChatCompletion (Zeilen 81–88) sendet eine Anfrage an die OpenAI-API, um mit dem GPT-3.5-Turbomodell und angegebenen Parametern eine Antwort zu erzeugen. Wenn Sie einen Fehlercode 500 von der OpenAI-API erhalten, möchten Sie das Gespräch nicht einfach abbrechen. Daher wird ein Fehler der API mit <Say> behandelt und das Gespräch in den Zeilen 90–107 zurück zur Function /transcribe geleitet.

Es ist auch möglich, dass die Anfrage an die OpenAI einfach nur eine Zeitüberschreitung verursacht. Daher wurde zwischen den Zeilen 109–131 eine Sperre hinzugefügt, um Zeitüberschreitungen elegant zu lösen und zu /transcribe umzuleiten, um es erneut zu versuchen.

Schließlich formatiert die Function formatConversation (Zeilen 136–158) den Gesprächsverlauf so, dass ihn die OpenAI-API versteht, indem zwischen den Rollen assistant und user gewechselt wird.

Jetzt ist Ihr Code aktualisiert, Ihre Abhängigkeiten sind festgelegt und Ihre Umgebungsvariablen sind konfiguriert. Sie können also mit der Bereitstellung beginnen. Mit Twilio Serverless könnte es nicht einfacher sein ... es ist nur ein einziger Befehl.

twilio serverless:deploy

Sobald die Bereitstellung abgeschlossen ist, können Sie mit den von Ihnen erstellten Functions gesprochene Eingaben von Anrufenden erfassen und sie in Text umwandeln, der an die API von ChatGPT gesendet wird. Die Antwort wird in Form von KI-generierter Sprache an die Anrufenden zurückgegeben. Drei Roboter, die nur für Sie zusammenarbeiten.

Live-Auftritt der elektronischen Musikband Kraftwerk

Das Modell

In dem obigen Beispiel wird das GPT-3.5-Turbomodell von OpenAI verwendet. Dies ist ein gutes (und günstiges!) Modell für Entwicklungszwecke und Proof-of-Concepts. Möglicherweise werden Sie aber feststellen, dass andere Modelle für bestimmte Anwendungsfälle besser geeignet sind. GPT-4 wurde gerade erst veröffentlicht und das in einer limitierten Betaversion. Selbst wir bei Twilio hatten noch keine Gelegenheit, es zu testen. Aber nach dem Developer-Livestream scheint es ein bedeutendes Upgrade gegenüber Version 3.5 zu sein, die bereits begeistert hat.

Eine weitere Überlegung: GPT-3 wurde durch 3.5 (und natürlich 4) ersetzt, aber die Modelle in GPT-3 verfügen über Funktionen zur Feinabstimmung, die bei fortschrittlicheren Modellen zum Zeitpunkt der Erstellung dieses Beitrags fehlen. Auch wenn die Trainingsdaten älter sind, können Sie beispielsweise mit Curie schnellere Antworten erhalten und Dinge wie Sentimentanalyse und Antwortstile nutzen. Sie haben die Wahl.

Rikki Don't Lose That Number

Nachdem Sie Ihre Function bereitgestellt haben, können Sie sie mit einem Anruf testen. Zunächst müssen Sie jedoch eine Telefonnummer konfigurieren, die die eben erstellten Functions verwendet. Dies ist über die Kommandozeile (CLI) schnell und einfach möglich. Geben Sie Folgendes in Ihr Terminal ein, um die Telefonnummern Ihres Kontos aufzulisten (wir gehen davon aus, dass Sie vorbereitet sind und zuvor eine Nummer eingerichtet haben).

twilio phone-numbers:list

Ihnen wird eine Liste mit den SIDs der Telefonnummern, den Telefonnummern und Anzeigenamen Ihres Kontos angezeigt. Sie können entweder die SID oder die vollständige E.164-formatierte Telefonnummer für Ihre Anfrage verwenden:

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

Grafische Benutzeroberfläche Ooey

Obi-Wan Kenobi aus dem Film Star Wars sagt, dass er noch nie eine Kommandozeile benutzt hat, und R2-D2 antwortet mit traurigen Pieptönen.

Wenn CLIs den Vibe-Check nicht bestehen, können Sie all die oben beschriebenen Punkte direkt in der Twilio-Konsole erledigen. Gehen Sie zunächst in der linken Navigationsleiste auf der Registerkarte Develop (Entwickeln) zum Abschnitt Functions and Assets (Functions und Assets) und klicken Sie auf Services. Klicken Sie auf Create Service (Service erstellen).

Vorgehensweise zum Erstellen eines Service in Twilio Voice ChatGPT

Benennen Sie Ihren Service. Ich nenne meinen voice-chatgpt-demo. Klicken Sie dann auf Next (Weiter).

Vorgehensweise zum Benennen eines Service in Twilio Voice ChatGPT

Sie sehen nun die Konsolenansicht für Ihren Service, mit Functions, Assets, Umgebungsvariablen und Abhängigkeiten in der linken Navigationsleiste. Außerdem sehen Sie einen Texteditor und eine Konsole zum Bearbeiten Ihres Codes und zum Überwachen der Protokolle. Als Erstes müssen Sie Ihre Umgebungsvariablen konfigurieren. Klicken Sie dazu auf Environment Variables (Umgebungsvariablen) in der unteren rechten Ecke.

Vorgehensweise zum Konfigurieren eines Service in Twilio Voice ChatGPT

Die SID Ihres Twilio-Kontos und das Authentifizierungstoken sind als Umgebungsvariablen bereits ausgefüllt. Sie müssen nur noch Ihren OpenAI-API-Schlüssel eingeben. Der Beispielcode wird als OPENAI_API_KEY bezeichnet. Diesen Namen sollten Sie beibehalten, wenn Sie so wenig wie möglich kopieren und einfügen möchten. Klicken Sie anschließend auf Add (Hinzufügen).

Vorgehensweise zum Hinzufügen von Umgebungsvariablen in Twilio Voice ChatGPT

Als Nächstes müssen Sie die Abhängigkeiten aktualisieren, damit das npm-Modul von OpenAI berücksichtigt wird und Sie Anfragen an die OpenAPI-API stellen können. Klicken Sie auf Dependencies (Abhängigkeiten) und geben Sie openai in das Textfeld Module (Modul) und 3.3.0 in das Textfeld Version ein. Klicken Sie auf Add (Hinzufügen).

Jetzt können Sie Functions erstellen. Sie werden zwei erstellen: /transcribe ist für die Spracherkennung zuständig und /respond gibt den transkribierten Text an die ChatGPT-API weiter und liest die Antwort mit einer Stimme der neuronalen Text-to-Speech-Funktion von Amazon Polly vor.

Klicken Sie auf die Schaltfläche Add (Hinzufügen) und wählen Sie Add Function (Function hinzufügen) aus dem Drop-down-Menü aus, um eine neue Function zu erstellen und sie /transcribe zu nennen.

Vorgehensweise zum Hinzufügen einer Function in Twilio Voice ChatGPT

Ersetzen Sie den Inhalt der neuen Function durch diesen Codeausschnitt und klicken Sie auf Save (Speichern). Ihre neue Function sollte folgendermaßen aussehen:

Vorgehensweise zum Transkribieren einer Function in Twilio Voice ChatGPT

Als Nächstes erstellen Sie eine weitere Function und nennen sie /respond. Ersetzen Sie den Inhalt dieser neuen Function durch diesen Codeausschnitt und klicken Sie erneut auf Save (Speichern). Wenn Sie wissen möchten, was genau dabei passiert, lesen Sie den CLI-Abschnitt dieses Beitrags, in dem wir den Code detaillierter erläutern.

Klicken Sie dann auf die Schaltfläche Deploy (Bereitstellen). Ihre gespeicherten Functions werden bereitgestellt und können nun in der Konfiguration Ihrer eingehenden Telefonnummern verwendet werden. Klicken Sie auf die drei vertikalen Punkte neben /transcribe, um Copy URL (URL kopieren) auszuwählen. Diese werden wir gleich benötigen.

Vorgehensweise zum Einrichten einer Telefonnummer in Twilio Voice ChatGPT

Navigieren Sie auf der Registerkarte Develop (Entwickeln) zum Abschnitt Phone Numbers (Telefonnummern). Klicken Sie dann auf Manage (Verwalten) und wählen Active Numbers (Aktive Nummern). Wenn Sie eine Nummer gefunden haben, die Sie verwenden möchten, scrollen Sie nach unten zum Abschnitt Voice & Fax (Sprache & Fax) und wählen Sie unter A call comes in (Eingehender Anruf) Function. Wählen Sie unter Service die Function mit dem Namen voice-chatgpt-demo, die wir eben erstellt haben. Wählen Sie dann ui für Environment (Umgebung) und schließlich /transcribe für Function Path (Function-Pfad), da Ihr Telefonanruf zuerst dorthin geleitet werden soll.

Rufen Sie jetzt Ihre neu konfigurierte Telefonnummer an, um alles zu testen.

Nicht zerlegen

Roboter aus dem Film „Nummer 5 lebt!“ sagt „Nicht zerlegen“ und rollt verstört davon

Ein besonders großer Vorteil dieser Integration ist, dass Ihnen als Entwickler sowohl die Eingaben als auch die Antworten zur Verfügung stehen: der Text der Spracherkennung in Form des Parameters SpeechResult, der an die Function /respond weitergegeben wird, und die von ChatGPT abgeleiteten Antworten in Form der TwiML <Say>, die bei den Aufrufen ausgeführt wird. Das bedeutet, dass diese Gespräche keine geschlossenen Business-Intelligence-Systeme sind. Obwohl die Functions in der Twilio Serverless-Umgebung ausgeführt werden, können Sie den Inhalt des Gesprächs über Call-Events-API abrufen. Hier sehen Sie, wie Sie die Details über die Twilio-CLI abrufen:

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

Mit dieser API können Sie die Anfragen, Antworten und zugehörigen Parameter abrufen und direkt in Ihre internen Systeme einspeisen, um Beschäftigte zum Beispiel vorab über die Frage von Anrufern zu informieren oder die Kundenprofile in einer Kundendatenplattform wie Segment mit Daten zu füllen.

Robot Rock

Daft Punk mit Bassgitarre und Schlagzeug aus dem Musikvideo zum Song Get Lucky

McKinsey und Forbes befassen sich in Publikationen bereits mit der Frage, wie Geschäftsprobleme mit KI-Technologien wie ChatGPT gelöst werden können. Wenn jetzt also drei Roboter für Sie arbeiten – wie hilft Ihnen eine solche Integration in der Praxis? Nehmen wir als Beispiel Beschäftigte im Bereich IT-Desktop-Support. Lassen Sie ChatGPT Google durchsuchen, damit das Ihre teure IT-Abteilung nicht tun muss. Erst wenn Anrufende und ChatGPT das Problem nicht lösen können, stellen Sie den Anruf zum Personal durch. Haben Sie lange Wartezeiten bei ärztlichem Fachpersonal? Anstatt Anrufende mit einer Melodie in Dauerschleife zu langweilen, lassen Sie ChatGPT bei allgemeinen, nicht bedenklichen Beschwerden helfen.

Zusammenfassung

Sie haben es geschafft: Mit Hilfe der Spracherkennung von Twilio, Twilio Functions, Amazon Polly Neural Voices und der API von OpenAI haben Sie jetzt Ihren eigenen interaktiven Voice-Chatbot erstellt. Behalten Sie diesen Bereich auf jeden Fall im Auge und halten Sie Ausschau nach Fortschritten im Bereich gesprächsbasierter KI und Chatbot-Funktionen, die Sie mit Twilio nutzen können.

Michael Carpenter (alias MC) beschäftigt sich schon sein halbes Leben mit Telekommunikations-APIs und bringt seit 2001 Telefone mit Software zum Klingeln. Als Produktmanager für Programmable Voice bei Twilio interessiert er sich für das Venn-Diagramm, der Schnittmenge von APIs, SIP, WebRTC und mobilen SDKs. Außerdem weiß er viel über Depeche Mode. Sie erreichen ihn unter mc (at) twilio.com oder auf LinkedIn.

Ein großer Dank auch an den vorausschauenden Beitrag von Dhruv Patel zum Thema So rufen Sie einen KI-Freund mit GPT-3 mit Twilio Voice und Functions an. Dhruv hat auch den Code in diesem Beitrag technisch überprüft. Dhruv Patel ist Entwickler im Developer Voices-Team von Twilio. Entweder treffen Sie ihn bei der Arbeit in einem Coffeeshop mit einem Cold Brew oder Sie erreichen ihn unter dhrpatel [at] twilio.com oder auf LinkedIn.

Verwandte Posts

Ähnliche Ressourcen

A newspaper article

Twilio Docs

Von APIs über SDKs bis hin zu Beispiel-Apps

API-Referenzdokumentation, SDKs, Hilfsbibliotheken, Schnellstarts und Tutorials für Ihre Sprache und Plattform.
An Open book

Ressourcen-Center

Die neuesten E-Books, Branchenberichte und Webinare

Lernen Sie von Customer-Engagement-Experten, um Ihre eigene Kommunikation zu verbessern.
User group reactions

Ahoy

Twilios Entwickler-Community-Hub

Best Practices, Codebeispiele und Inspiration zum Aufbau von Kommunikations- und digitalen Interaktionserlebnissen.