Fügen Sie Dialogflow und die Vonage SMS API zu Ihrer Flask-App hinzu

Dialogflow ist eine von Google bereitgestellte Plattform zum Verstehen natürlicher Sprache (NLU). Sie wird verwendet, um konversationelle Benutzeroberflächen in mobile und Web-Apps, Geräte, Bots und interaktive Sprachsysteme zu entwickeln und zu integrieren. In diesem Tutorial zeigen wir, wie man die Dialogflow- und Vonage-SMS-APIs integriert, um einen Quiz-Bot zu erstellen, der mit dem Endbenutzer per SMS interagiert. Wir werden nicht alle Teile der Anwendung abdecken, wenn Sie also von Grund auf neu anfangen, sollten Sie sich das vollständige Projekt-Repositorium (oder lesen Sie einen unserer früheren Tutorials über die Entwicklung von Flask von Grund auf!)

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

In diesem Lernprogramm wird auch eine virtuelle Telefonnummer verwendet. Um eine zu erwerben, gehen Sie zu Rufnummern > Rufnummern kaufen und suchen Sie nach einer Nummer, die Ihren Anforderungen entspricht.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Eine Anwendung erstellen

Wir beginnen mit der Verwendung des Vonage CLI-Modus, um eine App zu erstellen. Installieren Sie die Vonage CLI wie folgt auf Ihrem Rechner:

npm install -g @vonage/cli

Erstellen Sie lokal ein Verzeichnis für Ihre Anwendung:

mkdir your-application

Führen Sie in diesem Verzeichnis den folgenden Befehl aus:

vonage apps:create

Im interaktiven CLI-Modus:

Application Name: your-app-name
Select capabilities: press the space bar to select voice, messages and rtc
Create voice webhooks? No
Create messaging webhooks? No
Create RTC webhooks? No
Allow use of data for AI training? No

Die Anwendung sollte nun erstellt sein. Besuchen Sie das Dashboard und navigieren Sie zu Anwendungen. Ihre neue Anwendung sollte dort aufgelistet sein.

Einrichten des Dialogflow-Agenten

Um den Dialogflow-Agenten einzurichten, besuchen Sie https://console.cloud.google.com und erstellen Sie ein neues Projekt:

New Dialogflow project

Beachten Sie die PROJECT ID. Aktivieren Sie die Dialogflow-API in der Liste der APIs:

Enable Dialogflow

Besuchen Sie https://dialogflow.cloud.google.com um einen neuen Agenten zu erstellen:

Create Dialogflow agent

Um es Ihnen leicht zu machen, Ihre Anwendung zum Laufen zu bringen, habe ich eine Zip-Datei in das GitHub-Repositorium für dieses Projekt. Navigieren Sie zu dem dialogflow Verzeichnis, und unter resources laden Sie die quizzie.zip Datei herunter. Diese Zip-Datei wird von der Dialogflow-Einstellungsseite exportiert und enthält alle Intents, Kontexte und Antworten, die zum Einrichten eines Agenten auf dem Dialogflow-Dashboard erforderlich sind.

Klicken Sie auf dem Dialogflow-Dashboard auf Einstellungen und navigieren Sie zu Exportieren/Importieren. Importieren Sie die soeben heruntergeladene Zip-Datei:

Import settings

Unser Dialogflow-Quiz-Agent ist fertig eingerichtet und einsatzbereit!

In den nächsten Schritten müssen wir die Logik erstellen, die die Hin- und Rückmeldungen zwischen dem Endbenutzer und unserem Dialogflow-Agenten abwickeln wird.

Anwendungscode

Wir wollen eine Schnittstelle für den Versand einer SMS an den Endbenutzer schreiben. Stellen Sie zunächst sicher, dass Sie die Vonage Python-Bibliothek installiert haben:

pip install vonage

Die Funktion zum Senden einer SMS sieht wie folgt aus:

import vonage
import os
import json


def vonage_sms(message, recipient):
   VONAGE_API_KEY = os.getenv("VONAGE_API_KEY")
   VONAGE_API_SECRET = os.getenv("VONAGE_API_SECRET")
   VONAGE_NUMBER = os.getenv("VONAGE_NUMBER")

   client = vonage.Client(key=VONAGE_API_KEY, secret=VONAGE_API_SECRET)
   sms = vonage.Sms(client)

   response_data = sms.send_message(
       {
           "from": VONAGE_NUMBER,
           "to": recipient,
           "text": message,
       }
   )

   if response_data["messages"][0]["status"] == "0":
       return json.dumps("Message sent successfully.")
   else:
       return json.dumps(f"Message failed with error: {response_data['messages'][0]['error-text']}")

Als Nächstes fügen Sie den Code hinzu, der unseren Kunden benachrichtigen wird:

#! /usr/bin/env python3
import argparse
import sys
import os

from dotenv import load_dotenv

sys.path.append('../')
import vonage

APP_ROOT = os.path.join(os.path.dirname(__file__), '..')  # refers to application_top
dotenv_path = os.path.join(APP_ROOT, '.env')
load_dotenv(dotenv_path)


def notify_customer(number):
   text = "Hello. You can start your quiz with quizzie-bot by sending the following keywords: hi," \
          " hello or vonage."
   print(vonage_sms(text, number))

Sobald der Endnutzer die Nachrichten erhält, soll er darauf antworten. Wir müssen einen eingehenden Webhook-Endpunkt erstellen, um die Antwort zu erhalten. Erinnern Sie sich daran, dass wir die eingehende SMS-URL bereits bei der Erstellung einer App eingerichtet haben. Nun ist es an der Zeit, unserem Webhook eine Logik hinzuzufügen:

@app.route("/update/", methods=['POST'])
def update_url():
   trigger = request.get_json().get('message')
   project_id = os.getenv("PROJECT_ID")
   session_id = os.getenv("SESSION_ID")
   language_code = os.getenv("LANG_CODE")

   response = detect_intent_texts(project_id, session_id, trigger, language_code)
   phone = phone_number()

   return send_sms(response, phone)

Wir müssen die Antworten, die wir vom Endbenutzer erhalten, als Eingabe für unseren Dialogflow-Agenten verketten. Dazu müssen wir den Dialogflow-REST-Agenten verwenden.

Konkret müssen wir die Absicht des Benutzers erkennen und sie als Eingabe an den Agenten weitergeben:

def detect_intent_texts(project_id, session_id, texts, language_code):
   """Returns the result of detect intent with texts as inputs.
   Using the same `session_id` between requests allows continuation
   of the conversation."""
   import dialogflow_v2 as dialogflow

   session_client = dialogflow.SessionsClient()

   session = session_client.session_path(project_id, session_id)
   print('Session path: {}\n'.format(session))

   for text in texts:
       text_input = dialogflow.types.TextInput(
           text=text, language_code=language_code)

       query_input = dialogflow.types.QueryInput(text=text_input)

       response = session_client.detect_intent(
           session=session, query_input=query_input)

       return response.query_result.fulfillment_text

Schlussfolgerung

Die grundlegende Einrichtung ist nun abgeschlossen. Wir haben die Logik gezeigt, die für die App zum Senden und Empfangen von SMS-Nachrichten erforderlich ist, sowie die Verbindung mit dem Dialogflow-Agenten. Den vollständigen Code für die App finden Sie im Projekt-Repository: https://github.com/nexmo-community/Vonage-QnA-app. Wenn Sie weitere Fragen haben, können Sie mir gerne mir eine E-Mail schicken.