Distribuisci il tuo bot Facebook Messenger con Python

Quando è fatto bene, interagire con un computer attraverso il linguaggio naturale è incredibilmente potente e anche piuttosto divertente. I dispositivi di messaggistica e controllo vocale sono le prossime grandi piattaforme, e il computing conversazionale ha un ruolo importante nel creare esperienze avvincenti in realtà aumentata e virtuale. Ci sono diverse sfide uniche nella creazione di questo tipo di programmi, ad esempio: come posso rendere il mio chatbot accessibile al mondo esterno?

In questo tutorial, seguirai i passaggi necessari per distribuire un chatbot su Facebook Messenger, che conta oltre 1 miliardo di utenti attivi. Puoi raggiungere un pubblico enorme con poche righe di codice.

Ci sono 3 passaggi principali per riuscirci. Devi:

• creare un server che ascolti i messaggi da Facebook (usando flask)
• definire una funzione per inviare messaggi di risposta agli utenti (usando requests)
• inoltrare una connessione https alla tua macchina locale (usando ngrok)

Se vuoi saperne di più su come trasformare il linguaggio naturale in istruzioni per la macchina, dai un'occhiata al corso DataCamp Building Chatbots in Python.

Nota che in questo post non vedrai come far capire al tuo bot cosa dicono le persone e rispondere in modo appropriato. Per approfondire, dai un'occhiata a Rasa NLU, Rasa Core e al corso DataCamp appena citato.

Racchiudi il tuo chatbot in un server http

Il primo passo è creare un server http che ascolti i messaggi inviati da Facebook, ottenga una risposta a quel messaggio e infine invii la risposta all'utente su Facebook. Useremo flask per creare questo server. L'idea di base è la seguente:

• Crea un'app flask che ascolti i messaggi inviati a localhost:5000/webhook. Quando i messaggi vengono inviati su Facebook, arriveranno come richieste http a questo URL.
• La funzione listen() gestisce queste richieste http e verifica che contengano un messaggio Facebook valido
• Se il messaggio è valido, viene chiamata la funzione get_bot_response() e la risposta viene inviata a Facebook Messenger

Inoltre, creerai una funzione chiamata verify_webhook() che gestisce l'autenticazione iniziale tra Facebook e la tua app.

Lo script finale è il seguente (salvalo come 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"

Nello script sopra, le variabili VERIFY_TOKEN e PAGE_ACCESS_TOKEN non sono ancora definite, quindi dovrai impostarle. Il VERIFY_TOKEN può essere qualsiasi stringa: è usato come una sorta di password per far sapere a Facebook che questo server vuole ricevere messaggi. È una buona idea usare una lunga stringa casuale. Puoi farlo rapidamente eseguendo openssl rand -base64 32 nel tuo terminale.

Non preoccuparti ancora del PAGE_ACCESS_TOKEN: vedrai tra poco come ottenerlo!

Invia messaggi di risposta agli utenti

Ora scriverai una funzione che invia una risposta a Facebook Messenger usando una libreria Python chiamata requests. In particolare, userai il metodo post(), che crea una richiesta HTTP POST. Una richiesta POST è il modo tipico per inviare informazioni a un server.

La tua funzione dovrebbe essere così:

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()

Esporre un endpoint https e collegare una pagina Facebook

L'URL localhost:5000 funziona solo per richieste create sullo stesso computer in cui è in esecuzione il server. Quindi devi far sapere a Facebook come raggiungere il tuo server flask. Per farlo, prima installa ngrok.

Vai su questa pagina e installa la versione per il tuo sistema operativo. Se sei su Mac e hai homebrew, il modo più rapido per installare ngrok è con brew cask install ngrok.

Avvia il server ngrok nel tuo terminale con ngrok http 5000. Questo imposterà un endpoint https che viene inoltrato alla tua macchina sulla porta 5000, ad esempio https://51b6b3fa.ngrok.io.

Nota che se chiudi ngrok e lo riavvii, questo URL cambierà.

Crea un'app e una pagina Facebook

Il passo successivo è creare un'app e una pagina su Facebook. C'è una buona documentazione disponibile da Facebook, ma qui ripasserai i passaggi principali.

Per creare l'app vai qui e

• clicca su My Apps -> Add a New App e inserisci un nome
• verrai reindirizzato alla dashboard dell'app
• sotto Products, trova Add a Product e clicca su Messenger -> Set Up

Per creare la pagina, devi:

• andare alle impostazioni di Messenger, scorrere fino a Token Generation e cliccare sul link per create a new page per la tua app

Una volta creata una pagina, torna alle impostazioni di Token Generation e seleziona questa pagina dal menu a discesa. Copia il Page Access Token nel segnaposto per PAGE_ACCESS_TOKEN in server.py qui sopra.

Avvia il server del tuo bot

Ora che hai configurato tutto, è il momento di avviare il server del tuo chatbot! In un'altra scheda del terminale, esegui

FLASK_APP=server.py flask run

Configura il webhook

Infine, devi registrare il tuo webhook sulla pagina sviluppatori di Facebook.

• Vai di nuovo alla scheda Messenger in Products e scorri fino a Webhooks, clicca su Setup Webhooks
• Nel campo Callback URL inserisci il tuo URL ngrok, ad esempio https://51b6b3fa.ngrok.io/webhook. È importante che la tua app flask sia in esecuzione in questo momento, perché verify_token() verrà chiamata nel passaggio successivo
• Nel campo Verify Token, inserisci il valore che hai specificato nel file server.py
• In Subscription Fields assicurati che messages e messaging_postbacks siano selezionati. Click Verify and Save per completare l'autenticazione

Importante: torna a Products -> Messenger e, sotto Select a page to subscribe your webhook to the page events, seleziona la tua pagina e clicca su Subscribe.

Hai finito!

Il tuo bot è ora pronto per inviare e ricevere messaggi tramite Facebook Messenger. Al momento, la tua funzione get_bot_response() è ancora piuttosto semplice e non sembra ancora un vero chatbot! Per imparare tutto sulla creazione di chatbot, dai un'occhiata al corso DataCamp Building Chatbots in Python e al tutorial Building a Chatbot using Chatterbot in Python, oltre alle librerie Python Rasa NLU e Rasa Core.