Let's talk for a moment about how to know when a question should be handled by

the Conversation Service versus when it should handled by Discovery.

It all boils down to how confident Watson is with its responses.

Take a look at this graphic.

Notice that the frequently asked questions, the common questions,

are those that take place within the short tail of the distribution.

This is where the Conversation Service excels.

As questions become more esoteric and uncommon,

then we rush to the aid of the Discovery Service.

>> Now that reminds of an example here at Treehouse, right?

We could think of students asking very targeted questions

needing help learning programming.

They may say, what's the key word for a four loop in Javascript?

And that would something that we could easily answer and anticipate.

But then we get some other questions that would be either more obscure and

less frequent, or more like you said, esoteric, like

what's some advice for how to get unstuck when I'm working on a problem.

And for that kind of thing, maybe we could, upload, for example,

blog data that we have where we have host-related that kind of thing,

whether it's the Treehouse Blog or elsewhere.

Does that make sense?

>> Absolutely, what a great example that was, yes.

>> Okay, so we're back at our page and we can test this out.

Let's try asking our chatbot to find me an apartment.

Okay, so notice that we see the response about our chatbot's capabilities.

Let's take a look at the intent back here in our Conversation tab.

So if you remember, these capabilities are what we imported from the sample.

And actually, if you take a look at what we imported,

you can see there's a bunch of extra statements in here that

don't really have anything to do with what our chatbot's capabilities are, so

this is a little bit messy, because it's a test, a sample instance.

So, at this point let's just delete this.

We don't really need this anyhow, although you could pretty easily recreate this with

a more simplified set of intents here.

So I'm just going to click on the trash can over here to delete the intent,

yes, delete it.

And we'd like to do the same thing here for the entities,

let's delete anything related to capabilities.

And finally, in our dialog node, we did create an extra node for capabilities.

I'm going to delete this as well.

All right, let's try this again, find me an apartment.

Okay, so this is interesting.

I actually didn't expect this to match and

flip over to the Discovery Service just yet.

So let's take a look at the output from Conversation Service to see what happened.

Okay, so here in the terminal console,

this is where we are logging output from the Conversation Service.

And here we can see that it matched on the turn on intent with a confidence of,

yeah, 0.29, it was a really low confidence.

So we said find me an apartment and our chatbot understood what we were saying,

and it was like maybe they're trying to turn something on.

I guess it's very low confidence, it's a very low score.

But that is below the threshold, so

sure enough it went over to the Discovery Service.

In the conversation flow it ended up in the anything else node,

which it would have said, I didn't understand, you can try rephrasing.

But because we passed it over to Discovery it did run the query

that said find me an apartment.

So we want to train our Conversation Service at least a little bit

on how to handle this new kind of request.

So back here let's add a new intent, and

what we're going to do is create a new one to find things for us.

So let's call it a find intent, and lets add a few examples.

We'll say find me something, look for something, I need, maybe.

Locate, and how about find a.

Just a couple different ways.

And looks like I have a typo so I'm going to come back here.

Gonna delete find me and retype it as find me.

Yeah, okay, so this can be a little bit confusing.

In fact, I had some trouble trying to understand exactly when to use intents

like this and when and how to flip over to the Discovery Service.

And this is one of the things that there's no, or

at least there's not always a clear right answer for, in developing a chatbot.

When we know exactly what the user is looking for,

we do wanna be programmatic about it, like this, on the Conversation side of things.

When we are less certain in how we want it to respond, that's when we need to flip it

over to Discovery and somehow tie into a broader data set.

So what we're doing here is creating this new intent, and

we're going to do an example to find a couple of things,

very basic finding, but then when we ask for lodging or an apartment,

the confidence will fall and it will flip over to Discovery.

Alright so to continue this example, let's add some entities here,

we'll create a new one.

And we'll call these locations, and lets add a couple things in here first.

Lets do a gas station.

So for the synonyms lets say gas, fuels,

fueling station, and then lets add another value.

Lets do a hotel.

And for synonyms let's say motel, resort, and

how about place to stay, and bed and breakfast.

So, let's complete this with a dialogue and we'll make this real simple.

I'm gonna add a new node below turn on.

This one, let's name this based on the intent, name this find,

and the bot recognizes our find intent and

it matches on one of our location entities, at locations, any of those.

Then we will respond with just something generic.

Let me see what I can find.

