Marketing inteligente con Django, Rasa NLU y Vonage

Las empresas modernas recurren a tecnologías inteligentes como los chatbots para automatizar los procesos de trabajo. La tecnología inteligente puede automatizar tareas como la contabilidad, la contratación y el marketing. Gracias a la inteligencia artificial, las empresas pueden facilitar el trabajo y mejorar la interacción con los clientes. El mejor ejemplo de uso de tecnología inteligente son los asistentes virtuales y los chatbots. Estas herramientas inteligentes ayudan a las empresas a ser más productivas sin tener que hacer todo el trabajo manualmente.

Requisitos previos

Para esta aplicación vamos a utilizar lo siguiente:

Django - Un marco para el desarrollo web

Rasa NLU - Plataforma de procesamiento del lenguaje natural de código abierto

Marco de trabajo Rest de Django - Un paquete de Django utilizado para crear APIs

Angularjs x 1 - Un framework javascript frontend

Vuejs x 1 - Un framework javascript frontend

Docker - Plataforma de imágenes de contenedores

Heroku - Una plataforma de alojamiento web

API de SMS de Vonage - Una API para enviar mensajes de texto SMS

A continuación, veremos cómo instalar cada uno de estos paquetes.

Instalación

En primer lugar, empezaremos a instalar un entorno virtual. Un entorno virtual será como un almacén para todos nuestros paquetes. Estamos usando Linux así que ve a cmd y escribe virtualenv vonenv.

Esto creará un nuevo entorno virtual llamado vonenv. Actívalo escribiendo source/vonenv/bin/activate.

Instalación de Django

Utilizaremos Django como framework de nuestra aplicación. Instala Django escribiendo pip install Django. Puedes especificar la versión usando == y dando el nombre de la versión.

Instalación de Django Rest Framework

Tipo pip install Django rest framework. Además, instale python scheduler escribiendo pip install scheduler.

Instalación de Django-cors-headers

Instalaremos un paquete llamado django-cors-headers que ayudará a prevenir cualquier error de origen cruzado. Esto significa que podremos enviar y recibir peticiones HTTP de un servidor a otro. Para instalar el paquete, escriba:

pip install django-cors-headers

Crear nuestra aplicación

Para crear la aplicación escriba django-admin startproject vonage. Esto creará nuestro proyecto boilerplate con todo el código.

Navegue por su aplicación y escriba django-admin start project myapp. Esto creará el proyecto que vamos a utilizar.

Para probar la aplicación simplemente escriba python manage.py runserver y navegue hasta localhost:8000 en su navegador.

Configuración de los ajustes

Navega a la carpeta raíz de tu proyecto y abre el archivo settings.py. Este es el archivo que se utilizará para establecer la configuración del backend de nuestra aplicación.

En la lista de aplicaciones instaladas añade myapp, y rest framework al final. Esto registrará los paquetes e informará a Django de que queremos usarlos.

En el terminal ejecuta, python manage.py migrate. Esto ejecutará las migraciones iniciales de nuestra app y creará nuevas tablas en la base de datos.

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

Configuración de modelos

A continuación, tenemos que crear nuestros modelos de base de datos. Los modelos son las tablas que rellenaremos en la base de datos. Crearemos dos modelos que son TextMessage y UserActivity. El modelo TextMessage se utilizará para almacenar los detalles del objeto Text Message y el modelo UserActivity se utilizará para almacenar y rastrear la actividad del usuario.

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)

Creación de nuestra API

API son las siglas en inglés de Interfaz de Programación de Aplicaciones. Se trata de un conjunto de protocolos (reglas) definidos que indican cómo acceder a los datos y utilizarlos. Por ejemplo, una API REST utiliza GET/POST/DELETE/PUT. Estos son los protocolos de una API REST. Una API permite acceder a los datos de una base de datos mediante peticiones HTTP.

