Use multiple LUIS and QnA models

• 05/23/2019
• 16 minutes to read
• • 
  • 
  • 
  • 
  • 
  • +2

APPLIES TO: SDK v4 SDK v3

If a bot uses multiple LUIS models and QnA Maker knowledge bases (knowledge bases), you can use Dispatch tool to determine which LUIS model or QnA Maker knowledge base best matches the user input. The dispatch tool does this by creating a single LUIS app to route user input to the correct model. For more information about the Dispatch, including the CLI commands, refer to the README.

Prerequisites

• Knowledge of bot basics, LUIS, and QnA Maker.
• Dispatch tool
• A copy of the NLP with Dispatch from either the C# Sample or JS Sample code repository.
• A luis.ai account to publish LUIS apps.
• A QnA Maker account to publish the QnA knowledge base.

About this sample

This sample is based on a predefined set of LUIS and QnA Maker Apps.

The handler calls the LUIS or QnA Maker service and returns the generated result back to the user.

Create LUIS apps and QnA knowledge base

Before you can create the dispatch model, you'll need to have your LUIS apps and QnA knowledge bases created and published. In this article, we'll publish the following models that are included with the NLP With Dispatch sample in the \CognitiveModels folder:

Create LUIS apps

1. Log into the LUIS web portal. Under the My apps section, select the Tab Import new app. The following Dialog Box will appear:

   

2. Select the button Choose app file, navigate to the CognitiveModel folder of your sample code and select the file 'HomeAutomation.json'. Leave the optional name field blank.

3. Select Done.

4. Once LUIS opens up your Home Automation app, select the Train button. This will train your app using the set of utterances you just imported using the 'home-automation.json' file.

5. When training is complete, select the Publish button. The following Dialog Box will appear:

   

6. Choose the 'production' environment and then select the Publish button.

7. Once your new LUIS app has been published, select the MANAGE Tab. From the 'Application Information' page, record the values Application ID as "app-id-for-app" and Display name as "name-of-app". From the 'Key and Endpoints' page, record the values Authoring Key as "your-luis-authoring-key" and Region as "your-region". These values will later be used within your 'appsetting.json' file.

8. Once completed, Train and Publish both your LUIS weather app and your LUIS dispatch app by repeating the above steps for 'Weather.json' file.

Create QnA Maker knowledge base

The first step to setting up a QnA Maker knowledge base is to set up a QnA Maker service in Azure. To do that, follow the step-by-step instructions found here.

Once your QnA Maker Service has been created in Azure, you need to record the Cognitive Services Key 1 provided for your QnA Maker service. This will be used as <azure-qna-service-key1> when adding the QnA Maker app to your dispatch application. The following steps provide you with this key:

1. From within your Azure portal, select your QnA Maker cognitive service.

   

2. Select the Keys icon found under the Resource Management section on the left-hand menu.

   

3. Copy the value of Key 1 to your clipboard and save this locally. this will later be used for the (-k) key value <azure-qna-service-key1> when adding the QnA Maker app to your dispatch application.

4. Now sign in to the QnAMaker web portal.

5. At step 2, select the following:

   • Your Azure AD account.
   • Your Azure subscription name.
   • The name you created for your QnA Maker service. (If your Azure QnA service does not initially appear in this pull down list, try refreshing the page.)

   

6. At step 3, provide a name for your QnA Maker knowledge base. For this example use the name 'sample-qna'.

   

7. At step 4, select the option + Add File, navigate to the CognitiveModel folder of your sample code, and select the file 'QnAMaker.tsv'. There is an additional selection to add a Chit-chat personality to your knowledge base but our example does not include this option.

   

8. At step 5, select Create your knowledge base.

9. Once the knowledge base is created from your uploaded file, select Save and train and when finished, select the PUBLISH Tab and publish your app.

10. Once your QnA Maker app is published, select the SETTINGS Tab, and scroll down to 'Deployment details'. Record the following values from the Postman Sample HTTP request.

    POST /knowledge bases/<knowledge-base-id>/generateAnswer
    Host: <your-hostname>  // NOTE - this is a URL.
    Authorization: EndpointKey <qna-maker-resource-key>
    

    The full URL string for your hostname will look like "https://< >.azure.net/qnamaker". These values will later be used within your appsettings.json or .env file.

