Marketing inteligente com Django, Rasa NLU e Vonage

As empresas modernas estão recorrendo a tecnologias inteligentes, como os chatbots, para automatizar processos de trabalho. A tecnologia inteligente pode automatizar tarefas como contabilidade, recrutamento e marketing. Com o uso da Inteligência Artificial, as empresas podem facilitar o trabalho e melhorar o envolvimento e as interações com os clientes. O melhor exemplo do uso da tecnologia inteligente são os assistentes virtuais e os chatbots. Essas ferramentas inteligentes ajudam as empresas a serem mais produtivas sem precisar realizar todo o trabalho manualmente.

Pré-requisitos

Para este aplicativo, vamos usar o seguinte:

Django – Uma estrutura de trabalho para desenvolvimento web

Rasa NLU – Uma plataforma de Processamento de Linguagem Natural de código aberto

Django Rest Framework – Um pacote do Django usado para criar APIs

AngularJS x 1 – Um framework front-end em JavaScript

Vue.js x 1 – Um framework de front-end em JavaScript

Docker – Uma plataforma de imagens de contêineres

Heroku – Uma plataforma de hospedagem na web

SMS API da Vonage – Uma API para o envio de mensagens de texto SMS

A seguir, veremos como instalar cada um desses pacotes.

Instalação

Primeiro, vamos começar a instalar um ambiente virtual. Um ambiente virtual funcionará como um repositório para todos os nossos pacotes. Como estamos usando o Linux, abra o cmd e digite virtualenv vonenv.

Isso criará um novo ambiente virtual chamado vonenv. Ative-o digitando source/vonenv/bin/activate.

Instalando o Django

Usaremos o Django como nossa estrutura de aplicativos. Instale o Django digitando pip install Django. Você pode especificar a versão usando == e informando o nome da versão.

Instalando o Django Rest Framework

Digite pip install Django rest framework. Além disso, instale o agendador do Python digitando pip install scheduler.

Instalando o Django-cors-headers

Vamos instalar um pacote chamado django-cors-headers que ajudará a evitar erros de origem cruzada. Isso significa que poderemos enviar e receber solicitações HTTP de um servidor para o outro. Para instalar o pacote, digite:

pip install django-cors-headers

Criando nosso aplicativo

Para criar o tipo de aplicativo django-admin startproject vonage. Isso criará o modelo inicial do nosso projeto com todo o código.

Acesse seu aplicativo e digite django-admin start project myapp. Isso criará o projeto que vamos usar.

Para testar o aplicativo, basta digitar python manage.py runserver e acesse localhost:8000 no seu navegador.

Configurando as opções

Vá até a pasta raiz do seu projeto e abra o arquivo settings.py. Esse é o arquivo que será usado para definir a configuração do backend do nosso aplicativo.

Na lista de aplicativos instalados, adicione o myapp e o rest framework na parte inferior. Isso registrará os pacotes e informará ao Django que queremos usá-los.

No terminal, digite: python manage.py migrate. Isso executará as migrações iniciais do nosso aplicativo e criará novas tabelas no banco de dados.

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = [
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'django.contrib.sites',
   'myapp',
   'actstream',
   'rest_framework',
   'corsheaders',
]
SITE_ID = 1

Configuração de modelos

Em seguida, precisamos criar nossos modelos de banco de dados. Os modelos são as tabelas que iremos preencher no banco de dados. Criaremos dois modelos: TextMessage e UserActivity. O modelo TextMessage será usado para armazenar os detalhes do objeto TextMessage, e o modelo UserActivity será usado para armazenar e acompanhar a atividade do usuário.

from django.db import models
from django.contrib.auth import get_user_model
from django.db.models.signals import post_save
from actstream import action
from django.utils import timezone
# Create your models here.
class TextMessage(models.Model):
   user = models.ForeignKey(get_user_model(),on_delete=models.CASCADE)
   ffrom= models.IntegerField()
   to= models.IntegerField()
   text = models.CharField(max_length=1000)
   text_type = models.CharField(max_length=100,default='sms',blank=True)
   send_date = models.DateField(default='2020-12-12')
   send_time = models.TimeField()
   date_created = models.DateField(auto_now=True)

