Stelle deinen Facebook-Messenger-Bot mit Python bereit

Richtig umgesetzt ist die Interaktion mit dem Computer in natürlicher Sprache enorm leistungsfähig – und macht außerdem Spaß. Messaging- und sprachgesteuerte Geräte sind die nächsten großen Plattformen, und Conversational Computing spielt eine Schlüsselrolle bei fesselnden Augmented- und Virtual-Reality-Erlebnissen. Beim Entwickeln solcher Programme gibt es jedoch einige besondere Herausforderungen. Eine davon: Wie mache ich meinen Chatbot von außen erreichbar?

In diesem Tutorial gehst du Schritt für Schritt durch die Bereitstellung eines Chatbots auf Facebook Messenger, das über 1 Milliarde aktive Nutzer hat. Mit nur wenigen Zeilen Code erreichst du ein riesiges Publikum.

Dafür sind drei Hauptschritte nötig. Du musst:

• einen Server erstellen, der Nachrichten von Facebook empfängt (mit flask)
• eine Funktion definieren, die Antworten an Nutzer zurückschickt (mit requests)
• eine https-Verbindung zu deinem lokalen Rechner weiterleiten (mit ngrok)

Wenn du mehr darüber lernen willst, wie man natürliche Sprache in Maschinenanweisungen übersetzt, schau dir den DataCamp-Kurs Building Chatbots in Python an.

Hinweis: In diesem Beitrag geht es nicht darum, wie dein Bot versteht, was Menschen sagen, und darauf passend reagiert. Dafür lohnt sich ein Blick auf Rasa NLU, Rasa Core und den eben erwähnten DataCamp-Kurs.

Fasse deinen Chatbot in einem http-Server zusammen

Der erste Schritt ist, einen http-Server zu erstellen, der Nachrichten von Facebook entgegennimmt, darauf eine Antwort erzeugt und diese wieder an den Nutzer auf Facebook sendet. Wir verwenden dafür flask. Die Grundidee ist:

• Erstelle eine flask-App, die auf Nachrichten an localhost:5000/webhook hört. Wenn Nachrichten auf Facebook gesendet werden, kommen sie als http-Requests an dieser URL an.
• Die Funktion listen() verarbeitet diese http-Requests und prüft, ob sie eine gültige Facebook-Nachricht enthalten.
• Ist die Nachricht gültig, wird get_bot_response() aufgerufen und die Antwort an Facebook Messenger zurückgesendet.

Außerdem erstellst du eine Funktion verify_webhook(), die die initiale Authentifizierung zwischen Facebook und deiner App übernimmt.

Das finale Skript sieht so aus (speichere es als server.py):

from flask import Flask, request

app = Flask(__name__)

FB_API_URL = 'https://graph.facebook.com/v2.6/me/messages'
VERIFY_TOKEN = ''# <paste your verify token here>
PAGE_ACCESS_TOKEN = ''# paste your page access token here>"


def get_bot_response(message):
    """This is just a dummy function, returning a variation of what
    the user said. Replace this function with one connected to chatbot."""
    return "This is a dummy response to '{}'".format(message)


def verify_webhook(req):
    if req.args.get("hub.verify_token") == VERIFY_TOKEN:
        return req.args.get("hub.challenge")
    else:
        return "incorrect"

def respond(sender, message):
    """Formulate a response to the user and
    pass it on to a function that sends it."""
    response = get_bot_response(message)
    send_message(sender, response)


def is_user_message(message):
    """Check if the message is a message from the user"""
    return (message.get('message') and
            message['message'].get('text') and
            not message['message'].get("is_echo"))


@app.route("/webhook")
def listen():
    """This is the main function flask uses to 
    listen at the `/webhook` endpoint"""
    if request.method == 'GET':
        return verify_webhook(request)

    if request.method == 'POST':
        payload = request.json
        event = payload['entry'][0]['messaging']
        for x in event:
            if is_user_message(x):
                text = x['message']['text']
                sender_id = x['sender']['id']
                respond(sender_id, text)

        return "ok"

In diesem Skript sind die Variablen VERIFY_TOKEN und PAGE_ACCESS_TOKEN noch nicht gesetzt – das musst du nachholen. Der VERIFY_TOKEN kann ein beliebiger String sein. Er dient als eine Art Passwort, damit Facebook weiß, dass dieser Server Nachrichten empfangen möchte. Es ist sinnvoll, eine lange zufällige Zeichenkette zu verwenden. Das geht schnell mit openssl rand -base64 32 im Terminal.