Vamos a crear dos APIs REST, la API TextMessage y la API UserActivity. ¿Por qué utilizar APIs? Una API es importante para hacer peticiones HTTP y hacer la interacción con la base de datos mucho más fácil. Con las APIs, podemos hacer peticiones HTTP a nuestros endpoints API y utilizar cualquier framework JavaScript que elijamos. Esto hace que nuestras opciones de frontend sean flexibles y más fáciles de integrar.

Si aún no lo has hecho, instala el paquete Django REST framework escribiendo pip install Django-rest-framework. A continuación, añade el paquete a las aplicaciones instaladas y ejecuta python manage.py migrate para registrar los cambios en nuestra base de datos.

Configuración de vistas

El archivo views será responsable de almacenar nuestras funciones. Estas funciones serán capaces de renderizar datos, detectar errores, permitirnos hacer peticiones GET, POST, PUT, EDIT y DELETE a nuestras APIs.

Necesitaremos importar algunas funciones y métodos que serán utilizados por nuestras funciones y clases. Estos son métodos incorporados de nuestros paquetes instalados incluyendo 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

Vista de la página de destino

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

Esta función renderizará la plantilla de nuestra página de aterrizaje.

Vista de página del cuadro de mandos

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

Esta función mostrará la plantilla de nuestra página de panel de control.

Programación de SMS

Programaremos los SMS utilizando un paquete de Django llamado python scheduler. Estamos utilizando este paquete, ya que es fácil de configurar y 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)

Esta función es responsable de enviar el SMS al destinatario. Utiliza la biblioteca de solicitudes para realizar solicitudes posteriores al punto final de la API de Vonage, utilizando datos de la API de TextMessage como parámetros. Una vez llamada, la función envía el SMS utilizando los datos de la API de 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)

Configuración de URL

El archivo URL se utiliza para definir rutas para nuestra aplicación. Vamos a añadir las funciones de vista como nuestras rutas para navegar a través de cada plantilla.

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

Cuando usamos APIs necesitamos primero serializar los datos. La serialización es el proceso de convertir datos en pequeños bytes para su uso por software o dispositivos físicos. En nuestro marco API, es fácil serializar los datos. Creamos un archivo serializers.py, importamos nuestros modelos y definimos nuestros 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__'

Configuración de plantillas

Ahora que conocemos las páginas que se utilizarán en nuestra aplicación, necesitamos conectar nuestras plantillas a nuestros sistemas backend. Hacemos esto mediante el uso de JavaScript y también utilizar nuestras API como nuestra fuente de datos.

Asistente de página

Esta página actuará como nuestra página de interfaz de usuario del chatbot. Esta es la página que los usuarios utilizarán cuando hablen con nuestro chatbot y pasen datos. Usaremos Angular para interactuar con nuestro bot enviando peticiones HTTP a la API de Rasa. A continuación, gestionaremos los datos de respuesta utilizando jQuery. La página está diseñada como una aplicación de chat y todo lo que el usuario tiene que hacer es responder a las preguntas del 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>

Horario Página

Esta página se utiliza para mostrar todos los SMS programados en nuestra base de datos. El usuario podrá hacer un seguimiento de los datos en la base de datos y ver los detalles de cada SMS haciendo clic en cualquiera de los valores. Cuando el usuario haga clic en el botón de visualización será redirigido a la página de detalles del SMS. En esta página usamos Vue.js para hacer una simple petición HTTP GET a nuestra API en 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 del cuadro de mandos

Esta es la página que mantiene un registro de todas las actividades del usuario en la aplicación. En ella, el usuario verá todo su flujo de actividad y las fechas correspondientes. Esto es importante para que el usuario pueda tener una referencia de lo que hizo en una fecha y hora específica. Renderizamos las actividades utilizando la sintaxis de plantillas de Django y renderizando las acciones a través de las vistas.

<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 acceso

Esta página permitirá al usuario conectarse o iniciar sesión en la aplicación utilizando un nombre de usuario y una contraseña.

Página de inscripción

También llamada página de registro, esta página permite al usuario crear una nueva Account. Tras la autenticación, la página tiene acceso a las demás páginas.

Probar la aplicación