class UserActivity(models.Model):
   user = models.ForeignKey(get_user_model(),on_delete=models.CASCADE)
   verb = models.CharField(max_length=100)
   target = models.CharField(max_length=1000)
   time_stamp = models.DateField(auto_now=True)

Criação da nossa API

API significa Interface de Programação de Aplicativos. É um conjunto de protocolos (regras) definidos que indicam como acessar e utilizar dados. Por exemplo, uma API REST utiliza GET/POST/DELETE/PUT. Esses são os protocolos de uma API REST. Uma API permite acessar dados em um banco de dados por meio de solicitações HTTP.

Vamos criar duas APIs REST: a API TextMessage e a API UserActivity. Por que usar APIs? Uma API é importante para fazer solicitações HTTP e facilitar muito a interação com o banco de dados. Com as APIs, podemos fazer solicitações HTTP aos nossos endpoints de API e usar qualquer framework de JavaScript que escolhermos. Isso torna nossas escolhas de front-end mais flexíveis e fáceis de integrar.

Se você ainda não fez isso, instale o pacote Django REST Framework digitando pip install Django-rest-framework. Em seguida, adicione o pacote aos aplicativos instalados e execute python manage.py migrate para registrar as alterações em nosso banco de dados.

Configurando visualizações

O arquivo de visualizações será responsável por armazenar nossas funções. Essas funções poderão renderizar dados, detectar erros e nos permitir fazer solicitações GET, POST, PUT, EDIT e DELETE às nossas APIs.

Precisaremos importar algumas funções e métodos que serão utilizados por nossas funções e classes. Trata-se de métodos embutidos nos pacotes que instalamos, incluindo o Django.

from django.shortcuts import render
from .models import TextMessage, UserActivity
from .serializers import TextMessageSerializer, UserActivitySerializer
from django.http import Http404
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.utils.decorators import method_decorator
from django.http import HttpResponse
import schedule
from django.views.generic.detail import DetailView
from django.contrib.auth import login, authenticate
from django.contrib.auth.forms import UserCreationForm
from django.http import Http404, HttpResponseRedirect
import datetime
import requests

Visualização da página de destino

#landing page
def landing(request):
   return render(request,'myapp/landing.html')

Essa função irá renderizar nosso modelo de página de destino.

Visualização da página do painel

#dashboard view
def index(request):
   act = UserActivity.objects.all()
   return render(request,'index.html',{'act':act})

Essa função irá renderizar nosso modelo de página do painel.

Agendamento de SMS

Vamos programar o envio das mensagens SMS usando um pacote do Django chamado “python scheduler”. Estamos usando esse pacote porque é fácil de configurar e eficiente.

# extract dates and time from model
sms = TextMessage.objects.all()
for s in sms:
   date_to_send = s.send_date
   date_created = s.date_created
   days_left = date_created - date_to_send ,s.send_time
   print(days_left)
   days_left = str(days_left)
   daytime = str(s.send_time)

Essa função é responsável por enviar a mensagem SMS ao destinatário. Ela utiliza a biblioteca de solicitações para realizar solicitações POST ao endpoint da API da Vonage, usando dados da API TextMessage como parâmetros. Quando chamada, a função envia a mensagem SMS utilizando os dados da API TextMessage.

# here I used my own credentials for demo purposes
def job():
   r = requests.post("https://rest.nexmo.com/sms/json",data ={"from":s.ffrom,"text":s.text,"to":s.to,"api_key":"[YOUR API KEY]", "api_secret":"[YOUR API SECRET]"})
   print(r)

sms = TextMessage.objects.all()
for s in sms:
   date_to_send = s.send_date
   date_created = s.date_created
   days_left = date_created - date_to_send ,s.send_time
   print(days_left)
   total_days = str(days_left)
   daytime = str(s.send_time)
   #schedule each sms
   schedule.every(total_days).days.at(daytime).do(job)

