If you prefer watching videos to reading text, you can see great introduction to bot development in this AI Essentials Video, also available from AI Developer Resources page.
Do We Need Bots, and When?
Many people believe that in the future we will be interacting with computers using speech, in the same way we interact between each other. While the future is still vague, we can already benefit from conversational interfaces in many areas, for example:
- In user support, which has traditionally been based on interpersonal communication, automated chat-bots can solve a lot of routine problems for the users, leaving human specialists for solving only unusual cases.
- During surgical operation, when hands-free interaction is essential. From personal experience, I find it personally more convenient to set morning alarm and “good night” music through voice assistant before going to sleep.
- Automating some functions in interpersonal communication. My favorite example is a chat-bot that you can add to a group chat when organizing a party, and it will track how much money each of the participants spent on the preparation.
At the current state of development of conversational AI technologies, a chat bot will not replace a human, and it will not pass Turing test.
In practice, chat bots act as an advanced version of a command line, in which you do not need to know exact commands to perform an action.
Thus, successful bot applications will not try to pretend to be a human, because such behavior is likely to cause some user dissatisfaction in the future. It is one of the responsible conversational AI principles, which you need to consider when designing a bot.
Educational Bots
During the pandemic, one of the areas that is being transformed the most is education. We can envision educational bots that help student answer most common questions, or act as a virtual teaching assistant. In this blog post, I will show you how to create a simple assistant bot that will be able to handle several questions from the field of Geography.
Before we jump to this task, let’s talk about Microsoft conversational AI stack in general, and consider different development options.
Conversational AI Development Stack
When it comes to conversational AI, we can logically think of a conversational agent having two main parts:
- Conversational interface handles passing messages from the user to the bot and back. It takes care about communication between user messaging agent (such as Microsoft Teams, Skype or Telegram) and our application logic, and includes code to handle request-response logic.
- Intelligent backend adds some AI functionality to your bot, such are recognizing user’s phrases, or finding best possible answer.
A bot can exist without any intelligent backend, but it would not be smart. Still, bots like that are useful for automating simple tasks, such as form filling, or handling some pre-defined workflow.
Here I present slightly simplified view of the whole Bot Ecosystem, but this way it is easier to get the picture.
Conversational Interface: Microsoft Bot Framework and Azure Bot Services
At the heart of conversational interface is Microsoft Bot Framework - an open-source development framework (with source code available on GitHub), which contains useful abstractions for bot development. The main idea of Bot Framework is to abstract communication channel, and develop bots as web endpoints that asynchronously handle request-response communication.
Decoupling of bot logic and communication channel allows you to develop bot code once, and then connect it easily to different platforms, such as Skype, Teams or Telegram. Omnichannel bots are now made simple!
Bot Framework SDK supports primarily C#, Node.js, Python and Java, although C# or Node.js are highly recommended.
To host bots developed with Bot Framework on Azure, you use Azure Bot Services. It hosts bot logic itself (either as web application, or [Azure function][AzFunc]), as well as allows you to declaratively define physical channels that your bot will be connected to. You can connect your bot to Skype or Telegram through Azure Portal with a few simple steps.
Intelligent Backend: LUIS and QnA Maker
Many modern bots support some form of natural language interaction. To do it, the bot needs to understand the user’s phrase, which is typically done through intent classification. We define a number of possible intents or actions that the bot can support, and then map an input phrase to one of the intents.
This mapping is typically done using a neural network trained on some dataset of sample phrases. To take away the complexity of training your own neural network model, Microsoft provides Lanuguage Understanding Intelligent Service, or LUIS, which allows you to train a model either through web interface, or an API.
In addition to intent classification, LUIS also performs named entity recognition (or NER). It can automatically extract some entities of well-known types, such as geolocations or references to date and time, and can learn to extract some user-defined entities as well.
Having entities extracted and intent correctly determined it should be much easier to program the logic of your bot. This is often done using slot filling technique: extracted entities from the user’s input populate some slots in a dictionary, and if some more values are required to perform the task - additional dialog is initiated to ask additional info from the user.
Another type of bot behavior that often comes up is the ability to find best matching phrase or piece of information in some table, i.e. do an intelligent lookup. It is useful if you want to provide FAQ-style bot that can answer user’s questions based on some database of answers, or if you just want to program chit-chat behavior with some common responses. To implement this functionality, you can use QnA Maker - a complex service, that encapsulates Azure Cognitive Search, and provides simple way to build question-answering functionality. You can index any existing FAQ document, or provide question-answer pairs through the web interface, and then hook up QnA maker to your bot with a few lines of code.
Bot Development: Composer, Power Virtual Agents or Code?
As I mentioned above, bots can be developed using your favorite programming language. However, this approach requires you to write some boilerplate code, understand asynchronous calls, and therefore has a significant learning curve. There are some simpler options that are good for a start!
It is recommended to start developing your bot using low-code approach through Bot Framework Composer - an interactive visual tool that allows you to design your bot by drawing dialog diagrams.
Composer integrates LUIS and QnA maker out of the box, so that you do not need to train those services through web interface first, and then worry about integrating them to your bot. From the same UI, you are able to specify events triggered by some user phrases, and dialogs that respond to them.
Another similar low-code option would be to use Power Virtual Agents (PVA), a tool from Power Platform family of tools for business automation. It would be especially useful if you are already familiar with Power Platform, and using any of its tools to enhance productivity. In this case, PVA will be a natural choice, and it will integrate nicely into all your data points and business processes. In short - Composer is a great low-code tool for developers, while PVA is more for business users.
Getting Started with Bot Development
Let me show you how we can start the development of a simple educational bot that will help K-12 students with their geography classes. We will develop a simple bot, which you can later host on Microsoft Azure and connect to most popular communication channels, such as Teams, Slack or Telegram. If you do not have an Azure account, you can get a free trial (or here, if you are a student).
To begin with, we will implement three simple functions in our bot:
- Being able to tell a capital city for a country (What is the capital of Russia?).
- Giving definitions of most useful terms, eg. answering a questions like What is a capital?
- Support for simple chit-chat (How are you today?)
Those two functions cover two most important elements of our intelligent backend: QnA Maker (which can be used to implement the last two points) and LUIS.
Starting with Bot Composer
To begin development, you need to [install Bot Framework Composer][InstallComposer] - I recommend to do it as desktop application. Then, after starting it, click on New button, and chose starting template for your bot: QnA Maker and LUIS:
Once you do that, you will see the main screen of composer, with a list of triggers on the left, and the main pane to design dialogs:
Here, you can delete an unused trigger BuySurface (which is left over from the demo), and go to Welcome message to customize the phrase that the bot says to new user. The logic of Welcome Message trigger is a bit complex, you need to look for a box called Send a response, and change the message in the right pane.
The language used to define phrases is called Language generation, or lg. A few useful syntax rules to know:
- A phrase starts with
-. If want to chose from a number of replies, specify several phrases, and one of them will be selected randomly. For example: ```bash - Hello, I am geography helper bot!
- Hey, welcome!
- Hi, looking forward to chat with you! ```
- Comments start with
> - Some additional definitions start with
@ - You can use
${...} syntax for variable substitution (we will see an example of this later)
Connecting to Azure Services
To use intelligent backend, you need to create Azure resources for LUIS and QnA Maker and provide corresponding keys to Composer:
- Create LUIS Authoring Resource, and make sure to remember the region in which it was created, and copy key from Keys and Endpoint page in Azure Portal.
- Create QnA Maker Service, and copy corresponding key
- In Composer, go to bot settings by pressing Project Settings button in the left menu (look for a wrench icon, or expand the menu if unsure). Under settings, fill in LUIS Authoring Key, LUIS region and QnA Maker Subscription key.
Starting the Bot
At this point, you can already start chatting with your bot. Click Start bot in the upper right corner, and let some time for the magic to happen. When starting a bot, Composer actually creates and trains underlying LUIS model, builds bot framework project, and starts local web server with a copy of the bot, ready to serve your requests.
To chat with a bot, click Test in emulator button (you need to have Bot Framework Emulator) installed for this to work). This automatically opens up the chat window with all required settings, and you can start talking to your bot right away.
Creating QnA Maker Knowledge base
Let’s start with creating term dictionary using QnA Maker. Click on QnA left menu, and then Create new KB.
Here you can either start from some existing data (provided as an URL to html, pdf, Word or Excel document), or start creating phrases from scratch.
In most of the cases, you would have a document to start with, but in our case we will start from scratch. After creating a Knowledge base, you can click Add QnA Pair to add all question-answer combinations you need. Note that you can add several options of the question by using All alternative phrasing link.
In our case, I have added a how are you phrase (with several options), and a phrase to explain the meaning of the word capital.
Having added the phrases, we can start a bot and make sure that it correctly reacts to given phrases, or similar versions of those phrases - QnA maker does not require it to be an exact match, it looks for similar phrases to make a decision on which answer to provide.
Adding Specific Actions with LUIS
To give our bot an ability to give capitals of countries, we need to add some specific functionality to look for a capital, triggered by a certain phrase. We definitely do not want to type all 200+ countries and their capitals into QnA Maker!
A functionality to get information about a country is openly available via REST Countries API. For example, if we make GET request to https://restcountries.eu/rest/v2/name/Russia, we will get JSON response like this:
[ {"name":"Russian Federation",
"topLevelDomain":[".ru"],
"capital":"Moscow", ... } ]
To ask for a capital of a given country, a user will say something like What is a capital of Russia?, or I want to know the capital of Italy. This phrase intent can be recognized using LUIS, and the name of the country is also extracted.
To add LUIS trigger, from the Design page of the composer, select your bot dialog and press “…” next to it. You will see Add a trigger option in the drop-down box. Select it, and then chose Intent recognized as trigger type.
Intent Recognized is the most common trigger type. However, you can specify Dialog events, that allow you to structure part of the conversation as a separate dialog, or some conversational activities, such as Handoff to human.
Then, specify trigger phrases, using a variation of LG language. In our case, we will use the following:
- what is a capital of {country=Russia}?
- I want to know a capital of {country=Italy}.
- Give me a capital of {country=Greece}!
Here, we specify a number of trigger phrases starting with -, and we indicate that we want to extract part of the phrase as an entity country. LUIS will automatically train a model to extract entities based on the provided utterances, so make sure to provide a number of possible phrases.
There are some pre-defined entity types, such as datetimeV2, number, etc. Using pre-defined types is recommended, and entity type can be specified using @ <entity_type> <entity_name> notation. In our case, we can use geographyV2 entity type, which extracts geographic locations, including countries.
Once we have defined phrase recognizer, we need to add a block that will do the actual REST call and fetch information on the given country. Use use Send HTTP Request block, and specify the following parameters:
- Method = GET
- Url =
https://restcountries.eu/rest/v2/name/${@country}. Here, ${@country} will be substituted with the name of the recognized country. - Result property = dialog.result
- Response type = json
This would make the REST call to the API, and the result will be stored into dialog.result property. If we provided a valid country, json result will be automatically parsed, otherwise, invalid operation code will be recorded in dialog.result.statusCode - in our case, 404.
To test if the call was successful and define different logic based on the result, we insert Branch: If/Else block, and specify the following condition: = equals(dialog.result.statusCode,200). True condition will correspond to the left branch, and we will insert Send a response block there, with the following text:
- A capital of ${@country} is ${dialog.result.content[0].capital}
In case result code is not 200, the right branch will be executed, where we will insert an error message. Our final dialog should look like this:
It would be nice if your bot could respond to more everyday phrases, such as How old are you?, or Do you enjoy being a bot. We can define all those phrases in QnA Maker, but that would take us quite some time to do so. Luckily, there is Project Personality Chat that contains a number of pre-defined QnA Maker Knowledge bases for several languages, and for a number of personalities:
- Professional
- Friendly
- Witty
- Caring
- Enthusiastic
You can grab a link to the Knowledge base from here, then go to QnA Maker Portal, find your Knowledge base, and add this URL link to your service:
Having done that, click Save and Train, and enjoy a talk to your bot! You can even try ask it about life, universe and everything!
Testing the Bot and Publishing to Azure
Now that our basic bot functionality is complete, we can test the bot in bot emulator:
Once the bot is running locally, we can deploy it to Azure right from the Composer. If you go to Publish from the left menu, you will be able to define Publishing profile for your bot. Select Define new publishing profile, and chose one of the following:
The most standard way to deploy is to use Azure Web App. Composer will only require you to provide Azure subscription and resource group name, and it will take care of creating all the required resources (including bot-specific LUIS/QnA Maker instances) automatically. It may take awhile, but it will save you a lot of time and hassle of doing manual deployment.
Once the bot is published to Azure, you can go to Azure portal and configure Channels through which you bot would be available to external world, such as Telegram, Microsoft Teams, Slack or Skype.
Conclusion
Creating a bot using Bot Composer seems like an easy thing to do. In fact, you can create quite powerful bots almost without any code! And you can also hook them to your enterprise endpoint using such features as HTTP REST APIs and OAuth authorization.
However, there are cases when you need to significantly extend bot functionality using code. In this case, you have several options:
- Keep main bot authoring in Bot Composer, and develop Custom Actions in C#
- Export complete bot code using Custom Runtime feature of Composer, which exports complete bot code in C# or Javascript, which you can then fully customize. This approach is not ideal, because you will lose the ability to maintain the source of your bot in Composer.
- Write a bot from the beginning in one of the supported languages (C#, JS, Python or Java) using Bot Framework.
If you want to explore how the same Educational bot for Geography can be written in C#, check out this Microsoft Learn Module: Create a chat bot to help students learn with Azure Bot Service.
I am sure conversational approach to UI can prove useful in many cases, and Microsoft Conversational Platform offers you wide variety of tools to support all your scenarios.