Use multiple LUIS and QnA models

OnMessageActivityAsync is called for each user input received. This module finds the top scoring user intent and passes that result on to DispatchToTopIntentAsync. DispatchToTopIntentAsync, in turn, calls the appropriate app handler.

• ProcessSampleQnAAsync - for bot faq questions.
• ProcessWeatherAsync - for weather queries.
• ProcessHomeAutomationAsync - for home lighting commands.

onMessage is called for each user input received. This module finds the top scoring user intent and passes that result on to dispatchToTopIntentAsync. dispatchToTopIntentAsync, in turn, calls the appropriate app handler

• processSampleQnA - for bot faq questions.
• processWeather - for weather queries.
• processHomeAutomation - for home lighting commands.

on_message_activity is called for each user input received. This module finds the top scoring user intent and passes that result on to _dispatch_to_top_intent. _dispatch_to_top_intent, in turn, calls the appropriate app handler

• _process_sample_qna - for bot faq questions.
• _process_weather - for weather queries.
• _process_home_automation - for home lighting commands.

Installing packages

Prior to running this app for the first time ensure that several NuGet packages are installed:

• Microsoft.Bot.Builder
• Microsoft.Bot.Builder.AI.Luis
• Microsoft.Bot.Builder.AI.QnA

Manually update your appsettings.json file

Once all of your service apps are created, the information for each needs to be added into your 'appsettings.json' file. The initial C# Sample code contains an empty appsettings.json file:

appsettings.json

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

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

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

For each of the entities shown below, add the values you recorded earlier in these instructions:

appsettings.json

"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>",

When all changes are complete, save this file.

Installing packages

Prior to running this app for the first time you will need to install several npm packages.

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

To use the .env configuration file, your bot needs an extra package included:

npm install --save dotenv

Manually update your .env file

Once all of your service apps are created, the information for each needs to be added into your '.env' file. The initial JavaScript Sample code contains an empty .env file.

.env

MicrosoftAppId=
MicrosoftAppPassword=

QnAKnowledgebaseId=
QnAEndpointKey=
QnAEndpointHostName=

LuisAppId=
LuisAPIKey=
LuisAPIHostName=

Add your service connection values as shown below:

.env

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>

When all changes are in place, save this file.

Installing packages

Prior to running this app for the first time you will need to install several PyPI packages.

pip install azure
pip install botbuilder-core
pip install botbuilder-ai

Manually update your config.py file

Once all of your service apps are created, the information for each needs to be added into your 'config.py' file. The initial Python Sample code contains an empty config.py file.

config.py

class DefaultConfig:
    """ Bot Configuration """

    PORT = 3978
    APP_ID = os.environ.get("MicrosoftAppId", "")
    APP_PASSWORD = os.environ.get("MicrosoftAppPassword", "")

    QNA_KNOWLEDGEBASE_ID = os.environ.get("QnAKnowledgebaseId", "")
    QNA_ENDPOINT_KEY = os.environ.get("QnAEndpointKey", "")
    QNA_ENDPOINT_HOST = os.environ.get("QnAEndpointHostName", "")

    LUIS_APP_ID = os.environ.get("LuisAppId", "")
    LUIS_API_KEY = os.environ.get("LuisAPIKey", "")
    # LUIS endpoint host name, ie "westus.api.cognitive.microsoft.com"
    LUIS_API_HOST_NAME = os.environ.get("LuisAPIHostName", "")

For each of the entities shown below, add the values you recorded earlier in these instructions:

APP_ID = os.environ.get("MicrosoftAppId", "")
APP_PASSWORD = os.environ.get("MicrosoftAppPassword", "")

QNA_KNOWLEDGEBASE_ID = os.environ.get("QnAKnowledgebaseId", "<knowledge-base-id>")
QNA_ENDPOINT_KEY = os.environ.get("QnAEndpointKey", "<qna-maker-resource-key>")
QNA_ENDPOINT_HOST = os.environ.get("QnAEndpointHostName", "<your-hostname>")