Configuração de URLs

O arquivo URL é usado para definir rotas para nosso aplicativo. Vamos adicionar as funções de visualização como nossas rotas para navegar por cada modelo.

from django.contrib import admin
from django.urls import path, include
from myapp import views

urlpatterns = [
   path('',views.landing,name='land'),
   path('signup',views.signup,name='signup'),
   path('dashboard',views.index,name='dash'),
   path('von',views.assistant,name='von'),
   path('schedule',views.timetable,name='sched'),
   path('text/<int:pk>',views.TextMessageDetailView.as_view(),name='detail'),
   path('api/texts', views.TextMessageList.as_view(),name='list'),
   path('api/texts/<int:pk>', views.TextMessageDetail.as_view(),name='api-detail'),
   path('api/activity', views.UserActivityList.as_view(),name='actions'),
   path('api/activity/<int:pk>', views.UserActivityDetail.as_view(),name='action-detail'),
   path('accounts/', include('django.contrib.auth.urls')),
   path('admin/', admin.site.urls),
]

Serializadores

Ao usar APIs, precisamos primeiro serializar os dados. A serialização é o processo de converter dados em pequenos bytes para que possam ser utilizados por softwares ou dispositivos físicos. Em nossa estrutura de API, é fácil serializar dados. Criamos um arquivo serializers.py, importamos nossos modelos e definimos nossos serializadores.

from rest_framework import serializers
from rest_framework.serializers import ModelSerializer
from .models import TextMessage,UserActivity

class TextMessageSerializer(serializers.ModelSerializer):
   class Meta:
	model = TextMessage
	fields = '__all__'

class UserActivitySerializer(serializers.ModelSerializer):
   class Meta:
	model = UserActivity
	fields = '__all__'

Configuração de modelos

Agora que já sabemos quais páginas serão usadas em nosso aplicativo, precisamos configurar nossos modelos para que se conectem aos nossos sistemas de back-end. Fazemos isso usando JavaScript e também nossas APIs como fonte de dados.

Página de assistente

Esta página servirá como a interface do usuário do nosso chatbot. É nesta página que os usuários irão interagir com o chatbot e enviar dados. Usaremos o Angular para interagir com nosso bot, enviando solicitações HTTP para a API do Rasa. Em seguida, gerenciaremos os dados da resposta usando o jQuery. A página foi projetada como um aplicativo de bate-papo, e tudo o que o usuário precisa fazer é responder às perguntas do bot.

