Marketing intelligent avec Django, Rasa NLU et Vonage

Les entreprises modernes se tournent vers des technologies intelligentes telles que les chatbots pour automatiser les processus de travail. La technologie intelligente peut automatiser des choses telles que la comptabilité, le recrutement et le marketing. Grâce à l'intelligence artificielle, les entreprises peuvent faciliter le travail et améliorer l'engagement et les interactions avec les clients. Les assistants virtuels et les chatbots constituent le meilleur exemple d'utilisation des technologies intelligentes. Ces outils intelligents aident les entreprises à être plus productives sans faire tout le travail manuellement.

Conditions préalables

Pour cette application, nous allons utiliser les éléments suivants :

Django - Un cadre de travail pour le développement web

Rasa NLU - Plate-forme open-source de traitement du langage naturel

Cadre de travail Django Rest - Un paquetage Django utilisé pour créer des API

Angularjs x 1 - Un framework javascript frontend

Vuejs x 1 - Un framework javascript pour les applications frontales

Docker - Plate-forme d'images de conteneurs

Heroku - Une plateforme d'hébergement web

API SMS de Vonage - Une API pour l'envoi de Messages SMS

Ensuite, nous verrons comment installer chacun de ces paquets.

Installation

Tout d'abord, nous allons commencer à installer un environnement virtuel. Un environnement virtuel sera comme un entrepôt pour tous nos paquets. Nous utilisons Linux, alors allez à cmd et tapez virtualenv vonenv.

Cela créera un nouvel environnement virtuel appelé vonenv. Activez-le en tapant source/vonenv/bin/activate.

Installation de Django

Nous utiliserons Django comme cadre d'application. Installez Django en tapant pip install Django. Vous pouvez spécifier la version en utilisant == et en donnant le nom de la version.

Installation du framework Rest de Django

Type pip install Django rest framework. Installez également le planificateur python en tapant pip install scheduler.

Installation de Django-cors-headers

Nous allons installer un paquetage appelé django-cors-headers qui permettra d'éviter les erreurs d'origine croisée. Cela signifie que nous pourrons envoyer et recevoir des requêtes HTTP d'un serveur à l'autre. Pour installer le paquetage, tapez :

pip install django-cors-headers

Création de notre application

Pour créer l'application, tapez django-admin startproject vonage. Cela créera notre projet boilerplate avec tout le code.

Naviguez dans votre application et tapez django-admin start project myapp. Cela créera notre projet que nous utiliserons.

Pour tester l'application, tapez simplement python manage.py runserver et de naviguer vers localhost:8000 dans votre navigateur.

Configuration des paramètres

Naviguez jusqu'au dossier racine de votre projet et ouvrez le fichier settings.py. C'est le fichier qui sera utilisé pour configurer le backend de notre application.

Dans la liste des applications installées, ajoutez myapp, et rest framework en bas. Cela enregistrera les paquets et informera Django que nous voulons les utiliser.

Dans l'exécution du terminal, python manage.py migrate. Ceci lancera les migrations initiales de notre application et créera de nouvelles tables dans la base de données.

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

Configuration des modèles

Ensuite, nous devons créer nos modèles de base de données. Les modèles sont les tables que nous allons remplir dans la base de données. Nous allons créer deux modèles : TextMessage et UserActivity. Le modèle TextMessage sera utilisé pour stocker les détails de l'objet TextMessage et le modèle UserActivity sera utilisé pour stocker et suivre l'activité de l'utilisateur.

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)

Création de notre API