LUIS_APP_ID = os.environ.get("LuisAppId", "<app-id-for-dispatch-app>")
LUIS_API_KEY = os.environ.get("LuisAPIKey", "<your-luis-endpoint-key>")
# LUIS endpoint host name, ie "westus.api.cognitive.microsoft.com"
LUIS_API_HOST_NAME = os.environ.get("LuisAPIHostName", "<your-dispatch-app-region>")

When all changes are complete, save this file.

In BotServices.cs, the information contained within configuration file appsettings.json is used to connect your dispatch bot to the Dispatch and SampleQnA services. The constructors use the values you provided to connect to these services.

BotServices.cs

public class BotServices : IBotServices
{
    public BotServices(IConfiguration configuration)
    {
        // Read the setting for cognitive services (LUIS, QnA) from the appsettings.json
        // If includeApiResults is set to true, the full response from the LUIS api (LuisResult)
        // will be made available in the properties collection of the RecognizerResult

        var luisApplication = new LuisApplication(
            configuration["LuisAppId"],
            configuration["LuisAPIKey"],
           $"https://{configuration["LuisAPIHostName"]}.api.cognitive.microsoft.com");

        // Set the recognizer options depending on which endpoint version you want to use.
        // More details can be found in https://docs.microsoft.com/en-gb/azure/cognitive-services/luis/luis-migration-api-v3
        var recognizerOptions = new LuisRecognizerOptionsV2(luisApplication)
        {
            IncludeAPIResults = true,
            PredictionOptions = new LuisPredictionOptions()
            {
                IncludeAllIntents = true,
                IncludeInstanceData = true
            }
        };

        Dispatch = new LuisRecognizer(recognizerOptions);

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

    public LuisRecognizer Dispatch { get; private set; }
    public QnAMaker SampleQnA { get; private set; }
}

In dispatchBot.js the information contained within configuration file .env is used to connect your dispatch bot to the LuisRecognizer(dispatch) and QnAMaker services. The constructors use the values you provided to connect to these services.

bots/dispatchBot.js

// If the includeApiResults parameter is set to true, as shown below, the full response
// from the LUIS api will be made available in the properties  of the RecognizerResult
const dispatchRecognizer = new LuisRecognizer({
    applicationId: process.env.LuisAppId,
    endpointKey: process.env.LuisAPIKey,
    endpoint: `https://${ process.env.LuisAPIHostName }.api.cognitive.microsoft.com`
}, {
    includeAllIntents: true,
    includeInstanceData: true
}, true);

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

In dispatch_bot.py, the information contained within configuration file config.py is used to connect your dispatch bot to the QnAMaker and LuisRecognizer services. The constructors use the values you provided to connect to these services.

bots/dispatch_bot.py

class DispatchBot(ActivityHandler):
    def __init__(self, config: DefaultConfig):
        self.qna_maker = QnAMaker(
            QnAMakerEndpoint(
                knowledge_base_id=config.QNA_KNOWLEDGEBASE_ID,
                endpoint_key=config.QNA_ENDPOINT_KEY,
                host=config.QNA_ENDPOINT_HOST,
            )
        )

        # If the includeApiResults parameter is set to true, as shown below, the full response
        # from the LUIS api will be made available in the properties  of the RecognizerResult
        luis_application = LuisApplication(
            config.LUIS_APP_ID,
            config.LUIS_API_KEY,
            "https://" + config.LUIS_API_HOST_NAME,
        )
        luis_options = LuisPredictionOptions(
            include_all_intents=True, include_instance_data=True
        )
        self.recognizer = LuisRecognizer(luis_application, luis_options, True)

In the DispatchBot.cs file whenever the OnMessageActivityAsync method is called, we check the incoming user message against the Dispatch model. We then pass the Dispatch Model's topIntent and recognizerResult on to the correct method to call the service and return the result.

bots\DispatchBot.cs

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);
}

