The Importance Of Chatbot Prototyping & How Rasa’s Playground Can Help
Iterative Prototyping Is Useful In Developing Conversational AI Applications
Introduction
Getting started with chatbots in particular and Conversational AI in general can be daunting. You might have heard about chatbots and have a basic understanding of the gist. And now the next step is to get started by building something…but how?
Questions often asked include:
- How do I access the software?
- Do I need a GPU or extensive computing power?
- Will it be expensive?
- Do I need a specific design or prototyping tool?
- How do I gather training data?
- Does only the big players have what I need; i.e. Google, Facebook or AWS?
- Where and how do I host my bot?
- On which mediums should I surface my bot?
The Importance Of Prototyping
First, what is a prototype and why is it important…
Once you have decided you might need a chatbot, a first step will most probably be to build a user experience porotype. You do not need any specialized software, a paper based prototype is more than sufficient.
The longer and time consuming process of drawing out the conversation aides the design process. This paper based approach then represents enough of the appearance and functionality of the product to do a basic presentation.
Hence serving as a visual prototype with the correct size and appearance, but obviously not the functionality, of the intended design.
Here you can confirm design decisions before more costly levels of design effort are made.
This can serve as an initial and guided User Experience Prototypes. Getting user ideas and impressions.
Once you have the basic representation down, the logical next step is to build a Proof-of-Principle Prototype. At this stage you want to verify some key functional aspects of your intended design.
Obviously not with all the functionality, but still a working prototype and not merely a mockup or wireframe.
And piece of software you can interact with and get an idea of the work which lies ahead.
Iterate & Scale
The ideal would be to take this proof-of-principle prototype through multiple iterations up to the stage where a MVP takes shape. And what’s more, being able to scale this continuously without design and architecture impediments is first prize.
Scaling speaks to understanding the different components constituting the environment. And staring your project in its most basic form helps in getting to grips with the environment.
Rasa Playground ~ How Does It Help?
Is it production ready? — Yes and No.
Is it a development environment? — Yes and No.
Is it like a notebook? — Yes and No.
Is it an IDE? — Sort of.
What makes this interface unique is that you can build a prototype from scratch. And have real and verified iterations which can be trained and tested. You can even download your project and install it in a production area.
Hence efficiency is present and continuation is established.
Scaling is easier when you fully grasp the building blocks and how all the pieces fits together.
There is nothing wrong with running GitHub projects. But often the impediments encounters are:
- A false sense of rapid initial progress impedes comprehension of the complexity of the task at hand.
- Customization becomes harder due to a lack of understanding of the adopted frameworks vulnerability.
- Scaling becomes hard and is fraught with reworks with each iteration of scaling and adding functionality.
Rasa Playground ~ How Does It Work?
All you need to start is a browser and access the url. Incidentally, this is also a good starting point for getting to grips with Rasa 2.0. There are 5 five components to crafting the conversation: NLU Data, Responses, Stories, Forms and Rule.
Later you will learn of actions which are used for integration point. Let’s leave forms and rules out in this example for the sake of simplicity.
Let’s build the simples chatbot possible, for this we need to use three components:
- NLU Data
- Responses
- Stories
NLU Data
The NLU data contains the training data for your intents and entities. We have only two intents, greet and get_name. And one entity, name.
nlu:
- intent: greet
examples: |
- Hi
- Hey!
- Hallo
- Good day
- Good morning- intent: get_name
examples: |
- My name is [John](name)
- They call me [Mary](name)
- Yo can use [James](name)
- My name is [Brian](name)
- Call me [Susan](name)
- My name is [Karen](name)
Responses
For responses we have one slot called name. With that, two chatbot utterances; one which is dynamic.
slots:
name:
type: text
responses:
utter_greet:
- text: |
Hello! What is your name?
utter_name:
- text: |
Hallo {name}, so good to meet you.Stories
Lastly, our chatbot has one story. The simplest scenario possible.
stories:
- story: greet and name
steps:
- intent: greet
- action: utter_greet
- intent: get_name
- action: utter_nameThis is what the playground with only steps one, two and three populated look like. Forms and Rules are left empty.
After training, you can interact with your chatbot and test your functionality.
Conclusion
The idea is great, and has a lot of potential…there are some improvements I would like to see. The scroll bars render wrong and can be easily fixed; its evident on Edge, Firefox and Chrome. I did not test Safari.
It would be great if the playground can be resized; or even pop out, leaving the left-hand column behind.
I found with training, when there are errors, training just continues for a long time, without error feedback. Even when the code is 100%, there are instances where the code just runs, seemingly in a loop. Any progress indication or timeout will be helpful.
Lastly, you can only download a project, via the “Download Project” button, once training is done. Prior to training, the button is inactive. Perhaps the button needs to be grayed out, and only active after the first training iteration.
I am curious to know to which extend it will be developed and enhanced; I surely hope it does.