Um den PAGE_ACCESS_TOKEN kümmerst du dich gleich – unten steht, wie du ihn bekommst!

Sende Nachrichten an Nutzer zurück

Als Nächstes schreibst du eine Funktion, die mit der Python-Bibliothek requests eine Antwort an Facebook Messenger zurückschickt. Konkret nutzt du die Methode post(), die einen HTTP POST-Request erstellt. Ein POST-Request ist der typische Weg, Informationen an einen Server zu senden.

Deine Funktion sollte so aussehen:

import requests

def send_message(recipient_id, text):
    """Send a response to Facebook"""
    payload = {
        'message': {
            'text': text
        },
        'recipient': {
            'id': recipient_id
        },
        'notification_type': 'regular'
    }

    auth = {
        'access_token': PAGE_ACCESS_TOKEN
    }

    response = requests.post(
        FB_API_URL,
        params=auth,
        json=payload
    )

    return response.json()

Stelle einen https-Endpoint bereit und verbinde eine Facebook-Seite

Die URL localhost:5000 funktioniert nur für Requests vom gleichen Rechner, auf dem der Server läuft. Facebook muss also wissen, wie es deinen flask-Server erreicht. Installiere dafür zuerst ngrok.

Gehe auf diese Seite und installiere die Version für dein Betriebssystem. Wenn du auf dem Mac mit homebrew arbeitest, geht es am schnellsten mit brew cask install ngrok.

Starte den ngrok-Server im Terminal mit ngrok http 5000. Dadurch wird ein https-Endpoint eingerichtet, der auf deinen Rechner am Port 5000 weiterleitet, zum Beispiel https://51b6b3fa.ngrok.io.

Wichtig: Wenn du ngrok beendest und neu startest, ändert sich diese URL.

Erstelle eine Facebook-App und -Seite

Als Nächstes erstellst du eine App und eine Seite auf Facebook. Es gibt gute Dokumentation von Facebook, die wichtigsten Schritte findest du hier zusammengefasst.

Um die App zu erstellen, gehe hierhin und

• klicke auf My Apps -> Add a New App und gib einen Namen ein
• du wirst zum Dashboard der App weitergeleitet
• unter Products findest du Add a Product und klickst auf Messenger -> Set Up

Um die Seite zu erstellen, musst du:

• in die Messenger-Einstellungen gehen, zu Token Generation scrollen und auf den Link klicken, um eine neue Seite für deine App zu erstellen

Nachdem du eine Seite erstellt hast, gehst du zurück zu den Token Generation-Einstellungen und wählst diese Seite im Dropdown aus. Kopiere das Page Access Token in den Platzhalter für PAGE_ACCESS_TOKEN in server.py oben.

Starte deinen Bot-Server

Jetzt, wo alles eingerichtet ist, kannst du deinen Chatbot-Server starten. Führe in einem separaten Terminal-Tab aus:

FLASK_APP=server.py flask run

Richte den Webhook ein

Zum Schluss musst du deinen Webhook auf der Facebook-Developer-Seite registrieren.

• Gehe erneut zum Messenger-Tab unter Products und scrolle zu Webhooks, klicke auf Setup Webhooks
• Trage unter Callback URL deine ngrok-URL ein, zum Beispiel https://51b6b3fa.ngrok.io/webhook. Wichtig: Deine flask-App muss jetzt laufen, weil im nächsten Schritt verify_token() aufgerufen wird
• In das Feld Verify Token trägst du den Wert ein, den du in deiner server.py-Datei festgelegt hast
• Unter Subscription Fields stell sicher, dass messages und messaging_postbacks angehakt sind. Klicke auf Verify and Save, um die Authentifizierung durchzuführen

Wichtig: Gehe zurück zu Products -> Messenger und wähle unter Select a page to subscribe your webhook to the page events deine Seite aus und klicke auf Subscribe.

Geschafft!

Dein Bot kann jetzt über Facebook Messenger Nachrichten senden und empfangen. Deine Funktion get_bot_response() ist derzeit noch sehr einfach und fühlt sich noch nicht wie ein echter Chatbot an. Um alles rund um den Bau von Chatbots zu lernen, sieh dir den DataCamp-Kurs Building Chatbots in Python sowie das Tutorial Building a Chatbot using Chatterbot in Python und die Python-Bibliotheken Rasa NLU und Rasa Core an.