ABSTRACT

It is the dream of millions of students to study in a foreign university. They leave no stone
unturned in their journey of discovering their perfect university. Often times, it can be a
daunting task to find out about the universities to make a well informed decision. This project is
an attempt to make this task as simple as possible. We developed a conversational chatbot
which would cater to the queries of the prospective students. Deployed on Facebook
messenger platform, this acts as a familiar medium for the current generation of students to
learn about their university. This project also doubles as a lead managing service for the
university admission departments by collecting and maintaining the database of the
prospective students.
INTRODUCTION

Higher education and admission to a foreign university is a stressful period in every

student’s life. The situation becomes all the more stressful for international students who
relocate from their home country to study abroad. There are a lot of areas where the
student needs handholding and it becomes a tiring task for Universities.
UNESCO states that there are almost 5.3 million international students in 2017
(UNESCO Institute for Statistics) and this number is only increasing. Choosing the
perfect University can one of the crucial decisions of a student’s life. It is only common
that these students would be having numerous questions about their new would be
university. From admission requirements to placement assistance, international students
would be faced with lot of questions before arriving at the final choice of their university.
Each university would be accepting a number of students from all over the world and
with varied backgrounds. Answering such a huge number of queries from the students
can be burden for the admission department. And the different time zones of
international students would only augment this problem.
This project aims to address this very problem. It is given that the admissions office of
the university caters to the queries of a huge number of students. Fortunately, from our
discussions with the admissions team we understood that most of these questions are
repeated. Many students have similar queries and the admissions teams gives the same
response to all of them. This presented us with the opportunity to automate such a
repetitive task using a chatbot. This allows the admissions team more free time to cater
to the unique questions posed by the students which compulsorily require human
assistance. This additionally helps the students to get an answer to their queries at any
given time of the day irrespective of being in the different time zone as the university.
Chatbots are one of the notable outcomes of the current uprise of artificial intelligence.
Artificial Intelligence is the science of automating repetitive human tasks which require a
considerable amount of cognitive capabilities. And chatbots are an excellent example of
this very science.
The aim of this project is to make it easier for universities to start using chatbots too. We
have developed an intelligent chatbot to cater to the queries of international students.
Consulting with our admissions team, we have trained our chatbot to answer most of the
common questions. This chatbot has been linked to the Facebook messenger platform for
easier access to students. With such an easier and familiar access, students can use it to
find the information they are searching for instead of going thorough the hassle of
scouring all of the university website or forums.
We have added additional capabilities to this bot to make the work of admissions office
easier. When students are in need of human assistance from the admissions office, this
chatbot can collect their details and update it over a file in the cloud. The admissions
office can then contact the students with a solution. This helps the admissions office to
easily maintain a list of new leads for prospective international students. Additionally, if
the student wants to be kept up to date with the happenings of the university, the chatbot
can also add the student to the university newsletter mailing list. We believe this can
greatly assist both the students and the university.
Further, a survey has been done to find out the viability of this chatbot idea. The target
group of the survey is (prospective) international students who have themselves
experienced the difficulties in the process of admission to a foreign university.

LITERATURE REVIEW

Studies show that people are intrigued by chatbots and find it amusing to use them. It is easier
to text to a chatbot as it can work with short messages (Hill et al, 2015). This makes it easier for
students who are in a hurry to clear a doubt they have on a university. It saves them from going
through the hurdles of the formal procedure. (Holtgraves et al, 2007) suggests that
conversational bots have a very good potential to be deployed on websites as an initial
communication medium.
Prospective international students may come up with new queries and may want a quick
answer. But the admission councilor or university may not be available at the moment due to
time zone constraints. Though most of the information is available online on websites, it might
take considerable effort and time to find an answer for every little doubt they have. Chatbots
are the perfect solution in these situations. Chatbots provide a very quick way to find answers
(Brandtzaeg et al, 2017). One more advantage with the chatbots is the ease of accessibility.
Students can open up their phone and talk with the chatbot the same way they talk with their
friends online. We wanted the students to have a natural and familiar medium to access the
bot. We found no better solution than Facebook with 2.41 billion monthly active users
(Company Info, Facebook, 2019).
It has been found that people have a good acceptance of computer bots (Clément et al, 2015).
Researchers also found that people do not find any difference if they are communicating with a
person or a bot (Edwards et al, 2016). Universities can safely transition to this new chatbot
assisted admissions system smoothly without much change in the way they interact with their
prospective students