In the dispatchBot.js onMessage method, we check the user input message against the Dispatch model, find the topIntent, then pass this on by calling dispatchToTopIntentAsync.

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

    // First, we use the dispatch model to determine which cognitive service (LUIS or QnA) to use.
    const recognizerResult = await dispatchRecognizer.recognize(context);

    // Top intent tell us which cognitive service to use.
    const intent = LuisRecognizer.topIntent(recognizerResult);

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

    await next();
});

In the dispatch_bot.py file whenever the on_message_activity method is called, we check the incoming user message against the Dispatch model. We then pass the Dispatch Model's top_intent and recognize_result on to the correct method to call the service and return the result.

bots/dispatch_bot.py

async def on_message_activity(self, turn_context: TurnContext):
    # First, we use the dispatch model to determine which cognitive service (LUIS or QnA) to use.
    recognizer_result = await self.recognizer.recognize(turn_context)

    # Top intent tell us which cognitive service to use.
    intent = LuisRecognizer.top_intent(recognizer_result)

    # Next, we call the dispatcher with the top intent.
    await self._dispatch_to_top_intent(turn_context, intent, recognizer_result)

When the model produces a result, it indicates which service can most appropriately process the utterance. The code in this bot routes the request to the corresponding service, and then summarizes the response from the called service. Depending on the intent returned from Dispatch, this code uses the returned intent to route to the correct LUIS model or QnA service.

bots\DispatchBot.cs

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;
    }
}

If method ProcessHomeAutomationAsync or ProcessWeatherAsync are invoked, they are passed the results from the dispatch model within luisResult.ConnectedServiceResult. The specified method then provides user feedback showing the dispatch model top intent, plus a ranked listing of all intents and entities that were detected.

If method q_sample-qna is invoked, it uses the user input contained within the turnContext to generate an answer from the knowledge base and display that result to the user.

When the model produces a result, it indicates which service can most appropriately process the utterance. The code in this sample uses the recognized topIntent to show how to route the request on to the corresponding service.

bots/dispatchBot.js

async dispatchToTopIntentAsync(context, intent, recognizerResult) {
    switch (intent) {
    case 'l_HomeAutomation':
        await this.processHomeAutomation(context, recognizerResult.luisResult);
        break;
    case 'l_Weather':
        await this.processWeather(context, recognizerResult.luisResult);
        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;
    }
}

If method processHomeAutomation or processWeather are invoked, they are passed the results from the dispatch model within recognizerResult.luisResult. The specified method then provides user feedback showing the dispatch model's top intent, plus a ranked listing of all intents and entities that were detected.

If method q_sample-qna is invoked, it uses the user input contained within the turnContext to generate an answer from the knowledge base and display that result to the user.

When the model produces a result, it indicates which service can most appropriately process the utterance. The code in this sample uses the recognized top intent to show how to route the request on to the corresponding service.

bots\dispatch_bot.py

async def _dispatch_to_top_intent(
    self, turn_context: TurnContext, intent, recognizer_result: RecognizerResult
):
    if intent == "l_HomeAutomation":
        await self._process_home_automation(
            turn_context, recognizer_result.properties["luisResult"]
        )
    elif intent == "l_Weather":
        await self._process_weather(
            turn_context, recognizer_result.properties["luisResult"]
        )
    elif intent == "q_sample-qna":
        await self._process_sample_qna(turn_context)
    else:
        await turn_context.send_activity(f"Dispatch unrecognized intent: {intent}.")

If method _process_home_automation or _process_weather are invoked, they are passed the results from the dispatch model within recognizer_result.properties["luisResult"]. The specified method then provides user feedback showing the dispatch model top intent, plus a ranked listing of all intents and entities that were detected.

If method q_sample-qna is invoked, it uses the user input contained within the turnContext to generate an answer from the knowledge base and display that result to the user.