►
Description
This video is part 3 of a 3 part series on building conversational bots for Microsoft Teams. This part shows how to build a bot that takes commands using natural language with Adaptive Cards. You will learn how to use an adaptive card to capture information from a bot dialog, and how to update the adaptive card right in the Teams conversation to notify users of status changes. It also shows how to access Team roster using the Bot Builder SDK 4.6+.
Sample code in C# is provided; the concepts are the same in other languages.
Presenter: Bob German (Microsoft) | @Bob1German
Supporting materials:
• Adaptive Cards: https://adaptivecards.io
• 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
This
video
will
show
you
how
to
build
a
bot
that
takes
commands
using
natural
language
and
interacts
with
the
user
using
adaptive
cards
instead
of
a
continued
back
and
forth
dialogue.
I'll
show
you
how
to
use
an
adaptive
card
to
capture
information
within
a
bot.
Dialogue
I'll
also
show
you
how
to
access
the
team
roster
using
bot
builder,
SDK,
4.6
or
greater
and
I'll.
Show
you
how
to
update
an
adaptive
card.
That's
already
been
posted
in
the
team's
conversation.
So
let's
dive
in
so
team
supports
different
kinds
of
conversations.
A
You
can
have
multi
person,
conversations
in
teams,
channels
or
group
chat,
or
you
can
have
one-on-one
conversations
and
in
the
case
of
a
bot
that
really
allows
a
lot
more
complex,
back-and-forth
dialogue
between
the
user
and
the
bot.
If
multiple
people
are
involved,
you
want
to
limit
the
number
of
back-and-forth
interactions
and
make
sure
that
users
don't
get
confused
by
the
threading
in
teams.
Conversations
a
great
way
to
do.
This
is
with
adaptive
cards
and
that's
the
subject
of
this
video.
A
Now
I'll
recall
also
that
Lewis
is
a
great
way
to
get
started
for
your
bot
to
take
something
that
the
user
has
typed
and
interpret
it,
and
Louis
will
give
us
back
an
intent
and
some
entities
like
a
Dallas
to
the
contoso
project.
The
intent
is
to
add
someone
to
a
project
and
Alice
and
contoso
are
the
entities
that
we
need
to
to
actually
carry
out
that
action.
A
Ultimately
we're
trying
to
build
up
the
request,
information
on
the
write,
the
project
ID,
the
person
being
added
the
role
that
they're
going
to
take
and
three
months
of
forecasted
hours
so
that
we
can
budget
for
their
work.
Now
Louis
isn't
going
to
give
us
that
back
perfectly,
but
we
want
to
take
as
much
as
we
can
from
what
Louis
said
and
similar
to
the
conversational
bot
example
we're
going
to
refine
it
using
a
dialogue,
that's
gonna
prompt
for
any
missing
entities
and
resolve
and
disambiguate
the
entities.
A
The
difference
is,
in
this
case
I'll
use
adaptive
cards
instead
of
natural
language
conversation
to
do
the
disambiguation
and
the
prompting.
So,
let's
look
at
an
example:
we're
gonna
go
to
the
consulting
but
and
say
add
Alice
to
contoso,
and
we
get
back
an
adaptive
card,
so
it
actually
figured
out
some
of
the
information
it
figured
out.
That
contoso
was
the
client
name
and
that
alice
is
the
name
of
the
consultant,
and
but
there
are
two
Alice's
on
our
team.
A
So
I
can
now
disambiguate
that
here
on
the
card-
and
there
are
two
contoso
projects,
so
I
can
pick
the
right
one
and
then
also
easily
capture
all
the
other
information
that
I
need.
Now
the
user
here
isn't
going
to
get
confused
by
threading
or
having
to
add
mention
the
consulting
bot.
All
I
have
to
do
is
click
Submit
and
the
job
is
done
and
the
whole
team
can
see
what
happened
because
the
form
has
been
replaced
with
a
little
confirmation
card.
A
Saying:
hey
Alice
is
joining
our
project
and
here's
how
many
hours
she'll
have
available.
So
let's
do
a
code
walkthrough
and
you
can
get
the
code
at
HTTP
AKA.
Ms
slash
consulting
bob.
Also
here
are
a
couple
of
other
videos
that
I'm
assuming
that
you've
watched
and
understood
before.
You'll
really
understand
this,
this
code
walkthrough.
A
The
second
turn
it
sent
an
invoke
activity
back
to
the
bot,
which
then
took
the
information
that
I
had
selected
added
Alice
to
the
project
and
responded
with
a
second
card,
and
it
updated
and
I'll
show
you
the
code
for
this.
It
updated
the
first
card
and
replaced
it
with
the
second
card
so
that
it
would
sort
of
confirm
it
and
not
create
a
confusing
situation
with
perhaps
multiple
people
submitting
different
things
to
the
bot
okay.
So
let's
kind
of
trace
through
the
code.
A
So
it
begins
here
in
the
bot
controller,
so
this
is
sort
of
a
standard,
MVC
web
api
type
of
thing,
and
it's
going
to
get
passed.
The
bot
adapter
and
the
bot
has
through
dependency
injection
and
as
soon
as
it
sees
a
post
here
at
API
slush
messages.
That's
where
that's
been
coming
from.
In
some
of
the
other
demos,
it's
gonna
call
the
adapter
and
pass
in
the
bottom,
along
with
the
HTTP
request
and
response
object.
So
then
the
adapter
is
going
to
now
turn
that
into
something
that
the
bot
can
understand.
A
So
here's
my
bot
and
it
implements-
let's
see
it-
inherits
from
teams
activity
handler,
which
means
that
it
is
handling
activities
from
about
channel
service,
and
it
is
aware
of
Microsoft
teams,
which
is
important,
of
course,
so
inside
of
our
bot,
we're
gonna
override
a
method
called
on
turn
async.
This
gets
fired
every
time.
A
new
turn
begins,
and
so
this
is
what's
going
to
get
called
when
the
controller
gets.
A
That
message
from
my
first
turn
now,
in
this
case
I'm
gonna,
let
the
base
class
take
care
of
most
of
the
details
and
that's
going
to
call
quite
a
number
of
different
overrides
depending
on
what
the
activity
is.
That's
beginning
the
turn,
and
then
it's
going
to
save
away
our
state
so
that
we
don't
so
that
we
can
save
our
dialogue
state
from
any
dialogues
that
have
run
inside
the
bot.
A
This
waterfall
is
going
to
begin
by
checking
and
make
sure
making
sure
that
Luis
is
set
up
and
if
it
is
which
it
was
during
the
demo,
it's
gonna
call
Luis
and
figure
out
what
the
intent
was
now.
Remember
that
my
Louis
project
recognizer.
This
is
something
I
demoed
in
an
earlier
video.
It's
gonna
try
to
get
as
much
information
as
it
can
and
put
it
into
a
request.
Details
object
so
that
I
can
disambiguation.
A
A
So
then
it
will
begin
the
add
to
project
dialogue
now,
keep
in
mind
we're
still
in
the
same
turn
we're
still
in
that
same
first
turn
as
we
come
down
here
and
now
we're
at
the
first
step
of
the
add
to
project
dialogue,
which
is
another
waterfall
dialogue.
This
little
scheme
will
only
work
if
we
have
a
project
name.
A
So
we're
gonna,
try
it
whatever
the
user,
whatever
came
back
from
Luis
or
whatever
is
going
to
be
retried
here
using
this
retry
prompt
right,
we're
going
to
go
in
and
try
to
resolve
that
and
when
we
finally
get
a
project
that
is
in
the
database
or
that
matches
something
in
the
database,
then
we'll
display
the
ad
to
project
card.
So
what
this
does
is
I've
got
a
little
card
class
over
here,
actually
before
I.
A
For
this
project
name
and
return
as
best
as
it
can,
a
list
of
consulting
projects
which
is
part
of
my
data
model
and
resolve
person
is
going
to
try
to
resolve
the
person
name
who
I,
typed
and
I'll,
show
you
that,
because
it's
kind
of
interesting,
because
it
actually
pulls
the
people
out
of
Microsoft
teams.
So
this
is
going
to
return
a
list
of
person
objects
where
that's
also
part
of
my
data
model
person
and
the
way
it's
going
to
do
it.
A
Is
it's
going
to
go
to
teams
info
dot,
get
members
async,
so
there's
other
things
you
can
get
here
out
of
teams
info.
This
is
the
bot
SDK
knowing
fully
about
the
team
that
it's
running
in,
which
is
really
cool
that
it's
all
done
by
this
one
SDK,
so
I
get
back
a
list
of
members
and
lowercase
them
and
I
look
for
any
matches
between
what
the
user
typed
and
the
members
in
the
team.
A
So
if
you
remember
I
said
at
Alice-
and
there
were
a
couple
of
options
for
Alice,
because
we
had
two
different
people
named
Alice
on
the
team
and
I
also
typed
contoso,
and
there
were
two
different
projects
that
were
from
contoso
as
the
client.
So
that's
how
my
card
really
got
multiple
choices
for
the
project
and
multiple
choices
for
the
person
it
was
refined
down
as
best
we
could
from
what
the
user
typed
originally
now
I'm
going
to
call
I'm
going
to
go
to
my
own
class
called
add
to
project
card
now.
A
This
is
where
we're
sort
of
leaving
the
the
sort
of
standard
pattern
that
comes,
in
my
case,
I
start
with
the
core
bot
a
wolf
long
while
back
and
we're
leaving
the
the
the
normal
dialog
flow
and
going
into
I.
Guess
I'll
just
say
that
you
may
come
up
with
a
better
way
of
factoring
this
I
just
decided
that
cards
should
be
encapsulated
in
a
class.
So
that's
the
way.
A
I,
did
it
here
and
you'll
see
that
in
my
pattern
here,
which
you
can
copy
or
not,
what
I
did
was
I
made
a
unique
constant
for
the
submission
ID
so
that
when
somebody
submits
the
card,
I
can
tell
which
card
got
some
minute
and
then
I'm
going
to
use
the
adaptive
card
SDK
to
build
up
this
card.
So
I've
put
the
template
into
anis
into
a
resource
inside
of
dotnet.
A
So
it
comes
in
here
as
a
resource
stream,
and
here
is
the
add,
to
project
card
template
right,
and
so
you
can
play
with
this
inside
of
the
adaptive
card
designer
and
get
it
to
look
the
way
you
want
by
just
putting
in
the
data,
which
is
that
same
data
model
of
the
project
request
or
the
consulting
request
details.
So
I'll
go
ahead
and
bind
that
before
I
did
that
I
had
to
figure
out
what
is
for
the
forecast
of
the
next
three
months.
A
I
had
to
go
actually
compute
and
I
won't
bore
you
with
this
code,
but
it's
just
kind
of
crunching
through
a
little
bit
of
calendar
arithmetic
to
figure
out
what
are
the
next
three
months.
So
I
could
put
that
into
the
form
and
there's
my
data
and
I'm
gonna
call
the
adaptive
transformer
and
line
36
binds
the
data.
So
that's
my
same
consulting
request
details
that
we've
been
working
with
also
in
the
conversational
bot
same
same
data
structure.
A
It's
going
to
bind
that
into
the
template
and
give
me
back
an
adaptive
card
that
I
can
return.
So
the
dyad
to
project
dialog
gets
that
but
creates
a
reply
to
from
my
turn.
So
the
the
a
Dallas
to
contoso
message,
I'm
now
making
a
reply
to
that,
adding
the
project
card
as
an
attachment
and
sending
that
off
back
to
the
user,
and
at
this
point
the
turn
will
end.
A
A
A
I
will
check
that
and
if
it
works,
I'm
gonna
actually
return
this.
Whatever
the
card
itself
passes
in
so
again,
this
is
my
little
pattern
for
doing
it,
but
I
wanted
to
encapsulate
the
card
rendering
and
the
submit
logic.
So
I'm
gonna
go
back
to
that
same
static
class.
For
the
add
project
card
and
let
it
decide
how
to
respond
to
somebody
clicking
on
the
button.
So
let's
come
back
here
and
look
at
this
on
submit
method
and
it'll
do
a
little
checking.
You
know.
A
Let's
make
sure
it
really
is
a
submit
and
I'm
going
to
get
now
the
confirmation
card
and
and
fill
that
and
there's
so
the
same
pattern
here
for
the
confirmation
card
right:
here's,
the
template,
JSON
and
here's
its
class
and
so
get
card
async
for
it.
For
that
one
is
a
little
bit
simpler.
It's
just
going
to
take
the
data
that
it
got
back
from
the
first
card
and
bind
that
to
the
template
and
that's
how
I
made
the
confirmation
card.
A
A
It's
just
mocked
up
data,
but
I
think
you
can
hopefully
follow
how
you
would
build
this
sort
of
thing
with
real
data,
updating
it
at
you
know
after
the
users
submitted
notice
that
by
calling
online
52
update
activity
async
instead
of
send
activity
async
that
will
replace
the
old
card
with
the
confirmation
card,
thanks
for
watching
this
Microsoft
365
patterns
and
practices.
Video,
if
you
like
this
video,
please
subscribe
to
the
patterns
and
practices
youtube
channel
at
AKA,
ms
slash
SP,
p,
NP
of
videos,
I'm
bob
german!