API signifie Application Programming Interface (interface de programmation d'applications). Il s'agit d'un ensemble de protocoles (règles) définis qui indiquent comment accéder aux données et les utiliser. Par exemple, une API REST utilise les protocoles GET/POST/DELETE/PUT. Ce sont les protocoles d'une API REST. Une API vous permet d'accéder aux données d'une base de données à l'aide de requêtes HTTP.

Nous allons créer deux API REST, l'API TextMessage et l'API UserActivity. Pourquoi utiliser des API ? Une API est importante pour effectuer des requêtes HTTP et faciliter l'interaction avec la base de données. Avec les API, nous pouvons effectuer des requêtes HTTP vers nos points d'extrémité API et utiliser le cadre JavaScript de notre choix. Cela rend nos choix frontaux plus flexibles et plus faciles à intégrer.

Si vous ne l'avez pas encore fait, installez le paquetage du framework REST de Django en tapant pip install Django-rest-framework. Ajoutez ensuite le paquetage aux applications installées et exécutez python manage.py migrate pour enregistrer les modifications dans notre base de données.

Configuration des vues

Le fichier views sera responsable du stockage de nos fonctions. Ces fonctions seront capables de rendre les données, de détecter les erreurs, de nous permettre de faire des requêtes GET, POST, PUT, EDIT et DELETE à nos API.

Nous devons importer certaines fonctions et méthodes qui seront utilisées par nos fonctions et nos classes. Il s'agit de méthodes intégrées à nos paquets installés, y compris 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

Vue de la page d'atterrissage

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

Cette fonction rendra notre modèle de page d'atterrissage.

Vue de la page du tableau de bord

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

Cette fonction rendra notre modèle de page de tableau de bord.

Programmation des SMS

Nous planifierons les SMS à l'aide d'un paquetage Django appelé python scheduler. Nous utilisons ce paquetage car il est facile à mettre en place et efficace.

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

Cette fonction est responsable de l'envoi du SMS au destinataire. Elle utilise la bibliothèque des requêtes pour effectuer des requêtes postales au point de terminaison de l'API Vonage, en utilisant les données de l'API TextMessage comme paramètres. Lorsqu'elle est appelée, la fonction envoie le SMS en utilisant les données de l'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)

Configuration des URL

Le fichier URL est utilisé pour définir les routes de notre application. Nous ajouterons les fonctions de vue comme routes pour naviguer dans chaque modèle.

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),
]

Sérialiseurs

Lorsque nous utilisons des API, nous devons d'abord sérialiser les données. La sérialisation est le processus de conversion des données en petits octets destinés à être utilisés par des logiciels ou des dispositifs physiques. Dans notre cadre API, il est facile de sérialiser les données. Nous créons un fichier serializers.py, importons nos modèles et définissons nos sérialiseurs.

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__'

Configuration des modèles

Maintenant que nous connaissons les pages qui seront utilisées dans notre application, nous devons connecter nos modèles à nos systèmes dorsaux. Pour ce faire, nous utilisons JavaScript et nos API comme source de données.

Page assistante

Cette page servira de page d'interface pour le chatbot. C'est la page que les utilisateurs utiliseront pour parler à notre chatbot et lui transmettre des données. Nous utiliserons Angular pour interagir avec notre chatbot en envoyant des requêtes HTTP à l'API Rasa. Nous gérerons ensuite les données de réponse à l'aide de jQuery. La page est conçue comme une application de chat et tout ce que l'utilisateur doit faire est de répondre aux questions du 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>

Page de l'horaire

Cette page est utilisée pour afficher tous les SMS programmés dans notre base de données. L'utilisateur pourra suivre les données de la base et consulter les détails de chaque SMS en cliquant sur l'une des valeurs. Lorsque l'utilisateur clique sur le bouton d'affichage, il est redirigé vers la page des détails du SMS. Sur cette page, nous utilisons Vue.js pour effectuer une simple requête HTTP GET à notre API sur 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>

Page du tableau de bord

Il s'agit de la page qui permet de suivre toutes les activités de l'utilisateur dans l'application. Dans cette application, l'utilisateur verra tous ses flux d'activités et les dates correspondantes. Ceci est important pour que l'utilisateur puisse avoir une référence de ce qu'il a fait à une date et une heure spécifiques. Nous rendons les activités en utilisant la syntaxe de templating de Django et les actions de rendu via les vues.

<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 %}

Page de connexion

Cette page permet à l'utilisateur de se connecter ou de s'inscrire à l'application en utilisant un nom d'utilisateur et un mot de passe.

Page d'inscription

Également appelée page d'enregistrement, cette page permet à l'utilisateur de créer un nouveau compte. Après authentification, la page a accès aux autres pages.

Tester l'application

