Building a Bot As an Alternative to Classic User Interface. Why Is It Better?
After several attempts to build a classic Web UI application, we moved to a simplified Bot Flow. And this is why and how.
Join the DZone community and get the full member experience.
Join For FreeCreating a Bot with NASA API and Azure Bot Services, including Language Recognition: Part 1.
My team and I were working on an open-source customer project in the aerospace domain that provided scientific data for students and university data scientists. After several attempts to build a classic Web UI application, we moved to a simplified Bot Flow. And this is why and how.
The project has a short and straightforward data response. It contains only essential data like:
- Coordinates.
- Event time frames.
- Source type, etc.
However, some messages have links to the detailed report that is a classic Web UI. Having a chat with a bot is more natural as you feel like you are communicating with a person.
Introduction
In this article, I build a simplified version of a Bot that aggregates data from NASA API and provides the user with a simple workflow and short data feedback. Also, I use Azure Language Recognition (LUIS) service to improve and simplify the conversation flow.
The NASA Bot contains the following functions:
- Gather data from the NASA API.
- Aggregate and simplify data payload.
- Recognize the user input with Azure Language Recognition (LUIS). We will go into the LUIS below.
Before we dive deep into the details, let’s examine why the Bot is better than a classic UI.
Using the bot approach may significantly improve the user experience if you have:
- Simplified and short data payload.
- Intuitive user interaction flow that looks like a Q&A dialog.
- No complex UI.
- Focus on content.
UI is better than a Bot if you have:
- Complex data payload.
- Complex UI forms (Admin Portals, Editors, Maps, News Portals, Calendars).
- Complex data visualization (Dashboards, Charts).
The best option may be to combine both approaches and use all benefits from a Bot and a classic UI.
Why NASA API?
I have chosen NASA API because of:
- A granular and quite simple API design.
- Well-documented API calls.
- Easy and fast registration process.
- API key request.
NASA API is divided into categories or sub APIs, like:
- Space Weather Database Of Notifications, Knowledge, Information (DONKI).
- Mars Weather Service API.
- Two-line element data earth-orbiting objects at a given point in time (TLE API).
- Satellite Situation Center.
Why Azure Bot Service?
Azure Bot Service, alongside the Bot Framework, provides you with an opportunity to build, test, store your Bot. Bot Framework includes tools, SDK, AI services, and templates that allow you to make a bot quite quickly.
In my case, I have created a project with Visual Studio using the template and installed a toolset, SDK, and templates. I have used .NET Core and C#. However, this framework also allows using JavaScript and Python.
What is LUIS?
LUIS is a language understanding service that allows you to build and train your Bot to understand a natural language. I have included LUIS in my Bot to provide people with information from NASA API using different natural language construction.
For the current project, I have trained LUIS manually using the LUIS Portal. Below you can see that I added language sentences to train the LUIS to recognize user feedback and set the score. The LUIS portal also contains an option that allows you to test your data set and deploy it to different stages.
Of course, a manually trained model is suitable for small and middle-level bot projects. You should consider using pre-trained models that you quickly find in JSON format or set up for the production application.
You can also improve language understanding by adding QnA (Question and Answers) and language generation templates.
NASA Bot Architecture Overview
The NASA Bot architecture represents an N-tire structure based on an MVC pattern. The Bot includes API Controllers, Models, and Services.
The NASA bot consists of the following main components.
1. Nasa bot class is a component that contains the conversation flow event handlers like MembersAdded and MessageActivity. And it also serves as an entry point to start a conversation flow.
C#
xxxxxxxxxx
1
106
1
....
2
3
public class NasaBot : ActivityHandler
4
{
5
private Donki _donkiApi;
6
private IOptions<NasaApi> _config;
7
private readonly IOptions<Luis> _luisConfig;
8
private readonly IExternalApiAgregetionService _externalApiAgregetionService;
9
private readonly BotState _userState;
10
private readonly BotState _conversationState;
11
12
public NasaBot(
13
IOptions<NasaApi> config,
14
IOptions<Luis> luisConfig,
15
ConversationState conversationState,
16
UserState userState,
17
IExternalApiAgregetionService externalApiAgregetionService)
18
{
19
_donkiApi = new Donki();
20
_config = config;
21
_luisConfig = luisConfig;
22
_conversationState = conversationState;
23
_userState = userState;
24
_externalApiAgregetionService = externalApiAgregetionService;
25
}
26
27
protected override async Task OnMembersAddedAsync(IList<ChannelAccount> membersAdded, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
28
{
29
var welcomeText = "---- Welcome to the NASA Bot ----";
30
31
foreach (var member in membersAdded)
32
{
33
if (member.Id != turnContext.Activity.Recipient.Id)
34
{
35
await turnContext.SendActivityAsync(MessageFactory.Text(welcomeText), cancellationToken);
36
await turnContext.SendActivityAsync("Please enter something to start", null, null, cancellationToken);
37
}
38
}
39
}
40
41
protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
42
{
43
// Conversation Flow Accessors state setup
44
var conversationFlowAccessors = _conversationState.CreateProperty<ConversationFlow>(nameof(ConversationFlow));
45
ConversationFlow flow = await conversationFlowAccessors.GetAsync(turnContext, () => new ConversationFlow(), cancellationToken);
46
47
// ObservationParams state setup
48
var observationParamsAccessor = _userState.CreateProperty<ObservationParams>(nameof(ObservationParams));
49
ObservationParams observationParams = await observationParamsAccessor.GetAsync(turnContext, () => new ObservationParams(), cancellationToken);
50
51
// Start question Process
52
await StartQuestioningProcess(flow, observationParams, turnContext, cancellationToken);
53
54
// Save data changes
55
await _conversationState.SaveChangesAsync(turnContext, false, cancellationToken);
56
await _userState.SaveChangesAsync(turnContext, false, cancellationToken);
57
}
58
59
private async Task StartQuestioningProcess(ConversationFlow conversationFlow, ObservationParams observationParams, ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
60
{
61
string input = turnContext.Activity.Text?.Trim();
62
string message = string.Empty;
63
64
switch (conversationFlow.Question)
65
{
66
case Question.None:
67
// Move to the next question
68
conversationFlow.Question = Question.ObservationStartDateQuestion;
69
70
await turnContext.SendActivityAsync("Enter observation Start-Date", null, null, cancellationToken);
71
72
break;
73
case Question.ObservationStartDateQuestion:
74
75
observationParams.StartDate = DateTime.Parse(input);
76
77
await turnContext.SendActivityAsync("And please observation End-Date", null, null, cancellationToken);
78
79
// Move to the next question
80
conversationFlow.Question = Question.ObservationEndDateQuestion;
81
82
break;
83
case Question.ObservationEndDateQuestion:
84
85
observationParams.EndDate = DateTime.Parse(input);
86
87
await turnContext.SendActivityAsync("Observation type", null, null, cancellationToken);
88
conversationFlow.Question = Question.ObservationTypeQuestion;
89
90
break;
91
case Question.ObservationTypeQuestion:
92
93
observationParams.ObservationType = input;
94
95
string observationDataText = await _externalApiAgregetionService.GetObservarionText(_config.Value.ApiKey, observationParams.StartDate, observationParams.EndDate, turnContext, cancellationToken);
96
97
await turnContext.SendActivityAsync(MessageFactory.Text(observationDataText, observationDataText), cancellationToken);
98
99
await turnContext.SendActivityAsync("Observation type", null, null, cancellationToken);
100
101
// Move to the first question
102
conversationFlow.Question = Question.ObservationTypeQuestion;
103
break;
104
}
105
}
106
}
2. External API aggregation service joins logic related to language recognition and fetches data from NASA API.
C#
xxxxxxxxxx
1
41
1
namespace NASABot.Services
2
{
3
public class ExternalApiAgregetionService : IExternalApiAgregetionService
4
{
5
private Donki _donkiApi;
6
private readonly IOptions<Luis> _luisConfig;
7
8
public ExternalApiAgregetionService(IOptions<Luis> luisConfig)
9
{
10
_donkiApi = new Donki();
11
_luisConfig = luisConfig;
12
}
13
14
public async Task<string> GetObservarionText(string apiKey, DateTime startDate, DateTime endDate, ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
15
{
16
var observationRecognizer = new LanguageRecognitionService(_luisConfig);
17
18
var luisObservationTypeResult = await observationRecognizer.RecognizeAsync<ObservationType>(turnContext, cancellationToken);
19
20
string apiResult = "I don't get it. :( Could you please reformulate ?";
21
22
switch (luisObservationTypeResult.TopIntent().intent)
23
{
24
case ObservationType.Intent.CoronalMassEjection:
25
26
apiResult = await _donkiApi.GetCoronalMassEjection(apiKey, startDate, endDate);
27
28
break;
29
case ObservationType.Intent.GeomagneticStorm:
30
31
apiResult = await _donkiApi.GetGeomagneticStorm(apiKey, startDate, endDate);
32
33
break;
34
case ObservationType.Intent.None:
35
break;
36
}
37
38
return apiResult;
39
}
40
}
41
}
3. NasaApi library subproject is a wrapper of Nasa API calls. It contains logic to obtain, parse data from API and build a proper response for the business layer.
Java
xxxxxxxxxx
1
67
1
...
2
public class Donki
3
{
4
/// <summary>
5
/// Coronal Mass Ejection (CME)
6
/// </summary>
7
/// <returns></returns>
8
public async Task<string> GetCoronalMassEjection(string apiKey, DateTime startDate, DateTime endDate)
9
{
10
var dataString = new StringBuilder();
11
12
var coronalMassEjectionData = await Constants.NasaApiUrl
13
.AppendPathSegment("DONKI")
14
.AppendPathSegment("CME")
15
.SetQueryParams(new
16
{
17
api_key = apiKey,
18
startDate = startDate.ToString("yyyy-MM-dd"),
19
endDate = endDate.ToString("yyyy-MM-dd"),
20
}).GetJsonAsync<List<CoronalMassEjection>>();
21
22
dataString.AppendLine($" ---- Coronal Mass Ejection ----");
23
24
foreach (var item in coronalMassEjectionData)
25
{
26
dataString.AppendLine($"- Activity was at: {item.ActivityId} ");
27
dataString.AppendLine($" {item.Note} ");
28
}
29
30
return dataString.ToString();
31
}
32
33
/// <summary>
34
/// Geomagnetic Storm (GST)
35
/// </summary>
36
/// <param name="apiKey"></param>
37
/// <param name="startDate"></param>
38
/// <param name="endDate"></param>
39
/// <returns></returns>
40
public async Task<string> GetGeomagneticStorm(string apiKey, DateTime startDate, DateTime endDate)
41
{
42
var dataString = new StringBuilder();
43
44
var result = await Constants.NasaApiUrl
45
.AppendPathSegment("DONKI")
46
.AppendPathSegment("GST")
47
.SetQueryParams(new
48
{
49
api_key = apiKey,
50
startDate = startDate.ToString("yyyy-MM-dd"),
51
endDate = endDate.ToString("yyyy-MM-dd"),
52
}).GetJsonAsync<List<GeomagneticStorm>>();
53
54
dataString.AppendLine($" ---- Geomagnetic Storm ----");
55
56
if (result != null)
57
{
58
foreach (var item in result)
59
{
60
dataString.AppendLine($"- Activity was at: {item.StartTime} ");
61
dataString.AppendLine($"- Link: {item.Link} ");
62
}
63
}
64
65
return dataString.ToString();
66
}
67
}
Below is the list of other bot components with a link to the GIT repository:
- API (and BotController) is an endpoint to the Bot, and when you create your Bot with Visual Studio or VS Code, it creates a project that looks almost like a Web API project. The Web API is based on an MVC pattern.
- LanguageRecognitionService connects the Bot to the LUIS API and triggers the language recognition process.
- ObservationTypeModel contains all fields related to LUIS Response, including maximum intent score calculation logic.
Conversation Workflow
Below, I have added several screenshots that demonstrate an interaction with the Bot. As you see, here I used Bot Framework Emulator.
Conclusion
The article demonstrates the main advantages that bot services can bring in comparison to UI interfaces. In the next article, I will extend the Bot by adding more advanced features.
The link to the git repository where you can clone the project.
What is Next
In the next article, I will upgrade the Bot by adding:
- QnA maker and models.
- Unit Tests.
- Other APIs.
- Improved language recognition (Involve language generation).
- Bot deployment across multiple channels (Telegram, Slack).
Please feel free to suggest your ideas on what else should be added to the Bot or covered in the next article. Looking forward to hearing from you in the comments.
Topics:
azure,
cloud,
azure bot service
Opinions expressed by DZone contributors are their own.
Comments