diff --git a/Composer/packages/lib/code-editor/demo/src/richEditor.tsx b/Composer/packages/lib/code-editor/demo/src/richEditor.tsx
index 6784fa1030..0e345fdc47 100644
--- a/Composer/packages/lib/code-editor/demo/src/richEditor.tsx
+++ b/Composer/packages/lib/code-editor/demo/src/richEditor.tsx
@@ -5,8 +5,7 @@ import React, { useState } from 'react';
import { RichEditor } from '../../src';
-const LU_HELP =
- 'https://github.com/Microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md#lu-file-format';
+const LU_HELP = 'https://aka.ms/lu-file-format';
const content = `# Greeting
-Good morning
diff --git a/Composer/packages/lib/code-editor/src/LuEditor.tsx b/Composer/packages/lib/code-editor/src/LuEditor.tsx
index 8b584900b8..2df912c55e 100644
--- a/Composer/packages/lib/code-editor/src/LuEditor.tsx
+++ b/Composer/packages/lib/code-editor/src/LuEditor.tsx
@@ -12,7 +12,7 @@ import { registerLULanguage } from './languages';
import { createUrl, createWebSocket, createLanguageClient } from './utils/lspUtil';
import { RichEditor, RichEditorProps } from './RichEditor';
-const LU_HELP = 'https://github.com/microsoft/botframework-cli/blob/master/packages/luis/docs/lu-file-format.md';
+const LU_HELP = 'https://aka.ms/lu-file-format';
const placeholder = `> To learn more about the LU file format, read the documentation at
> ${LU_HELP}`;
diff --git a/docs/Create-Your-First-Bot.md b/docs/Create-Your-First-Bot.md
index 996ccbb039..6792514327 100644
--- a/docs/Create-Your-First-Bot.md
+++ b/docs/Create-Your-First-Bot.md
@@ -5,7 +5,7 @@ Follow these six steps to create a weather bot from scratch using Bot Framework
## Prerequisites
- [Bot Framework Composer](https://github.com/microsoft/BotFramework-Composer)
-- Bot Framework Emulator ([download](https://github.com/microsoft/BotFramework-Emulator/releases/tag/v4.5.2))
+- Bot Framework Emulator ([download](https://github.com/microsoft/BotFramework-Emulator/releases/latest))
- LUIS authoring key ([where to find](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys#programmatic-key))
## Step 1: Creating a new bot
@@ -22,7 +22,7 @@ On the right-hand side of the page, select **BF Language Understanding** for **R
In the text editor, type in the intents and utterances, then click **Save**.
-**Note**: You should use the correct file format to edit the recognizer (see example below). Follow this [link](https://github.com/Microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md#lu-file-format) to learn more about the LU format.
+**Note**: You should use the correct file format to edit the recognizer (see example below). Follow this [link](https://aka.ms/lu-file-format) to learn more about the LU format.
diff --git a/docs/CreateYourFirstBot.md b/docs/CreateYourFirstBot.md
index 3c526462b1..6792514327 100644
--- a/docs/CreateYourFirstBot.md
+++ b/docs/CreateYourFirstBot.md
@@ -1,74 +1,77 @@
# Create your first bot
+
Follow these six steps to create a weather bot from scratch using Bot Framework Composer. Alternatively, watch the [video](https://microsoft-my.sharepoint.com/:v:/p/t-yangxi/EVcxF6YjGKZOvJjPZstfS5EBLVlDldzoZ5yQiqJlNs_NKw?e=zkzymp).
## Prerequisites
-* [Bot Framework Composer](https://github.com/microsoft/BotFramework-Composer)
-* Bot Framework Emulator ([download](https://github.com/microsoft/BotFramework-Emulator/releases/tag/v4.5.2))
-* LUIS authoring key ([where to find](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys#programmatic-key))
+
+- [Bot Framework Composer](https://github.com/microsoft/BotFramework-Composer)
+- Bot Framework Emulator ([download](https://github.com/microsoft/BotFramework-Emulator/releases/latest))
+- LUIS authoring key ([where to find](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys#programmatic-key))
## Step 1: Creating a new bot
-On the Composer homepage, click **New**. Select **Create from scratch**. Click **Next**. Give your bot a name, for example *WeatherBot*. Once created, you should be able to see the following screen.
-
+On the Composer homepage, click **New**. Select **Create from scratch**. Click **Next**. Give your bot a name, for example _WeatherBot_. Once created, you should be able to see the following screen.
+
## Step 2: Setting up the intent recognizer
+
On the right-hand side of the page, select **BF Language Understanding** for **Recognizer Type**.
In the text editor, type in the intents and utterances, then click **Save**.
-**Note**: You should use the correct file format to edit the recognizer (see example below). Follow this [link](https://github.com/Microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md#lu-file-format) to learn more about the LU format.
+**Note**: You should use the correct file format to edit the recognizer (see example below). Follow this [link](https://aka.ms/lu-file-format) to learn more about the LU format.
-
## Step 3: Creating event handlers to handle the intents
+
On the **Events** pane, click the **add icon**, then select **Handle an Intent**.
-On the right-hand side of the page, give the intent a name, for example, *GreetingIntentHandler*. In the **Intent** field, type in the name of the intent that this event is intended to handle. **Note**: The name should match the intent name in the recognizer.
+On the right-hand side of the page, give the intent a name, for example, _GreetingIntentHandler_. In the **Intent** field, type in the name of the intent that this event is intended to handle. **Note**: The name should match the intent name in the recognizer.
-It's a good practice to create a handler for each intent. In this guide, we’ve created two handlers named *GreetingIntentHandler* and *CheckWeatherIntentHandler*.
+It's a good practice to create a handler for each intent. In this guide, we’ve created two handlers named _GreetingIntentHandler_ and _CheckWeatherIntentHandler_.
-
## Step 4: Adding actions to the handlers
Here we define the actions that the bot will take when an intent is recognized. You can add actions such as sending messages or performing computational tasks. You can also call a dialog ([SDK docs: Bot Framework Dialogs](https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-concept-dialog?view=azure-bot-service-4.0)) as part of the actions.
-### 4.1: Adding actions to *GreetingIntentHandler*
-Double-click on the *GreetingIntentHandler* node to get started.
+### 4.1: Adding actions to _GreetingIntentHandler_
+
+Double-click on the _GreetingIntentHandler_ node to get started.
-By design, we want the bot to send a message to the user in response to the *Greeting* intent. To do this, click the **add icon**, select **Send Messages**, then select **Send Activity**. On the **Language Generation** pane, type in the bot response. For example, *Hello from the bot!*.
+By design, we want the bot to send a message to the user in response to the _Greeting_ intent. To do this, click the **add icon**, select **Send Messages**, then select **Send Activity**. On the **Language Generation** pane, type in the bot response. For example, _Hello from the bot!_.
-### 4.2 Adding actions to *CheckWeatherIntentHandler*
-Double-click on the *CheckWeatherIntentHandler* node to get started. By design, we want the bot to begin a dialog (and take actions as specified in that dialog) in response to the *CheckWeather* intent. To do this, we first need to create a dialog (e.g. *CheckWeatherDialog*), then add this dialog to the *CheckWeatherIntentHandler*.
+### 4.2 Adding actions to _CheckWeatherIntentHandler_
+
+Double-click on the _CheckWeatherIntentHandler_ node to get started. By design, we want the bot to begin a dialog (and take actions as specified in that dialog) in response to the _CheckWeather_ intent. To do this, we first need to create a dialog (e.g. _CheckWeatherDialog_), then add this dialog to the _CheckWeatherIntentHandler_.
To create a dialog, click **Add** on the **Dialogs** pane, and follow the instructions to complete the process. Once a dialog is created, add actions to this dialog following the same process as described in 4.1.
-
-To add the newly created dialog to the event, first, go back to the root dialog, then select the event to which you want to add the dialog. Click the **add icon**, select **Dialogs**, select **Begin a Dialog**, then choose a dialog from the list.
+To add the newly created dialog to the event, first, go back to the root dialog, then select the event to which you want to add the dialog. Click the **add icon**, select **Dialogs**, select **Begin a Dialog**, then choose a dialog from the list.
-
## Step 5: (Optional) Creating handlers for other types of events
+
Besides recognized intents, you may want to handle other types of events, for example, when there are unrecognized intents or when a user joins the conversation. Creating handlers for these types of events is no different from creating intent handlers. You just need to select a different event type as shown below. For example, select **Greeting (ConversationUpdate)** if you want to send a welcome message to the user when they first join the conversation (when a conversationUpdate event is trigged).
-
## Step 6: Testing your bot
+
Now your bot is ready for testing! Click **Connect/Reload** on the top right corner of the screen, then select **Test in Emulator**.
**Note**: You may be prompted to **Publish LUIS models**. Please follow the link to the LUIS site, go to **Settings**, copy the **Authoring Key**, and fill out the fields to publish LUIS models.
diff --git a/docs/concept-events-and-triggers.md b/docs/concept-events-and-triggers.md
index 268686d479..5da7b3450b 100644
--- a/docs/concept-events-and-triggers.md
+++ b/docs/concept-events-and-triggers.md
@@ -96,7 +96,7 @@ For additional information, see [Custom event](how-to-define-triggers.md#custom-
## Further reading
- [Adaptive dialog: Recognizers, rules, steps and inputs](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/adaptive-dialog/docs/recognizers-rules-steps-reference.md#Rules)
-- [.lu format file](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md)
+- [.lu format file](https://aka.ms/lu-file-format)
- [RegEx recognizer and LUIS recognizer](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/adaptive-dialog/docs/recognizers-rules-steps-reference.md#regex-recognizer)
## Next
diff --git a/docs/how-to-define-advanced-intents-entities.md b/docs/how-to-define-advanced-intents-entities.md
index ee814edcfc..01677bbb76 100644
--- a/docs/how-to-define-advanced-intents-entities.md
+++ b/docs/how-to-define-advanced-intents-entities.md
@@ -1,17 +1,20 @@
-# Advanced intent and entity definition
-In this article, we will cover some details of how LUIS recognizer extracts the intent and entity you may define in Composer. We will also instruct on how to define the different types of entities as shown in the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample).
+# Advanced intent and entity definition
-## Prerequisites:
-- basic knowledge of [intent and entity](concept-language-understanding.md#core-lu-concepts-in-composer)
+In this article, we will cover some details of how LUIS recognizer extracts the intent and entity you may define in Composer. We will also instruct on how to define the different types of entities as shown in the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample).
+
+## Prerequisites:
+
+- basic knowledge of [intent and entity](concept-language-understanding.md#core-lu-concepts-in-composer)
- basic knowledge of [how to define an intent trigger](howto-defining-triggers.md#intent)
- basic knowledge of [how to use LUIS in Composer](howto-using-LUIS.md)
- LUIS account (apply [here](https://www.luis.ai/home))
- LUIS authoring key (how to get [here](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys?tabs=V2#programmatic-key))
## LUIS for entity extraction
-In addition to specifying intents and utterances as instructed in the [how to use LUIS in Composer](howto-using-LUIS.md) article, it is also possible to train LUIS to recognize named entities. Read more about the full capabilities of LUIS recognizers [here](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md).
-Extracted entities are passed along to any triggered actions or child dialogs using the syntax `@{Entity Name}`. For example, given an intent definition like below:
+In addition to specifying intents and utterances as instructed in the [how to use LUIS in Composer](howto-using-LUIS.md) article, it is also possible to train LUIS to recognize named entities. Read more about the full capabilities of LUIS recognizers [here](https://aka.ms/lu-file-format).
+
+Extracted entities are passed along to any triggered actions or child dialogs using the syntax `@{Entity Name}`. For example, given an intent definition like below:
```
# BookFlight
@@ -20,7 +23,7 @@ Extracted entities are passed along to any triggered actions or child dialogs us
- i want to go to {city=paris}
```
-When triggered, if LUIS is able to identify a city, the city name will be made available as `@city` within the triggered actions. The entity value can be used directly in expressions and LG templates, or [stored into a memory property](concept-memory.md) for later use. The JSON view of the query "book me a flight to London" in LUIS app looks like this:
+When triggered, if LUIS is able to identify a city, the city name will be made available as `@city` within the triggered actions. The entity value can be used directly in expressions and LG templates, or [stored into a memory property](concept-memory.md) for later use. The JSON view of the query "book me a flight to London" in LUIS app looks like this:
```json
{
@@ -34,9 +37,7 @@ When triggered, if LUIS is able to identify a city, the city name will be made a
}
},
"entities": {
- "city": [
- "london"
- ],
+ "city": ["london"],
"$instance": {
"city": [
{
@@ -47,9 +48,7 @@ When triggered, if LUIS is able to identify a city, the city name will be made a
"score": 0.834206,
"modelTypeId": 1,
"modelType": "Entity Extractor",
- "recognitionSources": [
- "model"
- ]
+ "recognitionSources": ["model"]
}
]
}
@@ -59,53 +58,62 @@ When triggered, if LUIS is able to identify a city, the city name will be made a
```
## Entities of different types
-In Composer, you can also define entities of different types. In this section, we focus on the following entity types and their definitions. For more entity types read [here](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md).
+
+In Composer, you can also define entities of different types. In this section, we focus on the following entity types and their definitions. For more entity types read [here](https://aka.ms/lu-file-format).
| Type | Description |
| ------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
| [Simple](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-quickstart-primary-and-secondary-data) | extract a single data concept contained in words or phrases |
| [List](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-quickstart-intent-and-list-entity) | extract entity data that matches a predefined list of items |
-### Simple entity
-The purpose of defining a Simple type entity is to teach LUIS to detect a single concept data in an utterance.
+### Simple entity
+
+The purpose of defining a Simple type entity is to teach LUIS to detect a single concept data in an utterance.
Use Simple type entities when the data has the following characteristics:
-- The data is a single concept.
-- The data is not well-formatted.
-- The data is not a prebuilt entity.
+
+- The data is a single concept.
+- The data is not well-formatted.
+- The data is not a prebuilt entity.
- The data does not match exactly to a list of known words.
-- The data does not contain other data items.
+- The data does not contain other data items.
-You can define [Simple]((https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-quickstart-primary-and-secondary-data)) type entities using $\:simple notation. Here is an example from the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample):
+You can define [Simple](<(https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-quickstart-primary-and-secondary-data)>) type entities using \$\:simple notation. Here is an example from the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample):
```markdown
-> Entity definitions
-$ itemTitle : simple
+> Entity definitions
+> \$ itemTitle : simple
+
+> AddItem intent that contains simple entity
-> AddItem intent that contains simple entity
# AddItem
+
- Add todo
- add a to do item
- could i add {itemTitle=medicine} to the todos list
- add {itemTitle} to my todo list
-...
+ ...
```
-This entity definition means that if the `AddItem` intent is detected, the extracted `itemTile` entity value will be passed along to any triggered actions or child dialogs, and is available as `@itemTitle`.
->![NOTE]
+This entity definition means that if the `AddItem` intent is detected, the extracted `itemTile` entity value will be passed along to any triggered actions or child dialogs, and is available as `@itemTitle`.
+
+> ![NOTE]
> For any labelled entity that is not explicitly assigned a type, the ludown parser defaults to simple entity type for that entity.
```markdown
-# getUserName
+# getUserName
+
- my name is {username=susan}
-> Without any explicit entity type definition, the entity defaults to 'Simple' entity type.
+> Without any explicit entity type definition, the entity defaults to 'Simple' entity type.
```
-### List entity
-The purpose of defining a List type entity is to teach LUIS to get entity data that matches a predefined list of items.
+### List entity
+
+The purpose of defining a List type entity is to teach LUIS to get entity data that matches a predefined list of items.
Use List type entities when the data has the following characteristics:
+
- Values of the data are a known set.
- The data does not exceed maximum [LUIS boundaries](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-boundaries).
- The text in the utterance is an exact match with a synonym or the canonical name.
@@ -113,39 +121,41 @@ Use List type entities when the data has the following characteristics:
You can define [List](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-quickstart-intent-and-list-entity) type entities using the following notation:
```markdown
-$listEntity:\=
- - \
- - \
+\$listEntity:\= - \ - \
```
-When using list entity, you should include a value from the list directly in the utterance, not an entity label or any other value. Here is an example definition of a list entity from the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample):
+When using list entity, you should include a value from the list directly in the utterance, not an entity label or any other value. Here is an example definition of a list entity from the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample):
```markdown
> Add a list entity to detect list tye
-$ listType : todo =
+> \$ listType : todo =
+
- to do
- todos
-- laundry
+- laundry
-$ listType : shopping =
-- shopping
+\$ listType : shopping =
+
+- shopping
- shop
- shoppers
-$ listType : grocery =
+\$ listType : grocery =
+
- groceries
- fruits
- vegetables
- household items
- house hold items
```
-This entity definition contains three lists of entities. Based on the user's input, any extracted normalized entity value (e.g. todo/shopping/grocery) will be available as `@listType` within any triggered actions.
-After publishing the model of [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample) to [LUIS](https://www.luis.ai/), you can view in [LUIS](https://www.luis.ai/) the intents and entities you have defined in Composer:
+This entity definition contains three lists of entities. Based on the user's input, any extracted normalized entity value (e.g. todo/shopping/grocery) will be available as `@listType` within any triggered actions.
+
+After publishing the model of [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample) to [LUIS](https://www.luis.ai/), you can view in [LUIS](https://www.luis.ai/) the intents and entities you have defined in Composer:
-And test the model using an example utterance such as "add an apple to my shopping list". The JSON view is as follows:
+And test the model using an example utterance such as "add an apple to my shopping list". The JSON view is as follows:
```json
{
@@ -159,14 +169,8 @@ And test the model using an example utterance such as "add an apple to my shoppi
}
},
"entities": {
- "itemTitle": [
- "apple"
- ],
- "listType": [
- [
- "shopping"
- ]
- ],
+ "itemTitle": ["apple"],
+ "listType": [["shopping"]],
"$instance": {
"itemTitle": [
{
@@ -177,9 +181,7 @@ And test the model using an example utterance such as "add an apple to my shoppi
"score": 0.905890763,
"modelTypeId": 1,
"modelType": "Entity Extractor",
- "recognitionSources": [
- "model"
- ]
+ "recognitionSources": ["model"]
}
],
"listType": [
@@ -190,19 +192,16 @@ And test the model using an example utterance such as "add an apple to my shoppi
"length": 8,
"modelTypeId": 5,
"modelType": "List Entity Extractor",
- "recognitionSources": [
- "model"
- ]
+ "recognitionSources": ["model"]
}
]
}
}
}
}
-
```
# Further reading
-- [Entities and their purpose in LUIS](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-entity-types)
-- [.lu file format](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md)
+- [Entities and their purpose in LUIS](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-entity-types)
+- [.lu file format](https://aka.ms/lu-file-format)
diff --git a/docs/how-to-define-triggers.md b/docs/how-to-define-triggers.md
index 4ba6a62024..508284c4d2 100644
--- a/docs/how-to-define-triggers.md
+++ b/docs/how-to-define-triggers.md
@@ -1,18 +1,20 @@
# Defining triggers
+
Each dialog in the Bot Framework Composer includes a set of triggers (event handlers) that contain actions (instructions) for how the bot will respond to inputs received when the dialog is active. There are several different types of triggers in Composer. They all work in a similar manner and can even be interchanged in some cases. This article explains how to define each type of trigger. Before you walk through this article, please read the [events and triggers](concept-events-and-triggers.md) concept article.
The table below lists the six different types of triggers in Composer and their descriptions.
-| Trigger Type | Description |
-| ----------------- | ------------------------------------------------------------------------------------------- |
-| [Intent recognized](#intent-recognized) | When an intent is recognized the **Intent recognized** trigger fires. |
-| [Unknown intent](#Unknown-intent) | The **Unknown intent** trigger fires when an intent is defined and recognized but there is no **Intent recognized** trigger defined for that intent.|
-| [Dialog events](#Dialog-events) | When a dialog event such as **BeginDialog** occurs it will fire the specified trigger. |
-| [Activities](h#Activities) | When an activity event occurs, such as when a new conversation starts, the **Activities** trigger will fire. |
-| [Message events](#message-events) | When a message activity occurs such as when a message is updated, deleted or reacted to, the **Message events** trigger will fire. |
-| [Custom event](#custom-event) | When an **Emit a custom event** occurs the **Custom event** trigger will fire.|
+| Trigger Type | Description |
+| --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Intent recognized](#intent-recognized) | When an intent is recognized the **Intent recognized** trigger fires. |
+| [Unknown intent](#Unknown-intent) | The **Unknown intent** trigger fires when an intent is defined and recognized but there is no **Intent recognized** trigger defined for that intent. |
+| [Dialog events](#Dialog-events) | When a dialog event such as **BeginDialog** occurs it will fire the specified trigger. |
+| [Activities](h#Activities) | When an activity event occurs, such as when a new conversation starts, the **Activities** trigger will fire. |
+| [Message events](#message-events) | When a message activity occurs such as when a message is updated, deleted or reacted to, the **Message events** trigger will fire. |
+| [Custom event](#custom-event) | When an **Emit a custom event** occurs the **Custom event** trigger will fire. |
## Intent recognized
+
This trigger type is used to define the actions to execute when an [intent](concept-language-understanding.md#intents) is found in a message sent from the user. The **Intent recognized** trigger works in conjunction with **recognizers**. There are two [recognizers](concept-dialog.md#recognizer) in Composer, one for [LUIS](#luis-recognizer) and the other for [Regular Expression](#regular-expression-recognizer). You define which recognizer is used, if any, at the dialog level.
To create the **Intent recognized** trigger, select **New Trigger** in the navigation pane then **Intent recognized** from the drop-down list. You will see the intent trigger menu as follows:
@@ -26,16 +28,17 @@ Once the **Intent recognized** trigger has been created, you can further refine
> [!TIP]
> You need to press the **Enter** key after entering an entity or it will not be saved.
-It is also possible to add a **condition** to the trigger. A condition is an expression that follows [Common Expression Language](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language) syntax. If a condition is specified, it must evaluate to "true" for the event to fire.
+It is also possible to add a **condition** to the trigger. A condition is an expression that follows [Common Expression Language](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language) syntax. If a condition is specified, it must evaluate to "true" for the event to fire.
- The basic steps to define an **Intent recognized** trigger are as follows:
+The basic steps to define an **Intent recognized** trigger are as follows:
1. Set up a [recognizer](./concept-dialog.md#recognizer) type in your dialog.
2. Define [intents](concept-language-understanding.md#intents) in the Language Understanding editor.
3. Create an **Intent recognized** trigger to handle each intent you created (one trigger per intent).
-4. Define [actions]((./concept-dialog.md#action)) in the trigger.
+4. Define [actions](<(./concept-dialog.md#action)>) in the trigger.
### LUIS recognizer
+
[LUIS](https://www.luis.ai/home) is a machine learning-based service you can use to build natural language capabilities into your bot. Using a LUIS recognizer enables you to extract intents and entities based on a LUIS application.
Composer enables developers to create language training data in the dialog authoring canvas because it is deeply integrated with the [LUIS](https://www.luis.ai/home) API. LUIS is able to take natural language input from users and translate it into a named intent and a set of extracted entity values the message contains.
@@ -44,46 +47,47 @@ Follow the steps to define an **Intent recognized** trigger with a LUIS recogniz
1. In the properties panel of your selected dialog, choose **LUIS** as recognizer type.
- 
+ 
+
+2. In the Language Understanding editor, create intents with sample [utterances](concept-language-understanding.md#utterances) following the [.lu file format](https://aka.ms/lu-file-format).
-2. In the Language Understanding editor, create intents with sample [utterances](concept-language-understanding.md#utterances) following the [.lu file format](https://github.com/Microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md#lu-file-format).
+ Below is a screenshot showing the **text editor** in a dialogs properties panel. This example captures two simple _intents_ ("Greeting" and "BookFlight") each with a list of example _utterances_ that capture ways users might express these two intents. You can use - or + or \* to denote lists. Numbered lists are not supported.
- Below is a screenshot showing the **text editor** in a dialogs properties panel. This example captures two simple _intents_ ("Greeting" and "BookFlight") each with a list of example _utterances_ that capture ways users might express these two intents. You can use - or + or * to denote lists. Numbered lists are not supported.
+ 
- 
+ > [!NOTE]
+ > Each intent contains a series of sample utterances which will be used as training data in LUIS to recognize any pre-defined intent.
- >[!NOTE]
- > Each intent contains a series of sample utterances which will be used as training data in LUIS to recognize any pre-defined intent.
-
- > [!IMPORTANT]
- > You will need a [LUIS authoring key](https://aka.ms/bot-framework-emulator-LUIS-keys?tabs=V2#programmatic-key) to get your training data published. For details, read [using LUIS for language understanding](how-to-use-LUIS.md) article.
+ > [!IMPORTANT]
+ > You will need a [LUIS authoring key](https://aka.ms/bot-framework-emulator-LUIS-keys?tabs=V2#programmatic-key) to get your training data published. For details, read [using LUIS for language understanding](how-to-use-LUIS.md) article.
-3. Select **Intent recognized** from the trigger menu and pick the intent you want the trigger to handle. Each **Intent** trigger handles one intent.
+3. Select **Intent recognized** from the trigger menu and pick the intent you want the trigger to handle. Each **Intent** trigger handles one intent.
- 
+ 
-4. Optionally, you can set the **Condition** property to avoid low confidence results given that LUIS is a machine learning based intent classifier. For example, set the **Condition** property to this in the **Greeting** intent:
+4. Optionally, you can set the **Condition** property to avoid low confidence results given that LUIS is a machine learning based intent classifier. For example, set the **Condition** property to this in the **Greeting** intent:
- `#Greeting.Score >=0.8`
+ `#Greeting.Score >=0.8`
- 
+ 
-This definition means that the **Greeting** intent trigger will only fire when the confidence score returned by LUIS is equal to or greater than 0.8.
+This definition means that the **Greeting** intent trigger will only fire when the confidence score returned by LUIS is equal to or greater than 0.8.
### Regular Expression recognizer
+
A [regular expression](https://regexr.com/) is a special text string for describing a search pattern that can be used to match simple or sophisticated patterns in a string. Composer exposes the ability to define intents using regular expressions and also allows regular expressions to extract simple entity values. While LUIS offers the flexibility of a more fully featured language understanding technology, the [regular expression recognizer](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/adaptive-dialog/docs/recognizers-rules-steps-reference.md#regex-recognizer) works well when you need to match a narrow set of highly structured commands or keywords.
In the example below, a similar book-flight intent is defined. However, this will _only_ match the very narrow pattern "book flight to [somewhere]", whereas the LUIS recognizer will be able to match a much wider variety of messages.
Follow the steps to define **Intent recognized** trigger with [Regular Expression](https://regexr.com/) recognizer:
-1. In the properties panel of your selected dialog, choose **Regular Expression** as recognizer type for your dialog.
+1. In the properties panel of your selected dialog, choose **Regular Expression** as recognizer type for your dialog.
- 
+ 
-2. In the regular expression editor, create a regular expression **intent** and **pattern** as shown in the screenshot below:
+2. In the regular expression editor, create a regular expression **intent** and **pattern** as shown in the screenshot below:
- 
+ 
3. You can then create an **Intent recognized** trigger to handle each intent you define as instructed in the [LUIS recognizer](how-to-define-triggers.md#LUIS-recognizer) section.
@@ -91,96 +95,102 @@ Follow the steps to define **Intent recognized** trigger with [Regular Expressio
> For more information on how to write regular expression, read [here](https://regexr.com/).
## Unknown intent
+
This is a trigger type used to define actions to take when there is no **Intent recognized** trigger to handle an existing intent.
Follow the steps to define an **Unknown intent** trigger:
1. In the navigation pane, select **New Trigger**.
-2. Select **Create a Trigger** from the **What is the type of this trigger?** drop-down list, then **Submit**.
+2. Select **Create a Trigger** from the **What is the type of this trigger?** drop-down list, then **Submit**.
- 
+ 
-2. After you select **Submit**, you will see an empty **Unknown intent** trigger in the authoring canvas.
+3. After you select **Submit**, you will see an empty **Unknown intent** trigger in the authoring canvas.
-3. Select the **+** sign under the trigger node to add any action node(s) you want to include. For example, you can select **Send a response** to send a message "This is an unknown intent trigger!". When this trigger is fired, the response message will be sent to the user.
+4. Select the **+** sign under the trigger node to add any action node(s) you want to include. For example, you can select **Send a response** to send a message "This is an unknown intent trigger!". When this trigger is fired, the response message will be sent to the user.
- 
+ 
## Dialog events
-This is a trigger type used to define actions to take when a dialog event such as `BeginDialog` is fired. Most dialogs will include an event handler (trigger) configured to respond to the `BeginDialog` event, which fires when the dialog begins and allows the bot to respond immediately. Follow the steps below to define a **Dialog started** trigger:
+
+This is a trigger type used to define actions to take when a dialog event such as `BeginDialog` is fired. Most dialogs will include an event handler (trigger) configured to respond to the `BeginDialog` event, which fires when the dialog begins and allows the bot to respond immediately. Follow the steps below to define a **Dialog started** trigger:
1. Select **New Trigger** in the navigation pane then select **Dialog events** from the drop-down list.
- 
+ 
-2. Select **Dialog started (Begin dialog event)** from the **Which event?** drop-down list then select **Submit**.
+2. Select **Dialog started (Begin dialog event)** from the **Which event?** drop-down list then select **Submit**.
- 
+ 
-3. Select the **+** sign under the *Dialog started* node and then select **Begin a new dialog** from the **Dialog management** menu.
+3. Select the **+** sign under the _Dialog started_ node and then select **Begin a new dialog** from the **Dialog management** menu.
- 
+ 
-4. Before you can use this trigger you must associate a dialog to it. You do this by selecting a dialog from the **Dialog name** drop-down list in the **properties panel** on the right side of the Composer window. You can select an existing dialog or create a new one. the example below demonstrates selecting and existing dialog named *weather*.
+4. Before you can use this trigger you must associate a dialog to it. You do this by selecting a dialog from the **Dialog name** drop-down list in the **properties panel** on the right side of the Composer window. You can select an existing dialog or create a new one. the example below demonstrates selecting and existing dialog named _weather_.
- 
+ 
## Activities
-This type of trigger is used to handle activity events such as your bot receiving a `ConversationUpdate` Activity. This indicates a new conversation began and you use a **Greeting (ConversationUpdate activity)** trigger to handle it.
-The following steps demonstrate hot to create a **Greeting (ConversationUpdate activity)** trigger to send a welcome message:
+This type of trigger is used to handle activity events such as your bot receiving a `ConversationUpdate` Activity. This indicates a new conversation began and you use a **Greeting (ConversationUpdate activity)** trigger to handle it.
-1. Select **New Trigger** in the navigation pane then **Activities** from the drop-down list.
+The following steps demonstrate hot to create a **Greeting (ConversationUpdate activity)** trigger to send a welcome message:
- 
+1. Select **New Trigger** in the navigation pane then **Activities** from the drop-down list.
+ 
-2. Select **Greeting (ConversationUpdate activity)** from the **Which activity type?** drop-down list then select **Submit**.
+2) Select **Greeting (ConversationUpdate activity)** from the **Which activity type?** drop-down list then select **Submit**.
- 
+ 
-3. Select the **+** sign under the *ConversationUpdate Activity* node and then select **Send a response**.
+3) Select the **+** sign under the _ConversationUpdate Activity_ node and then select **Send a response**.
-4. Author your response in the **Language Generation** editor in the **properties panel** on the right side of the Composer window, by entering a message following [.lg file format](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md) as demonstrated in the image below.
+4) Author your response in the **Language Generation** editor in the **properties panel** on the right side of the Composer window, by entering a message following [.lg file format](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md) as demonstrated in the image below.
- 
+ 
## Custom event
+
The **Custom event** trigger will only fire when a matching **Emit a custom event** occurs. It is a trigger that any dialog in your bot can consume. To define and consume a **Custom event** trigger, you need to create a **Emit a custom event** first. Follow the steps below to create a **Emit a custom event**:
### Emit a custom event
1. In the Composer navigation pane select the trigger you want to associate your custom event with. This opens the trigger in the authoring canvas where you can specify exactly where in the flow you want to trigger this event from. Once determined, select the **+** sign and then select **Emit a custom event** from the **Access external resources** drop-down list.
- 
+ 
-2. In the _properties panel_ of this activity, on the right side of the Composer window, enter a name ("*Weather*") into the **Event name** field, then select **Bubble event**.
+2. In the _properties panel_ of this activity, on the right side of the Composer window, enter a name ("_Weather_") into the **Event name** field, then select **Bubble event**.
- 
+ 
> [!TIP]
-> When **Bubble event** is selected, any event that is not handled in the current dialog will _bubble up_ to that dialogs parent dialog where it will continue to look for handlers for the custom event.
+> When **Bubble event** is selected, any event that is not handled in the current dialog will _bubble up_ to that dialogs parent dialog where it will continue to look for handlers for the custom event.
### Create a custom event trigger
-Now that your **Emit a custom event** has been created, you can create a **Custom event** trigger to handle this event. When the **Emit a custom event** occurs, any matching **Custom event** trigger at any dialog level will fire. Follow the steps to create a **Custom event** trigger to be associated with the previously defined **Emit a custom event**.
-1. Select **New Trigger** in the navigation pane, then select **Custom event** from the drop-down list, then **Submit**.
+Now that your **Emit a custom event** has been created, you can create a **Custom event** trigger to handle this event. When the **Emit a custom event** occurs, any matching **Custom event** trigger at any dialog level will fire. Follow the steps to create a **Custom event** trigger to be associated with the previously defined **Emit a custom event**.
-2. Enter "*Weather*" into the **Custom event name** field in the properties panel on the right side of the Composer window. You must enter the same name ("*Weather*") to associate this trigger with the **Emit a custom event** you defined previously.
+1. Select **New Trigger** in the navigation pane, then select **Custom event** from the drop-down list, then **Submit**.
- 
+2. Enter "_Weather_" into the **Custom event name** field in the properties panel on the right side of the Composer window. You must enter the same name ("_Weather_") to associate this trigger with the **Emit a custom event** you defined previously.
-4. Now you can add an action to your custom event handler, this defines what will happen when it is triggered. Do this by selecting the **+** sign and then **Send a response** from the actions menu. Enter the desired response for this action in the Language Generation editor, for this example enter "This is a custom trigger!".
+ 
- 
+3. Now you can add an action to your custom event handler, this defines what will happen when it is triggered. Do this by selecting the **+** sign and then **Send a response** from the actions menu. Enter the desired response for this action in the Language Generation editor, for this example enter "This is a custom trigger!".
+
+ 
Now you have completed both of the required steps needed to create and execute a custom event. When **Emit a custom event** fires, your custom event handler will fire and handle this event, sending the response you defined.
## References
+
- The [Events and triggers](./concept-events-and-triggers.md) concept article.
-## Next
+## Next
+
- Learn how to [control conversation flow](./how-to-control-conversation-flow.md).
diff --git a/docs/how-to-use-LUIS.md b/docs/how-to-use-LUIS.md
index 444dd6c526..7c547d0c23 100644
--- a/docs/how-to-use-LUIS.md
+++ b/docs/how-to-use-LUIS.md
@@ -1,76 +1,85 @@
-# Using LUIS for language understanding
-Language Understanding Intelligent Service ([LUIS](https://www.luis.ai/home)) is a cloud-based API service to build natural language into apps and bots. Adding LUIS to your bots enables them to understand the users' intents conversationally and contextually so that your bots can decide what to respond to the users. Bot Framework Composer provides tools to train and manage language understanding components and it's easier for developers to add LUIS when they develop bots with Composer. In this article, we will walk you through the steps to use LUIS when you develop your bots with Composer. To further explore how to use LUIS in Bot Composer, you may refer to the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample).
+# Using LUIS for language understanding
+
+Language Understanding Intelligent Service ([LUIS](https://www.luis.ai/home)) is a cloud-based API service to build natural language into apps and bots. Adding LUIS to your bots enables them to understand the users' intents conversationally and contextually so that your bots can decide what to respond to the users. Bot Framework Composer provides tools to train and manage language understanding components and it's easier for developers to add LUIS when they develop bots with Composer. In this article, we will walk you through the steps to use LUIS when you develop your bots with Composer. To further explore how to use LUIS in Bot Composer, you may refer to the [ToDoBotWithLuisSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/ToDoBotWithLuisSample).
+
+## Prerequisites
-## Prerequisites
- Basic knowledge of language understanding (concept article [here](./concept-language-understanding.md))
- Basic knowledge of events and triggers (concept article [here](./concept-events-and-triggers.md))
- LUIS account (apply [here](https://www.luis.ai/home))
- LUIS authoring key (how to get [here](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys?tabs=V2#programmatic-key))
-## How to add LUIS
-To determine user's intent, in Composer you define the **Intent recognized** trigger, and then specify the actions to take when an intent is recognized (and optionally **entities**). For more details please read the [events and triggers](./concept-events-and-triggers.md) article.
+## How to add LUIS
+
+To determine user's intent, in Composer you define the **Intent recognized** trigger, and then specify the actions to take when an intent is recognized (and optionally **entities**). For more details please read the [events and triggers](./concept-events-and-triggers.md) article.
-Composer currently supports two types of recognizers: LUIS recognizer (default) and Regular expression recognizer. You can only choose one type of recognizer for each dialog. Besides the recognizer, each dialog may contain a set of Language Understanding data authored in [.lu format](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md).
+Composer currently supports two types of recognizers: LUIS recognizer (default) and Regular expression recognizer. You can only choose one type of recognizer for each dialog. Besides the recognizer, each dialog may contain a set of Language Understanding data authored in [.lu format](https://aka.ms/lu-file-format).
-In this section, we will cover the steps to use LUIS as recognizer in your bot. These steps include the following: set a recognizer type for each dialog, author Language Understanding training data, publish your Language Understanding (LU) data, and test them in emulator.
+In this section, we will cover the steps to use LUIS as recognizer in your bot. These steps include the following: set a recognizer type for each dialog, author Language Understanding training data, publish your Language Understanding (LU) data, and test them in emulator.
-### Set LUIS as recognizer
-In Composer, each dialog can have one type of recognizer and might contain a set of Language Understanding training data. To add LUIS to your bot, you need to select LUIS as the recognizer type for the specific dialog you want to define. To set LUIS as recognizer, follow the steps:
+### Set LUIS as recognizer
-1. On the left navigation pane, select the dialog you want to set LUIS recognizer.
+In Composer, each dialog can have one type of recognizer and might contain a set of Language Understanding training data. To add LUIS to your bot, you need to select LUIS as the recognizer type for the specific dialog you want to define. To set LUIS as recognizer, follow the steps:
+
+1. On the left navigation pane, select the dialog you want to set LUIS recognizer.
2. On the properties panel on the right side, select **LUIS** as recognizer type.
### Author LU
-You can author Language Understanding (LU) in the inline editor and follow the [.lu file format](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md). An LU file usually consists of an intent with matching example utterances. You can author as many intents as you want to include in the dialog. The following screenshot shows two intents: **Greeting** and **CheckWeather** with the respective matching utterances.
+
+You can author Language Understanding (LU) in the inline editor and follow the [.lu file format](https://aka.ms/lu-file-format). An LU file usually consists of an intent with matching example utterances. You can author as many intents as you want to include in the dialog. The following screenshot shows two intents: **Greeting** and **CheckWeather** with the respective matching utterances.
-### Define an **Intent recognized** trigger
-You need to define an **Intent recognized** trigger to handle the pre-defined intents. This type of trigger works with the **recognizers**. Each **Intent recognized** trigger handles one intent. Follow the steps to define an **Intent recognized** trigger.
+### Define an **Intent recognized** trigger
+
+You need to define an **Intent recognized** trigger to handle the pre-defined intents. This type of trigger works with the **recognizers**. Each **Intent recognized** trigger handles one intent. Follow the steps to define an **Intent recognized** trigger.
1. Select the dialog on the left side navigation pane and click **New Trigger**
-2. In the pop-up window, select **Intent recognized** from the drop-down menu and then configure the intent to this trigger from the drop-down menu. Click **Submit**. You need to define an **Intent recognized** trigger to handle each pre-defined intent.
+2. In the pop-up window, select **Intent recognized** from the drop-down menu and then configure the intent to this trigger from the drop-down menu. Click **Submit**. You need to define an **Intent recognized** trigger to handle each pre-defined intent.
-After you define your trigger and configure it to specific intent, you can add actions to be executed after the trigger is fired. For example, you can send a response message.
+After you define your trigger and configure it to specific intent, you can add actions to be executed after the trigger is fired. For example, you can send a response message.
3. Click the " + " sign below the trigger node and select **Send a response**
-4. Define the response message in the language generation editor and follow the [.lg file format](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md). The screenshot below shows how to author a response message "This is a Greeting intent!" in the Language Generation editor.
+4. Define the response message in the language generation editor and follow the [.lg file format](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md). The screenshot below shows how to author a response message "This is a Greeting intent!" in the Language Generation editor.
-### Publish
-After you are done with all previous steps, you are ready to publish your language model to LUIS. Please do the following steps to publish your training data:
+### Publish
+
+After you are done with all previous steps, you are ready to publish your language model to LUIS. Please do the following steps to publish your training data:
1. click **Start Bot** on the upper right corner of your Composer
-2. fill in your LUIS authoring key and
-3. click **Publish**.
+2. fill in your LUIS authoring key and
+3. click **Publish**.
-Any time you hit **start bot** (or **restart bot**), Composer will evaluate if your LU content has changed. If so Composer will automatically make required updates to your LUIS application, train and publish them. If you go to your LUIS app website, you will find the newly published LU model.
+Any time you hit **start bot** (or **restart bot**), Composer will evaluate if your LU content has changed. If so Composer will automatically make required updates to your LUIS application, train and publish them. If you go to your LUIS app website, you will find the newly published LU model.
-### Test
-To test your bot which you just added LUIS to, click the **Test in Emulator** button on the upper right corner of Composer. When you emulator is running, send in messages indicating different intents to see if they match the pre-defined intents.
+### Test
+
+To test your bot which you just added LUIS to, click the **Test in Emulator** button on the upper right corner of Composer. When you emulator is running, send in messages indicating different intents to see if they match the pre-defined intents.
-## References
+## References
+
- [LUIS.ai](https://www.luis.ai/home)
- [Add natural language understanding to your bot](https://docs.microsoft.com/azure/bot-service/bot-builder-howto-v4-luis)
-- [Events and triggers](./concept-events-and-triggers.md)
+- [Events and triggers](./concept-events-and-triggers.md)
- [Language Understanding](./concept-language-understanding.md)
-## Next
-- Learn [how to add a QnA Maker knowledge base to your bot](./how-to-add-qna-to-bot.md).
+## Next
+- Learn [how to add a QnA Maker knowledge base to your bot](./how-to-add-qna-to-bot.md).
diff --git a/docs/how-to-use-validation.md b/docs/how-to-use-validation.md
index 1635ef0180..7a5053c079 100644
--- a/docs/how-to-use-validation.md
+++ b/docs/how-to-use-validation.md
@@ -1,22 +1,23 @@
# Linting and validation
-As an integrated development tool, Bot Framework Composer supports validation of data when you author an [.lg](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md) template, an [.lu](https://github.com/Microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md) template, and [expressions](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language) to fill in property fields. Error indicators will show in both inline editors and corresponding all-up views (**Bot Responses** and **User Input**). The **Notifications** page (click **Notifications** icon on the left navigation pane) displays an aggregation of all errors and warnings. With the help of linting and validation, your bot-authoring experience will be improved and you can easily build a functional bot that can "run".
+As an integrated development tool, Bot Framework Composer supports validation of data when you author an [.lg](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md) template, an [.lu](https://aka.ms/lu-file-format) template, and [expressions](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language) to fill in property fields. Error indicators will show in both inline editors and corresponding all-up views (**Bot Responses** and **User Input**). The **Notifications** page (click **Notifications** icon on the left navigation pane) displays an aggregation of all errors and warnings. With the help of linting and validation, your bot-authoring experience will be improved and you can easily build a functional bot that can "run".
> [!NOTE]
-> We are still working to improve the implementation of linting and validation in Composer. More user scenarios will be updated.
+> We are still working to improve the implementation of linting and validation in Composer. More user scenarios will be updated.
-Whenever you see `Start Bot` button in grey, this indicates your bot has errors that prevent it from running successfully.
+Whenever you see `Start Bot` button in grey, this indicates your bot has errors that prevent it from running successfully.
-The number beside the error icon indicates the number of errors. Click the error icon you will be navigated to the **Notifications** page listing all errors and warnings.
+The number beside the error icon indicates the number of errors. Click the error icon you will be navigated to the **Notifications** page listing all errors and warnings.
-Click any of the errors on the **Notifications** page will navigate you to the matching error location. After you fix all the errors, you will see the `Start Bot` button in blue, this indicates your bot has no errors and it will run successfully.
+Click any of the errors on the **Notifications** page will navigate you to the matching error location. After you fix all the errors, you will see the `Start Bot` button in blue, this indicates your bot has no errors and it will run successfully.
## .lg files
-When you author an [.lg template](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md) that has syntax errors, an indicator will show in the inline editor with a red wiggling line.
+
+When you author an [.lg template](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md) that has syntax errors, an indicator will show in the inline editor with a red wiggling line.
@@ -24,35 +25,34 @@ To diagnose and fix the error, you can read the error message beneath the editor
-Click **Bot Responses** on the left navigation pane, you will find the error is also saved and updated in the lg all-up view. The tiny red rectangle on the right end of the editor helps you to identify where the error is. This is especially helpful when you have a long list of templates. Hover your mouse over the erroneous part you will see detailed error message with suggested fixes.
+Click **Bot Responses** on the left navigation pane, you will find the error is also saved and updated in the lg all-up view. The tiny red rectangle on the right end of the editor helps you to identify where the error is. This is especially helpful when you have a long list of templates. Hover your mouse over the erroneous part you will see detailed error message with suggested fixes.
-
## .lu files
-When you author an [.lu template](https://github.com/Microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md) that has syntax errors, the entire lu inline editor will be in red frame. To diagnose and fix the error, you can read the error message beneath the editor and click `here` to refer to the syntax documentation.
+
+When you author an [.lu template](https://aka.ms/lu-file-format) that has syntax errors, the entire lu inline editor will be in red frame. To diagnose and fix the error, you can read the error message beneath the editor and click `here` to refer to the syntax documentation.
-Click **User Input** on the left navigation pane, you will see a popup window describing the lu error message.
+Click **User Input** on the left navigation pane, you will see a popup window describing the lu error message.
-Click **Edit** button you will see the error is also saved and updated in the lu all-up view. You can choose to fix the error either in the lu all-up view or in the inline editor.
+Click **Edit** button you will see the error is also saved and updated in the lu all-up view. You can choose to fix the error either in the lu all-up view or in the inline editor.
-
## Expressions
-When you fill in property fields with invalid [expressions](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language) or when a required property is missing, the entire form editor will be in red frame.
+
+When you fill in property fields with invalid [expressions](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language) or when a required property is missing, the entire form editor will be in red frame.
-To diagnose and fix the error, you can read the error message beneath the editor and click `here` to refer to the syntax documentation.
+To diagnose and fix the error, you can read the error message beneath the editor and click `here` to refer to the syntax documentation.
-
# Next
-TBD
+TBD
diff --git a/docs/olddocs/CreateYourFirstBot.md b/docs/olddocs/CreateYourFirstBot.md
index 4040625567..c6dc33d8ee 100644
--- a/docs/olddocs/CreateYourFirstBot.md
+++ b/docs/olddocs/CreateYourFirstBot.md
@@ -1,74 +1,77 @@
# Create your first bot
+
Follow these six steps to create a weather bot from scratch using Bot Framework Composer. Alternatively, watch the [video](https://microsoft-my.sharepoint.com/:v:/p/t-yangxi/EVcxF6YjGKZOvJjPZstfS5EBLVlDldzoZ5yQiqJlNs_NKw?e=zkzymp).
## Prerequisites
-* [Bot Framework Composer](https://github.com/microsoft/BotFramework-Composer)
-* Bot Framework Emulator ([download](https://github.com/microsoft/BotFramework-Emulator/releases/tag/v4.5.2))
-* LUIS authoring key ([where to find](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys#programmatic-key))
+
+- [Bot Framework Composer](https://github.com/microsoft/BotFramework-Composer)
+- Bot Framework Emulator ([download](https://github.com/microsoft/BotFramework-Emulator/releases/latest))
+- LUIS authoring key ([where to find](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys#programmatic-key))
## Step 1: Creating a new bot
-On the Composer homepage, click **New**. Select **Create from scratch**. Click **Next**. Give your bot a name, for example *WeatherBot*. Once created, you should be able to see the following screen.
-
+On the Composer homepage, click **New**. Select **Create from scratch**. Click **Next**. Give your bot a name, for example _WeatherBot_. Once created, you should be able to see the following screen.
+
## Step 2: Setting up the intent recognizer
+
On the right-hand side of the page, select **BF Language Understanding** for **Recognizer Type**.
In the text editor, type in the intents and utterances, then click **Save**.
-**Note**: You should use the correct file format to edit the recognizer (see example below). Follow this [link](https://github.com/Microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md#lu-file-format) to learn more about the LU format.
+**Note**: You should use the correct file format to edit the recognizer (see example below). Follow this [link](https://aka.ms/lu-file-format) to learn more about the LU format.
-
## Step 3: Creating event handlers to handle the intents
+
On the **Events** pane, click the **add icon**, then select **Handle an Intent**.
-On the right-hand side of the page, give the intent a name, for example, *GreetingIntentHandler*. In the **Intent** field, type in the name of the intent that this event is intended to handle. **Note**: The name should match the intent name in the recognizer.
+On the right-hand side of the page, give the intent a name, for example, _GreetingIntentHandler_. In the **Intent** field, type in the name of the intent that this event is intended to handle. **Note**: The name should match the intent name in the recognizer.
-It's a good practice to create a handler for each intent. In this guide, we’ve created two handlers named *GreetingIntentHandler* and *CheckWeatherIntentHandler*.
+It's a good practice to create a handler for each intent. In this guide, we’ve created two handlers named _GreetingIntentHandler_ and _CheckWeatherIntentHandler_.
-
## Step 4: Adding actions to the handlers
Here we define the actions that the bot will take when an intent is recognized. You can add actions such as sending messages or performing computational tasks. You can also call a dialog ([SDK docs: Bot Framework Dialogs](https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-concept-dialog?view=azure-bot-service-4.0)) as part of the actions.
-### 4.1: Adding actions to *GreetingIntentHandler*
-Double-click on the *GreetingIntentHandler* node to get started.
+### 4.1: Adding actions to _GreetingIntentHandler_
+
+Double-click on the _GreetingIntentHandler_ node to get started.
-By design, we want the bot to send a message to the user in response to the *Greeting* intent. To do this, click the **add icon**, select **Send Messages**, then select **Send Activity**. On the **Language Generation** pane, type in the bot response. For example, *Hello from the bot!*.
+By design, we want the bot to send a message to the user in response to the _Greeting_ intent. To do this, click the **add icon**, select **Send Messages**, then select **Send Activity**. On the **Language Generation** pane, type in the bot response. For example, _Hello from the bot!_.
-### 4.2 Adding actions to *CheckWeatherIntentHandler*
-Double-click on the *CheckWeatherIntentHandler* node to get started. By design, we want the bot to begin a dialog (and take actions as specified in that dialog) in response to the *CheckWeather* intent. To do this, we first need to create a dialog (e.g. *CheckWeatherDialog*), then add this dialog to the *CheckWeatherIntentHandler*.
+### 4.2 Adding actions to _CheckWeatherIntentHandler_
+
+Double-click on the _CheckWeatherIntentHandler_ node to get started. By design, we want the bot to begin a dialog (and take actions as specified in that dialog) in response to the _CheckWeather_ intent. To do this, we first need to create a dialog (e.g. _CheckWeatherDialog_), then add this dialog to the _CheckWeatherIntentHandler_.
To create a dialog, click **Add** on the **Dialogs** pane, and follow the instructions to complete the process. Once a dialog is created, add actions to this dialog following the same process as described in 4.1.
-
-To add the newly created dialog to the event, first, go back to the root dialog, then select the event to which you want to add the dialog. Click the **add icon**, select **Dialogs**, select **Begin a Dialog**, then choose a dialog from the list.
+To add the newly created dialog to the event, first, go back to the root dialog, then select the event to which you want to add the dialog. Click the **add icon**, select **Dialogs**, select **Begin a Dialog**, then choose a dialog from the list.
-
## Step 5: (Optional) Creating handlers for other types of events
+
Besides recognized intents, you may want to handle other types of events, for example, when there are unrecognized intents or when a user joins the conversation. Creating handlers for these types of events is no different from creating intent handlers. You just need to select a different event type as shown below. For example, select **Handle ConversationUpdate** if you want to send a welcome message to the user when they first join the conversation (when a conversationUpdate event is trigged).
-
## Step 6: Testing your bot
+
Now your bot is ready for testing! Click **Connect/Reload** on the top right corner of the screen, then select **Test in Emulator**.
**Note**: You may be prompted to **Publish LUIS models**. Please follow the link to the LUIS site, go to **Settings**, copy the **Authoring Key**, and fill out the fields to publish LUIS models.
diff --git a/docs/olddocs/testing_debugging.md b/docs/olddocs/testing_debugging.md
index 0469e708c7..96896f32f0 100644
--- a/docs/olddocs/testing_debugging.md
+++ b/docs/olddocs/testing_debugging.md
@@ -4,7 +4,7 @@ This document will explain different techniques you can use to test & debug your
**Pre-requisites:**
-[Bot Framework Emulator](https://github.com/microsoft/BotFramework-Emulator/releases/tag/v4.5.2)
+[Bot Framework Emulator](https://github.com/microsoft/BotFramework-Emulator/releases/latest)
[Bot Framework Composer](https://github.com/Microsoft/BotFramework-Composer#installing-bot-framework-composer)
@@ -78,7 +78,7 @@ Attempting to save changes that do not match the LU file format results in an er
-Seeing this error means that you have badly formatted lu data. Refer to the [LU file format](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md) for troubleshooting.
+Seeing this error means that you have badly formatted lu data. Refer to the [LU file format](https://aka.ms/lu-file-format) for troubleshooting.
_Saving LG data_
diff --git a/docs/olddocs/triggers_and_events.md b/docs/olddocs/triggers_and_events.md
index f8e4465ed6..50f55309ca 100644
--- a/docs/olddocs/triggers_and_events.md
+++ b/docs/olddocs/triggers_and_events.md
@@ -71,7 +71,7 @@ Once intents have been defined in the Language Understanding configuration of a
-In addition to specifying intents and utterances, it is also possible to train LUIS to recognize named entities and patterns. [Read more about the full capabilities of LUIS recognizers here](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md)
+In addition to specifying intents and utterances, it is also possible to train LUIS to recognize named entities and patterns. [Read more about the full capabilities of LUIS recognizers here](https://aka.ms/lu-file-format)
Extracted entities are passed along to any triggered actions or child dialogs using the syntax memory path `@[Entity Name]`. For example, given an intent definition like below:
@@ -117,7 +117,7 @@ TODO: clean this up
## Further Reading
-- [LU file format](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md)
+- [LU file format](https://aka.ms/lu-file-format)
- [LUIS.ai docs](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/home)
- [Adaptive Dialog Events](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/adaptive-dialog/docs/recognizers-rules-steps-reference.md#Rules)
- [Messaging processing pipeline in adaptive dialogs](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/adaptive-dialog/docs/anatomy-and-runtime-behavior.md#runtime-behavior-adaptive-dialog)
diff --git a/docs/tutorial/tutorial-luis.md b/docs/tutorial/tutorial-luis.md
index c223581f25..73abac6086 100644
--- a/docs/tutorial/tutorial-luis.md
+++ b/docs/tutorial/tutorial-luis.md
@@ -1,16 +1,18 @@
# Tutorial: Using LUIS for Language Understanding
-Up until this point, we have been using a simple regex recognizer to detect user intent. Bot Framework Composer has deep integration with LUIS.
+
+Up until this point, we have been using a simple regex recognizer to detect user intent. Bot Framework Composer has deep integration with LUIS.
In this tutorial, you learn how to:
> [!div class="checklist"]
-> * Add LUIS into your bot with Composer for Language Understanding
+>
+> - Add LUIS into your bot with Composer for Language Understanding
## Prerequisites
+
- Completion of the tutorial [Incorporating cards and buttons into your bot](./tutorial-cards.md).
- A working knowledge of the concepts taught in the [Language Understanding](../concept-language-understanding.md) article.
-- [LUIS](https://www.luis.ai/home) and how to get [LUIS authoring key](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys#programmatic-key).
-
+- [LUIS](https://www.luis.ai/home) and how to get [LUIS authoring key](https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-keys#programmatic-key).
## Update recognizer
@@ -18,11 +20,12 @@ In this tutorial, you learn how to:
-2. To work with LUIS recognizer, you can provide content in the [***.lu file foramt***](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md) that is highly similar to Language Generation format.
+2. To work with LUIS recognizer, you can provide content in the [**_.lu file format_**](https://aka.ms/lu-file-format) that is highly similar to Language Generation format.
- With this, intents are denoted using the markdown section notation - e.g. `# intentName` and utterances are provided as a list.
+ With this, intents are denoted using the markdown section notation - e.g. `# intentName` and utterances are provided as a list.
+
+ Replace the recognizer content with this -
- Replace the recognizer content with this -
```
> See https://aka.ms/lu-file-format to learn about supported LU concepts.
@@ -51,8 +54,8 @@ In this tutorial, you learn how to:
-3. Once you have done this, you need to re-configure the various **Intent** triggers within that dialog.
-4. Click on `weather` trigger in the left navigation. Select `Weather` from the intent drop-down menu in the properties panel on the right side of the Composer.
+3. Once you have done this, you need to re-configure the various **Intent** triggers within that dialog.
+4. Click on `weather` trigger in the left navigation. Select `Weather` from the intent drop-down menu in the properties panel on the right side of the Composer.
Update the title of the trigger to `Weather` instead of **Intent**
@@ -62,11 +65,11 @@ In this tutorial, you learn how to:
Update the title of the trigger to `Cancel` instead of **Intent**
-6. Given we are using LUIS which is a machine learning based intent classifier, we want to avoid low confidence results. To do this,
+6. Given we are using LUIS which is a machine learning based intent classifier, we want to avoid low confidence results. To do this,
- Set the **Condition** property to this
+ Set the **Condition** property to this
- `#Cancel.Score >= 0.8`
+ `#Cancel.Score >= 0.8`
@@ -76,31 +79,31 @@ In this tutorial, you learn how to:
Update the title of the trigger to `Help` instead of **Intent**
- Set the `Condition` property to this
+ Set the `Condition` property to this
- `#Help.Score >= 0.5`
+ `#Help.Score >= 0.5`
> This says do not fire the cancel trigger if the confidence score returned by LUIS is lower than or equal to 0.5
-7. Click on **Restart Bot**
+8. Click on **Restart Bot**
- Composer has now detected that you have LU information specified and it needs to create/ update corresponding LUIS applications.
+ Composer has now detected that you have LU information specified and it needs to create/ update corresponding LUIS applications.
For `Authoring key`, click on `environment` in the top right corner of your screen (this is right above where this documenation content is displayed) and copy `LUIS authoring key 1` into the composer window
-8. Click `Publish`. This should take a minute or two to complete. Composer will render progress at the top right corner of the screen.
-9. Click on **Test in Emulator** and talk to the bot.
+9. Click `Publish`. This should take a minute or two to complete. Composer will render progress at the top right corner of the screen.
+10. Click on **Test in Emulator** and talk to the bot.
---
With LUIS, you no longer have to type in exact regex patterns to trigger specific scenarios for your bot. Try things like:
-* "How is the weather"
-* "Weather please"
-* "Can you help me"
-* "Cancel please"
+- "How is the weather"
+- "Weather please"
+- "Can you help me"
+- "Cancel please"
@@ -108,16 +111,16 @@ With LUIS, you no longer have to type in exact regex patterns to trigger specifi
## Using LUIS for entity extraction
-You can use LUIS to recognize entities from what the user says.
+You can use LUIS to recognize entities from what the user says.
-As an example, the user could say "How is the weather in 98052?" and instead of prompting the user again for a zipcode, we could just go straight to pulling up weather information if the user had already provided that as part of their initial query.
+As an example, the user could say "How is the weather in 98052?" and instead of prompting the user again for a zipcode, we could just go straight to pulling up weather information if the user had already provided that as part of their initial query.
-Let's get this wired up.
+Let's get this wired up.
-10. Step one is to add a regex entity extractor to the LUIS app. To do this, click on `WeatherBot.Main` and on the right side, add the following entity definition at the end of the LU content -
+10. Step one is to add a regex entity extractor to the LUIS app. To do this, click on `WeatherBot.Main` and on the right side, add the following entity definition at the end of the LU content -
```
- > regex zipcode entity. Any time LUIS sees a five digit number, it will flag it as 'zipcode' entity.
+ > regex zipcode entity. Any time LUIS sees a five digit number, it will flag it as 'zipcode' entity.
$ zipcode : /[0-9]{5}/
```
@@ -126,20 +129,20 @@ Let's get this wired up.
11. Next, let's configure your `prompt for zipcode` to use the entity if LUIS finds it. To do this, open `getWeather` dialog from the left navigation menu, select `BeginDialog` trigger and scroll to and find the prompt.
- 
+ 
12. Let's insert an action **before** the prompt by clicking on **+**, musing over **Manage Properties** and selecting **Set a property**
-13. Since the prompt itself is trying to set the zipcode in the `user.zipcode`, let's set that property to the `@zipcode` entity.
+13. Since the prompt itself is trying to set the zipcode in the `user.zipcode`, let's set that property to the `@zipcode` entity.
- Set **Property** to
+ Set **Property** to
- `user.zipcode`
+ `user.zipcode`
- Set **Value** to
+ Set **Value** to
- `@zipcode`
+ `@zipcode`
- 
+ 
14. Click on **Restart Bot**, wait for the LUIS application to be updated (since you added a new entity) and then click on **Test in Emulator**
@@ -147,5 +150,4 @@ Let's get this wired up.
Now when you say "how is the weather in 98052" you should see your bot directly provide weather for that location instead of prompting you for zipcode.
-
----
+## 
diff --git a/toc.md b/toc.md
index 720cfb389e..5071868fb7 100644
--- a/toc.md
+++ b/toc.md
@@ -1,23 +1,31 @@
-
# Microsoft Bot Framework Composer
+
### Overview
+
- [Introduction to Bot Framework Composer](./docs/introduction.md)
-### Installation
+
+### Installation
+
- [Set up Composer using Yarn](./docs/setup-yarn.md)
+
### QuickStart
+
- [Tour of Composer](./docs/onboarding.md)
-- [Create your first bot](./docs/quickstart-create-bot.md)
+- [Create your first bot](./docs/quickstart-create-bot.md)
+
### Tutorials
+
0. [Introduction](./docs/tutorial/tutorial-introduction.md)
1. [Create a bot](./docs/tutorial/tutorial-create-bot.md)
-2. [Add a dialog](./docs/tutorial/tutorial-add-dialog.md)
-3. [Get weather report](./docs/tutorial/tutorial-get-weather.md)
-4. [Add help and cancel commands](./docs/tutorial/tutorial-add-help.md)
-5. [Add Language Generation](./docs/tutorial/tutorial-lg.md)
-6. [Use cards](./docs/tutorial/tutorial-cards.md)
-7. [Add LUIS](./docs/tutorial/tutorial-luis.md)
-
-### Concepts
+1. [Add a dialog](./docs/tutorial/tutorial-add-dialog.md)
+1. [Get weather report](./docs/tutorial/tutorial-get-weather.md)
+1. [Add help and cancel commands](./docs/tutorial/tutorial-add-help.md)
+1. [Add Language Generation](./docs/tutorial/tutorial-lg.md)
+1. [Use cards](./docs/tutorial/tutorial-cards.md)
+1. [Add LUIS](./docs/tutorial/tutorial-luis.md)
+
+### Concepts
+
- [Dialogs](./docs/concept-dialog.md)
- [Events and triggers](./docs/concept-events-and-triggers.md)
- [Conversation flow and memory](./docs/concept-memory.md)
@@ -25,32 +33,42 @@
- [Language understanding](./docs/concept-language-understanding.md)
### How to
+
#### Develop
+
- [Send messages](./docs/how-to-send-messages.md)
- [Ask for user input](./docs/how-to-ask-for-user-input.md)
- [Manage conversation flow](./docs/how-to-control-conversation-flow.md)
- [Add LUIS to your bot](./docs/how-to-use-LUIS.md)
- [Add QnA to your bot](./docs/how-to-add-qna-to-bot.md)
-- [Send cards](./docs/how-to-send-cards.md)
+- [Send cards](./docs/how-to-send-cards.md)
- [Define triggers and events](./docs/how-to-define-triggers.md)
- [Define advanced intents and entities](./docs/how-to-define-advanced-intents-entities.md)
- [Use OAuth](./docs/how-to-use-oauth.md)
- [Send an HTTP request](./docs/how-to-send-http-request.md)
+
#### Test
+
- [Test in Emulator](https://docs.microsoft.com/en-us/azure/bot-service/bot-service-debug-emulator?view=azure-bot-service-4.0&tabs=csharp)
+
#### Debug
+
- [Linting and validation](./docs/how-to-use-validation.md)
+
#### Publish
+
- [Publish your bot to Azure](/docs/how-to-publish-bot.md)
### Resources
+
- [Bot Framework Adaptive Dialog](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/adaptive-dialog)
- [Language generation](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/language-generation)
- [Common expression language](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/common-expression-language)
-- [.lu file format](https://github.com/microsoft/botbuilder-tools/blob/master/packages/Ludown/docs/lu-file-format.md)
+- [.lu file format](https://aka.ms/lu-file-format)
- [.lg file format](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md)
## Related projects
-* [Bot Framework](https://github.com/microsoft/botframework)
-* [Bot Framework SDK](https://github.com/microsoft/botframework-sdk)
-* [Bot Framework Emulator](https://github.com/microsoft/botframework-emulator)
+
+- [Bot Framework](https://github.com/microsoft/botframework)
+- [Bot Framework SDK](https://github.com/microsoft/botframework-sdk)
+- [Bot Framework Emulator](https://github.com/microsoft/botframework-emulator)