Ahora que hemos conectado todo lo necesario para ejecutar nuestra aplicación Django sólo nos queda ver si todo funciona bien. En terminal escribe python manage.py runserver y navega a localhost:8000. Navega usando los botones de navegación laterales para ver el aspecto de cada página. Todavía no hemos puesto ningún dato en nuestra base de datos por lo que no se mostrará ningún dato. Al hacer clic en los botones tampoco funcionará ya que no hemos conectado nuestro sistema frontend a la API de Rasa todavía. Ahora que el diseño está hecho podemos empezar a desarrollar nuestro bot Rasa.

Instalación de Rasa

Rasa es una plataforma de IA de código abierto que permite a los desarrolladores crear sus propios chatbots y asistentes de voz personalizados utilizando un conjunto de API de IA. Rasa utiliza una gran cantidad de procesamiento del lenguaje natural (NLP) por lo que es el más adecuado para la creación de aplicaciones NLP. Utilizaremos Rasa para crear nuestro propio chatbot personalizado que se conectará a nuestra interfaz de usuario.

Para instalar Rasa abre un nuevo terminal y crea un nuevo entorno virtual o reactiva el anterior. A continuación, escriba pip install rasa. Este comando descargará Rasa del sitio web de Rasa y lo instalará en tu máquina. Cuando la instalación haya terminado, un bot básico estará disponible para que hables con él. En el mismo terminal escribe rasa shell para interactuar con tu bot. Escribe hi o hola y pulsa enter. El bot responderá según su entrenamiento.

Configuración del dominio

Ahora vamos a programar nuestro bot para responder a nuestro caso de uso aquí. El objetivo de nuestro bot es tomar los datos del usuario y almacenarlos en una base de datos. Los datos se utilizarán para enviar un SMS a un número específico en un momento determinado. Así que tenemos que configurar nuestro bot para que registre los datos. Usando NLP el bot puede responder apropiadamente y seguir un flujo de respuesta específico.

Abra el archivo del dominio y en él verá algunos encabezados. Los encabezados son intents, actions y templates. Tenemos que cambiarlos para que la respuesta del bot sea específica y relevante para nuestra aplicación. Por ejemplo, añadimos intent ask_message y ask_recipient_number para que el bot pueda detectar que la entrada es el número de destinatario.

También tenemos que añadir ranuras y entidades a nuestro archivo. Las ranuras son los campos de entrada que utilizará el bot cuando reciba datos. En lugar de simplemente responder, el bot almacenará los datos como entrada de formulario y los enviará cuando haya terminado.

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"}'

Configurar historias

Las historias se refieren a las entradas que el usuario puede dar. Por ejemplo, le decimos al bot que espere un número de teléfono 55512345 de un usuario, o un número que sea similar, para que el bot esté familiarizado con la entrada del usuario. Escribimos las historias y especificamos con qué ranura están relacionadas. Las ranuras son entradas para el formulario.

## 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

Configuración de NLU

En el archivo NLU, escribimos las intenciones del usuario y ejemplos de cada intención. Es aconsejable escribir tantos ejemplos como sea posible para cada intención para que el bot sea más inteligente y pueda identificar más 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)

Configuración de acciones

El archivo de acciones es donde ahora ponemos todos los datos juntos y decidimos cómo se procesará toda la entrada del usuario. En nuestro caso estamos tomando la entrada del usuario como datos de formulario por lo que necesitamos enviar los datos dados por el usuario. Estos datos serán enviados a la API TextMessage que hicimos anteriormente en el post. Los datos se utilizarán como parámetros en la API de Messages API de Vonage al realizar una solicitud POST.

Archivo de configuración

Antes de continuar necesitamos decirle a Rasa que estamos tomando respuestas en un formato de formulario. Para ello abre config.yml y añade FormPolicy al final de la lista de políticas. Las políticas son importantes porque le dicen a tu bot cómo usar los datos, qué formato usar y determinan el tipo de flujo de datos. En este caso, el flujo de datos es el de un formulario.

# 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

