vania-janet/multiturn-rag-retrieval-data huggingface dataset:
[Shows the Move menu with a list of one intent options](https://cloud.ibm.com/docs-content/v1/content/a2b18c153837bce00a5b4de496e4b4ca64bbf56e/assistant-data/images/intent-move-conflict.png)

When deciding where to put an example, look for the intent that has synonymous, or nearly synonymous, examples.

If the exact same example is used by the other intent already, the move action only removes the example from the current intent. It does not add the same example to the other intent twice.
5. After moving or deleting the example, click Submit to resolve the conflict.

![Shows a resolved conflict](https://cloud.ibm.com/docs-content/v1/content/a2b18c153837bce00a5b4de496e4b4ca64bbf56e/assistant-data/images/intent-submit-conflict.png)

The Reset reverts your changes. Click the x to close the page without submitting your changes.
6. Repeat the previous steps to resolve other intents with conflicts.







 Deleting intents 

You can select a number of intents for deletion.

IMPORTANT: By deleting intents that you are also deleting all associated examples, and these items cannot be retrieved later. All dialog nodes that reference these intents must be updated manually to no longer reference the deleted content.



1. Go to the Intents page



* To delete all intents, meaning the intents listed on this and any additional pages, do not select any individual intents. Instead, click the Delete all intents icon. ![Delete option](https://cloud.ibm.com/docs-content/v1/content/a2b18c153837bce00a5b4de496e4b4ca64bbf56e/assistant-data/images/delete-c10.png)
Target The target is the resource against which the action is performed, attempted to perform, or is pending to complete. 



[Learn more](https://cloud.ibm.com/docs/services/activity-tracker?topic=activity-tracker-eventevent).





 Next steps 



1. [Define custom views](https://cloud.ibm.com/docs/services/activity-tracker?topic=activity-tracker-views).
2. Upgrade the IBM Cloud Activity Tracker service plan to a paid plan to be able to [search events by applying a query](https://cloud.ibm.com/docs/services/activity-tracker?topic=activity-tracker-viewsviews_step2) and [configure alerts](https://cloud.ibm.com/docs/services/activity-tracker?topic=activity-tracker-alerts).

For more information about IBM Cloud Activity Tracker service plans, see [Service plans](https://cloud.ibm.com/docs/services/activity-tracker?topic=activity-tracker-service_planservice_plan).
actionStarted Boolean Whether processing of the action started during handling of the message. 
 actionTitle String The title of the action that was visited during handling of the message (for example, I want to pay my bill). 
 actionsVisited String[] An array of strings listing the actions visited during handling of the message. 
 fallbackReason String The reason why the fallback action was visisted (for example, escalated to human agent or no action matches). 
 handler String The name of any handler that was called. 
 stepsVisited String[] An array of strings listing the steps visited during handling of the message. Each step name is prefixed with the action name. 
 subaction String The name of any other action that was called by the action that was triggered by the message. 



The following properties are included only for messages that were handled by a dialog skill:



 Property Type Description 

 branchExited Boolean Whether the dialog branch was exited during handling of the message. 
 branchExitedReason String The reason the dialog branch was exited (for example, completed). 
 nodesVisited String[] An array of strings listing the dialog nodes visited during handling of the message. For each dialog node, the string specifies the node title (if any) or the node ID. 







 Action Started 

Sent when processing of an action begins.



 Property Type Description 

 accountId String The ID of the IBM account. 
 action String The unique identifier of the action (for example, action_202). 
 actionTitle String The title of the action (for example, I want to pay my bill). 
 actionCompleted Boolean Whether the action completed during the same conversation turn. 
 actionCompletedReason String The reason the action completed (for example, all_steps_done or fallback.) 
 assistantId String The ID of the assistant. 
 browser String The browser that was used to send the message that triggered the action. 
 channel String The channel the customer used to send the message that triggered the action (for example, phone or chat). 
 device String The type of device that was used to send the message that triggered the action. 
 environment String The environment in which the action was started (such as draft or live.)
$toppings_array.getRandomItem() ?> is a great choice"
}
],
"response_type": "text",
"selection_policy": "sequential"
}
]
}
}

Result: "ham is a great choice!" or "onion is a great choice!" or "olives is a great choice!"

The resulting output text is randomly chosen.





 JSONArray.indexOf(value) 

This method returns the index number of the element in the array that matches the value you specify as a parameter or -1 if the value is not found in the array. The value can be a String ("School"), Integer(8), or Double (9.1). The value must be an exact match and is case sensitive.

For example, the following context variables contain arrays:

{
"context": {
"array1": ["Mary","Lamb","School"],
"array2": [8,9,10],
"array3": [8.1,9.1,10.1]
}
}

The following expressions can be used to determine the array index at which the value is specified:

<? $array1.indexOf("Mary") ?> returns 0
<? $array2.indexOf(9) ?> returns 1
<? $array3.indexOf(10.1) ?> returns 2

This method can be useful for getting the index of an element in an intents array, for example. You can apply the indexOf method to the array of intents generated each time user input is evaluated to determine the array index number of a specific intent.

intents.indexOf("General_Greetings")

If you want to know the confidence score for a specific intent, you can pass the prior expression in as the index value to an expression with the syntax intents[index].confidence. For example:

intents[intents.indexOf("General_Greetings")].confidence





 JSONArray.join(String delimiter)
Adding conditions to an action 

An action condition is a boolean test, based on some runtime value; the action executes only if the test evaluates as true. This test can be applied to any variable. By defining action conditions, you can do things such as control user access to actions or create date-specific actions.

This is a beta feature that is available for evaluation and testing purposes.

For more information about variables, see [Using variables to manage conversation information](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-manage-info).

A basic action condition is expressed in the following form:

If{variable}{operator}{value}

where:



* {variable} is the name of a variable or an expression.
* {operator} is the type of test to apply to the variable value (for example, is or is not).
* {value} is the value to compare to the variable.



For example, an action condition might read:

IfUser category?isemployee

In this example, User category can be a list of employees at your organization. This condition evaluates as true if the user is an active employee. If false, you can control access so that former employees can't use the action.

Conditions can be grouped together to construct complex tests.

To add an action condition:



1. In an action, click Customer starts with.
2. Click Conditions.

Zoom

![Conditions](https://cloud.ibm.com/docs-content/v1/content/ca9232b3702768f24bb897f48f10778fcda28718/watson-assistant/images/action-conditions-icon.png)

Conditions
3. Choose the variable for the condition. You can select any of the following:



* An action variable storing the customer response from a previous step in the action
* A session variable containing a value stored by any action
* A built-in variable set by the assistant or by an integration



You can also define a complex condition by writing an expression defining some other value.
update-intent Action username, password, iam_access_token, iam_apikey, iam_url, headers, headers[X-Watson-Learning-Opt-Out], url, workspace_id, intent, new_intent, new_description, new_examples Update an intent. 
 create-example Action username, password, iam_access_token, iam_apikey, iam_url, headers, headers[X-Watson-Learning-Opt-Out], url, workspace_id, intent, text Create a user input example. 
 delete-example Action username, password, iam_access_token, iam_apikey, iam_url, headers, headers[X-Watson-Learning-Opt-Out], url, workspace_id, intent, text Delete a user input example. 
 get-example Action username, password, iam_access_token, iam_apikey, iam_url, headers, headers[X-Watson-Learning-Opt-Out], url, workspace_id, intent, text, include_audit Get information about a user input example. 
 list-examples Action username, password, iam_access_token, iam_apikey, iam_url, headers, headers[X-Watson-Learning-Opt-Out], url, workspace_id, intent, page_limit, include_count, sort, cursor, include_audit List user input examples. 
 update-example Action username, password, iam_access_token, iam_apikey, iam_url, headers, headers[X-Watson-Learning-Opt-Out], url, workspace_id, intent, text, new_text Update a user input example. 
 create-counterexample Action username, password, iam_access_token, iam_apikey, iam_url, headers, headers[X-Watson-Learning-Opt-Out], url, workspace_id, text Create a counterexample.
This feature lets you to define a value for a session variable if a user-defined value isn't found. To learn more, see [Defining session variables](https://cloud.ibm.com/docs/assistant?topic=assistant-actionsactions-variables-global).





 16 July 2021 

Logging API changes
: The internal storage and processing of logs has changed. Some undocumented fields or filters might no longer be available. (Undocumented features are not officially supported and might change without notice.)

New API version
: The current API version (v1 and v2) is now 2021-06-14. The following changes were made with this version:



* The metadata property of entities detected at run time is deprecated. For detailed information about detected system entities, see the interpretation property.
* The data types of certain entity mentions are no longer automatically converted:



* Numbers in scientific notation (such as 1E10), which were previously converted to numbers
* Boolean values (such as false), which were previously converted to booleans





These values are now returned as strings.





 17 June 2021 

Actions skill now generally available
: As of this release, the beta program has ended, and actions skills are available for general use.

An actions skill contains actions that represent the tasks you want your assistant to help your customers with. Each action contains a series of steps that represent individual exchanges with a customer. Building the conversation that your assistant has with your customers is fundamentally about deciding which steps, or which user interactions, are required to complete an action. After you identify the list of steps, you can then focus on writing engaging content to turn each interaction into a positive experience for your customer. For more information, see [Actions skill overview](https://cloud.ibm.com/docs/assistant?topic=assistant-actions-overview).

Date and time response types
: New to action skills, these response types allow you to collect date and time information from customers as they answer questions or make requests. For more information, see [Response types](https://cloud.ibm.com/docs/assistant?topic=assistant-actionsactions-response-types).
Warranties Elements that refer to ongoing promises and obligations that are made in the contract that are currently true and will continue to be true in the future. Also, elements that discuss the consequences of such promises or obligations that are broken, and the rights to remedy the situation (for example, but not limited to, seeking damages). This category does not apply to elements that are concerned with representation statements (statements of fact about the past or the present), or to elements that lay out assumptions about things that occurred in the past. 







 Attributes 

The attributes array specifies any attributes that are identified in the sentence. Each object in the array includes three keys: type (the type of attribute from the following table), text (the applicable text), and location (the begin and end indexes of the attribute in the input document). Currently, supported attributes include:



Supported attributes

 attributes Description 

 Currency Monetary value and units. 
 DateTime A date, time, date range, or time range. 
 DefinedTerm A term that is defined in the input document. 
 Duration A time duration. 
 Location A geographical location or region. 
 Number A digital or textual number that describes a quantity of countable things and is not classified as one of the other numerical attribute types. 
 Organization An organization. 
 Percentage A percentage. 
 Person A person. 







 Effective dates 

The effective_dates array identifies the date or dates on which the document becomes effective.



Effective date values

 effective_dates Description 

 confidence_level The confidence level of the identification of the effective date. Possible values include High, Medium, and Low. 
 text An effective date, listed as a string. 
 text_normalized The normalized text of the text if available, listed as a string. 
 location The location of the date as defined by its begin and end indexes. 
 provenance_ids An array of hashed values that you can send to IBM to provide feedback or receive support. 







 Contract amounts 

The contract_amounts array identifies the monetary amounts specified in the document.



Amount values

 contract_amounts Description 

 confidence_level The confidence level of the identification of the contract amount. Possible values include High, Medium, and Low. 
 text A contract amount, listed as a string.
* Checking for number values: When comparing numbers, first make sure the entity or variable you are checking has a value. If the entity or variable does not have a number value, it is treated as having a null value (0) in a numeric comparison.

For example, you want to check whether a dollar value that a user specified in user input is less than 100. If you use the condition @price < 100, and the @price entity is null, then the condition is evaluated as true because 0 is less than 100, even though the price was never set. To prevent this type of inaccurate result, use a condition such as @price AND @price < 100. If @price has no value, then this condition correctly returns false.
* Checking for intents with a specific intent name pattern: You can use a condition that looks for intents that match a pattern. For example, to find any detected intents with intent names that start with 'User_', you can use a syntax like this in the condition:

intents[0].intent.startsWith("User_")

However, when you do so, all of the detected intents are considered, even those with a confidence lower than 0.2. Also check that intents which are considered irrelevant by Watson based on their confidence score are not returned. To do so, change the condition as follows:

!irrelevant && intents[0].intent.startsWith("User_")
* How fuzzy matching impacts entity recognition: If you use an entity as the condition and fuzzy matching is enabled, then @entity_name evaluates to true only if the confidence of the match is greater than 30%. That is, only if @entity_name.confidence > .3.







 Storing and recognizing entity pattern groups in input 

To store the value of a pattern entity in a context variable, append .literal to the entity name. Using this syntax ensures that the exact span of text from user input that matched the specified pattern is stored in the variable.



 Variable Value 

 email 



To store the text from a single group in a pattern entity with groups defined, specify the array number of the group that you want to store. For example, assume that the entity pattern is defined as follows for the @phone_number entity.
For example, to check if an entity or context variable contains the name O'Reilly, you must surround the name with parentheses.

@person:(O'Reilly) and $person:(O'Reilly)

Your assistant converts these shorthand references into these full SpEL expressions:

entities['person']?.contains('O''Reilly') and context['person'] == 'O''Reilly'

SpEL uses a second apostrophe to escape the single apostrophe in the name.
* Checking for multiple values: If you want to check for more than one value, you can create a condition that uses OR operators (||) to list multiple values in the condition. For example, to define a condition that is true if the context variable $state contains the abbreviations for Massachusetts, Maine, or New Hampshire, you can use this expression:

$state:MA || $state:ME || $state:NH
* Checking for number values: When comparing numbers, first make sure the entity or variable you are checking has a value. If the entity or variable does not have a number value, it is treated as having a null value (0) in a numeric comparison.

For example, you want to check whether a dollar value that a user specified in user input is less than 100. If you use the condition @price < 100, and the @price entity is null, then the condition is evaluated as true because 0 is less than 100, even though the price was never set. To prevent this type of inaccurate result, use a condition such as @price AND @price < 100. If @price has no value, then this condition correctly returns false.
* Checking for intents with a specific intent name pattern: You can use a condition that looks for intents that match a pattern. For example, to find any detected intents with intent names that start with 'User_', you can use a syntax like this in the condition:

intents[0].intent.startsWith("User_")

However, when you do so, all of the detected intents are considered, even those with a confidence lower than 0.2. Also check that intents which are considered irrelevant by Watson based on their confidence score are not returned.
Event destinations 

A destination is a delivery target for a notification. In other contexts, destinations are also called channels, sinks, or consumers.



 Destination categories 

Destinations are of two categories: human and service.



 Human destinations 

Human destinations are devices, servers, or applications that present notifications for human consumption. The following human destinations are supported by the Event Notifications service:



* [Inbuilt Email](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-destinations-email)
* [Inbuilt SMS](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-destinations-sms)
* [Microsoft® Teams](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-destinations-msteams)
* [PagerDuty](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-destinations-pagerduty)
* [Push notifications](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-destinations-push)



* [Android Push Notifications (FCM)](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-push-fcm)
* [iOS Push Notifications (APNs)](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-push-apns)
* [Chrome Push Notifications](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-push-chrome)
* [Firefox Push Notifications](https://cloud.ibm.com/docs/event-notifications?topic=event-notifications-en-push-firefox)
You can also use methods to perform additional mathematical operations. For more information, see [Expression language methods for actions](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-expression-methods-actionsexpression-methods-actions-numbers).





 Arrays 

To define an array value, type the value using square brackets, with commas separating the items (for example, [ "one", "two", "three" ]).

To reference an item in an array, use bracket notation and specify the zero-based index of the item in the array For example, ${Items}[0] represents the first item in the array Items.

You can also use the array method get() to retrieve an item from an array. For more information, see [Expression language methods for actions](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-expression-methods-actionsexpression-methods-actions-arrays-get).





 JSON objects 

Use JSON notation to define compound objects in expressions. For example, the following expression assigns a complex JSON object as the value for a variable:

{
"name": {
"firstname": "John",
"lastname": "Doe"
},
"age": 36
}

You can use variables and standard math within JSON to create dynamic objects that are calculated at run time. For example, the following expression defines a JSON object that references variables and calculates an average value:

{
"temp_1": ${temp_1},
"temp_2": ${temp_2},
"avg_temp": (${temp_1} + ${temp_2}) / 2
}

To refer to a child object contained in a JSON value, use dot notation to express the path to the object (for example, ${customer}.name.lastname).

If you need to refer to a child of an object that might or might not be defined, use the safe navigation operator (?).
It includes a new foundation model that is trained using a transformer architecture to improve intent detection and action matching for English.

Improvements include:



* Improved robustness to variations in user inputs such as typos and different inflection forms
* Less training data required to reach the same level of performance compared to previous algorithms



For more information, see [Algorithm version and training](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-algorithm-version).





 16 April 2023 

Autolearning beta for dialog skills removed
: As of this release, the autolearning beta has been removed from the Analytics section in dialog skills. In the new experience, you can test a new and improved autolearning beta. For more information, see [Using autolearning to improve assistant responses](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-autolearn).





 16 March 2023 

New algorithm version Latest (20 Dec 2022) provides improved irrelevance detection
: A new algorithm version is available. The Latest (20 Dec 2022) version includes a new irrelevance detection implementation to improve off-topic detection accuracy.

Improvements include:



* Relevant user inputs are expected to get higher confidence, so they are less likely to be considered irrelevant or require clarification
* Irrelevance detection is improved in the presence of direct entity references
* Irrelevance detection is more stable across small changes to input
* Intent detection is more stable regarding occurrence of numerics, such as postal codes
* For German-language assistants, intent detection is more robust in the presence of umlauts



This algorithm was first introduced as the Beta version in June 2022. Since then, support for more languages has been added. This algorithm version was stabilized in December 2022 with minor enhancements since that time.

With this new release, the June 1, 2022 version is now labeled as Previous (01 Jun 2022). The oldest release labeled as 01 Jan 2022 is no longer available for training. As of now, the new Beta version has the same behavior as the Latest (20 Dec 2022) version.