Okay, so if we open this, we can see that Watson is training on this new data.

And now it's done, and we can try this out.

Say find me a gas station.

And it matches on the find intent, knows the location was gas station,

and it says let me see what I can find okay.

All right so I'm gonna refresh to clear the page, and

let's try that down here the same thing, find me a gas station.

And we get the same response, let me see what I can find.

All right how about locate a hotel.

Okay, cool, so again, this is exactly what we just programmed.

But now, let's try it with something a little more vague.

Let's say, I'd like a place to stay near Central Park.

Well, interesting, it says it doesn't understand.

So, what exactly is happening?

If we scroll down, It didn't match on any intent at all.

So because I said I'd like, it doesn't know that we're trying to find something,

and it certainly doesn't match the turn on intent,

so it's kind of just lost without any kind of intent.

Interestingly, it did match our locations and hotel,

and that's because place to stay is a synonym for hotel.

So we could go and add this to our intent, or we could maybe try to control for

this a little bit differently.

But for now, I just want to try asking this in a different way.

Let's say, I'd like an AirBnb near Central Park.

Okay cool success.

All right check it out, we have in the responses, we have the title

of an AirBnb listing, and we have a review, this is the actual review text.

This is what we fed to our Discovery Service, and

there should be three of these.

So here's the second one, best deal, and if we scroll down there

should be one more, and yeah notice that these are all by Central Park.

In fact because these are individual reviews, we have two different reviews for

the same one.

So first, we need to look at the console.

So here we have the response from the Conversation Service and

it matched on the find intent, but as we wanted it to with a very low confidence.

So again, because we didn't have the language to match I'd like, and

because we didn't say hotel, or place to stay, or gas station.

It's trying to figure out what we want, but

it's just not very confident that it knows.

And in that case, it's like, alright,

well I'm gonna go over to the Discovery Service.

So then, over here, on the right side,

we can see the response from the Discovery Service.

And it has our input text, and it has a bit of information about the service and

the collection, and here is the output.

And we asked for three results which we got.

We have a listing name, we have some details about the listing, and

if we scroll through there are different things that are interesting to look about

for how to Discovery returns data.

There are different entities, you can see there's a person entity,

there are location entities, information about New York City.

Again, this was all pulled from the documents,

from the review documents that we fed to our collection.

And a lot of this extra information is because the Discovery Service

is hooked into other information sources.

So you can see there are even links to different pieces from the reviews that we

can tie into if we wanted to.

Let's try another example over here, let's say this time,

show me some good places to stay near Times Square.

Okay, and again, this was vague enough to flip over to Discovery, so

here we have a little bit of a different result.

So it tried to match on the turn on intent, because we said show me, it really

wasn't exactly sure what we were after and it was really low confidence in that.

So again, it flipped over to Discovery and, once again,

if we take a look on the right if we scroll down a bit,

there are different parts here that show the different entities.

And if you look, you can see things like it'll mention Time Square like this.

It matched it from the review.

So you should try this out with some different landmarks in New York City,

maybe some different ways of asking the question.

In fact, figuring out how to ask the question and how not to ask the question

was a little bit confusing for me and still trips me up from time to time.

And that's one of the things that has been hard for me to wrap my head around.

Because programming for this type of stuff is a little bit different than

more typical programming that I'm used to at least where we are giving

very specific questions and answers, very specific control flow.

So this kind of chatbot development requires a lot of testing and tweaking and

modifying, so if you think of different ways to say something

then you may want to program that into the Conversation Service.

It's also worth talking about how there isn't just one way to use

the Discovery Service.

You should follow your intuition and make it work for your chatbot or for your uses,

however you need to.

So in this case we are looking at the intent confidence,

and we would want to build up different intents and add more user examples.

But for now, we can see how we can get to a low confidence in a matched intent,

and we can query Discovery for help.

Now another way you might tackle this problem,

just if you have data that you're usign from Discovery.

You may want to set up an intent specifically

to relay the request to Discovery.

So you could imagine expanding our scenario, we could take this, find intent.

We could look at the location that was matched, and if it was a hotel or

a place to stay, if we made the synonyms match on that, we could look at that,

analyze it, and then we could In that case, pass over the attributes and

go into the Discovery Service.

This is actually how the food coach example is setup,

the food coach that we saw earlier.

It uses a dialog node to branch conversation into a Discovery Service.