Implementa tu bot de Facebook Messenger con Python

Cuando se hace bien, interactuar con un ordenador mediante lenguaje humano es increíblemente potente y, además, bastante divertido. Los dispositivos de mensajería y control por voz son la próxima gran plataforma, y la computación conversacional tiene mucho que aportar para crear experiencias de realidad aumentada y virtual más atractivas. Construir este tipo de programas plantea varios retos únicos, como: ¿cómo puedo hacer que mi chatbot esté disponible para el mundo exterior?

En este tutorial, seguirás los pasos necesarios para implementar un chatbot en Facebook Messenger, que cuenta con más de 1.000 millones de usuarios activos. Puedes llegar a una audiencia enorme con solo unas pocas líneas de código.

Hay 3 pasos principales para conseguirlo. Necesitas:

• crear un servidor que escuche los mensajes de Facebook (usando flask)
• definir una función para enviar mensajes de vuelta a los usuarios (usando requests)
• redirigir una conexión de https a tu máquina local (usando ngrok)

Si quieres saber más sobre cómo convertir el lenguaje humano en instrucciones de máquina, echa un vistazo al curso de DataCamp Building Chatbots in Python.

Ten en cuenta que en esta publicación no veremos cómo hacer que tu bot entienda lo que la gente dice y responda de forma adecuada. Para saber más sobre ello, te recomendamos Rasa NLU, Rasa Core y el curso de DataCamp que acabamos de mencionar.

Envuelve tu chatbot en un servidor de http

El primer paso es crear un servidor http que escuche los mensajes enviados por Facebook, obtenga una respuesta a ese mensaje y, por último, envíe la respuesta al usuario en Facebook. Usaremos flask para crear este servidor. La idea básica es la siguiente:

• Crear una app de flask que escuche los mensajes enviados a localhost:5000/webhook. Cuando se envíen mensajes en Facebook, llegarán como solicitudes http a esta URL.
• La función listen() gestiona estas solicitudes http y comprueba que contienen un mensaje válido de Facebook
• Si el mensaje es válido, se llama a la función get_bot_response() y la respuesta se envía de vuelta a Facebook Messenger

Además, crearás una función llamada verify_webhook() que gestiona la autenticación inicial entre Facebook y tu app.

El script final es así (guárdalo como 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"Con la tecnología de

En el script anterior, las variables VERIFY_TOKEN y PAGE_ACCESS_TOKEN aún no están definidas, así que tendrás que establecerlas. VERIFY_TOKEN puede ser cualquier cadena: se usa como una especie de contraseña para que Facebook sepa que este servidor quiere recibir mensajes. Es buena idea usar una cadena aleatoria larga. Puedes generarla rápidamente ejecutando openssl rand -base64 32 en tu terminal.

No te preocupes por PAGE_ACCESS_TOKEN todavía: ¡verás cómo obtenerlo más abajo!

Envía mensajes de vuelta a los usuarios

A continuación, escribirás una función que envíe una respuesta a Facebook Messenger usando una librería de Python llamada requests. En concreto, usarás el método post(), que crea una solicitud HTTP POST. Una solicitud POST es la forma habitual de enviar información a un servidor.

Tu función debería tener este aspecto:

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()
Con la tecnología de

Expón un endpoint https y conecta una página de Facebook

La URL localhost:5000 solo funciona para solicitudes creadas en el mismo ordenador en el que se ejecuta el servidor. Así que necesitas indicarle a Facebook cómo llegar a tu servidor de flask. Para ello, primero instala ngrok.

Ve a esta página e instala la versión para tu sistema operativo. Si estás en Mac y tienes homebrew, la forma más rápida de instalar ngrok es con brew cask install ngrok.

Inicia el servidor de ngrok en tu terminal con ngrok http 5000. Esto creará un endpoint https que redirige a tu máquina en el puerto 5000, por ejemplo https://51b6b3fa.ngrok.io.

Ten en cuenta que si cierras ngrok y lo vuelves a iniciar, esta URL cambiará.

Crea una app y una página de Facebook

El siguiente paso es crear una app y una página en Facebook. Hay una buena documentación disponible de Facebook, pero aquí repasaremos los pasos principales.

Para crear la app, ve aquí y

• haz clic en My Apps -> Add a New App e introduce un nombre
• serás redirigido al panel de la app
• en Products, busca Add a Product y haz clic en Messenger -> Set Up

Para crear la página, tienes que:

• ir a la configuración de Messenger, desplazarte hasta Token Generation y hacer clic en el enlace para crear una página nueva para tu app

Una vez creada la página, vuelve a la sección Token Generation y selecciónala en el menú desplegable. Copia el Page Access Token en el valor de PAGE_ACCESS_TOKEN en el server.py anterior.

Inicia tu servidor del bot

Ahora que ya lo tienes todo listo, ¡toca poner en marcha el servidor de tu chatbot! En otra pestaña de la terminal, ejecuta

FLASK_APP=server.py flask run
Con la tecnología de

Configura el webhook

Por último, necesitas registrar tu webhook en la página de desarrolladores de Facebook.

• Ve de nuevo a la pestaña Messenger en Products y desplázate hasta Webhooks, haz clic en Setup Webhooks
• En Callback URL, introduce tu URL de ngrok, por ejemplo, https://51b6b3fa.ngrok.io/webhook. Es importante que tu app de flask esté en ejecución en este momento, porque se llamará a verify_token() en el siguiente paso
• En el campo Verify Token, pon el valor que especificaste en tu archivo server.py
• En Subscription Fields, asegúrate de que messages y messaging_postbacks estén marcados. Haz clic en Verify and Save para completar la autenticación

Importante: Vuelve a Products -> Messenger y, en Select a page to subscribe your webhook to the page events, selecciona tu página y haz clic en Subscribe.

¡Listo!

Tu bot ya puede enviar y recibir mensajes a través de Facebook Messenger. De momento, tu función get_bot_response() sigue siendo bastante simple y aún no parece un chatbot de verdad. Para aprender todo sobre cómo crear chatbots, echa un vistazo al curso de DataCamp Building Chatbots in Python y al tutorial Building a Chatbot using Chatterbot in Python, además de las librerías de Python Rasa NLU y Rasa Core.