Ahora que hemos configurado todo lo que necesitamos para entrenar a nuestro bot, entrenamos al bot para que utilice todas nuestras configuraciones personalizadas de cada archivo. Así que en el tipo de terminal rasa train. El bot tardará unos segundos en analizar, validar y aplicar los cambios al bot. Si hay un error en los archivos el entrenamiento no funcionará.

Probar el nuevo bot

Ahora es el momento de probar la configuración de nuestro bot. Abre una nueva ventana de terminal y escribe rasa run actions.

En otro tipo de terminal rasa shell. Usaremos un shell para probar el bot. En la shell escribe hi y responde a las preguntas del bot. Si todo está en orden tu bot debería estar haciéndote pregunta tras pregunta, tomando todos los datos. Esto es FormPolicy en acción. Una vez que hayas proporcionado toda la información, el bot enviará los datos a tu API REST utilizando las peticiones que configuramos en nuestro archivo actions.py.

Conexión de Rasa y Django

Finalmente hemos terminado nuestra aplicación Django y nuestro bot Rasa pero ahora necesitamos conectar los dos para que nuestro bot pueda ser usado desde nuestro frontend Django. Sólo tenemos que cambiar algunas cosas en nuestro código JavaScript. Vamos a hacer peticiones HTTP POST a nuestro bot y mostrar los datos de respuesta.

En el terminal donde abrimos el shell Rasa necesitamos ahora ejecutar el servidor Rasa para peticiones HTTP usando el siguiente comando:

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

Este comando asegurará que Rasa pueda recibir peticiones HTTP desde un servidor remoto usando nuestro canal REST.

En el terminal, ahora debe tener 3 servidores en ejecución, uno para las acciones Rasa, Rasa HTTP, y el servidor Django para el frontend.

Vaya a la URL localhost:8000/von donde vive nuestro bot UI y haz clic en iniciar campaña. Esto enviará una solicitud HTTP POST a Rasa diciendo hola. Verás la respuesta del bot en la UI.

Ahora podemos interactuar con nuestro bot utilizando el cuadro de entrada de la parte inferior, así que responde a la pregunta del bot escribiendo un número y haciendo clic en enviar. El bot iniciará una secuencia en la que almacenará cada entrada en los campos del formulario y la enviará a nuestra API REST TextMessage.

Si abres el terminal de Django verás que se ha realizado correctamente una petición HTTP POST a api/textoslo que significa que nuestro formulario se ha enviado correctamente. En función de la hora y la fecha de envío al bot, deberías recibir un SMS en el número de destinatario que hayas indicado.

Nuestra aplicación ya funciona, pero tenemos que cambiar algunas cosas. Por el momento, la aplicación sólo está disponible en nuestras máquinas locales. Por lo tanto, tenemos que ponerla a disposición del público. Utilizaremos Heroku para el despliegue de Django y contenedores Docker para el despliegue del bot.

Despliegue en Heroku

En este post, sólo nos centraremos en el despliegue de la aplicación por lo que no vamos a enseñar acerca de Heroku específicos. Lo primero que hay que hacer es crear una Account en Heroku, así que dirígete a https://www.heroku.com para crear una Account gratuita.

Después de crear la Account necesitamos instalar Heroku en nuestra máquina para poder usarlo desde la terminal. Una vez que hayas creado tu Account dirígete a https://devcenter.heroku.com/articles/heroku-cli y siga las instrucciones sobre cómo instalar la CLI, en función de su sistema operativo.

A continuación, es necesario iniciar sesión en Heroku utilizando la CLI, ya que es mucho más fácil. Si todo está instalado correctamente, ya podemos desplegar nuestra aplicación Django en Heroku.

Antes de tratar con Heroku necesitamos instalar Git para el control de versiones. Git nos ayudará a realizar un seguimiento de los cambios que hagamos en nuestra aplicación sin perder ningún dato.

Para instalar Git, navegue hasta el intérprete de comandos y ejecute el siguiente comando: sudo dnf install git-all. Una vez completada la salida del comando, puede verificar la instalación escribiendo: git version.

