►
Description
This video is part 2 of a 3 part series on building conversational bots for Microsoft Teams. This part introduces the concept of bot dialogs and shows how to use them to prompt users for any missing or ambiguous information in their request. Sample code in C# is provided; the concepts are the same in other languages.
Presenter: Bob German (Microsoft) | @Bob1German
Supporting materials:
• Sample bot code: https://aka.ms/ConsultingBot
• Microsoft Bot Framework: https://dev.botframework.com/
• Teams Dev Center: https://developer.microsoft.com/en-us/microsoft-teams
PnP videos for Teams developers: https://www.youtube.com/playlist?list=PLR9nK3mnD-OWG3R399jMSrt1eFa5KErvc
PnP videos for Teams low-code developers: https://www.youtube.com/playlist?list=PLR9nK3mnD-OUEuwES5Zn66qUdUdD60PCZ
A
Hi,
my
name
is
Bob
German
in
this
video
is
building
a
conversational
bot
for
Microsoft
teams.
Part
two
in
the
last
video
I
showed
you
how
to
use
Louis
a
language
understanding
intelligent
service
to
predict
what
a
user
is
asking
the
bot
to
do
and
to
extract
information
called
entities
from
the
request
in
this
video
I'll
show
you
how
to
work
with
dialogues
so
that
you
can
interact
with
the
user
to
determine
exactly
what
the
user
wants.
A
A
Here's
an
example
I'm
entering
my
hours
as
a
consultant
and
I,
just
put
it
in
my
own
language
and
the
bot
understands
and
goes
ahead
and
bills
the
client
or,
if
I,
leave
out
information.
The
bot
will
prompt
me
for
anything.
That's
missing
so
here
I've
left
out
the
project
name
and
there
were
actually
two
projects
for
contoso,
so
it
dis
ambiguities
and
then
it
asks
me
for
every
other
detail
that
it
needs
until
it
builds
up
the
request
which
can
now
be
built
to
the
back
end.
A
Assuming
we
have
an
idea
of
the
intent
we
can
prompt
the
user
for
any
missing
entities
or
any
ambiguous
ones,
which
is
a
lot
better
than
just
giving
the
user
an
or
and
making
them
start
again.
Finally,
we
want
to
build
up
the
information
we
need
to
do
the
requested
action
in
this
case
that
information
is
in
the
white
box
on
the
right.
We
need
the
project
ID
number
of
minutes
and
the
date
the
work
was
delivered
in
order
to
build
a
client
recall
that
bots
interact
in
the
form
of
turns.
A
This
is
done
through
the
bot,
DK
concept
of
dialogues,
for
example,
suppose
I
said
I
want
pizza
and
the
bot
responded
what
kind
it
needs
to
know
because
it
doesn't
have
the
entity
value
for
the
flavor
of
pizza,
so
I
say
pepperoni
now,
if
another
web
server
happens
to
get
that
utterance
pepperoni.
What
am
I
talking
about?
How
does
it
know
that
I'm
ordering
a
pizza?
A
It's
a
dialogue,
that's
going
to
orchestrate
the
turns
and
correlate
the
information
so
that
it
will
remember
that
we're
talking
about
a
pizza
order
here
and
that
pepperoni
is
one
of
the
flavors.
Then
it
can
respond
with
another
piece
of
missing
information,
large
or
small
I
can
answer,
and
ultimately
the
dialogue
can
complete
when
it
finally
has
all
the
necessary
information.
A
There
are
a
lot
of
built
in
dialogues
in
the
bot
SDK.
You
can
see
on
the
right
text
number
date
time.
These
are
all
that
just
go
and
prompt
the
user
for
one
piece
of
information
and
return
it
back
to
the
caller.
These
are
all
called
prompt
dialogues.
The
other
two
major
types
of
dialogues
are
waterfall
dialogues
which
lead
to
the
user
through
a
sequence
of
steps,
and
that's
what
we're
going
to
use
in
this
case
or
component
dialogues
which
are
general-purpose
empty
dialogues
that
you
can
do
what
you
wish.
A
A
In
that
case,
I
might
use
table
storage
or
Cosmos
dB,
then
I'm
going
to
create
user
state,
so
keeping
track
of
the
state
of
the
users
of
the
bot
and
conversation
state.
These
will
be
passed
into
the
bot
using
dependency
injection,
so
you
can
see
them
here
coming
into
the
constructor
of
the
bot
conversation
state
user
state
coming
in
and
now
what
I'm
going
to
do
is
override
the
on
turn,
async
function,
which
gets
called
when
by
the
bot
framework
whenever
a
new
activity
comes
from
the
channel.
A
The
first
thing
it's
going
to
do
is
on
line
46,
it's
going
to
call
the
base
class,
which
will
actually
dispatch
this
out
to
any
one
of
a
number
of
different
functions
depending
on
what
kind
of
activity
it
was.
So
is
it
a
message,
activity
and
invoke
activity
or
a
conversation,
update
activity
or
something
else
then
I'm
going
to
save
the
state.
A
So
this
is
really
important
right
after
I've
handled
any
of
these
types
of
activity,
I
want
to
make
sure
that
I
write
the
state
back
to
any
persistent
database
that
might
be
storing
the
state.
So
that's
what's
going
on
in
line
four
9:50,
so
dialogue,
the
dialogue
system
and
my
code
can
just
update
the
state
and
know
that
it's
eventually
going
to
be
updated
at
the
end
of
the
turn.
A
So
here's
the
main
dialogue
and
if
you
look
at
its
constructor,
you
might
notice
that
it's
going
to
create
all
the
child
dialogues
that
it
might
use.
Now.
This
is
required
by
the
bot
SDK.
The
SDK
will
serialize
and
deserialize
the
entire
hierarchy
of
dialogues
and
all
their
state
for
you,
which
is
just
wonderful,
but
they
do
require
that
you
instantiate
all
of
the
child
dialogues
in
each
constructor
so
that,
basically,
when
it
calls
the
constructor
of
your
route
dialogue,
it's
gonna
eventually
build
the
entire
hierarchy
for
you
right
there
on
the
spot.
A
The
first
step
is
going
to
check
and
see
if
Luis
is
configured
and
if
we're
missing
the
app
ID
or
key
or
host
name,
then
we're
gonna
output,
a
message
and
prompt
the
user
to
fix
the
problem
and
then
we'll
go
on
to
the
next
step
in
the
waterfall
right.
If
we
do
have
the
Luis
information,
then
we'll
go
ahead
and
call
Luis
and
request
the
details
and
keep
in
mind
that
what
we're
doing
here
is
building
up
these
consulting
request
details,
which
is
the
information
that
we
need
to
update.
A
The
billing
system,
right
so
Luis,
will
come
in
with
some
of
that
information,
but
not
all
of
it.
Now
what
I'll
do
is
I'll
go
ahead
and
based
on
the
intent
that
I
got
from
Louis
called
the
ad
project
dialog
or
the
built
a
project
dialog
passing
in
those
requests
details
by
returning
the
begin
dialog
async
function.
It
will
actually
go
to
the
next
step
of
this
dialogue
automatically
when
those
child
dialogues
complete.
A
So
if
I
had
the
billing
or
the
an
to
project
dialogue,
if
that
succeeded,
it
would
have
put
the
result
of
the
updated
request
details
into
my
step
context
and
then
I
would
get
that
as
the
result
and
now
I
can
check
and
see
what
I
got
back.
So
if
I
got
it,
if
I
had
an
ad
project
or
build
a
project,
then
there's
really
nothing
else.
To
do
if
I
don't
have
either
of
those
then
I'm
gonna
have
to
handle
this
by
outputting.
A
A
generic
message,
in
this
case
I'll
use
Q&A
maker
to
do
that.
So
here,
finally,
is
the
built
to
dialog
project,
and
you
can
see
that
it's
creating
quite
a
lot
of
child
dialogues
in
its
constructor,
as
well
as
a
waterfall
dialogue.
That
might
look
a
little
familiar
remember.
The
first
thing
we
would
ask
for
if
we
needed
it
was
the
project
and
then
we
might
disambiguate
the
project
and
then
ask
for
the
time
worked.
A
Well,
these
are
the
exact
steps
at
the
end
we're
going
to
reconfirm-
and
it's
always
good
to
confirm
before
you
update
the
backend
system
and
then
finalize
so
which
would
be
actually
updating
the
backend
system.
So
here's
the
first
step
and
we're
going
to
come
in
and
the
request
details
that
we
passed
in
are
going
to
be
in
step,
context,
options
and
assuming
that
we
got
that
back,
we're
gonna
go
ahead
and
call
a
method
called
a
resolved
project.
A
Now
result
project
will
go
back
to
the
database
and
try
to
find
projects
containing
the
name
that
the
user
typed.
If
nothing
comes
back,
then
we're
going
to
prompt
the
user
and
here's
where
we're
going
to
prompt
we're
going
to
return
the
dialogue.
So
whatever
this
dialogue
does
is
going
to
move
us
to
the
next
step,
we're
going
to
return
this
dialogue,
which
is
going
to
prompt
the
user
for
the
project
name
and
you
notice
that
here
is
the
project
name
a
retry.
A
So
if
we
didn't
get
one,
the
prompt
dialogue
is
smart
enough
to
retry,
and
if
we
had
one
or
more
projects
come
back
from
a
result
project,
then
we
just
go
ahead
and
move
to
the
next
step.
So,
as
you
can
see,
I
don't
have
to
actually
send
any
messages
back
or
wait
for
another
turn.
I
can
move
to
the
next
step
of
the
waterfall
dialogue
in
this
same
turn,
without
any
interaction
at
all.
In
this
case,
if
we
had
the
information
we
needed,
there's
no
need
for
any
of
that
interaction.
A
So
now
step
two
is
going
to
disambiguate
the
project.
So
we're
going
to
go
to
get
the
request
details
again
we're
going
to
get
the
result,
which
is
what
came
back
from
the
last
step,
is
going
to
be
the
project
and
if
the
result
is
no,
then
we're
going
to
go
ahead
and
grab
the
project
and
call
result
project
again
and
if
it's
greater
than
one
we're
going
to
ask
and
prompt
set
up
a
choice,
prompt
and
say:
hey
user,
which
one
of
these
projects
did
you
mean
right?
A
If
we
got
exactly
one
project
back,
then
we're
happy
and
we'll
just
take
the
first
one
and
fill
all
that
in
and
return
that
now
for
the
next
step,
which
expects
a
found
choice,
object
which
happens
to
be
what
the
choice
dialogue
would
have
responded
or
what
we
didn't
need.
The
choice,
dialogue,
what
we
provided
here
in
the
else
clause.
A
So
this
is
just
going
to
kind
of
keep
going
down
and
each
step
we're
going
to
request
we're
going
to
see
if
we
have
a
piece
of
data
and
if
we
don't
we're
going
to
prompt
the
user
and
the
prompt
dialog
will
return
the
answer
or
the
response
back
to
the
next
step.
If
we
do
we'll
just
go
to
the
next
step
ourselves
and
pass
in
the
result
directly
so
that
we
don't
actually
have
to
interact
with
the
user
for
that
one,
so
that's
how
this
works.
A
It
goes
all
the
way
through
to
the
end,
using
this
method.
If
you
want
to
get
started
with
this
whole
approach,
I
recommend,
beginning
with
the
core
bot
template
in
either
c-sharp
or
JavaScript
or
typescript,
which
actually
sets
up
a
simple
lewis
model
and
a
couple
of
waterfall
dialogues
to
lead
you
through
a
very
simplified
airline
booking
thanks
for
watching
this
Microsoft
3
sixty-five
patterns
and
practices.
Video,
if
you
like
this
video,
please
subscribe
to
the
patterns
and
practices
youtube
channel
at
AKA,
ms
/
SP,
p
NP
of
videos,
I'm
bob
german.