Cursus
Introductie tot Python
4 uur
7.1M
Als het goed wordt aangepakt, is via menselijke taal met een computer communiceren enorm krachtig en ook gewoon leuk. Messaging en spraakgestuurde apparaten zijn de volgende grote platforms, en conversationele computing speelt een grote rol bij het creëren van boeiende augmented- en virtualreality-ervaringen. Er zijn een aantal unieke uitdagingen bij het bouwen van dit soort programma’s, zoals: hoe maak ik mijn chatbot beschikbaar voor de buitenwereld?
In deze tutorial doorloop je de stappen om een chatbot te deployen op Facebook Messenger, dat meer dan 1 miljard actieve gebruikers heeft. Met slechts een paar regels code kun je een enorm publiek bereiken.
Er zijn 3 hoofdstappen om dit voor elkaar te krijgen. Je moet:
- een server maken die naar berichten van Facebook luistert (met
flask) - een functie definiëren om berichten terug te sturen naar gebruikers (met
requests) - een
https-verbinding doorsturen naar je lokale machine (metngrok)
Wil je meer weten over hoe je menselijke taal omzet in machine-instructies, bekijk dan de DataCamp-cursus Building Chatbots in Python.
Let op: in dit artikel behandelen we niet hoe je bot kan begrijpen wat mensen zeggen en daar passend op reageert. Om daar meer over te leren, kijk je naar Rasa NLU, Rasa Core en de zojuist genoemde DataCamp-cursus.
Wikkel je chatbot in een http-server
De eerste stap is een http-server maken die luistert naar berichten die door Facebook worden verzonden, daar een reactie op krijgt en die reactie uiteindelijk terugstuurt naar de gebruiker op Facebook. We gebruiken flask om deze server te maken. Het basisidee is als volgt:
- Maak een
flask-app die luistert naar berichten die naarlocalhost:5000/webhookworden gestuurd. Wanneer er berichten op Facebook worden verzonden, komen die alshttp-requests op deze URL binnen. - De functie
listen()handelt dezehttp-requests af en controleert of ze een geldig Facebook-bericht bevatten - Als het bericht geldig is, wordt de functie
get_bot_response()aangeroepen en wordt de reactie teruggestuurd naar Facebook Messenger
Daarnaast maak je een functie genaamd verify_webhook() die de initiële authenticatie tussen Facebook en je app afhandelt.
Het uiteindelijke script ziet er zo uit (sla het op 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 het bovenstaande script zijn de variabelen VERIFY_TOKEN en PAGE_ACCESS_TOKEN nog niet gedefinieerd – die moet je dus instellen. De VERIFY_TOKEN kan elke string zijn; deze wordt gebruikt als een soort wachtwoord om Facebook te laten weten dat deze server berichten wil ontvangen. Het is een goed idee om een lange, willekeurige string te gebruiken. Dat kan snel door openssl rand -base64 32 in je terminal uit te voeren.
Maak je over de PAGE_ACCESS_TOKEN nog geen zorgen – hieronder zie je hoe je die krijgt!
Stuur berichten terug naar gebruikers
Vervolgens schrijf je een functie die een reactie terugstuurt naar Facebook Messenger met behulp van een Python-bibliotheek genaamd requests. In het bijzonder gebruik je de methode post(), die een HTTP POST-request aanmaakt. Een POST-request is de typische manier om informatie naar een server te sturen.
Je functie zou er zo uit moeten zien:
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()
Stel een https-endpoint bloot en koppel een Facebook-pagina
De url localhost:5000 werkt alleen voor requests die worden gemaakt op dezelfde computer als de draaiende server. Dus je moet Facebook laten weten hoe je flask-server te bereiken is. Installeer hiervoor eerst ngrok.
Ga naar deze pagina en installeer de versie voor jouw besturingssysteem. Als je op Mac werkt en homebrew hebt, is de snelste manier om ngrok te installeren met brew cask install ngrok.
Start de ngrok-server in je terminal met ngrok http 5000. Dit zet een https-endpoint op dat wordt doorgestuurd naar je machine op poort 5000, bijvoorbeeld https://51b6b3fa.ngrok.io.
Let op dat als je ngrok stopt en opnieuw start, deze URL verandert.
Maak een Facebook-app en -pagina
De volgende stap is een app en een pagina op Facebook maken. Er is goede documentatie beschikbaar van Facebook, maar we lopen hier de belangrijkste stappen door.
Om de app te maken ga je hierheen en
- klik je op My Apps -> Add a New App en voer je een naam in
- je wordt doorgestuurd naar het dashboard van de app
- zoek onder Products naar Add a Product en klik op Messenger -> Set Up
Om de pagina te maken moet je:
- naar de instellingen voor Messenger gaan, omlaag scrollen naar Token Generation en klikken op de link om een nieuwe pagina te maken voor je app
Zodra je een pagina hebt gemaakt, ga je terug naar de instellingen voor Token Generation en selecteer je deze pagina in het dropdownmenu. Kopieer de Page Access Token naar de placeholder voor PAGE_ACCESS_TOKEN in server.py hierboven.
Start je botserver
Nu alles is ingesteld, is het tijd om je chatbotserver te starten! Voer in een aparte terminaltab het volgende uit
FLASK_APP=server.py flask run
Stel de webhook in
Tot slot moet je je webhook registreren op de Facebook Developers-pagina.
- Ga opnieuw naar het Messenger-tabblad in Products en scroll omlaag naar Webhooks, klik op Setup Webhooks
- Voer onder de Callback URL je ngrok-URL in, bijvoorbeeld
https://51b6b3fa.ngrok.io/webhook. Het is belangrijk dat jeflask-app op dit moment draait, omdatverify_token()in de volgende stap wordt aangeroepen - In het veld Verify Token vul je de waarde in die je in je
server.py-bestand hebt opgegeven - Zorg ervoor dat in Subscription Fields
messagesenmessaging_postbackszijn aangevinkt Klik op Verify and Save om de authenticatie uit te voeren
Belangrijk: Ga terug naar Products -> Messenger, en selecteer onder Select a page to subscribe your webhook to the page events je pagina en klik op Subscribe.
Klaar!
Je bot is nu klaar om berichten te versturen en te ontvangen via Facebook Messenger. Op dit moment is je functie get_bot_response() nog vrij eenvoudig en voelt het nog niet als een echte chatbot! Wil je alles leren over het bouwen van chatbots, bekijk dan de DataCamp-cursus Building Chatbots in Python en de tutorial Building a Chatbot using Chatterbot in Python, evenals de Python-bibliotheken Rasa NLU en Rasa Core.
Onderwerpen