Dispatch app needs read access to existing apps

The dispatch tool needs authoring access to read the existing LUIS and QnA Maker apps in order to create a new parent LUIS app that dispatches to the LUIS and QnA Maker apps. This access is provided with the app IDs and authoring keys.

Service authoring keys

The authoring key is only used for creating and editing the models. You need an ID and key for each of the two LUIS apps and the QnA Maker app.

The authoring key is not used to get a prediction score or confidence score from the published application. You need the endpoint keys for this action. The endpoint keys are found and used later in this tutorial.

Create the dispatch model

The CLI interface for the dispatch tool creates the model for dispatching to the correct LUIS or QnA Maker app.

1. Open a command prompt or terminal window, and change directories to the CognitiveModels directory

2. Make sure you have the current version of npm and the Dispatch tool.

   npm i -g npm
   npm i -g botdispatch
   

3. Use dispatch init to initialize create a .dispatch file for your dispatch model. Create this using a filename you will recognize.

   dispatch init -n <filename-to-create> --luisAuthoringKey "<your-luis-authoring-key>" --luisAuthoringRegion <your-region>
   

4. Use dispatch add to add your LUIS apps and QnA Maker knowledge bases to the .dispatch file.

   dispatch add -t luis -i "<app-id-for-weather-app>" -n "<name-of-weather-app>" -v <app-version-number> -k "<your-luis-authoring-key>" --intentName l_Weather
   dispatch add -t luis -i "<app-id-for-home-automation-app>" -n "<name-of-home-automation-app>" -v <app-version-number> -k "<your-luis-authoring-key>" --intentName l_HomeAutomation
   dispatch add -t qna -i "<knowledge-base-id>" -n "<knowledge-base-name>" -k "<azure-qna-service-key1>" --intentName q_sample-qna
   

5. Use dispatch create to generate a dispatch model from the .dispatch file.

   dispatch create
   

6. Publish the dispatch LUIS app, just created.

Use the dispatch LUIS app

The generated LUIS app defines intents for each of the child apps and the knowledge base, as well as a none intent for when the utterance doesn't have a good fit.

• l_HomeAutomation
• l_Weather
• None
• q_sample-qna

These services need to be published under the correct names for the bot to run properly. The bot needs information about the published services, so that it can access those services.

Service endpoint keys

The bot needs the query prediction endpoints for the three LUIS apps (dispatch, weather, and home automation) and the single QnA Maker knowledge base. Use the following table to find the endpoint keys:

These values are used in the appsettings.json for C# and the .env file for javascript.

 "MicrosoftAppId": "",
 "MicrosoftAppPassword": "",

 "QnAKnowledgebaseId": "",
 "QnAEndpointKey": "",
 "QnAEndpointHostName": "",

 "LuisAppId": "",
 "LuisAPIKey": "",
 "LuisAPIHostName": "",

"MicrosoftAppId": "",
"MicrosoftAppPassword": "",
  
"QnAKnowledgebaseId": "<knowledge-base-id>",
"QnAEndpointKey": "<qna-maker-resource-key>",
"QnAEndpointHostName": "<your-hostname>",

"LuisAppId": "<app-id-for-dispatch-app>",
"LuisAPIKey": "<your-luis-endpoint-key>",
"LuisAPIHostName": "<your-dispatch-app-region>",

npm install --save botbuilder
npm install --save botbuilder-ai

npm install --save dotenv

MicrosoftAppId=
MicrosoftAppPassword=

QnAKnowledgebaseId=
QnAEndpointKey=
QnAEndpointHostName=

LuisAppId=
LuisAPIKey=
LuisAPIHostName=

MicrosoftAppId=""
MicrosoftAppPassword=""

QnAKnowledgebaseId="<knowledge-base-id>"
QnAEndpointKey="<qna-maker-resource-key>"
QnAEndpointHostName="<your-hostname>"

LuisAppId=<app-id-for-dispatch-app>
LuisAPIKey=<your-luis-endpoint-key>
LuisAPIHostName=<your-dispatch-app-region>

Connect to the services from your bot