<script>
 //start chat on button click
 var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope, $http,$interval) {
 $scope.sayHi = function(){
$http.post("http://localhost:5005/webhooks/rest/webhook",{"message":"hi"})
.then(function(response) {
   console.log(response.data)
   $(".chat").append("<br><li style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + 'Start a campaign'+ "</li><br>")
  $(".chat").append("<br><li style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
});
 }

})
//post user input to rasa api
$("#msg").click(function(){
axios.post("http://localhost:5005/webhooks/rest/webhook",{"message":$("#message").val()})
  .then(function (response) {
   $(".chat").append("<br><li class='human' style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + $('input').val()+ "</li><br>")
  $(".chat").append("<br><li class='bot' style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
 })
 .catch(function (error) {
   console.log(error);
 });

})
//post date to rasa api
$("#sub1").click(function(){
axios.post("http://localhost:5005/webhooks/rest/webhook",{"message":$("#date").val()})
  .then(function (response) {
 console.log(response)
   $(".chat").append("<br><li style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + $("#date").val() + "</li><br>")
  $(".chat").append("<br><li style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
 .catch(function (error) {
   console.log(error);
 });
 })

})
//post time to rasa api
$("#sub2").click(function(){
axios.post("http://localhost:5005/webhooks/rest/webhook",{"message":$("#time").val()})
  .then(function (response) {
 console.log(response)
   $(".chat").append("<br><li style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + $("#time").val() + "</li><br>")
  $(".chat").append("<br><li style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
 .catch(function (error) {
   console.log(error);
 });
 })
})
</script>

 <script>
 //  open date and time modal on chat click
 $("ul").click(function(){
 $("#op").click()
   $("#op2").click()
})
</script>

Página de programação

Esta página serve para exibir todas as mensagens SMS agendadas em nosso banco de dados. O usuário poderá acompanhar os dados no banco de dados e visualizar os detalhes de cada mensagem SMS clicando em qualquer um dos valores. Quando o usuário clicar no botão “Exibir”, ele será redirecionado para a página de detalhes da mensagem SMS. Nesta página, usamos o Vue.js para fazer uma simples solicitação HTTP GET à nossa API em localhost:8000.

<!--render api data-->

 <h2 class="mb-4">Schedule</h2>
<!--wrap vuejs syntax in verbatim tag as data will not render outside the verbatim tag-->
{% verbatim  %}
   <table id="app" class="table">
   <thead>
 <tr style="color:blue">
   	<b><td>ID</td></b>
	<b><td>TO</td></b>
	<b><td>FROM</td></b>
   <b><td>MESSAGE</td></b>
	<b><td>DATE</td></b>
  </tr>
  <tr v-for="stat in info">
   	<td>{{stat.id}}</td>
	<td>{{stat.to}}</td>
	<td>{{stat.ffrom}}</td>
	<td>{{stat.text}}</td>
	<td>{{stat.send_date}}</td>
	<td>{{stat.send_time}}</td>
	<td>{{stat.date_created}}</td>
  </tr>
   </tbody>
 </table>
  {% endverbatim %} </div>
 </div>
	</div>
<!--script to get api data-->
 <script>
new Vue({
 el: '#app',
 data () {
   return {
  info: null
   }
 },
 mounted () {
   axios
  .get('/api/texts')
  .then(response => (this.info = response.data))

 }
})
 </script>

Página do painel

Esta é a página que registra todas as atividades do usuário no aplicativo. Neste aplicativo, o usuário verá todo o seu histórico de atividades e as datas correspondentes. Isso é importante para que o usuário possa ter uma referência do que fez em uma data e hora específicas. Exibimos as atividades usando a sintaxe de modelos do Django e as ações de renderização por meio das visualizações.

<h2 class="mb-4">Activity Dashboard</h2>


<!--loop through actions-->


{% for a in act %}


<h3>{{a.user}} {{a.verb}} <span style="color:blue">{{a.target}}</span> at {{a.time_stamp}}</h3>
{% endfor %}

Página de login

Esta página permitirá que o usuário faça login ou acesse o aplicativo usando um nome de usuário e uma senha.

Página de inscrição

Também conhecida como página de cadastro, essa página permite que o usuário crie uma nova conta. Após a autenticação, a página dá acesso às demais páginas.

Testando o aplicativo

Agora que já conectamos tudo o que precisamos para rodar nossa aplicação Django, só precisamos verificar se tudo funciona bem. No terminal, digite python manage.py runserver e acesse localhost:8000. Navegue usando os botões laterais para ver como cada página fica. Ainda não inserimos nenhum dado em nosso banco de dados, portanto, nenhum dado será exibido. Clicar nos botões também não funcionará, pois ainda não conectamos nosso sistema front-end à API do Rasa. Agora que o design está pronto, podemos começar a desenvolver nosso bot do Rasa.

Instalando o Rasa

O Rasa é uma plataforma de IA de código aberto que permite aos desenvolvedores criarem seus próprios chatbots e assistentes de voz personalizados usando um conjunto de APIs de IA. O Rasa utiliza amplamente o processamento de linguagem natural (NLP), por isso é mais adequado para a criação de Applications de NLP. Usaremos a Rasa para desenvolver nosso próprio backend personalizado de chatbot de IA, que será integrado à nossa interface de usuário.

Para instalar o Rasa, abra um novo terminal e crie um novo ambiente virtual ou reative o anterior. Em seguida, digite pip install rasa. Esse comando baixará o Rasa do site do Rasa e o instalará no seu computador. Quando a instalação estiver concluída, um bot básico estará disponível para você interagir. No mesmo terminal, digite rasa shell para interagir com seu bot. Digite “hi” ou “hello” e pressione Enter. O bot responderá de acordo com seu treinamento.

Configuração do domínio

Agora vamos programar nosso bot para atender ao nosso caso de uso aqui. O objetivo do nosso bot é receber os dados do usuário e armazená-los em um banco de dados. Esses dados serão então usados para enviar um SMS para um número específico em um determinado horário. Portanto, precisamos configurar o bot para registrar esses dados. Com o uso de NLP, o bot pode responder de forma adequada e seguir um fluxo de resposta específico.

Abra o arquivo de domínio e, nele, você verá alguns títulos. Esses títulos são: intenções, ações e modelos. Precisamos alterá-los para que a resposta do bot seja específica e relevante para nosso aplicativo. Por exemplo, adicionamos intent ask_message e ask_recipient_number para que o bot possa detectar que a entrada é o número do destinatário.

Também precisamos adicionar slots e entidades ao nosso arquivo. Slots são os campos de entrada que serão usados pelo bot ao receber dados. Em vez de simplesmente responder, o bot armazenará os dados como entradas de formulário e os enviará quando terminar.

slots:
 from:
   type: text
 to:
 type: text
 message:
  type: text
 send_time:
  type: unfeaturized
 send_date:
  type: unfeaturized

entities:
 - from
 - to
 - message
 - send_time
 - send_date

intents:
 - greet
 - affirm
 - deny
 - from
 - to
 - message
 - send_time
 - send_date

forms:
 - text_form

actions:
- action_ask_details
- utter_ask_from
- utter_ask_to
- utter_affirm
- utter_deny
- utter_respond
- utter_ask_message
- utter_ask_send_time
- utter_ask_send_date

templates:
 utter_ask_from:
 - text: "Hello! Welcome to Vonage marketing. To begin please provide the number to send from?"

 utter_ask_to:
 - text: "Which number should I send to?"

 utter_ask_message:
 - text: "What's your message text?"

 utter_affirm:
 - text: "Good! Your data has been saved"

 utter_deny:
 - text: "Oh sorry to hear that. Please refresh your page to try again"

 utter_respond:
 - text: "I will now be scheduling your sms. You provided the following data:
   	From: {from} To: {to} Message: {message} Date: {send_date} Time: {send_time}. Is this correct?"

 utter_ask_send_time:
 - text: "Click here to schedule the time"

 utter_ask_send_date:
 - text: "Click here to select date"
   buttons:
   - title: "Select date"
  payload: '/send_date{"send_date": "send_date"}'

Configurando histórias

As histórias se referem às entradas que o usuário pode fornecer. Por exemplo, informamos ao bot para esperar que um usuário forneça o número de telefone 55512345, ou um número semelhante, para que o bot esteja familiarizado com as entradas do usuário. Escrevemos as histórias e especificamos a qual slot elas se referem. Slots são campos de preenchimento do formulário.

## happy path
* greet
 - utter_ask_from
 - text_form
 - form{"name": "text_form"}
 - slot{"requested_slot": "from"}
 - slot{"from": "350123456789"}
 - slot{"from": "230123456789"}
 - slot{"from": "263123456789"}
 - slot{"from": "299123456789"}
 - slot{"from": "502123456789"}
 - slot{"from": "224123456789"}
 - slot{"from": "592123456789"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "to"}
 - slot{"to": "350123456789"}
 - slot{"to": "230123456789"}
 - slot{"to": "263123456789"}
 - slot{"to": "299123456789"}
 - slot{"to": "502123456789"}
 - slot{"to": "224123456789"}
 - slot{"to": "592123456789"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "message"}
 - slot{"message": "welcome to team vonage!"}
 - slot{"message": "thank you for subscribing!"}
 - slot{"message": "buy one and get one extra for free"}
 - slot{"message": "this is a marketing sms!"}
 - slot{"message": "thank you for contacting us!"}
 - slot{"message": "we will holding a team conference next week,dont miss out!"}
 - slot{"message": "zoom meeting next week!"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "send_time"}
 - slot{"send_time": "13:30"}
 - slot{"send_time": "23:01"}
 - slot{"send_time": "23:31"}
 - slot{"send_time": "2:12"}
 - slot{"send_time": "5:00"}
 - slot{"send_time": "22:41"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "send_date"}
 - slot{"send_date": "12-12-2020"}
 - slot{"send_date": "11-09-2020"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - utter_respond

## happy path 2
* affirm
 - utter_affirm

## sad path 1
* deny
 - utter_deny

Configurando o NLU

No arquivo NLU, registramos as intenções do usuário e exemplos de cada uma delas. É recomendável incluir o maior número possível de exemplos para cada intenção, para que o bot seja mais inteligente e consiga identificar mais entradas.

## intent:from
- [350123456789](from)
- [230123456789](from)
- [263123456789](from)
- [299123456789](from)
- [502123456789](from)
- [224123456789](from)
- [592123456789](from)

## intent:to
- [350123456789](to)
- [230123456789](to)
- [263123456789](to)
- [299123456789](to)
- [502123456789](to)
- [224123456789](to)
- [592123456789](to)

## intent:message
- are you a bot?
- are you a human?
- am I talking to a bot?
- am I talking to a human?

## intent:send_time
- [13:30](send_time)
- [23:01](send_time)
- [21:31](send_time)
- [2:12](send_time)
- [5:00](send_time)
- [22:41](send_time)
- [5:00](send_time)

## intent:send_date
- [12-12-2020](send_date)
- [11-09-2020](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)

Configurando ações

O arquivo de ações é onde agora reunimos todos os dados e decidimos como todas as entradas do usuário serão processadas. No nosso caso, estamos recebendo as entradas do usuário como dados de formulário; portanto, precisamos enviar os dados fornecidos pelo usuário. Esses dados serão enviados para a API TextMessage que criamos anteriormente neste post. Os dados serão usados como parâmetros na API Vonage Messages ao fazer uma solicitação POST.

Arquivo de configuração

Antes de prosseguirmos, precisamos informar ao Rasa que estamos recebendo respostas no formato de formulário. Para isso, abra o arquivo config.yml e adicione FormPolicy ao final da lista de políticas. As políticas são importantes porque informam ao seu bot como usar os dados, qual formato utilizar e determinam o tipo de fluxo de dados. Neste caso, o fluxo de dados é o de um formulário.

# Configuration for Rasa NLU.
# https://rasa.com/docs/rasa/nlu/components/
language: en
pipeline: supervised_embeddings

# Configuration for Rasa Core.
# https://rasa.com/docs/rasa/core/policies/
policies:
 - name: MemoizationPolicy
 - name: KerasPolicy
 - name: MappingPolicy
 - name: FormPolicy

Agora que configuramos tudo o que precisamos para treinar nosso bot, vamos treiná-lo para que ele utilize todas as nossas configurações personalizadas de todos os arquivos. Portanto, no terminal, digite rasa train. O bot levará alguns segundos para analisar, validar e aplicar as alterações. Se houver algum erro nos arquivos, o treinamento não funcionará.

Testando o novo bot

Agora é hora de testar a configuração do nosso bot. Abra uma nova janela do terminal e digite rasa run actions.

Em outro tipo de terminal rasa shell. Usaremos um shell para testar o bot. No shell, digite hi e responda às perguntas do bot. Se tudo estiver correto, seu bot deverá fazer uma pergunta após a outra, coletando todos os dados. Isso é o FormPolicy em ação. Depois que você fornecer todas as informações, o bot enviará os dados para sua API REST usando as solicitações que configuramos em nosso arquivo actions.py.

Conectando o Rasa ao Django

Finalmente concluímos nosso aplicativo Django e nosso bot Rasa, mas agora precisamos conectar os dois para que nosso bot possa ser utilizado a partir do nosso front-end Django. Basta alterarmos algumas coisas em nosso código JavaScript. Vamos enviar solicitações HTTP POST ao nosso bot e exibir os dados da resposta.

No terminal em que abrimos o shell do Rasa, precisamos agora executar o servidor do Rasa para solicitações HTTP usando o seguinte comando:

rasa run -m-enable-api --cors ''*' --debug

Este comando garantirá que o Rasa possa receber solicitações HTTP de um servidor remoto por meio do nosso canal REST.

No terminal, você deve ter agora três servidores em execução: um para as ações do Rasa, um para o Rasa HTTP e um servidor Django para o front-end.

Acesse a URL localhost:8000/von onde fica a interface do nosso bot e clique em “Iniciar campanha”. Isso enviará uma solicitação HTTP POST para o Rasa, dizendo “oi”. Você verá a resposta do bot na interface.

Agora podemos interagir com nosso bot usando a caixa de entrada na parte inferior; portanto, responda à pergunta do bot digitando um número e clicando em “enviar”. O bot iniciará uma sequência na qual armazenará cada entrada nos campos do formulário e a enviará para nossa API REST do TextMessage.

Se você abrir o terminal do Django, verá que uma solicitação HTTP POST foi enviada com sucesso para api/texts, o que significa que nosso formulário foi enviado com sucesso! Com base na hora e na data em que você enviou a solicitação ao bot, você deve receber um SMS no número do destinatário que você forneceu.

Nosso aplicativo já está funcionando, mas precisamos fazer algumas alterações. No momento, o aplicativo está disponível apenas em nossos computadores locais. Portanto, precisamos disponibilizá-lo ao público. Usaremos o Heroku para a implantação do Django e contêineres Docker para a implantação do bot.

Implantação no Heroku

Nesta postagem, vamos nos concentrar apenas na implantação do aplicativo, portanto, não abordaremos detalhes específicos do Heroku. A primeira coisa a fazer é criar um Account no Heroku; então, acesse https://www.heroku.com para criar um Account gratuito.

Depois de criar a conta, precisamos instalar o Heroku em nosso computador para podermos usá-lo pelo terminal. Assim que tiver criado sua conta, acesse https://devcenter.heroku.com/articles/heroku-cli e siga as instruções sobre como instalar a CLI, de acordo com o seu sistema operacional.

Em seguida, você precisa fazer login no Heroku usando a CLI, pois é muito mais fácil. Se tudo estiver instalado corretamente, agora podemos implantar nosso aplicativo Django no Heroku.

Antes de começarmos a trabalhar com o Heroku, precisamos instalar o Git para controle de versão. O Git nos ajudará a acompanhar todas as alterações que fizermos em nosso aplicativo sem perder nenhum dado.

Para instalar o Git, acesse o prompt de comando e execute o seguinte comando: sudo dnf install git-all. Assim que a execução do comando for concluída, você poderá verificar a instalação digitando: git version.

Na pasta do seu projeto, digite git init, e depois git add –all. Em seguida, digite:

git commit -m "commit message"

Esses três comandos criarão um repositório Git local no seu computador.

É altamente recomendável armazenar seu código tanto online quanto offline; por isso, vamos todos enviar nosso código para o GitHub, um repositório online. Primeiro, precisamos criar um Account no GitHub; então, acesse https://github.com para começar.

Depois de criar sua Account, você pode clicar em “novo repositório” (dê o nome que quiser) e clicar em “iniciar com um README”; em seguida, clique em “criar”. Agora que seu repositório foi criado, podemos vincular o repositório do GitHub ao nosso projeto Django.

Na pasta raiz do seu projeto, digite git remote add origin 'your/Github/URL'. Esse comando adicionará o repositório do GitHub como o branch master remoto do seu projeto. Depois de fazer isso, envie seu projeto Django digitando:

git push origin master

Este comando enviará os arquivos do seu projeto para o branch remoto “master” no GitHub.

Agora precisamos fazer mais uma coisa: configurar nosso aplicativo para o Heroku. Precisaremos adicionar os arquivos Procfile e requirements.txt; portanto, no seu terminal, digite echo>>Procfile e, em seguida, pip freeze>requirements.txt

Abra o arquivo Procfile e adicione o seguinte:

web: vonage.wsgi

E é isso! Atualize seus repositórios do Git e do GitHub de acordo com essas alterações.

Implantação

Agora, para fazer a implantação no Heroku, digite heroku create vonbot; isso criará seu aplicativo no Heroku.

Em seguida, digite git push heroku master e seu projeto será enviado para o Heroku.

Digite heroku open e isso abrirá seu projeto em um navegador da web.

Implantação no Docker

A tarefa final é implantar nosso projeto Rasa usando o Docker.

Instalando o Docker

No terminal, digite estes comandos:

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io

Isso instalará o Docker no seu computador, caso você esteja usando o Ubuntu. Para outros sistemas operacionais, consulte as instruções do Docker.

Em seguida, confirme a instalação digitando sudo docker run hello-world.

Contêiner Rasa

Seguindo a documentação do Rasa, vamos implantar nosso bot usando o docker-compose. Acesse a raiz do seu bot do Rasa e crie um novo arquivo chamado docker-compose.yml. Insira os seguintes dados no arquivo:

version: '3.0'
services:
 rasa:
   image: rasa/rasa:1.10.16-full
   ports:
  - 5005:5005
   volumes:
  - ./:/app
   command:
  - run

Para executar os serviços configurados no seu arquivo docker-compose.yml, execute:

sudo docker-compose up

Isso iniciará o contêiner do Docker para o Rasa. Agora você pode executar o Rasa em um contêiner.

Servidor de Ação

Como configuramos as ações, também devemos ter um servidor de ações disponível.

Precisamos primeiro criar a imagem e, em seguida, referenciá-la em nosso arquivo do Docker Compose. Portanto, primeiro, na pasta raiz do bot, crie um diretório chamado “actions”. Em seguida, mova seu arquivo actions.py para essa pasta. Na mesma pasta, crie um arquivo init.py.

Em seguida, crie um arquivo Dockerfile na raiz do seu projeto de bot e insira o seguinte:

# Extend the official Rasa SDK image
FROM rasa/rasa-sdk:1.10.2

# Use subdirectory as the working directory
WORKDIR /app

# Copy any additional custom requirements, if necessary (uncomment next line)
# COPY actions/requirements-actions.txt ./

# Change back to root user to install dependencies
USER root

# Install extra requirements for actions code, if necessary (uncomment next line)
# RUN pip install -r requirements-actions.txt

# Copy actions folder to the working directory
COPY ./actions /app/actions

# By best practices, don't run the code with root user
USER 1001

A próxima coisa que você precisa fazer é criar um Account gratuito no Docker em https://www.docker.com. Em seguida, você criará um repositório onde sua imagem ficará armazenada, semelhante ao GitHub.

Depois de criar seu repositório, execute o comando a seguir, substituindo “username” pelo seu nome de usuário, “repository name” pelo nome do repositório e “image” pelo nome da sua imagem:

docker build . -t <account_username>/<repository_name>:<custom_image_tag>

Quando esse comando for executado com sucesso, sua imagem estará disponível nesse repositório. Você pode então voltar ao arquivo docker-compose.yml e adicionar o seguinte:

app:

image: <image:tag>

expose: 5055

Este comando instruirá o Docker a executar sua imagem “actions” na porta 5055.

Você pode executar docker-compose up e tanto o servidor HTTP do Rasa quanto as ações serão executadas usando o Docker, e você poderá se comunicar com eles.

Conseguimos criar e implementar com sucesso nossa ferramenta de marketing utilizando a API da Vonage, o Django e o Rasa NLU.