>> You're not going to want to miss this episode of
The AI Show where we talk
about conversational AI tooling.
You can get up and running all from
the command line locally or in the Cloud.
Justin and Carlos are going to show us how.
Make sure you watch this episode.
Hello, and welcome to
this episode of The AI Show where we're going
to talk all about conversational AI tool.
And I have two guests.
Why don't you introduce yourselves?
Tell us who you are, what you do.
We'll start with you, Carlos.
>> Yeah. Hello, I'm Carlos Castro.
I'm an Engineer at FUSE Labs
within Microsoft AI and Research.
>> Fantastic.
>> I'm Justin Wilaby. I am also an Engineer and
Developer at Microsoft FUSE Labs and AI Research.
>> Awesome. So, let's get started.
What are we talking about today?
>> Today, we're talking about
tooling for conversational AI.
>> Okay.
>> So, yeah, one would wonder,
why do we want tooling around conversational AI, right?
And the reason is that we want to empower Developers
to infuse AI into their applications,
and we want to do that through
a rich tool ecosystem that allows
them to span the entire development workflow,
and at the same time,
do it in any platform and do it in an open source way.
>> Awesome.
>> Yeah.
>> So, is this for building actual bots?
Or is it for something more general than that?
>> Yeah, this is going to be for the entire workflow.
So, as a Developer approaches the build of the bot,
the construction of a bot,
there's various services that they're going
to need to build and construct.
>> Sure.
>> This tooling helps the developer through each stage of
that workflow to accomplish what
they're trying to accomplish faster.
>> I see. So, it's just like
tooling for me to get up and running.
So, can you explain to me a little bit
like what the process is,
so I can get a sense for how this goes?
>> Yeah. For instance, one of the first steps in
building out a bot might be the planning stage,
and during the planning stage,
there's going to be presentations
that you'll have to make for
business and for the stakeholders to pitch your idea.
Part of that is modeling conversations.
So, we have tools that enable that.
You might want to model
a very simple conversation that would involve a greeting,
or a more complex workflow which would involve,
for instance, booking a hotel
or booking a table at a cafe.
So, the idea is that you generate
a conversation from a Markdown file,
and then, use our chat down tool to take
that Markdown file and convert it into a transcript.
That transcript then is going to have
the conversation between the bot and the person.
From that transcript, you can import it into
the emulator and play it back,
and it would display exactly how the conversation
might look to the user communicating with that bot.
>> I see.
>> You can present that to your stakeholders,
present that to business
to really help them internalize the idea.
>> So, instead of coming with some really crazy workflow,
this is an example of what
a conversation might look like.
You upload it, and then, it does
its magic to do its thing.
>> Yeah. In a sense, yeah.
>> All right. Do you have something you can show us?
>> Yeah, and it's quite amazing that instead of
building the bot before gaining
buy-off from your management,
you can create this transcript file
with our tools, and certainly,
you can playback the conversation,
for example, in this case for booking a table,
without actually building the bot.
But you could show your management
how the experience is going to be,
and then, show how people will book a table.
And then, your management will
accept it or request changes,
and then, you can go to next stage,
which is to actually build your bot.
>> I see. So, this is more like
a modeling tool of what
your conversation could look like,
and everyone's like, yeah, looks great.
Move on or no. They're probably going to
ask this or do that. You should model it in there.
>> Exactly.
>> And the nice thing about it is that makes it
easy to go over
multiple scenarios to really
understand what different scenarios
would look like to the user.
>> I see. So, for this,
is this just a Markdown file that I upload somewhere?
>> Yeah. So, this is
the Markdown file that you would author by hand.
This Markdown file then becomes
the input to the chatdown CLI.
So, we can show
an example of how this might be used in the command line.
>> Let's do it.
>> So, you open up the command line, type chatdown.
There's various options that are available to
you for use within this tool.
What we're going to be doing is, we're going to be taking
our Markdown file as the chatdown input.
>> Okay.
>> And that file is going to then output a transcript,
and this transcript is simply an array of
activities that we can then
use to import into the emulator.
So, once we've created a transcript,
we import it into the emulator,
and we can see that it plays
back those activities within that transcript.
>> I see. So, this is just a way to visualize
an entire conversation with
exactly how it would look like in the chat bot.
>> Yeah.
>> This is really creating anything
other than, for the stakeholders,
you're able to see the flow and get by off immediately.
>> Right.
>> Yeah.
>> Okay.
>> But at this point, you
could buy it for your management.
You're ready to build your bot.
>> Right. Yeah, because you've got something tangible.
>> Yeah.
>> And what's the first step to build a bot?
A bot is a service that will understand natural language.
So, we need to build and
infuse natural language understanding into that bot.
>> Great. And so, usually, what I would do is,
I would do something with the bot
framework and set something up.
It's just you're telling me there's something you
can do in the CLI to help do this.
>> Yeah.
>> Cool.
>> So, we're going to run through this
entire process in CLI.
>> Oh, okay. This is kind of cool.
>> Yeah.
>> Like we're going to make the whole thing from soup
to nuts direct. Okay, let's see it.
>> Yeah. So, the first step to
understand language is to generate a LUIS model.
At Microsoft, we have our
Language Understanding Intelligence Service.
So, LUIS allows you to create a model and define intent,
which are user intentions.
For example, greet, say hi, and for each intent,
define utterances, which are ways
in you could show that intention, right?
So, here, I have an example.
In another Markdown file,
we really like Markdown,
so we're extending it to the maximum possible extent.
So, here is an example of a greeting.
So, to show the greet intent,
I have two examples,
which are hello and hi.
>> I see.
>> And this is
a very simple way to create something really complex,
which is a very complex machine learning model
that will understand human language for us.
>> Oh, I think I'm starting
to understand because traditionally,
I would go into LUIS,
I would type in all the things,
I would mark up the thing,
and then, I would train it.
You're saying now, with this,
you can just define them in
files that we're all comfortable with,
and then, push it up at our convenience later.
>> Exactly. Yes. And not only that,
from this command line,
so we have our Markdown, right?
From this Markdown, we can generate
a LUIS model using the LUDown command line tool.
And once we have the LUIS model,
we can further actually import this into LUIS.
So, this command will actually
be the same as going to a portal
and creating all intents and everything just in one line.
And actually, there's another thing called MS Bot here,
where I'm piping the output of importing the model and.
Do you know what that is, for instance?
>> Sure. Yeah. Yeah. The Emulator really is central to
the workflow within a developer when
going through the bot traveling process.
It enables various functionality
that will allow the developer to move
through the progression of concept
to actually communicating with a LUIS model.
The MS Bot command line tool
allows you to do a couple of things.
One of them is create a bot file,
which then becomes the project file
you use in your emulator.
It also allows you to connect services
like the LUIS service to that bot file,
so that you can then import that into
your emulator and see that service in action.
>> So, let me see if I understand this correctly.
The MS Bot is the bot emulator?
Or is it more than that?
>> It's more than that.
So the bot file is your project file,
and that's going to define services that are
available to the emulator to go out and
retrieve intense from the LUIS model
that you just uploaded, that you just trained.
>> I see. So there's a bot project,
we just gave LUIS some ideas on how
it needs to do the greetings, for example,
and then what we're doing is we're
importing those files in the LUIS,
outputting them into the MS Bot application,
which is going to let us see how that actually interacts.
>> Yes.
>> That's correct.
>> Got it. Okay. Cool.
>> One way I like to think about it,
about the solution file in , Visual Studio.
Your project, these are on
the Visual Studio solution, right?
>> I see.
>> In other case,
you are on the bot file.
>> So, does the bot file include
other services like LUIS and other things?
>> Yes.
>> Okay. That makes sense now.
>> Yeah.
>> MS Bot allows us to link
connected services to our bot.
Think about QnA Maker,
LUIS, other cognitive services.
In this case, we're showing LUIS as an example-.
>> Okay. Cool.
>> -but it's an extensible model.
>> That's amazing.
>> Yeah.
>> Cool. So, what happens when you run that MS Bot,
LUIS import application command line?
>> So, not only I imported LUIS,
but I also connected my bot to LUIS.
And when I go to emulator,
we can see what happens.
>> Cool. And so,
there's a bot, right?
>> So here, I have my cafebot.bot file that
was generated from connecting the bot to LUIS,
and I can open it in the emulator.
And here it is. And I can say hello to my bot.
>> I see.
So, what's going on here,
now, I'm slow so I'm glad you're here to help me.
So what you're doing is that
MS Bot generating that bot file,
and the entire project so that you
can run this in the emulator?
>> Yeah.
>> With the connected services in the background.
>> Exactly.
>> Yeah. It provides a really easy way for
the developer to create their project file,
to import services to it, and then,
very quickly, open it up in the emulator and see
the result of those services that they've had.
>> What other command line tools do you have?
It feels like you're running out everything here.
>> Yeah. And this is a very exciting moment, right?
Because we have our bot,
we built it, right?
And one other thing we would want to do,
maybe, is to deploy it.
>> Right.
>>We want to publish it to Azure.
We want to get in Azure.
And so for that,
we have a tool called AZ which is,
the Azure command line too, it's nothing new.
But now, we have the new bot option,
which allows us to perform a lot of operations on bots.
We could create and update bots,
but also we can publish our code to a bot,
we can link a bot to GitHub.
>> This is cool, because now,
I'm envisioning scenarios of like
DevOps scenarios where we're able to
pull in new bot information,
create new bots on the fly,
take down bots, et cetera.
>> Yeah.
>> Cool.
>> Exactly. And another new feature
that was very much requested,
and we are very happy to announce it now,
is that we are supporting
Managing Canons through command line.
That means that you can create a bot,
only once, you publish it only once, but then,
with a simple command, you can
enable your bot, let's say,
in Microsoft Teams, or in Skype, or in Facebook.
>> That's cool. One of the hard things is that each
one of these services has their own API or whatever.
The power of the bot framework
is it allows you to connect to any of them.
>> Exactly. So, if I may show just one command.
>> Absolutely, let's do it.
>> Let's say I have my bot and I want
to enable it for Microsoft Teams.
So, what I will do,
I will write az bot create Ms Teams create,
and then, I just need to pass bot name.
I have one bot I already created.
So,I pass by -n and my bot name,
and only with this command,
I will be able to, later,
go to a portal and
take it that actually my bot can talk through Teams,
so people can simply add
it in Microsoft Teams and talk to it.
>> That's cool.
>> Yes. And actually, I would like to show that.
>> Okay. Let's look at it.
>> Because here is my bot in the Azure poll,
and we can see that in the "Channels",
we have Microsoft Teams now.
We can open it in Teams,
and let's say hi to the Mr. Cafe bot.
>> So, how was it able to connect to your Teams account?
And usually, you have to put some kind of key,
you're doing some kind of log in.
How does it know the link to the right one?
>> So, a bot, one of
the core pieces of a bot is the Microsoft AppID.
The Microsoft AppID is tied to every bot,
and that connects us to all the Microsoft services.
That's why it's so seamless to enable a bot for a Skype,
for Teams, for all the services we provide.
>> Because it knows who the owner of that service is,
so it knows what other services are
attached that you can actually link to.
>> Yes.
>> Awesome. Well, what else do you have to show me?
>> That's pretty much it.
>> Yes. That's about it.
This tool chain is designed for the developer to help
them through every step for their workflow
and creating a bot,
designing it all the way through,
and get it into the emulator,
and something they can actually test,
and hammer on, and use.
>> The thing I like about this
and I can't stress this enough is
I'm always afraid to create
some new service and play with it there.
This is actually letting me run it on my machine with
my own files to get a feeling
for what it looks like before
I can push it up really easily.
>> Exactly. That's one of the great features.
You can start locally, then go to a cloud.
Or you could start in the cloud
and then bring it locally,
or start in the cloud or make it to
GitHub and suddenly have
continuous integration in the
whole team working on a bot.
>> And so, the LUIS stuff that you showed,
does it have like markdown for
other types of services
that you can add for like QnA Maker?
Or is it just that service that has it?
>> Yeah. So, the MS Bot CLI would allow you to add
services like QnA Maker, LUIS, Dispatch,
and some others that are connected services,
creates that project file,
and allows you to view those in the emulator itself.
>> And the other question I had is I saw,
did it actually create
the actual bot code for you as well?
>> Yes.
>> So, when you create a new bot
through the Azure command line,
you got an echo bot created for you,
and you can start from there,
or you can actually enlist,
in our open source,
bot framework sample rebot and
then you can clone any of those samples,
and publish it using the AZ bot publish,
so you never go out of the command line.
>> Which is super cool.
>>Yes.
>> And now, is it
the Node.js version or
the C# version? Which one? Do you get to pick?
>> Whichever you like.
>> Okay. This is awesome. Well, I love this.
I'm all about command line for
making things a little bit easier.
We've been learning all about this.
If you haven't done anything with chat bots,
I think now is the time to literally
start right now because we have some awesome tools.
>> Yes.
>> So thanks so much for spending some time with us.
>> Thank you.
>> Thank you so much for watching.
We're learning all about how
to create chat bots using the command line.
My name is Seth Juarez. This is the AI show.
Thanks for watching. We'll see you next time. Take care.