To connect to the Dispatch, LUIS, and QnA Maker services, your bot pulls information from the settings file (either the appsettings.json or the .env file).

public BotServices(IConfiguration configuration)
{
    // Read the setting for cognitive services (LUIS, QnA) from the appsettings.json
    Dispatch = new LuisRecognizer(new LuisApplication(
        configuration["LuisAppId"],
        configuration["LuisAPIKey"],
        $"https://{configuration["LuisAPIHostName"]}.api.cognitive.microsoft.com"),
        new LuisPredictionOptions { IncludeAllIntents = true, IncludeInstanceData = true },
        true);

    SampleQnA = new QnAMaker(new QnAMakerEndpoint
    {
        KnowledgeBaseId = configuration["QnAKnowledgebaseId"],
        EndpointKey = configuration["QnAEndpointKey"],
        Host = configuration["QnAEndpointHostName"]
    });
}

}, true);

const qnaMaker = new QnAMaker({
    knowledgeBaseId: process.env.QnAKnowledgebaseId,
    endpointKey: process.env.QnAEndpointKey,
    host: process.env.QnAEndpointHostName
});

this.dispatchRecognizer = dispatchRecognizer;
this.qnaMaker = qnaMaker;

this.onMessage(async (context, next) => {
    console.log('Processing Message Activity.');

Call the services from your bot

For each input from your user, the bot logic checks user input against the combined Dispatch model, finds the top returned intent, and uses that information to call the appropriate service for the input.

protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    // First, we use the dispatch model to determine which cognitive service (LUIS or QnA) to use.
    var recognizerResult = await _botServices.Dispatch.RecognizeAsync(turnContext, cancellationToken);
    
    // Top intent tell us which cognitive service to use.
    var topIntent = recognizerResult.GetTopScoringIntent();
    
    // Next, we call the dispatcher with the top intent.
    await DispatchToTopIntentAsync(turnContext, topIntent.intent, recognizerResult, cancellationToken);
}

    // Next, we call the dispatcher with the top intent.
    await this.dispatchToTopIntentAsync(context, intent, recognizerResult);

    await next();
});