Maintenant que nous avons connecté tout ce dont nous avons besoin pour exécuter notre application Django, nous devons juste voir si tout fonctionne bien. Dans le terminal, tapez python manage.py runserver et naviguez vers localhost:8000. Naviguez en utilisant les boutons de navigation latéraux pour voir à quoi ressemble chaque page. Nous n'avons pas encore mis de données dans notre base de données, donc aucune donnée ne sera affichée. Cliquer sur les boutons ne fonctionnera pas non plus car nous n'avons pas encore connecté notre système frontal à l'API Rasa. Maintenant que le design est terminé, nous pouvons commencer à développer notre bot Rasa.

Installation de Rasa

Rasa est une plateforme d'IA open-source qui permet aux développeurs de créer leurs propres chatbots et assistants vocaux personnalisés à l'aide d'un ensemble d'API d'IA. Rasa utilise beaucoup de traitement du langage naturel (NLP), il est donc mieux adapté à la création d'applications NLP. Nous utiliserons Rasa pour créer notre propre chatbot personnalisé qui sera intégré à notre interface utilisateur.

Pour installer Rasa, ouvrez un nouveau terminal et créez un nouvel environnement virtuel ou réactivez le précédent. Tapez ensuite pip install rasa. Cette commande téléchargera Rasa depuis le site web de Rasa et l'installera sur votre machine. Une fois l'installation terminée, un bot basique sera disponible pour vous parler. Dans le même terminal, tapez rasa shell pour interagir avec votre robot. Tapez hi ou hello et appuyez sur entrée. Le bot répondra en fonction de sa formation.

Configuration du domaine

Programmons maintenant notre robot pour qu'il réponde à notre cas d'utilisation. L'objectif de notre robot est de collecter les données de l'utilisateur et de les stocker dans une base de données. Ces données seront ensuite utilisées pour envoyer un SMS à un numéro spécifique à une heure donnée. Nous devons donc configurer notre robot pour qu'il enregistre des données. En utilisant la PNL, le robot peut répondre de manière appropriée et suivre un flux de réponse spécifique.

Ouvrez le fichier du domaine et vous y verrez quelques rubriques. Les titres sont intents, actions et templates. Nous devons les modifier pour que la réponse du robot soit spécifique et pertinente pour notre application. Par exemple, nous ajoutons intent ask_message et ask_recipient_number pour que le robot puisse détecter que l'entrée est le numéro du destinataire.

Nous devons également ajouter des slots et des entités à notre fichier. Les slots sont les champs d'entrée qui seront utilisés par le bot lorsqu'il recevra des données. Au lieu de simplement répondre, le robot stockera les données sous forme de formulaire et les soumettra lorsqu'il aura terminé.

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

Configuration des histoires

Les histoires font référence aux données que l'utilisateur peut fournir. Par exemple, nous disons au robot d'attendre un numéro de téléphone 55512345 de la part d'un utilisateur, ou un numéro similaire, afin que le robot soit familiarisé avec les données de l'utilisateur. Nous écrivons les histoires et spécifions à quel slot elles se rapportent. Les slots sont les entrées du formulaire.

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

Configuration du NLU

Dans le fichier NLU, nous écrivons les intentions de l'utilisateur et des exemples pour chaque intention. Il est conseillé d'écrire autant d'exemples que possible pour chaque intention afin que le robot soit plus intelligent et puisse identifier plus d'entrées.

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

Configuration des actions

Le fichier d'actions est l'endroit où nous rassemblons toutes les données et où nous décidons comment toutes les entrées de l'utilisateur seront traitées. Dans notre cas, nous prenons les données de l'utilisateur sous forme de formulaire et nous devons donc soumettre les données fournies par l'utilisateur. Ces données seront envoyées à l'API TextMessage que nous avons créée plus tôt dans ce billet. Les données seront utilisées comme paramètres dans l'API Messages de Vonage lors d'une requête POST.

Fichier de configuration

Avant de continuer, nous devons indiquer à Rasa que nous prenons les réponses sous forme de formulaire. Pour cela, ouvrez config.yml et ajoutez FormPolicy en bas de la liste des politiques. Les politiques sont importantes car elles indiquent à votre robot comment utiliser les données, quel format utiliser, et déterminent le type de flux de données. Dans ce cas, le flux de données est celui d'un formulaire.

# 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