METHODOLOGY
Developing a chatbot from scratch is a mammoth task. We sought to utilize existing chatbot
developing frameworks to aide us in this project. These frameworks provide a structure to the
project. Chatbot developing frameworks contain necessary programming libraries and a set of
guidelines which help streamline the development process.
Our research presented with a good number of options for the chatbot frameworks.
Frameworks like Microsoft Bot Framework, Dialogflow, IBM Watson, RASA were found to be
interesting choices. We decided to use RASA for this project. RASA is an open source framework
and is developed using Python programming language. This makes it simpler for any college to
implement this chatbot on their website.

Development of the Chatbot

Software Installation
Rasa Framework needs a set of prerequisite software in order to fully function. These include
the Rasa framework itself and few other dependencies which support Rasa.
1) As we have worked on Windows, we have installed the Visual C++ Build tool. We
learned that this is required for some Python packages.
2) We have Anaconda installed on our system so both Rasa and Rasa X can be installed
using pip command
pip install rasa
pip install rasa x
3) We check for Python and find that we already have Python version 3.7 installed in our
system.
Structure of the Chatbot

1) Rasa NLU – teaches the bot to understand user’s input

Rasa NLU is a library of natural language understanding which classifies intents and extracts
entities from the user’s input. NLU teaches the bot to understand what the user says. We
define the user messages which the bot should be able to understand. To achieve this, we build
a Rasa NLU model and feed in the training data which we have prepared for our use case. The
model will then convert the data into a structured format consisting of intents and entities.
What are intents and entities?

things you expect users to say.

(e.g. book an appointment,
intents
check the application status,
etc)

entitie pieces of info you want to

extract from messages. (e.g.
s Name, Program, etc)

NLU Data Format

The training data consists of a list of messages that we expect to receive from the user. There
are different ways of providing the training data - as Markdown, as JSON, as a single file or
directory with multiple files. Markdown is the easiest Rasa NLU format for us to read and write,
hence, we have used the same in this project.
The training data for NLU was created in a markdown file and saved as nlu.md in the main
project folder. This file contains a list of statements annotated with intents and entities that
Rasa NLU will learn to extract. The more examples we give each intent (with corresponding
entity, if present), the better it the model will be able to classify a new intent. On an average,
we gave ten examples for each intent.
The lines starting with ## define the names of the intents or grouped messages with a similar
meaning. Example sentences are grouped by intent using minus (-), asterisk (*), or plus (+) and
entities are annotated as Markdown links. The example below from our nlu.md file makes this
clear. Rasa’s job is to predict the correct intent when users send new and unseen messages.

Example of NLU training data file:

## intent:enter_data

- I am interested in the [MBA](program) program

- I want to enquire about the [Masters in Management](program) program

- my email is [email@rasa.com](email)

- my email is [markjobs@ibm.com](email)

- my name is [preethi](person_name)

- I am [Romain](person_name)

- I am looking to join for the [spring](intake) intake

- tell me about the [Fall](intake) intake

2) Rasa Core - teaches the bot to respond

Rasa Core is a chatbot framework for dialogue management which uses machine learning to
predict the next best action based on the input from NLU, the training data and the
conversation history.
We are done with the NLU part. Our bot can now understand natural language, i.e, interpret
the user’s message. Now, it is time to add dialogue capabilities to our bot. In our case, it would
be to fetch an answer to the student’s query, book an admission call for the student or
subscribe him/her to the university’s admission newsletter. We will teach our bot to respond to
input by training a dialogue management model using Rasa Core.