this.onMembersAdded(async (context, next) => {
    const welcomeText = 'Type a greeting or a question about the weather to get started.';
    const membersAdded = context.activity.membersAdded;

    for (const member of membersAdded) {
        if (member.id !== context.activity.recipient.id) {
            await context.sendActivity(`Welcome to Dispatch bot ${ member.name }. ${ welcomeText }`);

Work with the recognition results

private async Task DispatchToTopIntentAsync(ITurnContext<IMessageActivity> turnContext, string intent, RecognizerResult recognizerResult, CancellationToken cancellationToken)
{
    switch (intent)
    {
        case "l_HomeAutomation":
            await ProcessHomeAutomationAsync(turnContext, recognizerResult.Properties["luisResult"] as LuisResult, cancellationToken);
            break;
        case "l_Weather":
            await ProcessWeatherAsync(turnContext, recognizerResult.Properties["luisResult"] as LuisResult, cancellationToken);
            break;
        case "q_sample-qna":
            await ProcessSampleQnAAsync(turnContext, cancellationToken);
            break;
        default:
            _logger.LogInformation($"Dispatch unrecognized intent: {intent}.");
            await turnContext.SendActivityAsync(MessageFactory.Text($"Dispatch unrecognized intent: {intent}."), cancellationToken);
            break;
    }
}

    case 'q_sample-qna':
        await this.processSampleQnA(context);
        break;
    default:
        console.log(`Dispatch unrecognized intent: ${ intent }.`);
        await context.sendActivity(`Dispatch unrecognized intent: ${ intent }.`);
        break;
    }
}

async processHomeAutomation(context, luisResult) {
    console.log('processHomeAutomation');

    // Retrieve LUIS result for Process Automation.
    const result = luisResult.connectedServiceResult;
    const intent = result.topScoringIntent.intent;

Test your bot

1. Using your development environment, start the sample code. Note the localhost address shown in the address bar of the browser window opened by your App: "https://localhost:<Port_Number>".

2. Open your Bot Framework Emulator, then select Create a new bot configuration. A .bot file enables you to use the Inspector in the bot emulator to see the JSON returned from LUIS and QnA Maker.

3. In the New bot configuration dialog box, enter your bot name, and your endpoint URL, such as http://localhost:3978/api/messages. Save the file at the root of your bot sample code project.

4. Open the bot file and add sections for your LUIS and QnA Maker apps. Use this example file as a template for settings. Save the changes.

5. Select the bot name in the My Bots list to access your running bot. For your reference, here are some of the questions and commands that are covered by the services built for your bot:

   • QnA Maker
     • hi, good morning
     • what are you, what do you do
   • LUIS (home automation)
     • turn on bedroom light
     • turn off bedroom light
     • make some coffee
   • LUIS (weather)
     • whats the weather in redmond washington
     • what's the forecast for london
     • show me the forecast for nebraska

Dispatch for user utterance to QnA Maker

1. In the bot emulator, enter the text hi and submit the utterance. The bot submits this query to the dispatch LUIS app and gets back a response indicating which child app should get this utterance for further processing.

2. By selecting the LUIS Trace line in the log, you can see the LUIS response in the bot emulator . The LUIS result from the dispatch LUIS app displays in the Inspector.

   {
     "luisResponse": {
       "entities": [],
       "intents": [
         {
           "intent": "q_sample-qna",
           "score": 0.9489713
         },
         {
           "intent": "l_HomeAutomation",
           "score": 0.0612499453
         },
         {
           "intent": "None",
           "score": 0.008567564
         },
         {
           "intent": "l_Weather",
           "score": 0.0025761195
         }
       ],
       "query": "Hi",
       "topScoringIntent": {
         "intent": "q_sample-qna",
         "score": 0.9489713
       }
     }
   }
   

   Because the utterance, hi, is part of the dispatch LUIS app's q_sample-qna intent, and is selected as the topScoringIntent, the bot will make a second request, this time to the QnA Maker app, with the same utterance.

3. Select the QnAMaker Trace line in the bot emulator log. The QnA Maker result displays in the Inspector.

{
    "questions": [
        "hi",
        "greetings",
        "good morning",
        "good evening"
    ],
    "answer": "Hello!",
    "score": 1,
    "id": 96,
    "source": "QnAMaker.tsv",
    "metadata": [],
    "context": {
        "isContextOnly": false,
        "prompts": []
    }
}

Resolving incorrect top intent from Dispatch

Once your bot is running, it is possible to improve the bot's performance by removing similar or overlapping utterances between the dispatched apps. For example, let's say that in the Home Automation LUIS app requests like "turn my lights on" map to a "TurnOnLights" intent, but requests like "Why won't my lights turn on?" map to a "None" intent so that they can be passed on to QnA Maker. These two utterances are too close for the dispatch LUIS app to determine if the correct child app is the LUIS app or the QnA Maker app.

When you combine the LUIS app and the QnA Maker app using dispatch, you need to do one of the following:

• Remove the "None" intent from the child Home Automation LUIS app, and instead add the utterances from that intent to the "None" intent in the dispatcher app.
• Add logic in your bot to pass the messages that match the Dispatch LUIS app's "None" intent on to the QnA maker service. Compare the score of the Dispatch LUIS app's score and the score of the QnA Maker app. Use the highest score. This effectively removes QnA Maker from the Dispatch cycle.

Either of the above two actions will reduce the number of times that your bot responds back to your users with the message, 'Couldn't find an answer.'

To update or create a new LUIS model

This sample is based on a preconfigured LUIS model. Additional information to help you update this model, or create a new LUIS model, can be found here.

To delete resources

This sample creates a number of applications and resources that you can delete using the steps listed below, but you should not delete resources that any other apps or services rely on.

To delete LUIS resources:

1. Sign in to the luis.ai portal.
2. Go to the My Apps page.
3. Select the apps created by this sample.
   • Home Automation
   • Weather
   • NLP-With-Dispatch-BotDispatch
4. Click Delete, and click Ok to confirm.

To delete QnA Maker resources:

1. Sign in to the qnamaker.ai portal.
2. Go to the My knowledge bases page.
3. Click the delete button for the Sample QnA knowledge base, and click Delete to confirm.

Best practice

To improve services used in this sample, refer to best practice for LUIS, and QnA Maker.