Maintenant que nous avons configuré tout ce dont nous avons besoin pour entraîner notre robot, nous entraînons le robot de façon à ce qu'il utilise toutes nos configurations personnalisées dans chaque fichier. Dans le terminal, tapez rasa train. Le bot prendra quelques secondes pour analyser, valider et appliquer les changements au bot. S'il y a une erreur dans les fichiers, l'entraînement ne fonctionnera pas.

Test du nouveau robot

Il est maintenant temps de tester la configuration de notre bot. Ouvrez une nouvelle fenêtre de terminal et tapez rasa run actions.

Dans un autre type de terminal rasa shell. Nous allons utiliser un shell pour tester le bot. Dans l'interpréteur de commandes, tapez hi et répondez aux questions du robot. Si tout est en ordre, votre robot devrait vous poser question après question, en prenant en compte toutes les données. C'est la FormPolicy en action. Une fois que vous avez fourni toutes les informations, le robot soumettra les données à votre API REST en utilisant les requêtes que nous avons configurées dans notre fichier actions.py.

Connecter Rasa et Django

Nous avons finalement terminé notre application Django et notre bot Rasa, mais nous devons maintenant connecter les deux pour que notre bot puisse être utilisé depuis notre frontend Django. Nous n'avons que quelques modifications à apporter à notre code JavaScript. Nous allons faire des requêtes HTTP POST à notre bot et afficher les données de réponse.

Dans le terminal où nous avons ouvert le shell Rasa, nous devons maintenant lancer le serveur Rasa pour les requêtes HTTP en utilisant la commande suivante :

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

Cette commande permet de s'assurer que Rasa peut recevoir des requêtes HTTP depuis un serveur distant en utilisant notre canal REST.

Dans le terminal, vous devez maintenant avoir 3 serveurs en cours d'exécution, un pour les actions Rasa, Rasa HTTP, et le serveur Django pour le frontend.

Naviguez jusqu'à l'URL localhost:8000/von où se trouve l'interface du bot et cliquez sur start campaign. Cela enverra une requête HTTP POST à Rasa en lui disant bonjour. Vous verrez la réponse du bot dans l'interface utilisateur.

Nous pouvons maintenant interagir avec notre bot en utilisant la zone de saisie en bas, alors répondez à la question du bot en tapant un nombre et en cliquant sur envoyer. Le robot va démarrer une séquence dans laquelle il stockera chaque entrée dans les champs du formulaire et la soumettra à notre API REST TextMessage.

Si vous ouvrez le terminal Django, vous verrez qu'une requête HTTP POST a été effectuée avec succès vers api/textesce qui signifie que notre formulaire a été soumis avec succès ! En fonction de l'heure et de la date que vous avez soumises au bot, vous devriez recevoir un SMS sur le numéro de destinataire que vous avez fourni.

Notre application est maintenant en ordre de marche, mais nous avons besoin de changer certaines choses. Pour l'instant, l'application n'est disponible que sur nos machines locales. Nous devons donc la rendre accessible au public. Nous utiliserons Heroku pour le déploiement de Django et les conteneurs Docker pour le déploiement du bot.

Déploiement sur Heroku

Dans ce billet, nous nous concentrerons uniquement sur le déploiement de l'application, nous n'aborderons donc pas les spécificités d'Heroku. La première chose à faire est de créer un Account Heroku. https://www.heroku.com pour créer un Account gratuit.

Après avoir créé le compte, nous devons installer Heroku sur notre machine pour pouvoir l'utiliser depuis le terminal. Une fois que vous avez créé votre Account, rendez-vous à l'adresse suivante https://devcenter.heroku.com/articles/heroku-cli et suivez les instructions pour installer le CLI, en fonction de votre système d'exploitation.

Ensuite, vous devez vous connecter à Heroku en utilisant le CLI, car c'est beaucoup plus facile. Si tout est installé correctement, nous pouvons maintenant déployer notre application Django sur Heroku.

Avant d'utiliser Heroku, nous devons installer Git pour le contrôle de version. Git nous aidera à garder une trace de toutes les modifications apportées à notre application sans perdre de données.

Pour installer Git, accédez à votre invite de commande et exécutez la commande suivante : sudo dnf install git-all. Une fois la sortie de la commande terminée, vous pouvez vérifier l'installation de l'installation en tapant : git version.