A) Writing Stories
Now we teach our bot how to respond to user messages. This is known as dialogue
management and is handled by Rasa core. A story is a conversation between a user and the
chatbot. The user’s inputs are expressed as intents and entities while the responses of the
chatbot are expressed as what we call the actions. Real conversational data is provided to the
core model in form of stories. Our model’s stories are stored in stories.md file. Below is an
example of training data from the file:

## Contact Admissions

* contact_admin

- utter_moreinformation

- admin_form

- form{"name": "admin_form"}

- slot{"requested_slot": "person_name"}

* form: enter_data{"person_name": "Manohar"}

- form: admin_form

- slot{"person_name": "Manohar"}

- slot{"requested_slot": "email"}

* form: enter_data{"email": "lol-677@hotmail.com"}

- form: admin_form

- slot{"email": "lol-677@hotmail.com"}

- slot{"requested_slot": "program"}

* form: enter_data{"program": "MSC"}

- form: admin_form

- slot{"program": "MSC"}

- slot{"requested_slot": "intake"}

* form: enter_data{"intake": "SPRING"}

 - form: admin_form

- slot{"intake": "SPRING"}

- slot{"intake": "SPRING"}

- form{"name": null}

- slot{"requested_slot": null}

- utter_confirm_adminrequest

- action_deactivate_form

- form{"name": null}

- slot{"requested_slot": null}

- action_restart

Format of a story

 ## A story starts with two hashes followed by a name. Giving a relevant name to the
story ( ‘Contact admissions’ in the above example) helps to debug later but there is no
rule as such for naming a story.

 * denotes the messages sent by the user in the format intent{"entity": "value"}.

 - Actions excuted by the chatbot are shown by lines starting with hyphen and contain
the name of the action.

 Events returned by an action are written immediately after that action. If an actions
returns a slotset event, this is shown as slot{“slot_name”: “value”}. An example from
our story above would be slot{"intake": "SPRING"}.

B) Defining a Domain
Domain is where our bot lives and operates. This includes what user inputs it expects , what
actions should it be able to predict , how to respond and what information to store. The domain
consists of five key parts :
  Intents
 Slots
 Entities
 Actions
 Templates

As we have already discussed the first two in the previous section, let us now focus on the
others. The table below defines each of them briefly.

things your bot can do and say (simple replies to sending an

actions
email)

information to keep track of during a conversation (e.g. a student’s

slots
email address)

template
template strings for the things your bot can say
s

Here is an example of our bot’s domain file in the form of a domain.yml :

entities:

- intake

- program

- person_name

- email

intents:

- enter_data: {use_entities: false}

- contact_admin

- signup_newsletter

- human_handoff
 - ask_builder

- ask_weather

- ask_howdoing

- ask_whatspossible

- ask_whatisrasa

- ask_isbot

slots:

person_name:

type: unfeaturized

auto_fill: false

program:

type: unfeaturized

auto_fill: false

intake:

type: unfeaturized

auto_fill: false

email:

type: unfeaturized

auto_fill: false

templates:

utter_ask_program:

- text: "Give me a moment to note it down ✍️..Meanwhile please enter your program
(MSc/MBA) of interest"

utter_ask_email:

- text: "Please enter your email address"

 utter_ask_person_name:

- text: "What's your name?"

utter_response_why_email:

- text: "I need your email address to sign you up to the admissions newsletter."

- text: "I need it so that I can sign you up to the admissions newsletter."

utter_ask_continue_admin:

- text: "Do you still want to talk to the admission team?"

utter_confirm_adminrequest:

- text: "Thanks a bunch {person_name}! Our admissions team will reach out to you
with details of the {program} program for the {intake} intake.! ✉️"

actions:

- utter_greet

