Curso
Introdução ao Python
4 h
7M
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
httpspara sua máquina local (usandongrok)
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
flaskque escute mensagens enviadas paralocalhost:5000/webhook. Quando mensagens são enviadas no Facebook, elas chegam como requisiçõeshttppara essa URL. - A função
listen()trata essas requisiçõeshttpe 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"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()
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
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 appflaskesteja rodando neste momento, pois overify_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
messagesemessaging_postbacksestejam 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.
Tópicos
