vania-janet/multiturn-rag-retrieval-data huggingface dataset:
References a dictionary that is created by using either the create dictionary statement, create external dictionary statement, or a dictionary file on the file system.
* [and '<dictionary>' and ... and '<dictionary>']

References additional dictionaries to be used for extraction.
* [with flags'<flags string>']

Controls dictionary matching. Currently, two options are supported:



* Exact

Provides exact, case-sensitive matching.
* IgnoreCase

Provides matching that is not case-sensitive.





If no flag is specified, the dictionary matches based on any flag that was specified when it was created. If no flag is specified during creation, it matches by using the IgnoreCase flag.





 Usage notes 



* Dictionaries are always evaluated on token boundaries. Specifically, a dictionary entry matches a region of text if the first token of the entry matches the first token of the text region, the second token of the entry matches the second token of the text region, and so on. Characters between two consecutive tokens are ignored.

For example, assume that you are using a simple white-space based tokenization model that is appropriate for a language such as English. Also, assume that the input text is “Let’s go fishing!” If a dictionary consists of the term go fish, no match exists in the text for Let's go fishing!. However, if the dictionary consists of the entry go fishing (notice the two white spaces between go and fishing), one match exists in the text Let's go fishing!. White space specifies that go and fishing are two distinct tokens. If one or more white-space characters exists between the two tokens go and fishing in the input text, a match is made.

For each match of a dictionary entry with input text, the extract dictionary statement generates an output tuple.







 Examples 

Example 1: Extracting terms from dictionary files

Find person names by using dictionary files of common given names and surnames with case-sensitive matching.

create view Name as
extract
dictionaries
'first.dict'
and 'last.dict'
with flags 'Exact'
on D.text
as name
from Document D;
In this case usage for 2 services has been returned. The current_total value reports the number of ingested lines during the queried time period. The percentage_of_total is the percentage of total lines ingested during the time period by all services.





 Additional examples 

The following provide additional, specific usage examples.



 List usage data for all services for the past 6 months 

This command list the aggregated usage information for all services for the past 6 months.

curl "https://api.us-south.logging.cloud.ibm.com/v1/usage/hosts" -u <SERVICE_KEY>:





 List usage data for the top N services for the past 6 months 

This command lists the aggregated usage information for the highest-usage N services for the past 6 months where N is an integer number.

curl "https://api.us-south.logging.cloud.ibm.com/v1/usage/hosts?limit=N" -u <SERVICE_KEY>:

Specifying 5 for N will return the information for the top 5 highest-usage services as shown in this example:

[
{
"name": "cloud-object-storage",
"current_total": 1418178,
"percentage_of_total": 59.35177415676025
},
{
"name": "containers-kubernetes",
"current_total": 287299,
"percentage_of_total": 12.023670768735
},
{
"name": "sysdig-monitor",
"current_total": 218164,
"percentage_of_total": 9.130321057818866
},
{
"name": "kms",
"current_total": 205699,
"percentage_of_total": 8.608651799894956
},
{
"name": "is-load-balancer",
"current_total": 107925,
Name: core.StringPtr("accountId"),
Value: core.StringPtr("12ab34cd56ef78ab90cd12ef34ab56cd"),
}

resourceModel := &contextbasedrestrictionsv1.Resource{
Attributes: []contextbasedrestrictionsv1.ResourceAttribute{resourceAttributeModel},
}

replaceRuleOptions := contextBasedRestrictionsService.NewReplaceRuleOptions(
"testString",
"testString",
)
replaceRuleOptions.SetDescription("this is an example of rule")
replaceRuleOptions.SetContexts([]contextbasedrestrictionsv1.RuleContext{ruleContextModel})
replaceRuleOptions.SetResources([]contextbasedrestrictionsv1.Resource{resourceModel})
replaceRuleOptions.SetEnforcementMode(contextbasedrestrictionsv1.ReplaceRuleOptionsEnforcementModeDisabledConst)

outRule, response, err := contextBasedRestrictionsService.ReplaceRule(replaceRuleOptions)
if err != nil {
panic(err)
}
b, _ := json.MarshalIndent(outRule, "", " ")
fmt.Println(string(b))

// Request models needed by this operation.

// RuleContextAttribute
const ruleContextAttributeModel = {
name: 'networkZoneId',
value: '76921bd873115033bd2a0909fe081b45',
};

// RuleContext
const ruleContextModel = {
attributes: [ruleContextAttributeModel],
};

// ResourceAttribute
const resourceAttributeModel = {
Expression language methods 

You can process values extracted from user utterances that you want to reference in a context variable, condition, or elsewhere in the response.



 Where to use the expression syntax 

To expand variable values inside other variables, or apply methods to output text or context variables, use the <? expression ?> expression syntax. For example:



* Referencing a user's input from a dialog node text response

You said <? input.text ?>.
* Incrementing a numeric property from the JSON editor

"output":{"number":"<? output.number + 1 ?>"}
* Adding an element to a context variable array from the context editor





 Context variable name Context variable value 

 toppings <? context.toppings.append( 'onions' ) ?> 



You can use SpEL expressions in dialog node conditions and dialog node response conditions also. When an expression is used in a condition, the surrounding <? ?> syntax is not required.



* Checking for a specific entity value from a dialog node condition

@city.toLowerCase() == 'paris'
* Checking for a specific date range from a dialog node response condition

@sys-date.after(today())



The following sections describe methods you can use to process values. They are organized by data type:



* [Arrays](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-dialog-methodsdialog-methods-arrays)
* [Date and Time](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-dialog-methodsdialog-methods-date-time)
* [Numbers](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-dialog-methodsdialog-methods-numbers)
* [Objects](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-dialog-methodsdialog-methods-objects)
Glossary 



Glossary

 Term Definition 

 Action Actions represent the tasks or questions that your assistant can help customers with. Each action has a beginning and an end, making up a conversation between the assistant and a customer. [Learn more](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-build-actions-overview). 
 Ask clarifying question A feature that enables the assistant to ask customers to clarify (disambiguate) their meaning when the assistant isn't sure what a user wants to do next. [Learn more](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-understand-questionsunderstand-questions-ask-clarifying-question). 
 Assistant Container for your actions, channels, and integrations. You add actions and at least one channel to an assistant, and then deploy the assistant when you are ready to start helping your customers. [Learn more](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-publish-overview). 
 Change conversation topic A feature that gives the user the power to direct the conversation. It allows digressions and prevents customers from getting stuck in a dialog thread; they can switch topics whenever they choose. [Learn more](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-change-topic). 
 Channel The location where your assistant interacts with your users, for example, over the phone, on a website, or in Slack. At least one channel is required for every assistant. [Learn more](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-deploy-assistant). 
 Completion Measures how often within a given time period users reach the end step of an action. [Learn more](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-analytics-action-completioncomplete-reasons). 
 Content The conversation logic and words that are used to respond to your customer. Content is required for every assistant.
before <br>string Identifier of prefix filter to handle the ordering and follow semantics:<br><br><br><br> * When a filter references another filter in it's before field, then the filter making the reference is applied before the referenced filter. For example: if filter A references filter B in its before field, A is applied before B.<br> * When a new filter is added that has the same before as an existing filter, then the older filter has its before field updated to point to the new filter. Starting with the preceding example, if filter C is added and references B in its before field, then A's before field must be modified to point to C, so the order of application would be A, C and finally B.<br> * A filter that has an empty before reference is applied last (though the date order mentioned still applies). So continuing these examples, if filter B has an empty before field, then it is applied last, but if filter D is created with an empty before field, then B's before field is modified to point to D, so B is applied before D. <br> Example: 1a15dcab-7e40-45e1-b7c5-bc690eaa9782<br><br><br> 
 ge <br>integer IP prefix greater than or equal to this number is processed. 
 le <br>integer IP prefix less than or equal to this number is processed. 
 updated_at <br>date-time The date and time that this prefix filter was last updated 





Table 5. Status codes

 Status code Details 

 201 The transit gateway connection prefix filters was created successfully. 
 400 An invalid prefix filter template was provided. 
 404 The specified transit gateway could not be found. 







 Example response 

This example illustrates the response that a prefix filter was added successfully:

{
"action": "permit",
"before": "1a15dcab-7e40-45e1-b7c5-bc690eaa9782",
"created_at": "2021-11-15T12:08:05Z",
"ge": 0,
* [Reuse across environments](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reuseblueprint-reuse-env)



* [Deployment pipelines](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reuseblueprint-pipelines)



* [Customization best practice](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reuseblueprint-customization-bp)



* [Blueprint customization](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reuseblueprint-customization)



* [Customizing environments with inputs](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reuseblueprint-customization-layers)
* [Using versioned inputs](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reusebp-version-input)
* [Blueprint input value precedence](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reuseblueprint-input-precedence)



* [No value](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reusebp-precedence-novalue)
* [Default value](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reusebp-precedence-defaultvalue)
* [Specified value](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-reusebp-precedence-specifiedvalue)





[Versioning blueprint environments](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-versioningblueprint-versioning)
<br> <br>"flat tire", "overcorrected" (as in steering), "asleep", "intoxicated", "[failed to negotiate]CONDITION a [curve]STRUCTURE", "[departed] the lane" or shoulder, but not "attempting to pass" unless this phrase is accompanied by "without enough room" or something similar, nor "departing the road", which is an INCIDENT. 
 INCIDENT An actual mention of a collision, or a car motion that is unambiguously inappropriate and likely destructive, such as going off-road, or some other damaging incident, like a car fire. <br> <br>Do not co-reference non-identical motions to each other, such as "impacted", "pushed rearward" and "came to final rest", even if they are closely associated. <br> <br>Exclude STRUCTURE from the extent; for example, "[came to rest]INCIDENT in a [ditch]STRUCTURE" or "[remaining in contact]INCIDENT with the [guardrail]STRUCTURE". 
 MANUFACTURER The company that makes the vehicle Toyota, Mazda, General Motors 
 MODEL The specific kind of car, made by a specific manufacturer. Exclude any extra terms / trim line indicators like "LX", or "SE" (e.g., only annotate "Xterra" for the phrase "Xterra SE"). Camry 
 MODEL_YEAR The model year that is part of the name of the car. '99, 2001 
 PART_OF_CAR A part of a vehicle, either inside or outside of it, regardless of whether specifically involved in the incident. Exclude listings of capabilities of such parts. Include indications of where in the car the part is, or something which just refers to a portion of a car without being a specific part. <br> <br>Can be plural. Can include specification of position in the vehicle, such as "[driver airbag]", "[RF door]" (meaning right-front), "[RR] passenger", "[LF and RF air bags]", "[first row passive/automatic restraints]", "[safety system] with EDR capabilities".
[Shows an intent with a user example list where one of the user examples has a Resolve conflicts button](https://cloud.ibm.com/docs-content/v1/content/a2b18c153837bce00a5b4de496e4b4ca64bbf56e/assistant-data/images/intent-resolve-conflicts.png)
3. Choose whether to delete the example from the intent or to move it to another intent.

![Shows the intent conflict details page](https://cloud.ibm.com/docs-content/v1/content/a2b18c153837bce00a5b4de496e4b4ca64bbf56e/assistant-data/images/intent-fix-conflict.png)

Similar user examples are displayed for each intent. These examples are not necessarily in conflict. They are shown to give you a quick view of the other types of user examples that are defined for each intent. It provides you with context that can help you make a more informed decision.

Keep each intent as distinct and focused on one goal as possible. If you have two intents with multiple user examples that overlap, maybe you don't need two separate intents. You can move or delete user examples that don't directly overlap into one intent, and then delete the other.
4. To move a user example, click Move, and then click the intent where you want to move the example.

![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.
A mention is any span of text that you consider relevant in your domain data. For example, in a type system about automotive vehicles, occurrences of terms like airbag, Ford Explorer, and child restraint system might be relevant mentions.





 Entity types 

An entity type is how you categorize a real-world thing. An entity mention is an example of a thing of that type. For example, the mention President Obama can be annotated as a PERSON entity type. The mention IBM can be annotated as an ORGANIZATION entity type. Entities are often nouns, but can also be verbs, as long as the verb is important to capture for the purposes of the application that will use the type system. For example, EVENT_CRASH might be a valid entity type for a type system about automotive vehicles, so that the word hit in the sentence, The car hit the barrier. can be annotated.

The goal of your annotation workspace is to annotate each mention in a document with the type of thing that it is. After a mention is classified by entity type, the labeled span of text is referred to as an entity.

A type system that you build with Knowledge Studio can include the following entity type attributes. The attributes help qualify mentions in text, but they are not marked as entity types by a machine learning model. For example, if the entity type ORGANIZATION has an entity subtype called COMMERCIAL, COMMERCIAL is not marked as an entity type on its own.



* Role

Qualifies the mention by the context in which the mention occurs. For example, the mention France in the statement, the students went to France, is marked with the entity type GPE because France is a geo-political entity. But, because France in this context is also a destination for the traveling students, the entity type is qualified by adding an attribute, in this case the role LOCATION. For another example, the mention Lawyers might be marked with the entity type PEOPLE and also by the role OCCUPATION.
* Entity subtype

Further classifies the entity type. For example, the entity type ORGANIZATION might include the subtypes COMMERCIAL, GOVERNMENT, MILITARY, and EDUCATION.
* Mention type

Qualifies the mention by certain parts of speech:
Use the following syntax to define the client action you want to request.

{
"context": {
"variable_name" : "variable_value"
},
"actions": [
{
"name":"<actionName>",
"type":"client",
"parameters": {
"<parameter_name>":"<parameter_value>",
"<parameter_name>":"<parameter_value>"
},
"result_variable": "<result_variable_name>"
}
],
"output": {
"text": "response text"
}
}
Show more

The actions array specifies the actions you want the client application to carry out. It can define up to five separate actions. Specify the following name and value pairs in the JSON array:



* <actionName>: Required. The name of the action you want the client application to perform. This name can be in any format (for example, calculateRate or get_balance), but it must be a name that your client application will recognize and know how to handle. The name cannot be longer than 256 characters.
* <type>: Indicates the type of call to make. For a client action, this property is optional (client is the default value).
* <action_parameters>: Any parameters that are required for the client action, which are specified as a JSON object. If the action does not require any parameters, omit this property.
* <result_variable_name>: The name of the context variable you want to use to store the JSON object that is returned by the client action. The client application is expected to use the specified variable to send the return value in the context of the next /message input, and subsequent dialog nodes can then access it. You can specify the result_variable_name by using the following syntax:



* my_result
* $my_result



The name cannot be longer than 64 characters.
It is the responsibility of the client application to carry out the requested action, store the result in the context, and send it back to the dialog with the next message.

You might call a client application to do the following types of things:



* Validate information that you collected from the user.
* Do calculations or string manipulations on user input that are too complex for supported SpEL expression methods to handle.
* Get data from another application or service.



The following diagram illustrates how client actions work, using the example of an action to get a weather forecast.

![Shows someone asking for a weather forecast and the dialog sending a request to a client app, which sends it to the external service and returns the result](https://cloud.ibm.com/docs-content/v1/content/417db917d18067d9dcc4cf2612564a9a87c3ddc8/assistant/images/forecast.png)

The flow of requests and responses follows this pattern:



1. The client application sends a message containing user input that asks for a weather forecast (using the message or message_stateless method).
2. The user input triggers a dialog node conditioned on a #weather intent. In its response to the client, this node specifies the get_weather client action, which is a name that the client application recognizes. (This is in addition to any text response, such as Checking the weather forecast....)
3. When it receives this response, the client application recognizes that the get_weather action is being requested. It calls an external web service (/weather) to get the actual forecast information, passing any specified parameters (such as the user's location). The client application then stores the returned information in context variable specified in the action request ($weather_forecast).
4. The client application sends another message to the service, including the updated context that contains the weather forecast information. From the dialog's perspective, this message is effectively the next round of user input, although the actual input text is blank.
5. A child node of the #weather node is triggered by the presence of the $weather_forecast context variable.
action: function () { return { message: 'Hello!' } }
}))





 For Python 

import composer

def hello(args):
return { 'message': 'hello' }

def main():
return composer.sequence(
'action1',
composer.action('hello', hello)
)

Zoom

![Sequence with inline action definition.](https://cloud.ibm.com/docs-content/v1/content/adc643f3bedeea02b638bc1c34732852dcb40a45/openwhisk/images/composer-inline.png)

Figure 5. Sequence with inline action definition









 Using other combinator definitions 

See the documentation for Composer on Apache OpenWhisk ([JavaScript](https://github.com/ibm-functions/composer/blob/master/docs/COMBINATORS.md) or [Python](https://github.com/ibm-functions/composer-python/blob/master/docs/COMBINATORS.md)) for the full list of combinators definitions.
<br>This field is set to true when MFA is enabled for users. 
 allowed_ip_addresses String List of IP addresses from where a user is allowed to access account resources. 
 iam_id String Defines the IBM ID of the user whose settings are being modified. 
 security_questions_setup Boolean Defines when a user requires security questions to log in to the account. <br>This field is set to true to indicate that questions are required. 
 self_manage Boolean Defines whether a user can configure his log in settings on how to log in to the account. <br>This field is set to true to allow a user to set password expiration, turn on security questions for login, and define allowed IP addresses for log in to IBM Cloud and from classic infrastructure API calls. 









 Events for managing account usage reports 

This section explains events that are generated when a user looks at the information that is provided through the Manage > Billing and usage > Usage section, or request an export of the data.

You can get events with reason.reasonCode = 404 that are generated when there is no usage data available for the request. The severity is set to normal.



 requestData fields 

The following table lists the fields that are available through the requestData field in the events with actions billing.account-summary.read, billing.account-summary.download, and billing.account-instances-usage-report.download:



Table 16. Account usage summary requestData fields

 Field Type Description Status 

 month String Indicates the month that the user selects to view usage data. Included always in the event 



The following table lists the fields that are available through the requestData field in the events with actions billing.account-usage-report.read:



Table 17. Account usage requestData fields

 Field Type Description Status 

 month String Indicates the month that the user selects to view usage data. Included always in the event 
 usage_report_type String Indicates the type of report. <br>Valid values are instances and rollup. Included always in the event 
 sub_account_id String Indicates the sub-account ID. Optional 
 resource_group String Indicates the resource group.