- utter_ask_goal

- utter_docu

- utter_contact_email

- utter_no_speak

- utter_out_of_scope

- utter_possibilities

forms:

- admin_form

- action_email_campaign
 C) Custom actions:
An action can run just about anything you want from booking a flight to checking your bank
balance. The endpoint should be a webserver that reacts to this call and runs the code.

For custom actions, the action name is the what use to return from the name method of the
custom action class
The file that contains our actions is called actions.py

An example of action from the actions.py file of our chatbot is shown below:

import logging

from typing import Text, Dict, Any, List

import json

import logging.config

from rasa_sdk import Action, Tracker,ActionExecutionRejection

from rasa_sdk.executor import CollectingDispatcher

from rasa_sdk.forms import FormAction,REQUESTED_SLOT

from rasa_sdk.events import SlotSet, UserUtteranceReverted,

ConversationPaused,FollowupAction, Form

from email.message import EmailMessage

from oauth2client.service_account import ServiceAccountCredentials

class emailCampaign(FormAction):

def name(self):

return "action_email_campaign"
 @staticmethod

def required_slots(tracker):

return [

"email"

def slot_mappings(self):

# type: () -> Dict[Text: Union[Dict, List[Dict]]]

"""A dictionary to map required slots to

- an extracted entity

- intent: value pairs

- a whole message

or a list of them, where a first match will be picked"""

return {"email": [self.from_entity(entity="email"),

self.from_text(intent="enter_data")]}

def submit(self, dispatcher, tracker, domain):

email = tracker.get_slot("email")

msg = EmailMessage()

msg['Subject'] = "Hello from JSB!"

 msg['From'] = "JediBSchool@gmail.com"

msg['To'] = email

msg.set_content("Hi! We are glad to assist you with your application or other

queries")

with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp:

smtp.login('JediBSchool@gmail.com', '#####')

smtp.send_message(msg)

return [SlotSet('email', email)]

dispatcher.utter_template("utter_sent_email", tracker)

return []

We define a method called “emailCampaign”. The purpose of this custom action is to collect
the email of the user and sends them an email automatically. To link this action with the
chatbot we added the action “action_email_campaign” to the list of actions in our
domain.yml file. We also added this action to the flow of stories in our stories.md file.
Lastly, we enable the custom action server using the endpoints file to let Rasa use this custom
action. Rasa calls an endpoint which we specify, when a custom action is predicted.
Shown below is our endpoints file called endpoints.yml

action_endpoint:

url: "http://localhost:5055/webhook"

D) Slots :
Slots are our chatbot’s memory. We use slots when we want our chatbot to remember
something and use it later in the conversation.
In our chatbot, we have slots for four values that we want our bot to remember :

 Name of the person (person_name),

 Email address (email),
 Program of Interest (program) and
 Intake (intake) of the program.
For example : When a user requests for a call with the admission team, the bot prompts the
user to submit details mentioned above. Slots hold these values entered by the user and at the
end send a confirmation message like “Thanks a bunch {person_name}! Our admissions team
will reach you at {email} with details of the {program} for the {intake}.
This adds to the personal touch our bot can offer to the student chatting with it.

Forms :
An important feature of Rasa are the Rasa forms which help us to design the flow of stories
easily with reliable slot filling. For example, our bot can book a call for the prospective students
with the university’s admissions team. Before scheduling the call, however, the bot needs to
know some important details like the email, program of interest, etc. To model conversations
like this will be difficult using slots alone, so we use Rasa forms which can be modelled with one
single story and ensure that our chatbot has all the required details collected before proceeding
further.
For our bot, we have used a Form Action defined in the class ‘adminForm’. This form action
collects student data and stores the data in a google sheet through API.

Model configuration
The configuration file defines the NLU and core components that our model uses. In our case,
we have used the supervised embedding pipeline. An NLU pipeline allows you to customize
your model. Our model’s configuration is stored in config.yml file and below is an example from
the file:

# Configuration for Rasa NLU

language: "en"

pipeline: "supervised_embeddings"
# Configuration for Rasa core

policies:

-name: AugmentedMemoizationPolicy

max_history: 6

- name: MemoizationPolicy

- name: KerasPolicy

- name: MappingPolicy

- name: FormPolicy

Training and running the model

 Finally, we trained our model using the following command:

rasa train

 To start our action server we run the following command from the command prompt:

rasa run actions

 To start chatting with the bot, run the following command

rasa run actions

Testing and validation
We can either use rasa interactive learning or Rasa x to validate and improve our bot’s
performance.
To validate the bot using rasa interactive, we use the command below to start validating the
bot’s responses.

rasa interactive

Here’s a screenshot of our bot’s interactive training:

We then tested the bot using Rasa X after quitting the rasa interactive terminal. (It is to be
noted that, the actions need to be running parallelly for the chatbot to work)

rasa x
Here’s the screenshot of the Rasa x user interface for our chatbot:

Rasa X provides an interactive user interface to understand and correct the real time
conversations. This helps to train the chatbot using the conversation data from the actual users
which in turn improves the chatbot’s performance.

Deploying the chatbot on Facebook

Steps :
Before we begin, we need to complete a few tasks on Facebook.

1) Create a new Facebook Messenger App:

 We logged in with our Facebook account to https://developers.facebook.com/

 We then created a new app called Yoda by clicking My Apps > Add New App
 On opening the dashboard for our new app, we found Messenger under Products
 We click the Set Up button

