{"id":2139,"date":"2016-09-12T17:00:00","date_gmt":"2016-09-12T17:00:00","guid":{"rendered":"https:\/\/www.microsoft.com\/reallifecode\/index.php\/2016\/09\/12\/servicing-faq-style-content-through-a-conversational-interface\/"},"modified":"2020-03-15T07:09:44","modified_gmt":"2020-03-15T14:09:44","slug":"servicing-faq-style-content-through-a-conversational-interface","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/ise\/servicing-faq-style-content-through-a-conversational-interface\/","title":{"rendered":"Servicing FAQ-Style Content Through a Conversational Interface"},"content":{"rendered":"

Background<\/h2>\n

Recent advances in Machine Learning coupled with the growing ubiquity of instant messaging apps have revived interest in the decades-old concept of chatbots, now more commonly known as \u2018bots\u2019.<\/p>\n

Microsoft has taken a leading position in this field with the release of the Bot Framework SDK<\/a> and LUIS<\/a> language understanding service.<\/p>\n

However developing for natural language can still be daunting when approaching the field for the first time. We present below an example of integrating an existing natural language powered service in order to serve structured, FAQ-style content through a conversational interface.<\/p>\n

The Problem<\/h2>\n

During a recent customer engagement we were asked to explore the possibility of publishing existing FAQ-style content via a conversational interface.<\/p>\n

Common with almost every consumer-facing business, our customer\u2019s call centre staff were spending significant amounts of their time answering simple queries that could otherwise have been found on the company\u2019s web site. Perhaps serving this content via a conversational interface could give customers a lower friction method to directly find the answers to their questions rather than searching a potentially long list of questions looking for a match.<\/p>\n

In addition, once made available through the Bot Framework, the same content can be simultaneously published to a wide variety of channels in a manner that makes detailed usage feedback almost trivial to collect.<\/p>\n

With only two days to complete the engagement we were concerned that a traditional approach involving building domain-specific language understanding models would prove too labour intensive. We needed to pull a rabbit out of a hat somehow. Step forward QnA Maker<\/a>.<\/p>\n

Outline Solution<\/h2>\n

The QnA Maker<\/a> service lets you easily create a knowledge base from existing online and editorial sources. You can tweak and train the responses and when satisfied with their quality, publish to an endpoint that can be accessed from your Bot. The service behind that endpoint takes care of all the complex natural language processing tasks needed to understand the question and returns the best answer it can find in the knowledge base.<\/p>\n

Calling the service is done through a super simple HTTP call. You can even call it directly from your browser:<\/p>\n

http:\/\/qnaservice.cloudapp.net\/KBService.svc\/GetAnswer?kbId=a3dae93561d24529b11a4c0eb8acd444&question=What%20is%20cortana<\/a><\/sub><\/p>\n

This makes publishing our FAQ almost trivial from within a Bot application and the top-level architecture similarly, extremely simple;<\/p>\n

\"Image<\/p>\n

At its most basic level all we have to do is pass any message the user asks straight through to the QnA Maker service and return the response, after a little processing, directly back to the user.<\/p>\n

In Node, our target language for this project, this is very simple:<\/p>\n

\n
\r\nvar<\/span> q<\/span> =<\/span> querystring<\/span>.<\/span>escape<\/span>(<\/span>'What is cortana?'<\/span>);<\/span>\r\n\/\/ Using the request library here to simplify calling the QnA service <\/span>\r\nrequest<\/span>(<\/span>config<\/span>.<\/span>get<\/span>(<\/span>'qnaUri'<\/span>)<\/span> +<\/span> q<\/span>,<\/span> function<\/span> (<\/span>error<\/span>,<\/span> response<\/span>,<\/span> body<\/span>)<\/span> {<\/span>\r\n  session<\/span>.<\/span>send<\/span>(<\/span>response<\/span>.<\/span>answer<\/span>);<\/span> \r\n});<\/span>\r\n\r\n<\/code><\/pre>\n<\/div>\n
where \u2018qnaUri\u2019 is our QnA service endpoint and \u2018q\u2019 is the verbatim, URI-escaped question.<\/p>\n
Of course we can add as much extra complexity to the system as we wish, additional commands and logging of user behaviour perhaps, but at it\u2019s core the solution really isn\u2019t much more complex than what we\u2019ve already shown, in fact the near-minimal implementation to just around 100 lines. Wow! That\u2019s some heavy lifting the Bot Framework and the QnA Maker are already doing for us.<\/p>\n
Implementation<\/h2>\n
The minimal implementation of the complete QnA bot runs to just around a hundred lines of code:<\/p>\n
\n
'use strict'<\/span>;<\/span>\r\n\r\n\/*\r\n  qnamakerbot - Minimal demo of integrating a bot with the QnA Maker \r\n  (https:\/\/qnamaker.botframework.com\/). \r\n\r\n  Uses the following libraries:\r\n\r\n  request (https:\/\/www.npmjs.com\/package\/request) - Simplifies calling HTTP services.\r\n  querystring (https:\/\/www.npmjs.com\/package\/query-string) - Escapes text strings suitable for using in HTTP queries.\r\n  restify (https:\/\/www.npmjs.com\/package\/restify) - Framework to simplify building RESTful APIs\r\n  botbuilder (https:\/\/www.npmjs.com\/package\/botbuilder) - The Microsoft Bot Framework SDK.\r\n*\/<\/span>\r\n\r\nvar<\/span> request<\/span> =<\/span> require<\/span>(<\/span>'request'<\/span>);<\/span>\r\nvar<\/span> querystring<\/span> =<\/span> require<\/span>(<\/span>'querystring'<\/span>);<\/span>\r\n\r\nvar<\/span> restify<\/span> =<\/span> require<\/span>(<\/span>'restify'<\/span>);<\/span>\r\nvar<\/span> botbuilder<\/span> =<\/span> require<\/span>(<\/span>'botbuilder'<\/span>);<\/span>\r\n\r\n\/\/ Config can appear in the environment, argv or in the local config<\/span>\r\n\/\/ file (don't check this in!!)<\/span>\r\nvar<\/span> config<\/span> =<\/span> require<\/span>(<\/span>'nconf'<\/span>).<\/span>env<\/span>().<\/span>argv<\/span>().<\/span>file<\/span>({<\/span> file<\/span>:<\/span> '.\/localConfig.json'<\/span> });<\/span>\r\n\r\nfunction<\/span> createChatConnector<\/span>()<\/span> {<\/span>\r\n\r\n  \/\/ Create the chat connector which will hook us up to the Bot framework<\/span>\r\n  \/\/ servers. This is all very standard stuff.<\/span>\r\n  \/\/ Full details here: https:\/\/docs.botframework.com\/en-us\/node\/builder\/overview\/#navtitle<\/span>\r\n\r\n  let<\/span> opts<\/span> =<\/span> {<\/span>\r\n    \/\/ You generate these two values when you create your bot at<\/span>\r\n    \/\/ https:\/\/dev.botframework.com\/<\/span>\r\n    appId<\/span>:<\/span> config<\/span>.<\/span>get<\/span>(<\/span>'BOT_APP_ID'<\/span>),<\/span>\r\n    appPassword<\/span>:<\/span> config<\/span>.<\/span>get<\/span>(<\/span>'BOT_APP_PASSWORD'<\/span>)<\/span>\r\n  };<\/span>\r\n\r\n  let<\/span> chatConnector<\/span> =<\/span> new<\/span> botbuilder<\/span>.<\/span>ChatConnector<\/span>(<\/span>opts<\/span>);<\/span>\r\n\r\n  let<\/span> server<\/span> =<\/span> restify<\/span>.<\/span>createServer<\/span>();<\/span>\r\n\r\n  server<\/span>.<\/span>post<\/span>(<\/span>'\/qna'<\/span>,<\/span> chatConnector<\/span>.<\/span>listen<\/span>());<\/span>\r\n\r\n  \/\/ Serve the static file containing the embedded web control<\/span>\r\n  \/\/ directly from the local filesystem<\/span>\r\n  server<\/span>.<\/span>get<\/span>(<\/span>\/<\/span>\/?<\/span>.*\/<\/span>,<\/span> restify<\/span>.<\/span>serveStatic<\/span>({<\/span>\r\n    directory<\/span>:<\/span> __dirname<\/span> +<\/span> '\/html'<\/span>,<\/span>\r\n    default<\/span>:<\/span> 'index.html'<\/span>,<\/span>\r\n  }));<\/span>\r\n\r\n  server<\/span>.<\/span>listen<\/span>(<\/span>3978<\/span>,<\/span> function<\/span> ()<\/span> {<\/span>\r\n    console<\/span>.<\/span>log<\/span>(<\/span>'%s listening to %s'<\/span>,<\/span> server<\/span>.<\/span>name<\/span>,<\/span> server<\/span>.<\/span>url<\/span>);<\/span>\r\n  });<\/span>\r\n\r\n  return<\/span> chatConnector<\/span>;<\/span>\r\n}<\/span>\r\n\r\nfunction<\/span> qna<\/span>(<\/span>q<\/span>,<\/span> cb<\/span>)<\/span> {<\/span>\r\n\r\n  \/\/ Here's where we pass anything the user typed along to the<\/span>\r\n  \/\/ QnA service. Super simple stuff!!<\/span>\r\n\r\n  q<\/span> =<\/span> querystring<\/span>.<\/span>escape<\/span>(<\/span>q<\/span>);<\/span>\r\n  request<\/span>(<\/span>config<\/span>.<\/span>get<\/span>(<\/span>'qnaUri'<\/span>)<\/span> +<\/span> q<\/span>,<\/span> function<\/span> (<\/span>error<\/span>,<\/span> response<\/span>,<\/span> body<\/span>)<\/span> {<\/span>\r\n    if<\/span> (<\/span>error<\/span>)<\/span> {<\/span>\r\n      cb<\/span>(<\/span>error<\/span>,<\/span> null<\/span>);<\/span>\r\n    }<\/span>\r\n    else<\/span> if<\/span> (<\/span>response<\/span>.<\/span>statusCode<\/span> !==<\/span> 200<\/span>)<\/span> {<\/span>\r\n      \/\/ Valid response from QnA but it's an error<\/span>\r\n      \/\/ return the response for further processing<\/span>\r\n      cb<\/span>(<\/span>response<\/span>,<\/span> null<\/span>);<\/span>\r\n    }<\/span>\r\n    else<\/span> {<\/span>\r\n      \/\/ All looks OK, the answer is in the body<\/span>\r\n      cb<\/span>(<\/span>null<\/span>,<\/span> body<\/span>);<\/span>\r\n    }<\/span>\r\n  });<\/span>\r\n}<\/span>\r\n\r\nfunction<\/span> initialiseBot<\/span>(<\/span>bot<\/span>)<\/span> {<\/span>\r\n\r\n  \/\/ Someone set up us the bot :-)<\/span>\r\n\r\n  \/\/ Use IntentDialog to watch for messages that match regexes<\/span>\r\n  let<\/span> intents<\/span> =<\/span> new<\/span> botbuilder<\/span>.<\/span>IntentDialog<\/span>();<\/span>\r\n\r\n  \/\/ Any message not matching the previous intents ends up here<\/span>\r\n  intents<\/span>.<\/span>onDefault<\/span>((<\/span>session<\/span>,<\/span> args<\/span>,<\/span> next<\/span>)<\/span> =><\/span> {<\/span>\r\n\r\n    \/\/ Just throw everything into the qna service<\/span>\r\n    qna<\/span>(<\/span>session<\/span>.<\/span>message<\/span>.<\/span>text<\/span>,<\/span> (<\/span>err<\/span>,<\/span> result<\/span>)<\/span> =><\/span> {<\/span>\r\n      if<\/span> (<\/span>err<\/span>)<\/span> {<\/span>\r\n        console<\/span>.<\/span>error<\/span>(<\/span>err<\/span>);<\/span>\r\n        session<\/span>.<\/span>send<\/span>(<\/span>'Unfortunately an error occurred. Try again.'<\/span>);<\/span>\r\n      }<\/span>\r\n      else<\/span> {<\/span>\r\n        \/\/ The QnA returns a JSON: { answer:XXXX, score: XXXX: }<\/span>\r\n        \/\/ where score is a confidence the answer matches the question.<\/span>\r\n        \/\/ Advanced implementations might log lower scored questions and<\/span>\r\n        \/\/ answers since they tend to indicate either gaps in the FAQ content<\/span>\r\n        \/\/ or a model that needs training<\/span>\r\n        session<\/span>.<\/span>send<\/span>(<\/span>JSON<\/span>.<\/span>parse<\/span>(<\/span>result<\/span>).<\/span>answer<\/span>);<\/span>\r\n      }<\/span>\r\n    });<\/span>\r\n  });<\/span>\r\n\r\n  bot<\/span>.<\/span>dialog<\/span>(<\/span>'\/'<\/span>,<\/span> intents<\/span>);<\/span>\r\n}<\/span>\r\n\r\nfunction<\/span> main<\/span>()<\/span> {<\/span>\r\n  initialiseBot<\/span>(<\/span>new<\/span> botbuilder<\/span>.<\/span>UniversalBot<\/span>(<\/span>createChatConnector<\/span>()));<\/span>\r\n}<\/span>\r\n\r\nif<\/span> (<\/span>require<\/span>.<\/span>main<\/span> ===<\/span> module<\/span>)<\/span> {<\/span>\r\n  main<\/span>();<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\n<\/div>\n
Setting up the Services<\/h2>\n
The complete solution requires a couple of moving parts to be up and running in order to succesfully process questions from the user.<\/p>\n
The Bot App<\/strong> – This is the code we actually write and is responsible for receiving messages from the Bot Framework, hosted in the cloud, and passing them along to the QnA service. When the QnA Service sends us a reply our app simply checks the validity of the response, extracts the answer from the reply body and sends it, via the Bot Framework, back to the user. During development this will run on our dev machine. When we want to go to production we\u2019ll need to find a place to run this permanently in the cloud.<\/p>\n
The Bot Framework<\/strong> – Hosted by Microsoft and running in the cloud this is the glue that links together the client applications, such as Skype, Slack, Telegram etc running on the user\u2019s machine to the Bot app running either on our dev machine or in the cloud.<\/p>\n
The QnA Service<\/strong> – Hosted by Microsoft and running in the cloud this is the service that will receive the question the user asks from our Bot application, search its knowledge base and return the most likely answer.<\/p>\n
ngrok<\/strong> – ngrok helps us during development by making it easy for the Bot Framework components to\nconnect to the Bot app instance running on our dev machines despite the dev machine likely sitting behind a fireweall.<\/p>\n
Setup ngrok<\/h3>\n
ngrok\u2019s a great tool that allows you to serve content to the public internet directly from your local machine. We\u2019ll be using it to allow the cloud-hosted components of the Bot Framework to call into the Bot application running on your dev machine.<\/p>\n
Download ngrok here<\/a>.<\/p>\n
Set it running:<\/p>\n
\n
tobe ~\/src\/qnamakerbot $ <\/span>ngrok http 3978\r\n<\/code><\/pre>\n<\/div>\n
You should see something like this:\n \"Image<\/p>\n
The important bit here is the https forwarding address. Copy that URI (should look something like https:\/\/xxxxx.ngrok.io), we\u2019re going to be using it the next section.<\/p>\n
Leave ngrok running throughout the remaining steps.<\/p>\n
Register Your Bot<\/h3>\n
Head over to the Bot Registration Page<\/a> (MSA\/Azure Subscription required) and fill out the details of your bot. Full details can be found here<\/a>.<\/p>\n
Under the Configuration section, there\u2019s a section called \u2018messaging endpoint\u2019. This is how the framework is going to contact the bot app running on your machine. The ngrok URI you copied in the previous step goes in here. If you restart ngrok at any point the URI will change and you\u2019ll have to update this value. When you come to deploy your bot outside of your own machine you\u2019ll also have to come back here to update this value to the new, public address of your Bot instance.<\/p>\n
IMPORTANT:<\/strong> When you click the button to generate your Microsoft App ID and password for your bot be sure you save the password somewhere safe<\/em><\/strong>. This is the only time you\u2019ll be shown this and if you lose it you\u2019ll have to go through all this setup stuff from the top again.<\/p>\n
With everything filled in, hit Register to create all the back-end stuff that will connect the various channels to your Bot application instance. Let\u2019s go ahead and get this hooked up to our actual bot.<\/p>\n
Build the Bot<\/h3>\n
Clone the solution repo qnamakerbot<\/a>:<\/p>\n
\n
tobe ~\/src $ <\/span>git clone https:\/\/github.com\/CatalystCode\/qnamakerbot.git\r\nCloning into 'qnamakerbot'<\/span>...\r\nremote: Counting objects: 400, done<\/span>.\r\nremote: Compressing objects: 100% (<\/span>4\/4)<\/span>, done<\/span>.\r\nremote: Total 400 (<\/span>delta 0)<\/span>, reused 0 (<\/span>delta 0)<\/span>, pack-reused 396\r\nReceiving objects: 100% (<\/span>400\/400)<\/span>, 1.18 MiB | 2.07 MiB\/s, done<\/span>.\r\nResolving deltas: 100% (<\/span>232\/232)<\/span>, done<\/span>.\r\nChecking connectivity... done<\/span>.\r\ntobe ~\/src $ <\/span>cd <\/span>qnamakerbot\/\r\ntobe ~\/src\/qnamakerbot $ <\/span>tree\r\n.\r\n\u251c\u2500\u2500 README.md\r\n\u251c\u2500\u2500 app.js\r\n\u251c\u2500\u2500 assets\r\n\u2502\u00a0\u00a0 \u2514\u2500\u2500 qna.png\r\n\u251c\u2500\u2500 html\r\n\u2502\u00a0\u00a0 \u2514\u2500\u2500 index.html\r\n\u251c\u2500\u2500 localConfig.json\r\n\u2514\u2500\u2500 package.json\r\n\r\n2 directories, 6 files\r\n<\/code><\/pre>\n<\/div>\n
A quick run through the project structure:<\/p>\n
README.md<\/strong> – The Github readme.\napp.js<\/strong> – The entire bot app in a single file. All<\/em><\/strong> the code lives here.\nassets\/qna.jpg<\/strong> – Image referenced from the README file.\nhtml\/index.html<\/strong> – The file we\u2019re going to serve from the app that contains the webchat control through which was can talk to the Bot.\nlocalConfig.json<\/strong> – Contains all our configuration secrets. We\u2019ll need to fill this in later.\npackage.json<\/strong> – Details about this package and its dependencies.<\/p>\n
Before we go any further, let\u2019s remember to install the required node packages:<\/p>\n
\n
tobe ~\/src\/qnamakerbot $ <\/span>npm install\r\n<\/code><\/pre>\n<\/div>\n
Now let\u2019s take a look at those important configuration files:<\/p>\n
\n
tobe ~\/src\/qnamakerbot $ <\/span>cat localConfig.json \r\n{<\/span>\r\n  \"qnaUri\"<\/span> : \"http:\/\/qnaservice.cloudapp.net\/KBService.svc\/GetAnswer?kbId=a3dae93561d24529b11a4c0eb8acd444&question=\"<\/span>,\r\n  \"BOT_APP_ID\"<\/span> : \"<YOUR_APP_ID_HERE>\"<\/span>,\r\n  \"BOT_APP_PASSWORD\"<\/span> : \"<YOUR_APP_PASSWORD_HERE>\"<\/span>\r\n}<\/span>\r\ntobe ~\/src\/qnamakerbot $ <\/span>\r\n<\/code><\/pre>\n<\/div>\n
localConfig.json<\/strong> is where we\u2019re keeping all our secrets and configurables. You\u2019ll need to edit this to fill out the details that will be specific to your Bot. It\u2019s probably not a good idea to check this file into any publicly visible source control. Doing so could allow a malicious user to impersonate your app<\/em>.<\/p>\n
Here\u2019s what those config settings do:<\/p>\n
qnaUri<\/strong> – The QnA service endpoint. This one is preconfigured to point at a endpoint that serves the FAQ content for the Microsoft Bot Framework SDK. You\u2019ll be replacing this with your own in the next section.<\/p>\n
BOT_APP_ID<\/strong> – The Microsoft Application ID. Replace with the ID you were assigned when you registered your Bot.<\/p>\n
BOT_APP_PASSWORD<\/strong> – The application password. Replace with the one you got at the same time as the application ID.<\/p>\n
There\u2019s just one more secret to fill in, an attribute for the webchat control:<\/p>\n
\n
tobe ~\/src\/qnamakerbot $ <\/span>cat html\/index.html \r\n<html>\r\n<head\/>\r\n<body>\r\n<iframe src<\/span>=<\/span>\"https:\/\/webchat.botframework.com\/embed\/qnabot?s=<YOUR_APP_SECRET_HERE>\"<\/span> style<\/span>=<\/span>\"height: 502px; max-height: 502px;\"<\/span>><\/iframe>\r\n<\/body>\r\n<\/html>\r\n<\/code><\/pre>\n<\/div>\n
YOUR_APP_SECRET_HERE<\/strong> – You\u2019ll find this on your Bot configuration page (the same place you registered your Bot). Click \u2018Edit\u2019 next to Web Chat in the Channels section and you\u2019ll be shown the secret to copy and paste into the IFRAME src attribute.<\/p>\n
Running the Bot<\/h3>\n
With all that out of the way we can now run our Bot for the first time:<\/p>\n
\n
tobe ~\/src\/qnamakerbot $ <\/span>node app.js \r\nrestify listening to http:\/\/[::]:3978\r\n<\/code><\/pre>\n<\/div>\n
Head over to http:\/\/localhost:3978<\/a> and you should be looking at something like this:<\/p>\n
 \"Image<\/p>\n
 <\/p>\n
Awesome! We now have a fully functioning Bot. Anything you type in the web chat control is sent, with some help from ngrok, via the Bot Framework to the app running on your desktop. From there a call is made to an existing QnA service that has been preconfigured to answer questions from the Micrsoft Bot SDK FAQ. Go ahead and ask a it a few questions to see everything working.<\/p>\n
Now let\u2019s go right ahead and set up a new QnA Service that can answer questions from whatever FAQ-style content we have to hand.<\/p>\n
Configure the QnA Service<\/h3>\n
Head one over to the QnA Maker site<\/a> (MSA login required).\nChoose Create new QnA service and give your bot a name.<\/p>\n
Now we get to actually provide our QnA content. We have three options here which we can mix and match to create our knowledge base.<\/p>\n
Web Crawling<\/h4>\n
The simplest is just to point QnA at an existing webpage which already contains our FAQ. QnA will crawl the site structure looking for text patterns that look like question\/answer pairs to build its knowledge base.<\/p>\n
The pre-configured QnA Service we\u2019ve been using so far was trained on the Microsoft Bot SDK FAQ. All I had to do was paste this uri: https:\/\/docs.botframework.com\/en-us\/faq\/<\/a> into the configuration to have it learn the FAQ contents.<\/p>\n
Editorial Style<\/h4>\n
We can also add colon-separated QnA pairs directly into the text box in the editorial section. This is useful for adding bits of custom content that your existing FAQ base may not already contain.<\/p>\n
Structured Text<\/h4>\n
You\u2019ll get the most control over exactly what content QnA will process by using the final option which is to bulk upload the question\/answer pairs in a text document structured so that the ingest process can easily separate the two. I had best success with the tab-separated option. NOTE: The .suffix of the file is significant here. If you want to use a tab-separated document it must<\/em> have the .tsv suffix<\/strong> to be recognised as such. It\u2019s also important that there are no duplicate questions in our document as this will cause the parser to exit early and you\u2019ll end up with fewer questions than you thought you had.<\/p>\n
Extraction<\/h4>\n
Once you\u2019ve shown QnA where to get hold of your content choose \u2018Extract\u2019 to have it go and build its knowledge base. This should only take a short amount of time.<\/p>\n
Once that\u2019s done you\u2019ll be able to play around with the knowledge base directly. Type a few questions into the web chat. If you see a few answers that don\u2019t match your questions you now have the opportunity to tweak those.<\/p>\n
Training the Knowledge Base<\/h4>\n
If some of the answers you\u2019re getting don\u2019t match the questions you asked QnA Maker gives you a super simple method to refine the knowledge base.<\/p>\n
 \"Image<\/p>\n
Everytime QnA Maker returns you an answer in training mode it also show you a selection of the other high-scoring answers for that questions. If you think one of those fits the question better just click on the bubble on the left-hand side to let QnA Maker know you think that was a better response. If none seem to match choose \u2018None of the above\u2019 to tell QnA to look for other answers next time.<\/p>\n
Similarly if you think there are different ways of asking a question that QnA is not picking up on, you have the option to provide those in the edit box on the right hand side.<\/p>\n
Most of the time QnA Maker does a really good job of figuring this stuff out for itself but it\u2019s great to have the option to fine-tune the knowledge base should you need it.<\/p>\n
Just click \u2018Re-Train\u2019 any time you want to try the new model and you should now find your edits taken into account when you next ask those problematic questions.<\/p>\n
Publish the QnA Service<\/h4>\n
As easy as clicking the Publish button. You\u2019ll be taken to a page showing you the address of your service endpoint. Copy this and use it as the value for the \u2018qnaUri\u2019 variable in the localConfig.json at the project root.<\/p>\n
Restart the app and you should now be able to use the webchat control to query your FAQ content using natural language.<\/p>\n
That\u2019s it!<\/h3>\n
Well.. not quite. Of course once you\u2019re ready to unleash your FAQ answering Bot on the world you\u2019ll need to deploy your Bot app in the cloud somewhere and update the Bot configuration to point at that new URI. A full guide can be found here<\/a>.<\/p>\n
Summing Up<\/h3>\n
QnA Maker provides us with a very low friction path to servicing FAQ-style content through a conversational interface. All the complex natural language processing tasks usually associated with projects of this kind have been taken care of for us. QnA Maker is an excellent way to dip our toe into the world of conversational interfaces and get real results quickly.<\/p>\n
And remember.. the code is freely available under an Open Source License from GitHub:<\/p>\n
https:\/\/github.com\/CatalystCode\/qnamakerbot\/tree\/minimal<\/a><\/p>\n
Suggestions for Further Development<\/h3>\n
What\u2019s been presented here is close to the minimal possible solution for clarity\u2019s sake. It\u2019s easy to add whatever extra features we can imagine. Here are some ideas:<\/p>\n
Consider using metadata to control response rendering<\/h4>\n
One technique that I\u2019ve seen used to good effect is to add metadata to the answer text which is stripped out and used to influence how the response is rendered before it\u2019s returned to the user. The Botbuilder SDK allows a variety of rich media responses<\/a> to be returned to the user and does a good job of translating these into forms appropriate for the channels. Where appropriate you might choose to return a HeroCard or perhaps an embdedded video instead of block of text.<\/p>\n
Add telemetry to better understand how well the FAQ performing<\/h4>\n
Data\u2019s always useful to understand systems are being used. The QnA maker returns us a confidence score along with the answer text. In situations where that confidence falls below a certain threshold we could ask the user if the previous answer was helpful. The responses to that question could help identifiy areas where the content might extra attention to better serve the customer\u2019s need.<\/p>\n","protected":false},"excerpt":{"rendered":"
Using Microsoft Bot Framework’s QnA Maker to create a conversational interface for publishing FAQ-style content.<\/p>\n","protected":false},"author":21384,"featured_media":11110,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[13,19],"tags":[109,110,231,250,268,301],"class_list":["post-2139","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-bots","category-machine-learning","tag-bot-framework-sdk","tag-bots","tag-language-understanding-intelligent-service-luis","tag-microsoft-cognitive-services","tag-natural-language-processing","tag-qna-maker"],"acf":[],"blog_post_summary":"
Using Microsoft Bot Framework’s QnA Maker to create a conversational interface for publishing FAQ-style content.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/posts\/2139","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/users\/21384"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/comments?post=2139"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/posts\/2139\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/media\/11110"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/media?parent=2139"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/categories?post=2139"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/tags?post=2139"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}