En la carpeta del proyecto, escriba git inity a continuación git add –all. A continuación, escriba :

git commit -m "commit message"

Estos 3 comandos crearán un repositorio git local en tu máquina.

Es muy recomendable almacenar el código tanto en línea como fuera de línea, así que subiremos nuestro código a GitHub, un repositorio en línea. En primer lugar, tenemos que crear una Account en GitHub, así que dirígete a https://github.com para empezar.

Una vez que hayas creado tu Account puedes hacer click en 'nuevo repositorio' (ponle el nombre que quieras) y haz click en 'iniciar con un README', luego haz click en 'crear'. Ahora que tu repositorio ha sido creado podemos vincular el repositorio de GitHub a nuestro proyecto Django.

En la carpeta raíz del proyecto, escriba git remote add origin 'your/Github/URL'. Este comando añadirá el repositorio de GitHub como rama maestra remota de tu proyecto. Una vez hecho esto, sube tu proyecto Django escribiendo:

git push origin master

Este comando empujará los archivos del proyecto a la rama remota master en Github.

Ahora tenemos que hacer una cosa más, que es configurar nuestra aplicación para Heroku. Necesitaremos añadir un archivo Procfile y requirements.txt, así que en tu terminal escribe echo>>Procfile y luego pip freeze>requirements.txt

Abra Procfile y añada lo siguiente:

web: vonage.wsgi

Y ya está. Actualice sus repositorios Git y GitHub en consecuencia.

Despliegue

Ahora para desplegar en Heroku escribe heroku create vonbotesto creará tu aplicación Heroku.

A continuación escribe git push heroku master y tu proyecto será subido a Heroku.

Escriba heroku open y se abrirá el proyecto en un navegador web.

Despliegue en Docker

La tarea final es desplegar nuestro proyecto Rasa utilizando Docker.

Instalación de Docker

En el terminal escriba estos comandos:

sudo apt-get update

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

Esto instalará Docker en su máquina si está ejecutando Ubuntu. Para otros sistemas operativos, consulte las instrucciones de Docker.

A continuación, confirme la instalación escribiendo sudo docker run hello-world.

Contenedor Rasa

Usando los documentos de Rasa desplegaremos nuestro bot con docker-compose. Navega a la raíz de tu bot Rasa y crea un nuevo archivo docker-compose.yml. Pon los siguientes datos en el archivo:

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

Para ejecutar los servicios configurados en su docker-compose.yml ejecute:

sudo docker-compose up

Esto iniciará el contenedor Docker para Rasa. Ahora puede ejecutar Rasa en un contenedor.

Servidor de acción

Ya que hemos configurado acciones, también deberíamos tener un servidor de acciones disponible.

Primero tenemos que construir la imagen, y luego hacer referencia a ella en nuestro archivo docker-compose. Así que primero, en la carpeta raíz del bot, crea un directorio actions. A continuación, mueve tu archivo actions.py a esa carpeta. En la misma carpeta crea un directorio init.py.

A continuación, crea un Dockerfile en la raíz de tu proyecto bot y pon lo siguiente:

# 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

Lo siguiente que debes hacer es crear una Account gratuita de Docker en https://www.docker.com. Entonces crearás un repositorio donde vivirá tu imagen, similar a Github.

Después de haber creado tu repositorio ejecuta el siguiente comando, sustituyéndolo por tu nombre de usuario, el nombre del repositorio y el nombre de tu imagen:

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

Cuando este comando se ejecute correctamente tu imagen estará disponible en ese repositorio. A continuación, puede volver al archivo docker-compose.yml y añadir lo siguiente:

app:

image: <image:tag>

expose: 5055

Este comando le dirá a Docker que ejecute su imagen de acciones en el puerto 5055.

Puede ejecutar docker-compose up y tanto el servidor HTTP Rasa como las acciones se ejecutarán usando Docker y podrás comunicarte con ellos.

Hemos creado y desplegado con éxito nuestra herramienta de marketing utilizando la API de Vonage, Django y Rasa NLU.