Messenger platform was added to our new app

 2) Create a Facebook page :

 A Facebook page will work as an identity to our chatbot. We have created a page with a
fictional school name called Jedi School of Business. Here’s the link to our Facebook
page : https://www.facebook.com/Jedi-School-of-Business-113232816727121/

3) Webhook Configuration:

 We opened the settings under for Messenger, scrolled down and found Webhooks.
Webhooks are a way for students all over the world access our Chatbot, which runs
based out of our local machine.
We clicked on Subscribe to Events option.

 We selected messages, messaging_postbacks,

messaging_options,message_deliveries,message_reads subscription fields and filled the
Callback URL by the public URL of our webhook. We verified the token which has to
match the verify entry in our credentials.yml file
 We finally save and exit

4) Ngrok for local testing

We have used Ngrok (https://ngrok.com/ ) to create a local webhook from our

machine that is available publicly on the internet.
This will allow us to connect with platforms like Facebook, Slack, etc.
We then run a ngroj instance for port 5005:

ngrok http 5005

Ngrok creates a https address (https://xxxxxx.ngrok.io) and we will use it in Callback

URL field while creating Webhook in Facebook app.

Callback URL will look like https://xxxxxx.ngrok.io/webhooks/facebook/webhook.

Here is a screenshot of our webhooks settings on the Facebook Developers portal:

Facebook Messenger will send a GET request to our webhook with the verify token we
provided. If everything is valid, the webhook will be saved.

5) Subscribing our chatbot to a Facebook page

 We open Settings for Messenger under Products

 We Scroll down and find Access Tokens

 We then select our newly created Jedi School of Business page to subscribe our
app Yoda to.

 We copy the token that appears in the ‘Page Access Token’ field

That’s all! The Messenger Platform will now be able to send the webhook events we have
subscribed to for our School’s page to our webhook.

6) Rasa Credentials

We have added our Facebook credentials to a credential file which Rasa will use during
integration. The credential file should contain the following:
 Verify - We have used “rasa-bot” to verify our chatbot.

 Secret - We copy the app secret value from our Facebook app chatbot dashboard.

 page-access-token - Access Token can be found under

Settings for Messenger under Products.

Here is the credentials.yml file for our chatbot:

facebook:

verify: "rasa-bot"

secret: "6bXXdc2c24c5cXX99ceXXffe62e"