Dans le dossier de votre projet, tapez git init, puis git add –all. Ensuite, tapez :

git commit -m "commit message"

Ces 3 commandes vont créer un repo git local sur votre machine.

Il est fortement recommandé de stocker votre code à la fois en ligne et hors ligne. Nous allons donc tous télécharger notre code sur GitHub, un dépôt en ligne. Tout d'abord, nous devons créer un Account GitHub. https://github.com pour commencer.

Une fois que vous avez créé votre Account, vous pouvez cliquer sur " new repository " (nommez-le comme vous le souhaitez) et cliquez sur " initiate with a README " (initier avec un README), puis sur " create " (créer). Maintenant que votre dépôt a été créé, nous pouvons lier le dépôt GitHub à notre projet Django.

Dans le dossier racine de votre projet, tapez git remote add origin 'your/Github/URL'. Cette commande ajoutera le dépôt GitHub en tant que branche principale distante pour votre projet. Une fois que cela est fait, téléchargez votre projet Django en tapant :

git push origin master

Cette commande va pousser les fichiers de votre projet vers la branche distante master sur Github.

Maintenant, nous devons faire une dernière chose, qui est de configurer notre application pour Heroku. Nous allons devoir ajouter un fichier Procfile et un fichier requirements.txt, donc dans votre terminal tapez echo>>Procfile puis pip freeze>requirements.txt

Ouvrez Procfile et ajoutez ce qui suit :

web: vonage.wsgi

Et c'est tout ! Mettez à jour vos dépôts Git et GitHub en conséquence.

Déploiement

Maintenant, pour déployer sur Heroku, tapez heroku create vonbotce qui créera votre application Heroku.

Ensuite, tapez git push heroku master et votre projet sera téléchargé sur Heroku.

Tapez heroku open et votre projet s'ouvrira dans un navigateur web.

Déploiement sur Docker

La dernière tâche consiste à déployer notre projet Rasa à l'aide de Docker.

Installation de Docker

Dans le terminal, tapez ces commandes :

sudo apt-get update

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

Cela installera Docker sur votre machine si vous utilisez Ubuntu. Pour les autres systèmes d'exploitation, reportez-vous aux instructions de Docker.

Ensuite, confirmez l'installation en tapant sudo docker run hello-world.

Rasa Container

En utilisant la documentation de Rasa, nous allons déployer notre bot avec docker-compose. Naviguez vers la racine de votre bot Rasa et créez un nouveau fichier docker-compose.yml. Mettez les données suivantes dans le fichier :

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

Pour exécuter les services configurés dans votre docker-compose.yml, exécutez :

sudo docker-compose up

Cela démarre le conteneur Docker pour Rasa. Vous pouvez maintenant exécuter Rasa dans un conteneur.

Serveur d'action

Puisque nous avons configuré des actions, nous devrions également disposer d'un serveur d'actions.

Nous devons d'abord construire l'image, puis la référencer dans notre fichier docker-compose. Donc tout d'abord, dans le dossier racine du bot, créez un répertoire actions. Ensuite, déplacez votre fichier actions.py dans ce répertoire. Dans le même dossier, créez un fichier init.py.

Ensuite, créez un Dockerfile dans la racine de votre projet bot et mettez ce qui suit :

# 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

La prochaine chose à faire est de créer un compte Docker gratuit sur le site suivant . https://www.docker.com. Vous créerez ensuite un dépôt où votre image sera conservée, comme sur Github.

Après avoir créé votre dépôt, exécutez la commande suivante, en la remplaçant par votre nom d'utilisateur, le nom du dépôt et le nom de votre image :

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

Lorsque cette commande s'exécute avec succès, votre image sera disponible dans ce dépôt. Vous pouvez alors retourner au fichier docker-compose.yml et ajouter ce qui suit :

app:

image: <image:tag>

expose: 5055

Cette commande indiquera à Docker d'exécuter votre image d'actions sur le port 5055.

Vous pouvez exécuter docker-compose up et le serveur HTTP et les actions de Rasa seront exécutés en utilisant Docker et vous pourrez communiquer avec eux.

Nous avons créé et déployé avec succès notre outil de marketing en utilisant l'API Vonage, Django et Rasa NLU.