Faça deploy do seu bot do Facebook Messenger com Python

Quando bem feito, interagir com um computador por meio da linguagem humana é incrivelmente poderoso — e também muito divertido. Dispositivos de Mensageria e de Voz são as próximas grandes plataformas, e a computação conversacional tem um papel importante na criação de experiências envolventes em realidade aumentada e virtual. Há vários desafios únicos ao construir esse tipo de programa, por exemplo: como deixar seu chatbot acessível para o mundo externo?

Neste tutorial, você vai passar pelo passo a passo para fazer o deploy de um chatbot no Facebook Messenger, que tem mais de 1 bilhão de usuários ativos. Com poucas linhas de código, dá para alcançar um público enorme.

São 3 etapas principais para concluir isso. Você precisa:

• criar um servidor que escute mensagens do Facebook (usando flask)
• definir uma função para enviar mensagens de volta aos usuários (usando requests)
• encaminhar uma conexão https para sua máquina local (usando ngrok)

Se quiser saber mais sobre como transformar linguagem humana em instruções de máquina, confira o curso da DataCamp Building Chatbots in Python.

Observe que este post não cobre como fazer seu bot entender o que as pessoas dizem e responder de forma adequada. Para aprender mais sobre isso, vale a pena ver o Rasa NLU, o Rasa Core e o curso da DataCamp mencionado acima.

Encapsule seu chatbot em um servidor http

O primeiro passo é criar um servidor http que escute as mensagens enviadas pelo Facebook, gere uma resposta para essa mensagem e, por fim, envie a resposta de volta ao usuário no Facebook. Vamos usar o flask para criar esse servidor. A ideia básica é a seguinte:

• Criar um app flask que escute mensagens enviadas para localhost:5000/webhook. Quando mensagens são enviadas no Facebook, elas chegam como requisições http para essa URL.
• A função listen() trata essas requisições http e verifica se contêm uma mensagem válida do Facebook
• Se a mensagem for válida, a função get_bot_response() é chamada e a resposta é enviada de volta ao Facebook Messenger

Além disso, você vai criar uma função chamada verify_webhook() que lida com a autenticação inicial entre o Facebook e seu app.

O script final fica assim (salve 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"Tecnologia

No script acima, as variáveis VERIFY_TOKEN e PAGE_ACCESS_TOKEN ainda não estão definidas — então você vai precisar configurá-las. O VERIFY_TOKEN pode ser qualquer string; ele funciona como uma espécie de senha para informar ao Facebook que este servidor quer receber mensagens. É uma boa ideia usar uma string longa e aleatória. Você pode gerar isso rapidamente executando openssl rand -base64 32 no terminal.

Não se preocupe com o PAGE_ACCESS_TOKEN por enquanto — já já você vai ver como obtê-lo!

Envie mensagens de volta aos usuários

Em seguida, você vai escrever uma função que envia uma resposta de volta ao Facebook Messenger usando a biblioteca Python requests. Em particular, você usará o método post(), que cria uma requisição HTTP POST. Uma requisição POST é a forma típica de enviar informações para um servidor.

Sua função deve ficar assim:

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

Exponha um endpoint https e conecte uma página do Facebook

A URL localhost:5000 só funciona para requisições criadas no mesmo computador em que o servidor está rodando. Então você precisa informar ao Facebook como alcançar seu servidor flask. Para isso, primeiro instale o ngrok.

Acesse esta página e instale a versão para o seu sistema operacional. Se você usa Mac e tem o homebrew, a forma mais rápida de instalar o ngrok é com brew cask install ngrok.

Inicie o servidor do ngrok no terminal com ngrok http 5000. Isso vai configurar um endpoint https que encaminha para sua máquina na porta 5000, por exemplo https://51b6b3fa.ngrok.io.

Atenção: se você encerrar o ngrok e reiniciar, essa URL vai mudar.

Crie um app e uma página no Facebook

O próximo passo é criar um app e uma página no Facebook. Há uma boa documentação do próprio Facebook, mas vamos passar pelos principais passos aqui.

Para criar o app, acesse aqui e

• clique em My Apps -> Add a New App e informe um nome
• você será redirecionado para o dashboard do app
• em Products, encontre Add a Product e clique em Messenger -> Set Up

Para criar a página, você precisa:

• ir nas configurações do Messenger, rolar até Token Generation e clicar no link para create a new page para o seu app

Depois de criar a página, volte às configurações de Token Generation e selecione essa página no menu suspenso. Copie o Page Access Token para o espaço de PAGE_ACCESS_TOKEN no server.py acima.

Inicie o servidor do seu bot

Agora que está tudo configurado, é hora de iniciar o servidor do seu chatbot! Em outra aba do terminal, execute

FLASK_APP=server.py flask run
Tecnologia

Configure o webhook

Por fim, você precisa registrar seu webhook na página de desenvolvedores do Facebook.

• Volte à aba Messenger em Products e, em Webhooks, clique em Setup Webhooks
• Em Callback URL, informe sua URL do ngrok, por exemplo, https://51b6b3fa.ngrok.io/webhook. É importante que seu app flask esteja rodando neste momento, pois o verify_token() será chamado na etapa seguinte
• No campo Verify Token, informe o valor que você definiu no arquivo server.py
• Em Subscription Fields, garanta que messages e messaging_postbacks estejam marcados. Clique em Verify and Save para concluir a autenticação

Importante: volte em Products -> Messenger e, em Select a page to subscribe your webhook to the page events, selecione sua página e clique em Subscribe.

Pronto!

Seu bot agora está preparado para enviar e receber mensagens pelo Facebook Messenger. Neste momento, sua função get_bot_response() ainda é bem simples e não parece um chatbot de verdade! Para aprender tudo sobre como construir chatbots, confira o curso da DataCamp Building Chatbots in Python e o tutorial Building a Chatbot using Chatterbot in Python, além das bibliotecas em Python Rasa NLU e Rasa Core.