page-access-token: "EAAGyyJIXXXXXXD"

Testing Rasa chatbot in Facebook Messenger

We can now chat with our bot on Facebook. Here is a screenshot of our chat with our
bot Yoda on Facebook.
Improvising the project further:

After deploying a bot which can handle FAQ’s about the university we improvised it a bit
by training it to handle small talk from users for questions like “What’s the time now?”,
“Can you suggest me a restaurant?” , “Who created you?” and so on.
The next step was to utilise the Rasa actions effectively. After some brainstorming, we
decided that we can add two very useful features to our bot. They are:
1) Book a call with the admissions team : It is common for prospective students to
want to call an admission team member but often, they either don’t get the right
contact details. Even if they get to connect with the admissions team, a lot of time
is wasted in collecting the student’s information the call. We know that the
 admissions team is usually very busy handling a lot of student queries especially
during the major intake periods of the university. In such a situation the student is
forced to wait for a few more days/hours before their data is processed and they
get their queries answered.

We can solve this problem if we already collect the student information relevant
to his query like their program of interest, email, etc and store it in the school’s
database.
The admission team can then look up the data and contact the student with the
required information.

 To implement this, we decided to use Google Sheets API

 We created a Google account exclusively for our Business school with the
id : JediBSchool@gmail.com
 We then headed over to the Google Developers portal and downloaded
our API credentials in the form of a JSON file. We saved this in our local
directory with the name client_secret.
Here is the client_secret.json file :

"type": "service_account",

"project_id": "yoda-1571913072086",

"private_key_id": "xxxx448d2d347d7854ad116089d32dxxxx",

"private_key": "-----BEGIN PRIVATE

KEY-----\nMIIEvgIBADANBgkqhkiXXXXEAAoIBAQCcDpZ/0LFXAgg/\ + +\n-----END PRIVATE
KEY-----\n",

"client_email": "yoda-838@yoda-1571913072086.iam.gserviceaccount.com",

"client_id": "10768xxx44633406”,

“auth_uri”: “https://accounts.google.com/o/oauth2/auth”,

“token_uri”: “https://oauth2.googleapis.com/token”,

“auth_provider_x509_cert_url”: “https://www.googleapis.com/oauth2/v1/certs”,

“client_x509_cert_url”: “https://www.googleapis.com/robot/v1/metadata/x509/yoda-
838%40yoda-1571913072086.iam.gserviceaccount.com”

}
 We now open google sheets and share it with the client email address mentioned
above.
 Lastly, we code an action in Python to fetch the slot values from the Rasa form
and save them in the Google sheets.
 We tested to see if it worked by chatting with our bot on Facebook and providing
all the details it asked us.
 We then opened the Google sheets associated with the School’s account.

Here’s the screenshot of the Google Sheet which was updated by the user’s
details.

2) For the next big thing, we wanted the bot to subscribe the students to the
university’s admission newsletter. Most universities across the world have an
admissions newsletter which when subscribed by the student, keeps them
informed about the admission events, campus updates etc.

 To implement this idea, we decided to use Python to send emails to

students who express their interest to sign up to the university’s admission
newsletter.
 We used Python’s SMTP module to achieve this. SMTP stands for Simple
Mail Transfer Protocol and is useful for sending emails by communicating
with mail server.
 We coded an action in Python to achieve this task of collecting the email
from the bot user and sending them an email from the Gmail account
which we have created previously for the university.
 We tested it by chatting with the bot on Facebook and providing with our
email when prompted.
 We then checked our email and found a mail from the Gmail account of
the school.
 Here’s a screenshot of the email received from the university.

SURVEY
We conducted a survey to test the viability of our chatbot. We created a Google form with a
collection of questions to get an opinion on our project. This survey was targeted at a group of
students who have/ or going to have a study abroad experience. Through this survey, we aim to
understand the problems faced by students when trying to find answers to their questions
about universities and how our chatbot could have made that experience simpler.

RESULTS
We personally experienced roadblocks while trying to find the right information at the right
time using traditional means. We developed this chatbot to help students facing similar
problems.
We developed a conversational chatbot using the RASA framework to cater to the queries of
international students. Readily available information helps create a connect between the
student and the university. This chatbot can easily be deployed by any university which is trying
to lower the overhead on their admissions team. Our chatbot, Yoda, can automate the data
collection process of the prospective students and assists the admissions team in pursuing
leads.

CONCLUSION
We received 26 completed responses from students all over the world. All of the respondents
are past/current/prospective international students and a majority of them were in pursuit of
Master’s degree (80.8%). Notable findings from our survey:
University admissions office and college website was found to be their primary sources of
information. 57.7% of the respondents agreed to having faced difficulties in finding the
information about the University.
After using our chatbot, Yoda, majority of the students agreed that they could find the
information quicker and easier than compared to traditional means.

76.9 percent of the students felt that a chatbot like Yoda would have helped them in accessing
information about the university easily instead of looking up multiple websites and forums.
After analyzing the overall results of the survey, we found that majority of the respondents
have an affinity for the chatbots and welcome the idea of having chatbots for their universities.
84.6 percent of the respondents appreciated the idea of having a chatbot like Yoda for their
university.
These results helped in quantifying the validity of this project. In this fast paced life, time is of
utmost value and students expect information in a blink of an eye. This project provides the
students with a familiar medium to access the information they eagerly seek and help them
make informed decisions about one of their biggest life choices. We hope that universities
implement similar chatbots which provide immense value to both the students and the
administration staff, making it a win-win situation.
LIMITATIONS AND FURTHER SCOPE

We could not find university APIs to use in our project. Using a university API would have made
the development process easier as we would then get the FAQ’s directly instead of researching
and writing our own FAQ’s.
Providing more conversations in terms of both the volume and variety from the users would
increase the bot’s ability to make better sense of new and unseen user inputs.
The bot can further be enhanced with additional features like helping the students find the
right program, tracking the application status of the students, and connecting the them with
their faculty.

REFERENCES

 http://data.uis.unesco.org/index.aspx?queryid=169
 Jennifer Hill, W. Randolph Ford, Ingrid G. Farreras, Real conversations with artificial
intelligence: A comparison between human–human online conversations and human–
chatbot conversations, Computers in Human Behavior, Volume 49, 2015, Pages 245-250,
ISSN 0747-5632, https://doi.org/10.1016/j.chb.2015.02.026.
 T.M. Holtgraves, S.J. Ross, C.R. Weywadt, T.L. Han, Perceiving artificial social agents,
Computers in Human Behavior, Volume 23, Issue 5, 2007, Pages 2163-2174, ISSN 0747-
5632, https://doi.org/10.1016/j.chb.2006.02.017.
 Brandtzaeg P.B., Følstad A. (2017) Why People Use Chatbots. In: Kompatsiaris I. et al.
(eds) Internet Science. INSCI 2017. Lecture Notes in Computer Science, vol 10673.
Springer, Cham
 https://newsroom.fb.com/company-info/
 Maxime Clément, Matthieu J. Guitton, Interacting with bots online: Users’ reactions to
actions of automated programs in Wikipedia, Computers in Human Behavior, Volume
50, 2015, Pages 66-75, ISSN 0747-5632, https://doi.org/10.1016/j.chb.2015.03.078.
 Chad Edwards, Austin J. Beattie, Autumn Edwards, Patric R. Spence, Differences in
perceptions of communication quality between a Twitterbot and human agent for
information seeking and learning, Computers in Human Behavior, Volume 65, 2016,
Pages 666-671, ISSN 0747-5632, https://doi.org/10.1016/j.chb.2016.07.003.
 https://rasa.com/docs/rasa-x/
 https://forum.rasa.com/
 https://github.com/RasaHQ