Aura – Docs

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Request access to Aura repositories in Github

Steps for L-CDO developers willing to access to aura-bot and aura-nlp Github repositories

How can L-CDO developers access to Github repositories?

All local CDO developers are enrolled into a specific team in Github for each country, which provides the access to the relevant Aura repositories in Github, such as https://github.com/Telefonica/aura-bot-libraries.

To gain access to your local CDO team in Github, you have to fulfill the following requirements:

Having a personal account in Github.
Two factor authentication (2FA) enabled for the account.
Your personal profile page in Github must fulfill the following requisites:

3.1. It must include a personal image, not an avatar, distinct from the one Github assigns by default.

3.2. It must include your name and surname.

3.3. It must include a “@telefonica.com” as the public personal email account associated to the Github profile.

ℹ️ Please, have a look at https://github.com/Korreca as an example of a valid personal profile page in Github.

ℹ️ You can also check the document Configuring two-factor authentication.

Once the previous requirements have been successfully fulfilled, please send a message to the “[APE] AURA-LCDO-XY-GENERAL” chat in Microsoft Teams (where “XY” should be substituted by the 2 letters code associated to your country) requesting access to the Aura repositories in Github.

A member of the APE team will request your registration into the Telefónica organization in Github. Afterwards, you will receive an email message including your personal invitation to be registered in it.

Once you have been included in the Telefónica organization in Github, a member of the APE team will enroll yourself in the appropriate “Aura Development XY” (where “XY” should be substituted by the 2 letters code associated to your country) which will grant you access to all the relevant Aura repositories in Github.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

account-linking dialog

Description of the account-linking dialog, one of the dialogs that handles users’ account linking

Introduction

The account-linking dialog is included in the global linking library.

It is in charge of handling user’s account linking for channels using integrated authentication, that is, channels that already have a proper user’s identifier that should be linked with the corresponding auraId and that cannot handle Kernel authentication directly:

WebClient
Facebook
WhatsApp

This dialog launches authentication in Kernel based on browser navigation. It includes several steps to validate the Terms and Conditions of the services and to launch the user’s autentication in the OB authenticator and in Kernel that, in the end, would register the auraId in Aura users’ database.

Environment variables

Property	Type	Scope	Description
LINKING_FP_ACCESS_SESSIONS_ENDPOINT	string	Local	URL to Kernel Access Sessions API
LINKING_FP_CALLBACK_LOGIN_URL	string	Local	URL to redirect to authentification login
LINKING_FP_CALLBACK_LOGOUT_URL	string	Local	URL to redirect to authentification logout
LINKING_TERMS_AND_CONDITIONS_URL	string	Local	URL to terms and conditions HTML file. By default: `/documents/termsandconditions.html`
SAFETY_CHECK_ENDPOINT	string	Local	URL API client endpoint

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura NLP Adapters

What are Aura NLP adapters

Adapters are used in order to modify the response achieved by the rest of the pipeline stages.

The different types of adapters are included in the following sections.

Description

The specific intent recognition stage (CLU, Exact match, Grammars, etc.) recognizes the user’s intent.
Aura NLP will provide as an output a recognized intent and an entity ID.

Path

Files

Keys: intent
Value: the value for each key corresponds to an ID from different sources.

An example is shown below. Each intent is mapped with a specific ID.

```typescript
{
"intent.exact-match.faq.1": "1",
"intent.exact-match.faq.2": "2",
"intent.exact-match.faq.3": "3"
}
```

Afterwards, aura-bot will receive the recognized intent and the entity ID as an output from the NLP stage.

Review that all the included IDs in this file are existing in the corresponding sources and the matching between the intents and entities for this ID.
Review that the intent name is previously defined.
Include the intents in alphabetical order.
It is recommended to include in the E2E tests phrases to validate that the mapping is correctly done.

Configuration

This stage requires the following configuration in the nlp.json configuration file, in which the field intent_template should point to the use case intent.

As an example, if Exact match is the intent recognizer stage, it can be:

        "intent_template":"intent.exact-match.faq"
        }

Intent Entity Mapper

Description

It can be used in:

Personalized experiences to configure a particular entity based on a specific intent.

In both scenarios:

An intent recognition stage (CLU, Exact match, Grammars, etc.) recognizes the user’s intent.
Intent Entity Mapper adapter is trained to map the intent with an entity name and label.
Aura NLP provides as an output the recognized intent and entity.

Path

auracog_pipelines.stage_wrappers.adapter_wrapper.intent_entity_mapper_wrapper.IntentEntityMapperWrapper

Files

This stage requires an intent_entity_mapper.json file. It maps a specific intent with an entity name and label:

The keys are the intent names.
Values for each key contain another key-value pair:
- entity_name (mandatory): The name of the new entity.
- entity_label (optional): The label of the new entity. If not provided, it uses the label defined in the nlp.json configuration file.

An example is shown below:

{
    "intent.exact-match.faq.1": {
        "entity_name": "1",
    },
    "intent.exact-match.faq.2": {
        "entity_name": "2",
        "entity_label": "test-label" 
    },
    "intent.exact-match.faq.3": {
        "entity_name": "3"
    }
}

Afterwards, aura-bot will receive the recognized intent and the entity name as an output from the NLP stage.

Best practices to edit `intent_entity_mapper.json`

Review that all the included entity names in this file exist in the corresponding sources.
Review the matching between the intents and entities.
Review that the intent name is previously defined.
Include the intents in alphabetical order.
It is also recommended to include it in the E2E test phrases to validate whether the mapping is correctly done.

Configuration

This stage requires the following settings in the nlp.json configuration file, under the intent_entity_mapper key:

intent_template (mandatory): The intent name to replace the original intent.
entity_label_template (optional, default None): A default label name for the entities not defined in the intent_entity_mapper.json file.
entity_type_template (optional, default faq): The type of the new entities.
1. The OpenaiEmbeddingsRecognizer stage is included in the same pipeline.

Here is an example:

"intent_entity_mapper": {
    "intent_template": "intent.tv.search",
    "entity_label_template": "REAL MADRID",
    "entity_type_template": "ent.audiovisual_sports_team",
}

None Handler

Description

None Handler is a stage used when the intent recognized by the pipeline stages is None. It modifies the None intent by the intent predefined in the file none_mapper.json for the specific domain. You can select any intent defined in the system to be pointed in this adapter.

Path

auracog_pipelines.stage_wrappers.adapter_wrapper.none_handler_wrapper.NoneHandlerWrapper

Files

None Handler requires one file: none_mapper.json that indicates, within a specific domain, which intent must be set if the recognized intent is None. Therefore, if the domain is already defined and the system recognizes the intent None, then the intent is replaced by the value indicated in the file.

In this file:

Keys: different domains
Values: value for each key is the intent mapped with this domain.

Developers can select any intent defined in the system to be pointed in this adapter.

An example is shown below:

{
  "domain.tv_content": "intent.tv.none",
  "domain.tv_desco": "intent.tv.none",
  "domain.tv_record": "intent.tv.none",
  "domain.tv_wh3": "intent.tv.none"
}

In the example, if the domain is domain.tv_content and the system recognizes the intent None, then this intent is replaced by intent.tv.none.

Configuration

This stage does not require any configuration.

Standard Threshold

Description

Standard Threshold allows the establishment of a threshold for the scores provided by preceding pipeline stages. If the score obtained by the previous stages is lower than the established threshold, the Standard Threshold provides score 0 and the intent is replaced by the default value set in the configuration.

This stage is useful to prevent false positives and can be included in any place of the pipeline. The NLP Global Team recommends to set this threshold to 0.6.

Path

auracog_pipelines.stage_wrappers.adapter_wrapper.standard_threshold_wrapper.StandardThresholdWrapper

Files

Standard Threshold does not require any file.

Configuration

This stage requires the following configuration in the nlp.json file, depending on the language and the channel:

{
  "es-es": {
    "mp": {
      "threshold": {
         "default": {
           "threshold": 0.1,
           "intent": "intent.default" 
        },
         "intent.test": {
            "threshold": 0.8,
            "intent": "None" 
        }
      } 
    }     
  }

The fields are explained below:

threshold: value between 0 and 1 indicating the limit that triggers the action of the adapter.
- This field can be defined per intent, thus having a different threshold for each intent.
- The default intent must be always specified and, additionally, you can define a different threshold for other specific intent in order to improve the recognition process.
- The NLP Global Team recommends to set this threshold to 0.6.
intent: this field contains an internal string identifier, that is associated if the score value is lower than the threshold.

In the previous example, the default config applies to every intent, with accuracy 0.1 and intent intent.default. But, specifically for the intent intent.test, the applied configuration has accuracy 0.8 and the associated intent is None.

Entity Tagger Adapter

Description

Entity Tagger Adapter is a stage that allows entities tagging through the definition of aliases and labels on them.

Path

auracog_pipelines.stage_wrappers.adapter_wrapper.entity_tagger_adapter_wrapper.EntityTaggerAdapterWrapper

Files

The Entity Tagger Adapter stage requires four files:

sdict_items: Items dictionary including the canonical values of entities.
sdict_aliases: Alias dictionary including the aliases for an entity.
ner_entity_translation.json
ner_aliases.json

ner_entity_translation.json

ner_entity_translation.json indicates, for each entity type, if canon and label have been defined for the entity type or not.

It is a JSON file that must be generated manually to define properties for each entity type.

The keys are entity types.
Values for each key contain another key-value pair:
- Keys: canon and label
- Values: boolean operators (true/false) depending on whether a canon and/or label has been defined for a given entity type or not.

An example of ner_entity_translation is shown below:

{
  "DEFAULT": {
    "canon": false,
    "label": false
  },
  " ent.audiovisual_actor ": {
    "canon": true,
    "label": false
  }
}

Where default represents the default value if the entity type is not included in the dictionary. The default field is not mandatory if all the entity types are defined in the file.

When a new entity is added, it must be included in the ner_entity_translation.json file with the expected behavior for the canon and label. Likewise, if the behavior for canon and label of an entity changes, it is required to update this file.

As best practices, entities should be ordered alphabetically.

ner_aliases.json

ner_aliases.json is an optional file required if you need to match/map the canon value to some other value requested by an API or search engine (currently, it is used by Spain to search content in the M+ database).

It is a JSON dictionary that must be generated manually, where:

Keys: entity types.
The value of each key includes another key-value pair:
- Keys: labels
- Value for each key: list of values contemplating just the canonical form(s) of the entity label

When adding a new entity, in case the entity should have a label, the label has to be assigned to the canons that we want to be identified by this label.

An example of ner_aliases dictionary is shown below:

{
    "ent.audiovisual_genre": {
        "CN": [
            "movies",
            "films"
        ],
        "CT": [
            "shorts",
            "short film"
        ]
    },
}

The following example shows the mapping between alias-canon-label and their corresponding files:

   docu (`sdict_aliases`) -> documentary (`sdict_items`)-> DC  (`ner_aliases`)

Best practices for the edition of ner_aliases.json

Canon names should be expressed as in sdict_items.json, including capitalization, diacritic marks and punctuation.
Entities should be ordered alphabetically.
Labels inside entities should be ordered alphabetically.

Configuration

No configuration is required.

Description

If the disambiguation process cannot discern between multiple entities, then the intent returned by Aura NLP to the bot will be a disambiguation intent as a top intent at first level. In this intent, each option is composed of the original top intent and one entity per option. These options will be presented to the user for him to choose the most appropriate one.

The input for this stage includes: a list of intents; 1 top intent (intent recognized with the higher score); a list of entities.
The output from this stage includes: the top intent and different options (options in the data model) of recognized entities.

Here is an example of the input and output data models for the disambiguation by entities stage, where entities are IDs.

Input data model:

{
    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [
            {
                'entity': '14', 'type': 'faq', 'score': 0.90, 'start_index': 1, 'end_index': 1, 'canon': '14', 'label': null
            },
            {
                'entity': '16', 'type': 'faq', 'score': 0.88, 'start_index': 1, 'end_index': 1, 'canon': '16', 'label': null
            },
            {
                'entity': '12', 'type': 'faq', 'score': 0.60, 'start_index': 1, 'end_index': 1, 'canon': '12', 'label': null
            }
        ],
        'intents': [
        ]
    },
    'domain_result': {}
}

Output data model:


    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [],
        'top_result': {'intent': 'intent.disambiguation', 'score': 1.0},
        'intents': [
            {'intent': 'intent.disambiguation', 'score': 1.0}
        ]
    },
    'domain_result': {},
    'options': [
        {
            'query': 'original Phrase',
            'channel': 'mp',
            'intent_result': {
                'entities': [
                    {
                        'entity': '14', 'type': 'faq', 'score': 0.90, 'start_index': 1, 'end_index': 1, 'canon': '14', 'label': null
                    }
                ],
                'intents': [
                ]
            }
            'domain_result': {},
            'options': []
        },
        {
            'query': 'original Phrase',
            'channel': 'mp',
            'intent_result': {
                'entities': [
                    {
                        'entity': '16', 'type': 'faq', 'score': 0.88, 'start_index': 1, 'end_index': 1, 'canon': '16', 'label': null
                    }
                ],
                'intents': [
                ]
            },
            'domain_result': {},
            'options': []
        }
    ]
},

Path

Files

Configuration

This stage requires the following configuration in the nlp.json file depending on the language and the channel:

{
  "es-es": {
    "mp": {
        "disambiguation_margin": 0.2,
        "exact_match": 0.92,
        "intent_template": "intent.disambiguation",
      } 
    }     
  }
}

The fields determine how the disambiguation process is carried out:

intent_template: This field contains an internal string identifier corresponding to the intent resulting from this stage if no disambiguation can be carried out.
exact_match: value between 0 and 1. This value is used to check if any recognized entity score is above this value.
disambiguation_margin: value between 0 and 1 used to set an interval.

The combination of these two last parameters provides different scenarios:

The score of certain entities is equal or higher than exact_match (left graphic).
- Only the entity with the best score is considered.
- In case of tie (more than one entity with the highest score), all of them are returned.
The score of all entities is below the exact_match (right graphic). Only those entities whose score is in the interval: ([top score], [top score - disambiguation_margin]) (both included) are considered.

Intent Disambiguation Adapter

Description

The goal of this stage is to disambiguate when, in an utterance, several intents are recognized.

If the disambiguation process cannot discern between multiple intents, then the intent returned by this stage will be a disambiguation intent as a top intent at first level. In this intent, each option is composed of one intent (that fulfils the conditions to be disambiguated) and a list of entities. These options will be presented to the user to choose the most appropriate one.

The general behavior of this stage is explained below:

The input for this stage includes: a list of intents and a list of entities.
The output for this stage includes: the different options for intents recognized during the disambiguation (options in the data model) and the original list of entities.

However, if black lists are defined, the behavior is explained in the following sub-section.

Intent disambiguation with a blacklist of intents

Aura NLP allows the integration of configurable blacklists of intents for a custom behavior of disambiguation. In this case, the disambiguation mechanisms will not apply for the intents included in the blacklist. The use case constructors can edit a blacklist of intents in the nlp.json configuration file, filling the parameter intent_blacklist.

When there is a blacklist of intents, the disambiguation process behaves as explained below:

a. If the top scored intent is included in the intent_blacklist, the pipeline will return this unique intent (no disambiguation is launched).

b. If the top scored intent is not included in the intent_blacklist, then the predefined values of the configuration parameters come into play:

If the score of the top scored intent is higher than exact_match, then this intent is returned. In case of tie (more than one intent with the highest score), all of them are returned.
If the score of the top scored intent is lower than exact_match, then all the intents whose score is in the interval between the top score and the disambiguation_margin and are not in the intent_blacklist are returned.
In this case, the final intent will be the one described in intent_template (with a score of 1.0) and the selected intents will be placed in the options of the result.

Path

auracog_pipelines.stage_wrappers.adapter_wrapper.intent_disambiguation_wrapper.IntentDisambiguationAdapterWrapper

Files

No files are required.

Configuration

This stage requires the following configuration in the nlp.json file for each country and channel, within the key intent_disambiguation.

The following parameters are required for this stage:

exact_match: Float number, value between 0 and 1. If the intent with the highest score is greater than this value, the result is this intent (if this intent is not included in the intent_blacklist).
disambiguation_margin: Float number. Margin between the highest score and the lower score considered for the response.
intent_template: String. Name of the intent that the stage returns when there are multiple options as response.
intent_blacklist: List of intents for which the disambiguation mechanisms will not apply. This parameter is mandatory. If there are no blacklisted intents, it will have to be an empty list.
⚠️ none intent must always be included in the blacklist, as it is not going to be offered as an option to disambiguate.

See an example of nlp.json file configuration for this stage:

{
  "es-es": {
    "mp": {
      "intent_disambiguation": {
         "disambiguation_margin": 0.2,
         "exact_match": 0.92,
         "intent_template": "intent.disambiguation",
         "intent_blacklist": ["intent.blacklisted_intent1", "intent.blacklisted_intent2"]
      },
      ...
    }
  }
}

Examples of intent disambiguation adapter

Basic example for intent disambiguation adapter inclusion in a pipeline

{
  "name": "IntentDisambiguationExample",
  "initial_node_id": "IntentDisambiguationExamplePipeline",
  "elements": {
    "IntentDisambiguationExamplePipeline": {
      "type": "joint",
      "classpath": "auracog_pipelines.pipelines.base.BasePipeline"
    },
    "RecognizerWrapper": {
      "type": "stage",
      "classpath": "auracog_pipelines.stage_wrappers.recognizer_wrapper"
    },
    "IntentDisambiguationAdapterWrapper": {
      "type": "stage",
      "classpath": "auracog_pipelines.stage_wrappers.adapter_wrapper.intent_disambiguation_wrapper.IntentDisambiguationAdapterWrapper"
    }
  },
  "links": {
    "IntentDisambiguationExamplePipeline": [
      "RecognizerWrapper",
      "IntentDisambiguationAdapterWrapper"
    ]
  }
}

General behavior of intent disambiguation stage (with no blacklist of intents)

Here is an example of the input and output data models for the intent disambiguation stage, belonging to the OpenAI embeddings stage, where the disambiguation margin is 0.2:

Input data model

{
    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [
            {
                'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1,         'end_index': 2, 'canon': 'canon1', 'label': 'label1'
            },
            {
                'entity': 'name2', 'type': 'type2', 'score': 0.78, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label2'
            }
        ],
        'top_result': {'intent': 'intent.tv.search', 'score': 0.96},
        'intents': [
            {'intent': 'intent.tv.search', 'score': 0.96},
            {'intent': 'intent.tv.display', 'score': 0.90},
            {'intent': 'intent.tv.launch', 'score': 0.60}
        ]
    },
    'domain_result': {}
}

Output data model (2 intents fulfil the predefined criteria)

{
    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [],
        'top_result': {'intent': 'intent.disambiguation', 'score': 1.0},
        'intents': [
            {'intent': 'intent.disambiguation', 'score': 1.0}
        ]
    },
    'domain_result': {},
    'options': [
        {
            'query': 'original Phrase',
            'channel': 'mp',
            'intent_result': {
                'entities': [
                    {
                        'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label1'
                    },
                    {
                        'entity': 'name2', 'type': 'type2', 'score': 0.78, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label2'
                    }
                ],
                'top_result': {'intent': 'intent.tv.search', 'score': 0.96},
                'intents': [
                    {'intent': 'intent.tv.search', 'score': 0.96}
                ]
            },
            'domain_result': {},
            'options': []
        },
        {
            'query': 'original Phrase',
            'channel': 'mp',
            'intent_result': {
                'entities': [
                    {
                        'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label1'
                    },
                    {
                        'entity': 'name2', 'type': 'type2', 'score': 0.78, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label2'
                    }
                ],
                'top_result': {'intent': 'intent.tv.display', 'score': 0.90},
                'intents': [
                    {'intent': 'intent.tv.display', 'score': 0.90}
                ]
            },
            'domain_result': {},
            'options': []
        }
    ]
}

Behavior of intent disambiguation stage with a blacklist of intents.
Scenario 1: top intent is included in the blacklist

Input data model

{
    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [
            {
                'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label1'
            }
        ],
        'top_result': {'intent': 'intent.common.greetings', 'score': 0.96},
        'intents': [
            {'intent': 'intent.common.greetings', 'score': 0.96},
            {'intent': 'intent.tv.display', 'score': 0.90},
            {'intent': 'None', 'score': 0.60}
        ]
    },
    'domain_result': {}
}

Output data model: the top intent is included in the blacklist, therefore, no disambiguation is launched.

{
    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [
            {
                'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label1'
            }
        ],
        'top_result': {'intent': 'intent.common.greetings', 'score': 0.96},
        'intents': [
            {'intent': 'intent.common.greetings', 'score': 0.96},
            {'intent': 'intent.tv.display', 'score': 0.90},
            {'intent': 'None', 'score': 0.60}
        ]
    },
    'domain_result': {}
}

Behavior of intent disambiguation stage with a blacklist of intents
Scenario 2: top intent is included in the blacklist

Input data model

{
    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [
            {
                'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label1'
            }
        ],
        'top_result': {'intent': 'intent.tv.search', 'score': 0.96},
        'intents': [
            {'intent': 'intent.tv.search', 'score': 0.96},
            {'intent': 'None', 'score': 0.90}
            {'intent': 'intent.tv.display', 'score': 0.89}
        ]
    },
    'domain_result': {}
}

Output data model: the top intent is not included in the blacklist and more than one intent fulfil the condition for disambiguation » The options in the blacklist are ignored and the remaining intents are disambiguated.

{
    'query': 'original Phrase',
    'channel': 'mp',
    'intent_result': {
        'entities': [],
        'top_result': {'intent': 'intent.disambiguation', 'score': 1.0},
        'intents': [
            {'intent': 'intent.disambiguation', 'score': 1.0}
        ]
    },
    'domain_result': {},
    'options': [
        {
            'query': 'original Phrase',
            'channel': 'mp',
            'intent_result': {
                'entities': [
                    {
                        'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label1'
                    }
                ],
                'top_result': {'intent': 'intent.tv.search', 'score': 0.96},
                'intents': [
                    {'intent': 'intent.tv.search', 'score': 0.96}
                ]
            },
            'domain_result': {},
            'options': []
        },
        {
            'query': 'original Phrase',
            'channel': 'mp',
            'intent_result': {
                'entities': [
                    {
                        'entity': 'name1', 'type': 'type1', 'score': 0.88, 'start_index': 1, 'end_index': 2, 'canon': 'canon1', 'label': 'label1'
                    }
                ],
                'top_result': {'intent': 'intent.tv.display', 'score': 0.89},
                'intents': [
                    {'intent': 'intent.tv.display', 'score': 0.89}
                ]
            },
            'domain_result': {},
            'options': []
        }
    ]
}

Length Adapter

Description

The objective of this stage is to control the maximum and minimum length of a phrase in order to avoid it to be too short or too long. The maximum/minimum number of characters is configurable. The stage discards the out-of-range phrases, as they are not recognized properly by Aura NLP, thus saving time and resources in the recognition process.

The Length Adapter returns a configurable intent template if the length of the received phrase in the pipeline message is higher than the maximum number of configurable characters or lower than the minimum one. The intent template is also configurable.

Path

auracog_pipelines.stage_wrappers.adapter_wrapper.lenght_adapter_wrapper.LenghtAdapterWrapper

Files

No files required.

Configuration

This stage requires a specific configuration in the pipeline configuration file pipeline.json, within the args section of this file, that contains the following fields:

max: maximum number of characters in the phrase of the received pipeline message.
min: minimum number of characters in the phrase of the received pipeline message.
intent_template: intent name to be returned if the number of characters is lower than the min value or higher than max value.

      "args": {
         "max": 50,
         "min": 1,
         "intent_template": "intent.example"
      }

You can also configure more than one stage of the Length Adapter to return different intents for max or min length characters.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura configuration API admin module

Admin module description for aura-configuration-api

Introduction

The administration module defines services associated with general administration tasks in aura-configuration-api server.

All these services are defined in the admin namespace (/admin).

Servers definition

By default, the servers defined in the swagger include the base path (for v2): /aura-services/v2/configuration.

Therefore, in order to access the services, the base path and service path must be used.

Examples:

aura-services/v2/configuration/admin/export
aura-services/v2/configuration/admin/import

Endpoints

Path	Method	Description
/admin/export	GET	Export configuration
/admin/import	POST	Import configuration

You can read the complete documentation of each service in the aura-configuration-api swagger file.

Export modules

Export all

To export all configuration, a GET call to /admin/export path must be made.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/admin/export' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

The service will respond with an ExportModel type object:

export interface ExportModel {
    /** Export metadata */
    metadata?: ExportMetadata;
    /** Export data */
    data?: ExportModelData;
}

metadata: It contains information related to the export itself: export date (data), current API version (apiVersion), bot configuration version (version).
data: Module data information indexed by module name.

Further information about ExportModel interface.

Export one or several specific modules

It is possible to export one or several modules using the module parameter in the call to /admin/export endpoint.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/admin/export?modules=channels' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

The result will have the same format as for complete export, but in the data field only includes the indicated modules.

Import modules

To import, data from a previous export must be used. The import can be from a complete or partial export of certain modules.

To import all configuration, a POST call to /admin/import path must be made.

curl --location --request POST 'http://aura-configuration-api:8999/aura-services/v2/configuration/admin/import' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX' \
--header 'Content-Type: application/json' \
--data-raw 'PREVIOUS_EXPORT_DATA'

How is an import processed?

During the import process, the following tasks are performed:

For each module to export, the import method of each of those modules is called.
The necessary mappers are executed to adapt the export version to the current server version (if applicable).
The objects of each module are validated with json schema.
The objects are inserted in the appropriate collection.

flowchart TD
    A[Import] --> B{Are there modules?}
    B --> |Yes| Mappers[Apply mappers]
    Mappers --> Validate[Validate using json schema]
    Validate --> Add[Add to collection]
    Add --> B
    B ---->|No| E[End]

Result of the import process

The import service will respond with an ImportResult type object:

export interface ImportResult {
    version: string;
    fromVersion: string;
    modules: ImportModuleResult[];
    status: ProcessStatus;
}

export interface ImportModuleResult {
    name: string;
    patches?: ImportPatches;
    result: ProcessResult;
}

export enum ProcessStatus {
    Ok = 'Ok',
    Error = 'Error'
}

version: Version to which the import has been made.
fromVersion: Original import version.
modules: array of ImportModuleResult with the result of the import of each module.
status: Status with the overall result of the import process. If any module fails the result will be Error.

Database

The database to store the aura-configuration-api information must be named with the following format:

aura-configuration-<ENVIRONMENT_NAME>-<BOT_VERSION>

Example for the ap-next environment and 7.4.0 version:

aura-configuration-ap-next-7-4-0

As a general rule, all those modules that define a DAO will have a collection associated with that module.The currently existing collections are described in the following sections.

Channels collection

This collection stores channel information using channels collection.

Fields

Field name	Type	Required
name	string	true
prefix	string	true
nlp	{}	true
nlp.enabled	boolean	true
auraBotCacheTTL	number	false
id	string	true
dialogLibraries	Array<{}>	false
actions	{}	false
actions.afterLogin	{}	false
actions.afterLogin.action	string	false
actions.afterLogin.type	string	false
actions.afterLogin.data	{}	false
actions.thirdPartyApp	{}	false
actions.thirdPartyApp.action	string	false
actions.thirdPartyApp.type	string	false
actions.thirdPartyApp.data	{}	false
actions.thirdPartyApp.contentType	string	false
rcs	{}	false
rcs.agentId	string	true
rcs.clientToken	string	true
rcs.email	string	true
rcs.privateKey	string	true
requestOptions	{}	false
requestOptions.fileAttachments	{}	false
requestOptions.fileAttachments.enabled	boolean	true
requestOptions.fileAttachments.enabledExtensions	Array<string[]>	false
requestOptions.fileAttachments.customProactiveDialogId	string	false
requestOptions.fileAttachments.validations	{}	false
requestOptions.requestOptionsVersion	{}	false
responseOptions	{}	false
responseOptions.dialogContext	{}	false
responseOptions.dialogContext.disabled	boolean	false
responseOptions.dialogContext.disabledMerge	boolean	false
responseOptions.dialogContext.normalizeTerms	boolean	false
responseOptions.dialogContext.defaultListType	’none’,‘ordinalCardinal’,‘ordinal’,‘cardinal’	false
responseOptions.dialogContext.promptChoice	{}	false
responseOptions.dialogContext.promptChoice.generateList	boolean	false
responseOptions.dialogContext.promptChoice.generate	’never’,‘always’,‘custom’	false
responseOptions.dialogContext.cardActions	{}	false
responseOptions.dialogContext.cardActions.generateList	boolean	false
responseOptions.dialogContext.cardActions.generate	’never’,‘always’,‘custom’	false
responseOptions.dialogContext.returnToClient	boolean	false
responseOptions.dialogContext.processFromClient	boolean	false
responseOptions.versions	{}	false
responseOptions.needsEmptyResponseEvent	boolean	false
responseOptions.outputMessageFormat	‘custom’,’enrich’,‘html5’,‘simple’,‘voice’	false
responseOptions.sendSpeak	boolean	false
responseOptions.disambiguationFormat	‘disabled’,‘prompts’,‘suggestions’	false
responseOptions.textConvert	boolean	false
responseOptions.suggestionType	‘actions’,‘attachment’	false
responseOptions.suggestionsNumber	number	false
responseOptions.tv.actions	Array<Action[]>	false
security	{}	false
security.anonymous	‘anonymous’,‘identifiable’	false
security.allowUserProfile	boolean	false
security.channelId	string	false
security.authScopes	string	true
security.authPurposes	string	true
security.federatedAuthentication	{}	false
security.federatedAuthentication.loginUrl	string	false
security.federatedAuthentication.auraIdSeparator	string	false
security.federatedAuthentication.loginCallback	{}	false
security.federatedAuthentication.loginCallback.method	string	false
security.federatedAuthentication.loginCallback.integrated	boolean	false
security.federatedAuthentication.loginCallback.endpoint	string	false
security.federatedAuthentication.loginCallback.queryParams	string	false
security.federatedAuthentication.loginCallback.headers	Array<string[]>	false
security.federatedAuthentication.loginCallback.body	string	false
security.federatedAuthentication.logoutCallback	{}	false
security.federatedAuthentication.logoutCallback.method	string	false
security.federatedAuthentication.logoutCallback.integrated	boolean	false
security.federatedAuthentication.logoutCallback.endpoint	string	false
security.federatedAuthentication.logoutCallback.queryParams	string	false
security.federatedAuthentication.logoutCallback.headers	Array<string[]>	false
security.federatedAuthentication.logoutCallback.body	string	false
security.termsAndConditions	{}	false
security.termsAndConditions.authenticated	{}	false
security.termsAndConditions.authenticated.version	string	true
security.termsAndConditions.authenticated.service	string	true
security.termsAndConditions.anonymous	{}	false
security.termsAndConditions.anonymous.version	string	true
security.termsAndConditions.anonymous.service	string	true
whatsapp	{}	false
whatsapp.client	{}	false
whatsapp.client.id	string	true
whatsapp.client.secret	string	true
whatsapp.client.purposes	string	false
whatsapp.client.scopes	string	false
whatsapp.phoneNumber	string	false
whatsapp.listOptions	{}	false
whatsapp.listOptions.type	‘button’,’enumeratedList’,’list’	false
whatsapp.listOptions.rules	Array<{}>	false
whatsapp.type	‘whatsapp’	false
metadata	{}	false
metadata.version	string	false
metadata.createdAt	string	false
metadata.updatedAt	string	false

Indexes

[
    {
        "version": 1,
        "name": "idx_channel_id",
        "keys": {
            "id": 1
        },
        "unique": true
    },
    {
        "version": 1.1,
        "name": "idx_updated_at",
        "keys": {
            "metadata.updatedAt": -1
        }
    },
    {
        "version": 1,
        "name": "idx_channel_library",
        "keys": {
            "id": 1,
            "dialogLibraries.name": 1
        }
    }
]

skills collection

This collection stores skills information using skills collection.

Fields

Field name	Type	Required
id	string	true
name	string	true
appId	string	true
skillEndpoint	string	true
channels	Array<string[]>	true
disabled	boolean	false
external	boolean	false
metadata	{}	false
metadata.version	string	false
metadata.createdAt	string	false
metadata.updatedAt	string	false

Indexes

[
    {
        "version": 1.1,
        "name": "idx_skill_id",
        "keys": {
            "id": 1
        },
        "unique": true
    },
    {
        "version": 1.1,
        "name": "idx_updated_at",
        "keys": {
            "metadata.updatedAt": -1
        }
    }
]

applications collection

This collection stores applications information using applications collection.

Fields

Field name	Type	Required
id	string	true
name	string	true
brand	string	true
disabled	boolean	false
agents	string[]	false
nlp.channelId	string	false
models.level	Level	false
models.presets	string[]	true
metadata.version	string	false
metadata.createdAt	string	false
metadata.updatedAt	string	false

Types

Type name	Type	Options
Level	string	Set the different levels of access for the application. It can only be changed by Aura Global Team

Indexes

[
    {
        "version": 1.5,
        "name": "idx_app_id",
        "keys": {
            "id": 1
        },
        "unique": true
    },
    {
        "version": 1.5,
        "name": "idx_updated_at",
        "keys": {
            "metadata.updatedAt": -1
        }
    }
]

presets collection

This collection stores presets information using presets collection.

Fields

Root

Field name	Type	Required
id	string	true
name	string	true
description	string	false
group	string	false
session	Session	false
generative	Generative	false
rag	Rag	false
metadata	Metadata	false

Types

Action

Field name	Type	Required
name	string	true
target	string	false
params	object	false
postBack	object	false

Session

Field name	Type	Required
session.window	number	false
session.timeout	number	false

Generative

Field name	Type	Required
generative.model.id	string	false
generative.model.parameters.max_tokens	number	false
generative.model.parameters.temperature	number	false
generative.model.parameters.top_p	number	false
generative.injectionMaxLength	number	false
generative.prompts.template	string	false
generative.prompts.preamble.text	string	false
generative.prompts.preamble.args.name	string	false
generative.prompts.examples	string[]	false
generative.prompts.promptRegexClean	string	false
generative.prompts.promptMaxLength	number	false

RAG

Field name	Type	Required
rag.type	string	false
rag.references.maximum	number	false
rag.references.baseUrl	string	false
rag.model.id	string	false
rag.model.parameters.max_tokens	number	false
rag.model.parameters.temperature	number	false
rag.model.parameters.top_p	number	false
rag.stages.language	string	false
rag.stages.security.heuristics.example	string	false
rag.stages.security.maxLength	number	false
rag.stages.translation.prompt	string	false
rag.stages.translation.language	string	false
rag.stages.clean.prompt.default	string	false
rag.stages.clean.prompt.es	string	false
rag.stages.context.prompts.recreatedQuestion.default	string	false
rag.stages.context.prompts.recreatedQuestion.es	string	false
rag.stages.context.prompts.sameContext.default	string	false
rag.stages.context.prompts.sameContext.es	string	false
rag.stages.context.stickyContext	string	false
rag.stages.retrieval.sourceDataId	string	false
rag.stages.postFiltering.candidatesPostFiltering	string	false
rag.stages.postFiltering.prompt.default	string	false
rag.stages.postFiltering.prompt.es	string	false
rag.stages.generative.ragStrategy	string	false
rag.stages.generative.prompts.stuff.default	string	false
rag.stages.generative.prompts.stuff.es	string	false
rag.stages.generative.prompts.refine.default	string	false
rag.stages.generative.prompts.refine.es	string	false
rag.outputRefine.candidates	boolean	false
rag.outputRefine.filterOutputMetadata.map.fileType	string	false
rag.outputRefine.filterOutputMetadata.map.pageNumber	string	false
rag.outputRefine.filterOutputMetadata.groupBy	string	false
rag.outputRefine.filterOutputMetadata.aggregate	string	false
rag.outputRefine.filterOutputMetadata.outputFilter	string[]	false
rag.outputRefine.filterOutputMetadata.root	string[]	false

Metadata

Field name	Type	Required
metadata.version	string	false
metadata.createdAt	string	false
metadata.updatedAt	string	false

Indexes

[
    {
        "version": 1.10,
        "name": "idx_preset_id",
        "keys": {
            "id": 1
        },
        "unique": true
    },
    {
        "version": 1.10,
        "name": "idx_updated_at",
        "keys": {
            "metadata.updatedAt": -1
        }
    },
    {
        "version": 1.10,
        "name": "idx_preset_name",
        "keys": {
            "name": 1
        },
        "unique": true
    }
]

suggestions collection

This collection stores suggestion information using suggestions collection.

Fields

Field name	Type	Required
id	string	true
name	string	true
intent	string	true
entities	Array<{}>	true
resources	Array<{}>	true

Indexes

[ 
    {
        "version": 2.1,
        "name": "idx_suggestion_id",
        "keys": {
            "id": 1
        },
        "unique": true
    },
    {
        "version": 2.1,
        "name": "idx_updated_at",
        "keys": {
            "metadata.updatedAt": -1
        }
    },
    {
        "version": 2.1,
        "name": "idx_suggestion_name",
        "keys": {
            "name": 1
        },
        "unique": true
    }
]

tv-section collection

This collection stores TV Section information using the tv-sections collection.

Fields

Field name	Type	Required	Description
id	string	true	Unique identifier for the TV Section (UUID)
pid	string	false	External or process identifier
name	string	false	Name of the TV Section
canon	string	false	Canonical name of the TV Section
type	string	false	Section type (`app` or `section`)
metadata	object	false	Document metadata (version, creation and update dates)

Example of `metadata`:

Field	Type	Description
version	string	Configuration version when the document was created
createdAt	string	Creation date (ISO 8601)
updatedAt	string	Update date (ISO 8601)

Indexes

  {
    "version": 2.0,
    "name": "idx_tvsections_id",
    "keys": { "id": 1 },
    "unique": true
  },
  {
    "version": 2.0,
    "name": "idx_tvsections_pid",
    "keys": { "pid": 1 },
    "unique": true
  },
  {
    "version": 2.0,
    "name": "idx_updated_at",
    "keys": { "metadata.updatedAt": -1 }
  },
  {
    "version": 2.0,
    "name": "idx_tvsections_name",
    "keys": { "name": 1 },
    "unique": true
  }
]

agents collection

This collection stores agent information using the agents collection.

Fields

Field name	Type	Required	Description
id	string	true	UUID that identifies the agent univocally in Aura.
name	string	true	Name that identifies the agent univocally in Aura.
description	string	false	Agent description description.
communication	object	true	Communication configuration of the agent. See `communication` object.
flowConfig	object	false	Configuration of the agent flow.
deploymentName	string	false	Name of the deployment where the agent is running.
metadata	object	false	Document metadata (version, creation and update dates). See metadata object.

communication object (HTTP)

Field	Type	Description
endpoint	string	HTTP endpoint where the agent is listening to.
headers	object	HTTP headers associated with the agent.
communicationType	string	Communication type (`http`).
timeout	number	Timeout for the agent.
retries	number	Number of retries for the agent.

metadata object

Field	Type	Description
version	string	Configuration version when the document was created
createdAt	string	Creation date (ISO 8601)
updatedAt	string	Update date (ISO 8601)

Indexes

[
  {
    "version": 2.0,
    "name": "idx_agent_id",
    "keys": { "id": 1 },
    "unique": true
  },
  {
    "version": 2.0,
    "name": "idx_updated_at",
    "keys": { "metadata.updatedAt": -1 }
  },
  {
    "version": 2.0,
    "name": "idx_agent_name",
    "keys": { "name": 1 },
    "unique": true
  }
]

routing filters collection

This collection stores routing filters information using the routing-filters collection.

Fields

Field name	Type	Required	Description
id	string	true	UUID that uniquely identifies a routing filter in Aura.
name	string	true	Name that uniquely identifies a routing filter in Aura.
description	string	false	Routing Filter description.
type	string	true	Contains the type of filter. Currently, there is only one type ‘userId’.
entities	string[]	true	Contains at least one entity necessary to generate the data for the filter.
dataBase	object	true	Contains an object with the collections necessary to store and process data. See database object.
vars	object	true	Contains an object with the custom variables necessary for any phase of the filter. Encrypted field.
fields	object	true	Contains the field mapping for grouping and its relationship with the previously defined entities. Encrypted field.
sourceFilters	object	false	Contains an object to filter source data when loading from entity data. Encrypted field.
match	object	true	Contains an object with the MongoDB aggregation format that must return grouped data. Encrypted field.
summary	object	true	Contains an object with MongoDB command format to insert these obtained aggregates into a summary collection. Encrypted field.
actions	object[]	true	Contains an array of objects with the actions to be performed on the filtered data.
summaryFilter	object	true	Contains an object with MongoDB command format to select the records that meet the filter. Encrypted field.
metadata	object	false	Document metadata (version, creation and update dates). See metadata object.

database object

Field	Type	Description
dataFilterCollection	object	Contains an object with the name of the collection for raw data and its expiration in seconds. See filterCollection object.
dataSummaryCollection	object	Contains an object with the name of the collection for summary data and its expiration in seconds. See filterCollection object.

filterCollection object

Field	Type	Description
collectionName	string	Contains the name of the collection.
expiration	object	Contains the value in seconds of the expiration of the collection data.
indexes	object[]	A optional array with indexes in mongodb format. Example: `[{"seq1": 1}]`

metadata object

Field	Type	Description
version	string	Configuration version when the document was created
createdAt	string	Creation date (ISO 8601)
updatedAt	string	Update date (ISO 8601)

Indexes

[
    {
        "version": 2.2,
        "name": "idx_routing_filter_id",
        "keys": {
            "id": 1
        },
        "unique": true
    },
    {
        "version": 2.2,
        "name": "idx_updated_at",
        "keys": {
            "metadata.updatedAt": -1
        }
    },
    {
        "version": 2.2,
        "name": "idx_routing_filter_name",
        "keys": {
            "name": 1
        },
        "unique": true
    }
]

A example with a complete filter definition

 {
        "name": "preset-filter-stb-conversational-search",
        "id": "4a879583-5f76-4e6b-87c1-6250e8743dda",
        "description": "Limit the number of messages per user in a month for stb conversational search preset",
        "type": "userId",
        "entities": [
            "GATEWAYMESSAGE"
        ],
        "vars": {
            "llm_execution_limit": 10
        },
        "dataBase": {
            "dataFilterCollection": {
                "collectionName": "dataFilterPreset",
                "expiration": 5356800,
                "indexes": [
                    {
                        "seqId": 1
                    }
                ]
            },
            "dataSummaryCollection": {
                "collectionName": "dataSummaryStbConvSearch",
                "expiration": 5356800,
                "indexes": [
                    {
                        "month": 1,
                        "total": 1,
                        "year": 1
                    },
                    {
                        "itemId": 1,
                        "month": 1,
                        "year": 1
                    }
                ]
            }
        },
        "fields": {
            "MatchingValue": "^ef3d0603-3fef-4109-a577-0ab92f9060df$",
            "forId": "USER_ID",
            "forMatchingField": "AURA_PRESET_NAME",
            "forTime": "MESSAGE_TM"
        },
        "sourceFilters": [
            {
                "field": "USER_ID",
                "op": "notEqual",
                "val": ""
            }
        ],
        "match": [
            {
                "$match": {
                    "fieldForMatch": "{{fields.forMatchingField}}",
                    "seqId": {
                        "$gt": "{{ctx.lastSeqId|number}}"
                    },
                    "valueForMatch": {
                        "$options": "i",
                        "$regex": "{{fields.MatchingValue}}"
                    }
                }
            },
            {
                "$group": {
                    "_id": {
                        "itemId": "$itemId",
                        "month": "$month",
                        "year": "$year"
                    },
                    "seqId": {
                        "$max": "$seqId"
                    },
                    "total": {
                        "$sum": 1
                    }
                }
            },
            {
                "$project": {
                    "_id": 0,
                    "itemId": "$_id.itemId",
                    "month": "$_id.month",
                    "seqId": 1,
                    "total": 1,
                    "year": "$_id.year"
                }
            }
        ],
        "summary": {
            "filter": {
                "itemId": "{{doc.itemId}}",
                "month": "{{doc.month|number}}",
                "year": "{{doc.year|number}}"
            },
            "options": {
                "upsert": true
            },
            "update": {
                "$inc": {
                    "total": "{{doc.total|number}}"
                },
                "$set": {
                    "expiresAt": "{{ctx.expiration|expires}}",
                    "month": "{{doc.month|number}}",
                    "updatedAt": "{{__DATE_NOW__}}",
                    "year": "{{doc.year|number}}"
                }
            }
        },
        "summaryFilter": {
            "filter": {
                "month": "{{ctx.month|number}}",
                "total": {
                    "$gt": "{{vars.llm_execution_limit|number}}"
                },
                "year": "{{ctx.year|number}}"
            },
            "options": {
                "projection": {
                    "_id": 0,
                    "itemId": 1,
                    "month": 1,
                    "total": 1,
                    "year": 1
                }
            }
        },
        "metadata": {
            "updatedAt": "2025-10-03T06:06:49.609Z",
            "version": "10.5.0"
        }
    }

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

agent-dispatcher-api plugin

Technical description of the agent-dispatcher-api plugin

Introduction

agent-dispatcher-api plugin manages and dispatches the requests to the agent API.

Consumes components (IOC)

Name	Type	Description
configurationManager	PluginType.Service	Configuration manager
redisConnector	PluginType.Service	Redis connector
sessionService	PluginType.Service	Session service
agentsConfiguration	PluginType.Service	Agents Configuration

Provides components (IOC)

Name	Type	Description
agentDispatcherApi	PluginType.API	Agent dispatcher API

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Alertmanager dashboard

Information provided by Alertmanager dashboards

Panels

Received alerts rate

It shows a time series with the received alerts rate aggregated by one minute.

The x-axis shows the time series and the y-axis shows received alerts rate.

The queries used to get the panel information are:

sum(rate(prometheus_notifications_alertmanagers_discovered[1m])) by(status)

An example of this panel is shown below:

The available metrics are defined in the following sections.

Successful notification rate

It shows a time series with the successful notifications rate aggregated by one minute.

The x-axis shows the time series and the y-axis shows the successful notifications rate.

The queries used to get the panel information are:

sum(rate(prometheus_notifications_sent_total[1m])) by(integration)

An example of this panel is shown below:

Failed notifications rate

It shows a time series with the failed notifications rate aggregated by one minute.

The x-axis shows the time series and the y-axis shows the failed notifications rate.

The queries used to get panel information are:

sum(rate(prometheus_notifications_errors_total[1m])) by(integration)

An example of this panel is shown below:

CPU usage rate

It shows a time series with the CPU usage rate aggregated by one minute. It also shows the current minimum, maximum and average cpu consumption of alertmanager.

The x-axis shows the time series and the y-axis shows the CPU usage rate.

The queries used to get panel information are:

sum(rate(container_cpu_usage_seconds_total{container="alertmanager"}[1m])) by (pod_name)

An example of this panel is shown below:

Memory usage

It shows a time series with the memory usage. It also shows the current minimum, maximum and average memory consumption of alertmanager.

The x-axis shows the time series and the y-axis shows the memory usage.

The queries used to get panel information are:

sum (container_memory_working_set_bytes{container="alertmanager"}) by (pod_name)

An example of this panel is shown below:

Pods network I/O

It shows a time series with the network I/O average aggregated by one minute. It also shows the current minimum, maximum and average network I/O.

The x-axis shows the time series and the y-axis shows the network usage.

The queries used to get panel information are:

sum (rate (container_network_receive_bytes_total{pod!="",pod=~"alertmanager.*"}[1m])) by (pod)
- sum (rate (container_network_transmit_bytes_total{pod!="",pod=~"alertmanager.*"}[1m])) by (pod)

An example of this panel is shown below:

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Bot architecture

Description of Aura Bot architecture and starting components

Introduction to Bot Framework service

A bot is an application, particularly an HTTP server, that allows interaction with users in a conversational way. Different means of interaction are available, such as text, cards with images, video or audio and speech.

Users interact with the bot through a given channel, that is the final application used directly by the users. For instance, the bot can be accessible from Facebook, WhatsApp or from any private application, such as My O2 or Mi Movistar. Every message exchanged between the user and the bot is called an activity.

Microsoft Bot Framework Service, that is the main component of Azure Bot Service, is responsible for sending the user’s request to the particular bot instance, in this case, to the corresponding instance of aura-bot. Channels communicating with a bot should include additional information required by this specific bot to handle the message in the body of the request, i.e., in the activity. aura-bot provides a definition of the channelData field of the activity, so channels are able to send and receive this information needed to handle Aura use cases.

aura-bot, as a bot based on Microsoft Bot Framework, understands different types of activities. The most basic types of activities used by aura-bot are:

Message: Means to transmit the user’s needs to the bot.
Event: Events are in charge of the end-to-end communication between aura-bot and channels. They are managed by the incoming-event-middleware.
ConversationUpdate: Activity that describes a change in conversation’s members, description, existence, etc.

Communication between BotFramework Service and aura-bot is based on HTTP. BotFramework Service sends an HTTP POST request to the bot, with the incoming activity from the user. The bot should respond with a 200 HTTP status code to this request. In aura-bot, this is executed before going on with the processing of the activity, so the echo message of the user is returned before the activity generated as an answer. These activities are sent to BotFramework Service as HTTP POST request, that is responded with 200 HTTP status code, too.

Once an activity arrives at the bot, the HTTP server should pass it to the BotFramework Adapter, that starts the activity processing.

At this moment, a turn starts, that refers to all the steps done from the moment that an activity enters the bot until all the answer activities are returned to the user. Each turn lays on a TurnContext, that holds all the information about the current activity. Bot Framework automatically includes in the TurnContext object some information, but aura-bot extends this object with extra information that makes it easier to provide a response to the user.

Please, check detailed information about Microsoft Bot Framework Service and the related SDK.

Aura Bot core architecture

The following diagram shows all the components running in any aura-bot instance. They are shown as they are loaded during bot start-up.

Legend
Blue boxes: singleton components Yellow boxes within them: components that are handled the same way Middlewares: - M: mandatory ones - O: optional, executed only if they are properly configured Execution mode: - F: execution flow stops when middleware fails - T: execution continues when middleware fails

Aura Bot messages flowchart

As explained before, messages are a type of activities that manage requests from the users: aura-bot receives a request from a user and provides an answer back.

The following diagram include the messages flow through aura-bot.

Aura Bot starting components and modules: Aura orchestrator

Currently, aura-bot includes an orchestrator that controls how the system is loaded and indicates which components and modules are required for the bot start-up.

The orchestrator handles a sorted array of components that must implement a series of methods that may receive the bot configuration if necessary. Modules are then initialized asynchronously, although they were synchronous.

This behavior simplifies both the definition of the singleton modules and how the orchestrator initializes them, with a minimum loss of performance during start-up.

        const orderedModules = [ModuleA, ModuleB, ModuleC];
        // Instantiate the Service App.
        const appOrchestrator = new Orchestrator();
        // Add configuration, that will be required by almost all other modules
        appOrchestrator.setConfigurationManager(Configuration);
        // Add the dependent modules in order.
        appOrchestrator.addModules(sortedModules);
        // Initiate the App.
        await appOrchestrator.init();

The orchestrator module is created during the server start-up with the following parameters:

ConfigurationManager:

Class that handles aura-bot configuration, that is the component in charge of loading the environment variables.

Singleton Modules:

They are: MiniBotServiceMock, AuraChannelsConfiguration, AuraMongoDb.Connector, KpiHandler, HttpMonkeyPatcher, PluginManager, LocaleManager, AuraCacheManagement, AuraBotServer.

These modules are loaded in the given order. If any of these modules does not start correctly, aura-bot does not start. Otherwise, AuraBotServer is up and running at the end of the process. All these modules are available all along the bot.

MiniBotServiceMock is only started if the bot is running locally through Aura minibot.

How to define singleton modules in Aura

In order to develop a new singleton module that can be used by aura-bot both internally and during the dialog execution, developers should keep in mind the following issues:

All modules added to the orchestrator need and publish a static variable called instance, that holds the singleton instance of that module.
Modules must have a public static method: init, that could be async or not depending on the needs of the module start-up. This method creates the singleton instance (and sets it to then instance variable). This method should only be called once by module or must throw an exception. It is only called by the orchestrator.
It is also recommended to provide an empty private constructor that avoids the creation of new instances of the module.

An example of implementation is shown below:

export class Class1 {
    public static instance: Class1;
    private constructor() {
        // Stuff here...
    }
    public static async init(config: Configuration): Promise<Class1 > {
        if (!Class1 .instance) {
            Class1 .instance = new Class1 ();
            // More stuff here

            return Class1 .instance;
        } else {
            throw new Error('An instance of Class1  already exists');
        }
    }
}

To use any of these modules:

Import its dependency.
Access the module instance property and call the required method.

The following example shows how to get a text translated by the LocaleManager.

import { LocaleManager } from '@telefonica/aura-utilities/lib/aura-locale-manager';
…
LocaleManager.instance.getText('errors:error.invalidScopes', auraUser, corr);

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura bridge architecture

Description of Aura bridge general architecture at the level of components

Introduction

aura-bridge architecture is designed based on three fundamental components:

aura-bridge: It is identified as the core component of the aura-bridge. It is in charge of starting the basic functionality modules, loading the plugins and starting the expressjs server.
aura-bridge-common: It can be defined as an SDK (Software Development Kit) to be able to develop a plugin.
aura-bridge-plugin. Component that provides functionality to aura-bridge. This component works the same way as a service in an architecture oriented to microservices (isolated, small and self-contained).

Aura bridge

As mentioned above, it is the core of the system and can work without the need for any plugin.

Source code structure

src
├── cache               # Two level cache module
├── config              # Configuration manager module 
├── controllers         # Generic and metric controllers (oastool)
├── make                # Aura bridge make up
├── message-sync        # Queue management system
├── middlewares         # Express middlewares
├── modules             # Bridge modules: behavior-manager, plugin-manager
└── utils               # Bridge utilities: prometheus-utils

Aura bridge common

aura-bridge-common contains all the necessary utilities in order to develop a new aura-bridge plugin and the models used in these utilities.

Aura bridge plugin

Base class to develop an aura-bridge client.

To implement a new client, it is only necessary to extend the class AuraBridgeClient and implement the sendMessage method.

export class TestClient extends AuraBridgeClient {

    public async sendMessage(message: TestMessage, options: SendMessageOptions): Promise<any> {
      ...
    }
}

If the new aura-bridge client needs to use the OAuth protocol, it is possible to extend the class AuraBridgeClientOAuthTokens and indicate the configuration of OAuth clients, passing the parameter authClients in constructor. In this way, the tokens will be updated automatically.

export class TestOauthClient extends AuraBridgeClientOAuthTokens {
  ...
}

aura-bridge-flow

AuraBridgeFlow allows the generation of a “processor” type plugin in a quickly and standardized way: control of errors, logs, metrics, client retry policies, etc.

As a rule, a “processor” type plugin receives, converts and sends a message to a destination. In case of error, it can send messages to another list of destinations.

sequenceDiagram
    Origin->>+Processor Plugin: Message
    Processor Plugin->>+Processor Plugin: Convert message

    alt ok
        Processor Plugin->>+Destination: Converted message
    end
    opt Extra response
        Processor Plugin->>+Error destination (1): Error message (1)
        Processor Plugin->>+Error destination (2): Error message (2)
    end

aura-bridge-utils

AuraBridgeUtils contains utilities for request information, get generic errors, etc.

aura-bridge plugins

A plugin is a module/component that provides aura-bridge with new functionality and works independently without affecting other existing functionality in the system.

📃 Find here detailed descriptive documentation about aura-bridge plugins.

📃 Find here the guidelines for the generation of a plugin and activation in aura-bridge.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA Model Gateway architecture and components

Development architecture and technical components of the atria-model-gateway

Technical foundations

atria-model-gateway is responsible for managing the communication with different AI models. This component receives a request from aura-gateway-api, together with other input data, and makes a call the corresponding AI models.

If the selected AI model is RAG, then atria-model-gateway calls the atria-rag-server, which is in charge of executing the RAG chain and making the corresponding calls to the LLM models and databases.

Functional components

The functional components of atria-model-gateway are described in the document LLM/LMM Experiences Builder

Architecture overview

The following diagram schematically shows the main technical components integrated into atria-model-gateway.

A brief description of these components is included below:

Access module

Module for the management of different profiles to access atria-model-gateway.

Context module

Module in charge of the storage of a conversation history in a cache (currently, Redis is used) over a period of time, grouped by session ID. These conversations are taken into account when calling the generative LLM models.

Model manager

Module that includes the available models and presets. It is in charge of receiving the info from aura-gateway-api and calling the corresponding model.

Models

Available AI models integrated into the atria-model-gateway.

Presets

Presets are configurable entities to define the specific model to work with and certain parameters associated to it: model Id, name, description, model parameters, etc.

Constructors can use the default presets or build new ones: Go to document ATRIA configuration.

When configuring an application, all the presets that can be used for this application must be previously defined.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA RAG Server architecture and components

Development architecture and technical components of the atria-rag-server

Architecture overview

The following diagram schematically shows the main technical components integrated into atria-rag-server.

A brief description of the technical components is included below:

Project

A project contains information required for the execution of the RAG pipeline: specific models for semantic search and lexical search; path where the documents to feed the LLMs are located; allowed file extensions, etc.

Semantic search (embeddings)

Qdrant database that stores the embeddings generated through semantic search (OpenAI embeddings) technology.

Lexical search (LLMs)

Database that stores the required documentation for making lexical searching, based on keywords.

Configuration

atria-rag-server includes a default configuration. Constructors can use it as is or they can modify it to be adapted to their requirements or business models: Go to document ATRIA configuration.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Complex Logic Framework architecture and components

Architecture and main components that you should handle when working over Aura Complex Logic Framework

CLF architecture

Aura Complex Logic Framework is a docker container, meaning that it is configured as a lightweight, stand-alone, executable package of software that includes all the required elements to run an application.

The Complex Logic Framework architecture is schematically shown in the following figure, containing different elements described in the succeeding sections.

CLF main components

Sandbox

A sandbox is an isolated testing environment that enables users to run programs or execute files without affecting the application, system or platform on which they run and to test new programming code.

Plugins

Plugins in Aura Complex Logic Framework are components that add a specific feature to an existing computer program, enabling its customization.

The role of plugins within the Complex Logic Framework is to receive data, make the required computations and return an adequate response to the handler.

CLF manages different types of plugins, which are encapsulated in the sandbox. Moreover, it contains several global plugins, but it is possible for developers to add custom ones.

Some key features of CLF plugins are defined below:

Architecture allows each package of plugins to be deployed in its own environment: it is possible to have an isolated container deployed in an independent way containing all the plugins of a specific package (for instance, global plugins).
Each package is isolated by being run as a different process by a unique user with randomized name. The rationale behind this is to provide an isolated sandbox to make sure no package of plugins is a security risk. Thereby, each user has limited privileges and computational resources (memory, file descriptors and CPU time) and only runs one process for package.
The running packages can only receive data from a socket, and the appropriate plugin is then executed depending on both the plugin type and the intent contained in the data. The API handler is in charge of forwarding the data to the package, acting as a proxy, but it also checks the requests and transforms the responses back.

To ease working with this architecture, packages, users and sockets have the same random name. This name also appears in the information and error log files.

OBs can develop their own custom plugins in the Aura Complex Logic Global repository, with each plugin implemented as a class that inherits from PluginBase and overwrites run method. This method receives the request data and contains the logic of the plugin. It must also generate a response that will be returned to the API handler. When a request is performed, depending on the intent, the request data will be forwarded to the corresponding plugin automatically. Note that two intents can trigger the same plugin but it is not possible to trigger two plugins with the same intent.
Each package of plugins is watched by a supervisor. If the package process crashes, it will be restarted automatically by supervisor. The causes of abrupt exit could be excessive consumption of resources (CPU time, memory or file descriptors) or plugin internal malfunction.

Stub

A stub, in the context of distributed computing, is a piece of code that is used to convert parameters during a remote procedure call (RPC). An RPC allows a client computer to remotely call procedures on a server computer.

The parameters used in a function call have to be converted because the client and server computers use different address spaces. Stubs perform this conversion so that the remote server computer perceives the RPC as a local function call.

API server

API server is the process that listens for requests. This API server is based on the cognitive API package and, in this case, is configured to run the Complex Logic module.

HTTP requests will be passed to the package API handlers according to the CLF configuration.

It is also important to mention that API server process is watched by supervisor (meaning that it is fault-tolerant).

API handler

In Aura Complex Logic Framework, API handlers are classes that inherit from BaseComplexLogicAPIHandler. They are responsible for dealing with HTTP requests through the following methods:

Checking the request is valid.
Checking that the response is in the correct format.
Making a new request to the corresponding package process, which contains a group of plugins.

The first two items are implemented by the declaration of schemas that define the query request and the response. Plugin API handlers are only responsible for defining which request schema is accepted and which response is valid (also by using a schema).

The request to a specific package is made automatically by the system as long as the specific intent that summons the trigger is recognized. The configuration is described in plugins configuration.

API plugin

API plugin is an internal component based on the cognitive API package. It exposes the plugins contained in a package.

Kernel Platform connectors

Kernel is the database where Telefónica stores all the data of its customers in a safe and reliable way, allowing users to control their data at the same time.

These data can be consulted through a Kernel API with the necessary permissions. From the Complex Logic Framework, the only way to access Kernel is through our connectors. The connectors are used, for example, to obtain customer invoices or offer the catalog of devices and services.

These connectors provide total security in order to avoid problems of wrong, malicious or not careful use by third party developers. For this purpose, prior to any request to Kernel, a check of the required permits is made.

CLF Sequence diagram

The following sequence diagram shows the functional flow of the Complex Logic Framework, starting with the request from aura-bot to the Complex Logic module.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA application

Definition and role of applications in ATRIA

Introduction

Within ATRIA’s framework, an application is defined as an entity that allows the connection of a channel, service or skill with aura-gateway-api, the component in charge of managing the access to the different ATRIA capabilities.

ATRIA application

As a preliminary step for leveraging any ATRIA AI-driven capability, the use case constructor must configure an application, including different parameters:

To indicate which specific ATRIA capabilities are utilized in the use case.
In this framework, applications supported by ATRIA can be classified as follows:
- Applications that make use only of the NLP as a Service capabilities
- Applications that use Generative capabilities
- Applications that use RAG capabilities
The difference between Generative and RAG capabilities relies solely on the definition of the preset that is associated. But the same application can make use of one, several or all of these capabilities, combining their configuration.
Once the capabilities are selected, to set the required fields for its operation

For example, if we want to use Generative AI for the use case resolution, firstly, certain parameters must be set corresponding to:
- Establishing admin accesses.
- Setting the presets that the application can use, that is, the instructions to work with the AI model, that will be defined in the application configuration.

How to configure an application

An ATRIA application must be configured with specific parameters. For this purpose, follow the guidelines Configure an application in ATRIA, using the specific parameters for the ATRIA AI-driven technology to be used.

Example of application

This is a example of an application that makes use of NLPaaS, Generative and RAG capabilities:

    {
        "id": "8832550f-f03c-4e18-bdbe-7c6fc7adf5ff",
        "name": "app",
        "disabled": false,
        "brand": "0401",
        "nlp": {
            "channelId": "1234"
        },
        "models": {
            "level": "user",
            "presets": ["atria-rag-gpt-4", "generative-preset"]
        }
    }

Applications model

Common fields

Field name	Type	Description
id	string	Unique application identifier. UUID
name	string	Unique application name
brand	string	Identifier of the Telefónica Brand associated to the application. Available values in the document Telefónica brands management
disabled	boolean	Boolean value to enable or disable the application.

NLPaaS fields

Field name	Type	Description
nlp.channelId	string	Channel identifier used to call NLP

Generative/RAG fields

Field name	Type	Description
models.level	string	It indicates the level application in atria-model-gateway, meaning that it has specific access and control privileges. Default value `user`
models.presets	string[]	It indicates all the available ATRIA presets that the application can use. - Check the list of available presets by default - Learn here how to add a new preset or modify one

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA components default configuration

Description of the default configuration (internal configuration) for ATRIA components

Introduction

The default configuration of ATRIA corresponds to the server configuration, that is, the internal configuration for ATRIA components.

Within a specific configuration type, parameters are organized by component:

Fields for atria-model-gateway configuration
Fields for atria-rag-server
Common fields for both components

1. Server configuration

Fields related to the internal configuration of ATRIA components

Target users: ATRIA development and installation teams

The default server configuration fields are non-modifiable by ATRIA constructors (excepting prompts)

1.1. Logging configuration

Configuration field shared between atria-model-gateway and atria-rag-server that enables the configuration of logs in a customizable and independent way

The logging configuration is done through a json configuration file that is set by default, as shown below.

{
  "version": 1,
  "disable_existing_loggers": false,
  "logging": {
    "handlers": {
      "hdl2": {
        "class": "logging.StreamHandler",
        "formatter": "json",
        "level": <AUTOCOMPLETED>
      }
    },
    "loggers": {
      "atria_model_gw": {
         "level": <AUTOCOMPLETED>,
         "handlers":[
            "hdl2"
         ],
         "filters":[],
         "propagate": false
      }
    },
    "root": {
      "level": <AUTOCOMPLETED>,
      "handlers": []
    }
  }
}

Fields

The main fields are explained below. However, for more details, developers are kindly requested to read the General Python logging documentation

Parameter	Subparameters	Definition	Type/Default values
`version`		Version of the logging configuration	number
`disable_existing_loggers`		Boolean value to indicate whether or not the already existing loggers when this call is made are disabled or not	boolean
`handlers`		Dictionary with different logging handlers. Each key is the name of a handler
	`class`	It is configured with Python logging handlers (See Python documentation)
	`formatter`	It configures the format of logs.	`json`, `string`, `console`, `simple`
	`level`	Level of the logging event. It must be filled with the labels	`INFO`, `ERROR`, `WARN` or `DEBUG`
`loggers`		Python dictionary in which each key is a logger name and each value is a dictionary describing how to configure the corresponding logger instance
	`level`	(Optional) Level of the logger.
	`handlers`	(Optional) List with the IDs of the handlers for this logger
	`filters`	(Optional) List with the IDs of the filters for this logger
`root`		Configuration for the root logger.
	`level`	(Optional) Level of the logger.
	`handlers`	(Optional) List with the IDs of the handlers for this logger

1.2. atria-model-gateway default configuration

This section includes the parameters configured by default in atria-model-gateway:

Defaults

General-purpose field with parameters to define the behavior of atria-model-gateway

Defaults fields

Parameter	Subparameters	Definition	Type/Default values
`session_params`		(Optional) Default values for a session	object
	`window`	(Optional) Session window	number
	`timeout`	(Optional) Session expiration time	number
`service_params`		(Optional) Default values for the server	object
	`preflight_max_age`	(Optional) Preflight max age	number
`messages`		(Optional) Message options	object
	`types`	(Optional) Types of messages.	list[string]
`openai_proxy`		Activate OpenAI proxy	boolean
`trimmer`		(Optional) Expression to trim the response	string

If the timeout is 0, the last conversation in the session will not be saved, but the session history will be used.

Defaults by default

The default configuration is described as follows:

defaults:
  # Default values for a session
  session_params:
    window: 2
    timeout: 3600

  # Default values for the server
  service_params:
    preflight_max_age: 86400

  # Message options
  messages:
    types:
      - feedback

  # Activate openai proxy
  openai_proxy: false

Redis

This section includes the Redis connection configuration for atria-model-gateway.

Redis fields

Parameter	Definition	Type/Default values
`connection_mode`	(Mandatory) Connection mode	`single`, `sentinel`, `cluster`
`pool_size`	(Mandatory) Pool size	number
`database`	(Mandatory) Database	number
`password`	(Mandatory) Password	string
`uri`	(Mandatory) URI name	string
`prefix`	(Mandatory) Prefix	string
`sleep_time`	(Optional) Sleep time	number
`max_retries`	(Optional) Maximum number of retries	number

Redis by default

The default configuration for Redis is described as follows:

redis:
  connection_mode: <AUTOCOMPLETED>
  pool_size: 100
  database: <AUTOCOMPLETED>
  password: <AUTOCOMPLETED>
  uri: <AUTOCOMPLETED>
  prefix: <AUTOCOMPLETED>

Redis Subscriber

This section includes the Redis event subscriber connection configuration for atria-model-gateway.

Redis subscriber fields

Parameter	Definition	Type/Default values
`connection_mode`	(Mandatory) Connection mode	`single`, `sentinel`, `cluster`
`pool_size`	(Mandatory) Pool size	number
`database`	(Mandatory) Database	number
`password`	(Mandatory) Password	string
`uri`	(Mandatory) URI name	string
`prefix`	(Mandatory) Prefix	string
`sleep_time`	(Optional) Sleep time	number
`max_retries`	(Optional) Maximum number of retries	number
`channels`	List of channels to subscribe to	list[string]

Redis subscriber by default

The default configuration for Redis is described as follows:

redis_subscriber:
  connection_mode: <AUTOCOMPLETED>
  pool_size: 100
  database: <AUTOCOMPLETED>
  password: <AUTOCOMPLETED>
  uri: <AUTOCOMPLETED>
  prefix: <AUTOCOMPLETED>
  channels:
    - "ApplicationConfiguration"
    - "PresetConfiguration"

Config API

Field with parameters for the API configuration for atria-model-gateway

Config API fields

Parameter	Definition	Type/Default values
`base_url`	(Mandatory) API config URL	string
`api_key`	(Mandatory) APIKey	string

Config API by default

The default configuration is described as follows:

aura_config_api:
  base_url: <AUTOCOMPLETED>
  api_key:  <AUTOCOMPLETED>

Allow logging prompts with INFO level

Field to allow logging prompt with INFO level for atria-model-gateway. It should only be used for debugging errors in environments where there are no debug logs. Due to the size of the prompts, this variable should be set to false once it is not needed.

Allow logging prompts

Parameter	Definition	Type/Default values
`allow_log_prompts`	Allow logging prompts	boolean

Allow logging prompts by default

The default configuration is described as follows:

allow_log_prompts: false

Models

Predefined AI models included in atria-model-gateway by default.

The model(s) to be used must be selected when configuring an application.

Model fields

Parameter	Subparameters	Definition	Type/Default values
`type`		(Mandatory) Identifier type of model	`rag`, `openai`, `mock`, `perplexity`
`name`		(Optional) Model name. If this value does not exist, `id` is used	string
`class_params`		(Mandatory) Preset description	object
	`endpoint`	(Mandatory) Endpoint of the model	string
	`type`	(Mandatory for RAG) Type of the model	`langchain`
	`path`	(Mandatory for RAG) Path of endpoint model	string
	`azure_name`	(Mandatory for OpenAI) Azure name of the model	string
	`model_name`	(Mandatory for OpenAI) Model name	string
	`api_key`	(Mandatory for OpenAI) APIkey to be used in the model call	string
	`api_version`	(Mandatory for OpenAI) API version to be used in the model call	string
	`output`	(Mandatory for mocks) Response to be used in the model call	string
`description_params`		(Optional) Description of the model params	object
	`context_window`	(Optional) Context window of model	number
`tokenizer`		(Optional) Tokenizer of model	string

Models by default

atria-rag model

Model for using the atria-rag-server.

The default configuration is described as follows:

  atria-rag:
    type: rag
    name: Rag server model
    class_params:
      type: langchain
      endpoint: <AUTOCOMPLETED>
      path: <AUTOCOMPLETED>

gpt-4

Model for using Azure OpenAI GPT-4 model.

The default configuration is described as follows:

      gpt-4:
        type: openai
        local: false
        class_params:
          azure_name: deployment_gpt-4
          model_name: gpt-4
          api_key: <AUTOCOMPLETED>
          endpoint: <AUTOCOMPLETED>
          api_version: <AUTOCOMPLETED>
          timeout:
             timeout: 60
             read: 60
        description_params:
          context_window: 300

gpt-4o

Model for using Azure OpenAI GPT-4o model.

The default configuration is described as follows:

      gpt-4o:
        type: openai
        local: false
        class_params:
          azure_name: deployment_gpt-4o
          model_name: gpt-4o
          api_key: <AUTOCOMPLETED>
          endpoint: <AUTOCOMPLETED>
          api_version: <AUTOCOMPLETED>
          timeout:
            timeout: 60
            read: 60
          description_params:
            context_window: 128000

gpt-4o-mini

Model for using Azure OpenAI GPT-4o-mini model.

The default configuration is described as follows:

      gpt-4o-mini:
        type: openai
        local: false
        class_params:
          azure_name: deployment_gpt-4o-mini
          model_name: gpt-4o-mini
          api_key: <AUTOCOMPLETED>
          endpoint: <AUTOCOMPLETED>
          api_version: <AUTOCOMPLETED>
          timeout:
            timeout: 60
            read: 60
          description_params:
            context_window: 128000

o3-mini

Model for using Azure OpenAI o3-mini model.

The default configuration is described as follows:

      o3-mini:
        type: openai
        local: false
        class_params:
          azure_name: deployment_o3-mini
          model_name: o3-mini
          api_key: <AUTOCOMPLETED>
          endpoint: <AUTOCOMPLETED>
          api_version: <AUTOCOMPLETED>
          timeout:
            timeout: 60
            read: 60
          description_params:
            context_window: 128000

gpt-4.1-nano

Model for using Azure OpenAI gpt-4.1-nano model.

gpt-4.1-nano:
  type: openai
  local: false
  class_params:
    azure_name: deployment_gpt-4.1-nano
    model_name: gpt-4.1-nano
    api_key: <AUTOCOMPLETED>
    endpoint: <AUTOCOMPLETED>
    api_version: <AUTOCOMPLETED>
    timeout:
      timeout: 60
      read: 60
    description_params:
      context_window: 128000

perplexity-sonar

This model will be available in ATRIA in upcoming releases. Model for using Perplexity sonar model.

The default configuration is described as follows:

perplexity-sonar:
 type: perplexity
 local: false
 class_params:
   model_name: sonar
   api_key: <AUTOCOMPLETED>
   endpoint: <AUTOCOMPLETED>
   timeout:
     timeout: 20
     read: 45
   http_raise_when_retry_limit_exceeded_recognizer: false
 description_params:
   context_window: 300

Important: This model does not support the same parameters as the previous ones. Check Microsoft document API & feature support.
The following parameters are not supported by the model: temperature, top_p, presence_penalty, frequency_penalty, logprobs, top_logprobs, logit_bias, max_tokens.

1.3. atria-rag-server default configuration

This section includes the parameters configured by default in atria-rag-server:

LLMs

Predefined parameter to define the Large Language Models (LLMs) that call from atria-model-gateway to atria-rag-server.

Currently, only one LLM with the necessary configuration to connect atria-model-gateway to atria-rag-server is defined. It cannot be modified.

LLMs fields

Parameter	Definition	Type/Default values
`name`	(Optional) LLM name. If this value does not exist, `id` is used	string
`model_type`	(Mandatory) Model type	string
`endpoint`	(Mandatory) Endpoint of the model	string

LLm by default

atria-model-gateway:

  atria_model_gateway:
    name: Local Model Gateway
    model_type: llm_manager
    endpoint: http://atria-model-gw:6391/aura-services/v1/atria-model-gw

Embeddings

Parameters to define the embeddings, vector representations to find text blocks that contain the information to resolve the input request.

Two types of Embeddings are available for use:

Local Embeddings: Generated by the atria-rag-server in local mode.
Embeddings OpenAI: Generated by OpenAI.

Embeddings fields

Parameter	Definition	Type/Default values
`name`	(Mandatory) Embedding name	string
`type`	(Mandatory) LLM name. Type of the model	`sentence_transformer`, `azure_openai`
`model`	(Mandatory) Used model	string
`openai_api_version`	(Mandatory to call Azure OpenAI) OpenAI API version	string
`openai_api_type`	(Mandatory to call Azure OpenAI) OpenAI API type	string
`openai_api_key`	(Mandatory to call Azure OpenAI) OpenAI APIKey	string
`azure_endpoint`	(Mandatory to call Azure OpenAI) Azure endpoint	string

Embeddings by default

The predefined embeddings in atria-rag-server are shown below:

Local Sentence Transformer from HuggingFace:

This is an open-source model that appears in sentence-transformers library.

It maps sentences & paragraphs to a 384 dimensional dense vector space and can be used for several tasks like:

Clustering
Multilingual similarity searches
Retrieval-based tasks
Classification

A brief characterization of this embedding regarding different parameters is included below:

Cost: Free to use once downloaded (local execution). No API call costs.
Latency: Low, since it runs locally without external API calls.
Performance: Satisfactory for general-purpose sentence embeddings, supporting multiple languages.
Vector Length: 384 dimensions (smaller than OpenAI’s ADA model).
Hardware Requirements: Needs a GPU for faster inference; otherwise, it can be slow on a CPU.
Model Size: Requires local storage (~120MB).
Quality: Slightly lower accuracy than larger models, especially for complex NLP tasks.

This embedding can be configured with a yaml file:

local_st:
    name: Local Sentence Transformer from HuggingFace
    type: sentence_transformer
    model: paraphrase-multilingual-MiniLM-L12-v2

Distilbert-based Local Sentence Transformer from HuggingFace

This is an open-source model that appears in sentence-transformers library.

It has been trained on 215M (question, answer) pairs from diverse sources.

It maps sentences & paragraphs to a 768 dimensional dense vector space and was designed for several tasks like:

Semantic search
Question answering
Passage retrieval

A brief characterization of this embedding regarding different parameters is included below:

Cost: Free (local execution). No API call costs.
Latency: Fast, optimized for question-answer retrieval tasks.
Performance: Outperforms MiniLM in retrieval-based tasks due to DistilBERT’s training on QA data.
Vector Length: 768 dimensions (higher than MiniLM, better at capturing semantics).
Hardware Requirements: Similar to MiniLM, requires a GPU for optimal performance.
Model Size: Larger than MiniLM (~250MB).
Quality: Primarily trained for English, not as strong for multilingual applications.

This embedding can be configured with a yaml file:

test_distilbert:
    name: Distilbert-based Local Sentence Transformer from HF
    type: sentence_transformer
    model: multi-qa-distilbert-cos-v1

OpenAI Embeddings ADA

This is one of OpenAI’s latest models for generating embeddings and has quickly become a top choice for tasks:

Recommendation systems
Chatbots
Semantic search
Large-scale applications

A brief characterization of this embedding regarding different parameters is included below:

Cost: Paid API model (depends on token usage, $0.0001/1k Tokens). It can be expensive for high-volume applications.
Latency: API calls introduce certain delay, specially in large-scale real-time applications.
Performance: State-of-the-art embeddings with high accuracy for a wide range of NLP tasks.
Hardware Requirements: No local hardware requirements, it works via API.
Vector Length: 1536 dimensions (rich semantic representation).
Quality: Strong performance across multiple languages.

This embedding can be configured with a yaml file:

text-embedding-ada-002:
  name: text-embedding-ada-002 model from Azure OpenAI API
  type: azure_openai
  model: deployment_text-embedding-ada-002
  openai_api_version: <AUTOCOMPLETED>
  openai_api_type: azure
  openai_api_key: <AUTOCOMPLETED>
  azure_endpoint: <AUTOCOMPLETED>

Redis Subscriber

This section includes the Redis event subscriber connection configuration for the atria-rag-server.

Redis subscriber fields

Parameter	Definition	Type/Default values
`connection_mode`	(Mandatory) Connection mode	`single`, `sentinel`, `cluster`
`pool_size`	(Mandatory) Pool size	number
`database`	(Mandatory) Database	number
`password`	(Mandatory) Password	string
`uri`	(Mandatory) URI name	string
`prefix`	(Mandatory) Prefix	string
`sleep_time`	(Optional) Sleep time	number
`max_retries`	(Optional) Maximum number of retries	number
`channels`	List of channels to subscribe to	list[string]

Redis subscriber by default

The default configuration for Redis is described as follows:

redis_subscriber:
  connection_mode: <AUTOCOMPLETED>
  pool_size: 100
  database: <AUTOCOMPLETED>
  password: <AUTOCOMPLETED>
  uri: <AUTOCOMPLETED>
  prefix: <AUTOCOMPLETED>
  channels:
    - "PresetConfiguration"

Prompts

A prompt is defined as an input instruction given to an AI model to generate a response. It guides the AI in the required kind of output.

A prompt by default is defined in ATRIA for different RAG stages. This can be used when a specific prompt is not defined in the preset.

Prompts structure for RAG

The hierarchy of default prompts in RAG stages is shown below:

prompts  
 |___ <stage>
        |___ default
        |       |___ text
        |       |___ args
        |___ <language>
                |___ text
                |___ args

The first level in the prompts configuration are the stages of the RAG process. Each stage has its own configuration and purpose.
Prompts configuration works at language level, so it is possible to have different prompts for different languages, indicated by the language code:
- <language>: Any language prompt configuration (ISO 639-1 Code)
- default: Default prompt configuration (in a specific language)
For each language, the prompts structure must include the fields text and args:
- text: This field contains the text of the prompt that will be sent to the language model. It includes placeholders (e.g., {query}, {target_language}) that are mandatory for the prompt to work. These placeholders will be dynamically replaced with the specific values when the prompt is executed.
- args: Optional field that contains a dictionary of arguments that will be used to replace the placeholders in the text field.

Default prompts in RAG stages

The following stages are currently defined in RAG:

cleanStg

This stage is responsible for cleaning the user query. It ensures that the query is in a proper format before further processing.

See how to include this stage in the default prompt code here

translationStg

This stage handles the translation of the user query into the target language, if necessary.

See how to include this stage in the default prompt code here

contextStg

This stage determines the context of the user query, ensuring it is aligned with the previous conversation or context.

Default prompts in this stage:

sameContext: Configuration to check if the query is in the same context.
recreatedQuestion: Configuration to rewrite the original question. It is composed of following prompts:
- default: Configuration for rewriting the original question.
- system: System prompt configuration.
- human: Human prompt configuration.
system: System prompt configuration.
human: Human prompt configuration.
order: Array of strings with prompts names sorted.

See how to include this stage in the default prompt code here

postFilteringStg

This stage filters the retrieved documents or data to ensure relevance to the user query.

Default prompts in this stage:

relevantDocument: Configuration to check if the document is relevant.
relevantSql: Configuration to check if the SQL data is relevant.

See how to include this stage in the default prompt code here

generativeStg

This stage generates the final response using the retrieved and filtered data.

Default prompts in this stage:

stuff: Configuration for the “stuff” strategy. It is composed of the following sub-stages:
- default: Configuration for the “stuff” strategy.
- system: System prompt configuration.
- human: Human prompt configuration.
notAnswerResponse: Configuration for responses when the question cannot be answered.
informationExtraction: Configuration for extracting information. It is composed of following prompts:
- human1: Human prompt configuration.
- ia: IA prompt configuration.
- human: Human prompt configuration.
responseConsolidation: Configuration for consolidating the response.
sqlPrompt: Configuration for generating SQL query statements.

See how to include this stage in the default prompt code here

RAG default prompt

The current section includes the prompt defined by default for ATRIA RAG capability.

You can also access the yaml file in the Github repository.

In case of any discrepancy between the content of this document and that on GitHub, the GitHub version shall always be considered the most up-to-date

RAG default prompt

prompts:
  cleanStg:
    es:
      text: |
        A continuación hay una consulta del usuario.
        Por favor, limpie la consulta y responda solo con la pregunta del usuario o alguna charla informal.
        -------
        {query}        
    default:
      text:
        A user query follows.
        Please clean the query and respond with just the user question or small talk. The query must be written in English.
        -------
        {query}
  translationStg:
    default:
      text: |
        Translate the following question to {target_language}: {question}

        Instructions:
        1. Maintain the formal tone of the original text.
        2. Do not translate proper names and specific terms (e.g., company names, product names, countries).
        3. Provide the translation in the same format and structure as the original text.

        Translated Text:
        Finally, return the result as a unique JSON object, with the following structure:

        ```
        {{
            "source_languge": The original question language,
            "target_language": The target language,
            "translation": The translation of the question to the target_language. ,
            "possible": true|false,
            "reason": The reason why it is possible or not possible to translate the question.
        }}
        ```        
  contextStg:
    sameContext:
      default:
        text: |
          Below is a conversation followed by a question. You must determine if the question corresponds to the same context as the conversation or if it is from a different context.
          Respond only with: [SAME CONTEXT] o [DIFFERENT CONTEXT]

          Conversation:
          {memory}

          Question:
          {query}          
      es:
        text: |
          A continuación hay una conversación y seguidamente una pregunta. Debes responder si la pregunta corresponde al mismo contexto de la conversación o es una pregunta de un contexto diferente.
          Responde únicamente con: [MISMO CONTEXTO] o [DIFERENTE CONTEXTO]

          Conversación:
          {memory}

          Pregunta:
          {query}          
    recreatedQuestion:
      default:
        default:
          text: |
            Answer with just a new question or the original question.
            Rewrite the original question only if it follows the conversation. Always rewritten question in the same language as the user's question.

            Conversation:
            {memory}

            Original question:
            {query}

            Rewritten question:            
        es:
          text: |
            Responde sólamente con una nueva pregunta.
            Reescribe la pregunta original si es una continuación de la conversación. Utiliza el idioma de la peticion del usuario para rescribir la pregunta.

            Conversación:
            {memory}

            Pregunta original:
            {query}

            Pregunta reescrita:            
      system:
        default:
          text: |
            The user text contains a query, plus the previous conversation turn.
            - If the previous conversation is relevant for the current query, incorporate it into the query and produce a rewritten query
            - else just repeat the current query.

            Always rewrite the question in the same language as the user's question.            
        es:
          text: |
            El texto del usuario contiene una consulta, además del turno anterior de la conversación.

            - Si la conversación anterior es relevante para la consulta actual, incorpórala en la consulta y produce una consulta reescrita.
            - Si no es relevante, simplemente repite la consulta actual.

            Reescribe siempre la consulta en el mismo idioma en que está formulada la consulta del  usuario.            
      human:
        default:
          text: |
            Previous conversation:
            {memory}

            Current query:
            {query}

            Rewritten query:            
        es:
          text: |
            Conversación anterior:
            {memory}

            Consulta actual:
            {query}

            Consulta reescrita:            
      order: ["system", "human"]
  postFilteringStg:
    relevantDocument:
      default:
        text: |
          Below is an excerpt of text followed by a question. You must determine if the excerpt is relevant or irrelevant for answering the question.
          Respond only with: [RELEVANT] o [IGNORABLE]

          Excerpt:
          {extract}

          Question:
          {query}          
      es:
        text: |
          A continuación hay un extracto de texto y seguidamente una pregunta. Debes responder si el extracto es relevante o ignorable para responder la pregunta.
          Responde únicamente con: [RELEVANTE] o [IGNORABLE]

          Extracto:
          {extract}

          Pregunta:
          {query}          
    relevantSql:
      default:
        text: |
          Given the following question:
          `{question}`

          Is it possible to answer, using the data contain in the following table?:
          ```sql
          {sql_table_definition}
          ```


          **Explain briefly, all your decisions**.
          First, identify which tables are necessary to answer the question. Justify why you selected each of these tables.
          Use the following format:
          ```
          I need the following tables to answer the question:
            - <table_name>: <reasoning>
            - <table_name>: <reasoning>
            ...
          ```

          Then, identify which columns are necessary to answer the question. Justify why you selected each of these columns.
          Write the list of columns you identified, and the reasoning after each column, using the following format:
          ```
          I need the following columns to answer the question:
            - <table name>:
              - <column_name>: <reasoning>
              - <column_name>: <reasoning>
              ...
            - <table_name>:
              - <column_name>: <reasoning>
              - <column_name>: <reasoning>
              ...
            ...
          ```

          Then, tell if the tables and columns you identified are enough to answer the question.
          Write the answer using the following format:
          ```
          Possible to answer the question using the former columns:
            - <reasoning>
            - Result: <Yes|No>
          ```

          Then, explain, step by step, how you would write the SQL query to answer the question, using the columns you identified.
           **Use the full qualified names of the columns**. **DO NOT USE THE `JSON_OBJECT` FUNCTION IN THE QUERY**.

          Finally, tell if the question can be answered using this format:

          ```
          {{
              "possible": true|false,
              "reason": The reason why it is possible or not possible to answer the question.
          }}
          ```          
  generativeStg:
    stuff:
      default:
        default:
          text: |
            Use the following context extractions to answer the question at the end.

            Contexto:
            {context}

            If the extracted context do not contain the answer avoid coming up with an answer, and response you do not have information for answering and kindly invite the user to make a new question.

            Question:
            {question}

            Never include information by your own using your own knowledge.
            {extra_prompt}            
        es:
          text: |
            Utilice el siguiente contexto que ha sido extraido  para responder la pregunta del final.

            Contexto:
            {context}

            Usando esta información, responde a la pregunta del usuario.
            Si la información no contiene la respuesta evita firmemente responder, di que desconoces la respuesta e invita educadamente al usuario a que formule una nueva pregunta.

            Pregunta:
            {question}

            Nunca incluyas información utilizando tus propios conocimientos.
            {extra_prompt}            
      system:
        default:
          text: |
            Respond in language {user_query_language}.

            Question:
            {question}            
          args:
            user_query_language: "#.auto.language.user_query"
        es:
          text: |
            Responde en el idioma {user_query_language}.

            Pregunta:
            {question}            
          args:
            user_query_language: "#.auto.language.user_query"
      human:
        default:
          text: |
            You are going to generate an answer for a user question or query.
            To generate the answer, take always into account all the information available in the context provided.

            Context:
            {context}

            Question:
            {question}

            Never include information by your own using your own knowledge.
            {extra_prompt}            
        es:
          text: |
            Vas a generar una respuesta para una pregunta o consulta del usuario.
            Para generar la respuesta, ten siempre en cuenta toda la información disponible en el contexto proporcionado.

            Pregunta:
            {question}

            Contexto:
            {context}

            Nunca incluyas información utilizando tus propios conocimientos.
            {extra_prompt}            
      order: ["system", "human"]
    notAnswerResponse:
      default:
        text: |
          You are a question answering agent. You have tried to answer this question: {query}
          However you do not have information to answer this.
          Please, tell the user that you are not able to answer, apologize and invite the user to make other question.
          Avoid any harmful answer, such as sexual, rude, sexist or racist.
          Respond in language {user_query_language}.

          User question:
          {query}          
        args:
          user_query_language: "#.auto.language.user_query"
      es:
        text: |
          Eres un agente de respuesta a preguntas. Has intentado responder a esta pregunta: {query}
          Sin embargo, no tienes información para responder a esto.
          Por favor, dile al usuario que no puedes responder, discúlpate e invita al usuario a hacer otra pregunta.
          Evita cualquier respuesta dañina, como sexual, grosera, sexista o racista.
          Responde en el idioma {user_query_language}.

          Pregunta del usuario:
          {query}          
        args:
          user_query_language: "#.auto.language.user_query"
    informationExtraction:
      default:
        default:
          text: |
            The original question is this: {question}
            We have provided a previous answer: {existing_answer}
            Only if necessary, refine the answer exclusively with the context below.
            ------------
            {context_str}
            ------------
            Given the new context, refine the original answer to improve the quality of the response.
            If the context is useless, respond with the exact words of the original answer.
            {extra_prompt}            
        es:
          text: |
            La pregunta original es esta: {question}
            Hemos proporcionado una respuesta previa: {existing_answer}
            Sólo si es necesario refina la respuesta exclusivamente con el contexto a continuación.
            ------------
            {context_str}
            ------------
            Dado el nuevo contexto, refina la respuesta original para mejorar la calidad de la respuesta.
            Si el contexto es inútil responde con las mismas palabras de la respuesta original.
            {extra_prompt}            
      human1:
        default:
          text: "{question}"
        es:
          text: "{question}"
      ia:
        default:
          text: "{existing_answer}"
        es:
          text: "{existing_answer}"
      human:
        default:
          text: |
            Refine the existing answer only if necessary, exclusively with the context below.
            ------------
            {context_str}
            ------------
            Given the new context, refine the original answer to improve the quality of the response.
            If the context is useless, respond with the exact words of the original answer.
            {extra_prompt}            
        es:
          text: |
            Refina la respuesta existente, sólo si es necesario, exclusivamente con el contexto a continuación.
            ------------
            {context_str}
            ------------
            Dado el nuevo contexto, refina la respuesta original para mejorar la calidad de la respuesta.
            Si el contexto es inútil responde con las mismas palabras de la respuesta original.
            {extra_prompt}            
      order: ["human1", "ia", "human"]
    responseConsolidation:
      default:
        default:
          text: |
            Below I provide you a context.
            ---------------------
            {context_str}
            ---------------------

            Given exclusively the context, and without using any prior knowledge, respond with a single sentence to the question:
            {question}

            {extra_prompt}            
        es:
          text: |
            A continuación te doy un contexto.
            ---------------------
            {context_str}
            ---------------------

            Dado exclusivamente el contexto, y sin usar ningún conocimiento previo responde con una única frase a la pregunta:
            {question}

            {extra_prompt}            
      system:
        default:
          text: |
            Below I provide you a context.
            ---------------------
            {context_str}
            ---------------------

            Given exclusively the context, and without using any prior knowledge, respond with a single sentence to the question:
            {question}

            {extra_prompt}            
        es:
          text: |
            A continuación te doy un contexto.
            ---------------------
            { context_str }
            ---------------------

            Dado exclusivamente el contexto y sin usar ningún conocimiento previo responde con una única frase a cualquier pregunta.

            { extra_prompt }            
      human:
        default:
          text: "{question}"
        es:
          text: "{question}"
      order: ["system", "human"]
    sqlPrompt:
      default:
        text: |
          Generate a SQL query statement to answer the following question:
          `{question}`

          Use the data contained in the following table, as defined in SQL:
          ```sql
          {sql_table_definition}
          ```

          The following tables, containing auxiliary information, are also available:
          ```sql
          CREATE TABLE D_CBD_Static_Geo_Area_v6 (GEO_AREA_ID VARCHAR, CBD_GEO_AREA_LEVEL1_ID VARCHAR, CBD_GEO_AREA_LEVEL2_ID VARCHAR, CBD_GEO_AREA_LEVEL3_ID VARCHAR, CBD_GEO_AREA_LEVEL4_ID VARCHAR, OB_ALPHA_ID VARCHAR, EXTRACTION_TM VARCHAR);
              COMMENT ON TABLE D_CBD_Static_Geo_Area IS 'Geographical areas. This table contains foreign keys to the different levels of geographical areas. In particular, it contains the foreign keys to these tables: CBD_Static_Geo_Area_Level1, CBD_Static_Geo_Area_Level2, CBD_Static_Geo_Area_Level3, CBD_Static_Geo_Area_Level4. Therefore, this tables is used, via JOIN, to query the geographical information contained in the different levels of geographical areas. For instance, if you have a table T with a field GEO_AREA_ID and you need to check whether this location corresponds to the region of Asturias you will need to look for GEO_AREA_ID in this table, then extract the CBD_GEO_AREA_LEVEL4_ID and query the table CBD_Static_Geo_Area_Level4 to get the name of the region.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area.GEO_AREA_ID IS 'Identifier of the geographical area considered. FORMAT: string containing a numerical code. This field does not contain location names.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area.CBD_GEO_AREA_LEVEL1_ID IS 'Identifier of the geographical area Level 1 (max level of detail: CP or similar). FORMAT: string containing a numerical code. This field does not contain location names.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area.CBD_GEO_AREA_LEVEL2_ID IS 'Identifier of the geographical area Level 2 (City/Town). FORMAT: string containing a numerical code. This field does not contain location names.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area.CBD_GEO_AREA_LEVEL3_ID IS 'Identifier of the geographical area Level 3 (Province). FORMAT: string containing a numerical code. This field does not contain location names.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area.CBD_GEO_AREA_LEVEL4_ID IS 'Identifier of the geographical area Level 4 (State/Region). FORMAT: string containing a numerical code. This field does not contain location names.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area.OB_ALPHA_ID IS 'Alphanumeric Organizational Business ID';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area.EXTRACTION_TM IS 'Date-time of the record';

          CREATE TABLE D_CBD_Static_Geo_Area_Level2_v6 (CBD_GEO_AREA_LEVEL2_ID VARCHAR, GEO_AREA_LEVEL_DES VARCHAR, CBD_GEO_AREA_LEVEL3_ID VARCHAR, LONGITUDE_LON_CO DOUBLE, LATITUDE_LAT_CO DOUBLE, GEO_AREA_ID VARCHAR, GEO_STD_AREA_CD VARCHAR, OB_ALPHA_ID VARCHAR, EXTRACTION_TM VARCHAR);
              COMMENT ON TABLE D_CBD_Static_Geo_Area_Level2 IS 'Geographical area level 2 (State)';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.CBD_GEO_AREA_LEVEL2_ID IS 'Identifier of the geographical area Level 2 (City/Town). FORMAT: string containing a numerical code.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.GEO_AREA_LEVEL_DES IS 'Description associated to the identifier level 2. FORMAT: alphanumeric string containing the name of the city/town.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.CBD_GEO_AREA_LEVEL3_ID IS 'Identifier of the geographical area Level 3 (Province)';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.LONGITUDE_LON_CO IS 'Longitude coordinates (in WGS84) associated with level 2';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.LATITUDE_LAT_CO IS 'Latitude coordinates (in WGS84) associated with level 2';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.GEO_AREA_ID IS 'Identifier of the geographical area considered. FORMAT: string containing a numerical code.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.GEO_STD_AREA_CD IS 'Standard code of the geo area';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.OB_ALPHA_ID IS 'Alphanumeric Organizational Business ID';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level2.EXTRACTION_TM IS 'Date-time of the record';

          CREATE TABLE D_CBD_Static_Geo_Area_Level3_v6 (CBD_GEO_AREA_LEVEL3_ID VARCHAR, GEO_AREA_LEVEL_DES VARCHAR, CBD_GEO_AREA_LEVEL4_ID VARCHAR, LONGITUDE_LON_CO DOUBLE, LATITUDE_LAT_CO DOUBLE, ISO_3166_2_CD VARCHAR, GEO_AREA_ID VARCHAR, GEO_STD_AREA_CD VARCHAR, OB_ALPHA_ID VARCHAR, EXTRACTION_TM VARCHAR);
              COMMENT ON TABLE D_CBD_Static_Geo_Area_Level3 IS 'Geographical area level 3 (Region)';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.CBD_GEO_AREA_LEVEL3_ID IS 'Identifier of the geographical area Level 3 (Province). FORMAT: string containing a numerical code.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.GEO_AREA_LEVEL_DES IS 'Description associated to the identifier level 3. FORMAT: alphanumeric string containing the name of the province.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.CBD_GEO_AREA_LEVEL4_ID IS 'Identifier of the geographical area Level 4 (State/Region). FORMAT: string containing a numerical code.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.LONGITUDE_LON_CO IS 'Longitude coordinates (in WGS84) associated with level 3';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.LATITUDE_LAT_CO IS 'Latitude coordinates (in WGS84) associated with level 3';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.ISO_3166_2_CD IS 'ISO 3166-2 associated';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.GEO_AREA_ID IS 'Identifier of the geographical area considered. FORMAT: string containing a numerical code.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.GEO_STD_AREA_CD IS 'Standard code of the geo area';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.OB_ALPHA_ID IS 'Alphanumeric Organizational Business ID';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level3.EXTRACTION_TM IS 'Date-time of the record';

          CREATE TABLE D_CBD_Static_Geo_Area_Level4_v6 (CBD_GEO_AREA_LEVEL4_ID VARCHAR, GEO_AREA_LEVEL_DES VARCHAR, LONGITUDE_LON_CO DOUBLE, LATITUDE_LAT_CO DOUBLE, HASC_1_CD VARCHAR, GEO_AREA_ID VARCHAR, GEO_STD_AREA_CD VARCHAR, OB_ALPHA_ID VARCHAR, EXTRACTION_TM VARCHAR);
              COMMENT ON TABLE D_CBD_Static_Geo_Area_Level4 IS 'Geographical area level 4 (min. Detail)';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.CBD_GEO_AREA_LEVEL4_ID IS 'Identifier of the geographical area Level 4 (State/Region). FORMAT: string containing a numerical code.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.GEO_AREA_LEVEL_DES IS 'Description associated to the identifier level 4. FORMAT: alphanumerical string containing the name of the state/region. EXAMPLE VALUES: ''Asturias'', ''Andaluc\u00eda'', etc.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.LONGITUDE_LON_CO IS 'Longitude coordinates (in WGS84) associated with level 4';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.LATITUDE_LAT_CO IS 'Latitude coordinates (in WGS84) associated with level 4';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.HASC_1_CD IS 'Hierarchical administrative subdivision codes ';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.GEO_AREA_ID IS 'Identifier of the geographical area considered. FORMAT: string containing a numerical code.';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.GEO_STD_AREA_CD IS 'Standard code of the geo area';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.OB_ALPHA_ID IS 'Alphanumeric Organizational Business ID';
              COMMENT ON COLUMN D_CBD_Static_Geo_Area_Level4.EXTRACTION_TM IS 'Date-time of the record';

          CREATE TABLE D_CBD_Static_Station_Type_v6 (STATION_TYPE_CD VARCHAR, TECH_LEVEL_WEIGHT_QT FLOAT, STATION_TYPE_L2_DES VARCHAR, STATION_TYPE_L1_DES VARCHAR, STATION_TYPE_L2_ORDER_NUM INT, STATION_TYPE_L1_ORDER_NUM INT, STATION_TYPE_ORDER_NUM INT, CONSCIOUS_IND BOOLEAN, EXTRACTION_TM VARCHAR);
              COMMENT ON TABLE D_CBD_Static_Station_Type IS 'Station types';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.STATION_TYPE_CD IS 'Device type';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.TECH_LEVEL_WEIGHT_QT IS 'Associated weight for the technologic level of the home';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.STATION_TYPE_L2_DES IS 'Station type level 2';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.STATION_TYPE_L1_DES IS 'Station type level 1';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.STATION_TYPE_L2_ORDER_NUM IS 'Station type order level 2';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.STATION_TYPE_L1_ORDER_NUM IS 'Station type order level 1';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.STATION_TYPE_ORDER_NUM IS 'Station type order';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.CONSCIOUS_IND IS 'Indicates if the related device type has energy efficiency';
              COMMENT ON COLUMN D_CBD_Static_Station_Type.EXTRACTION_TM IS 'Date-time of the record';

          CREATE TABLE D_Segment_v8 (OPERATOR_ID VARCHAR, SEGMENT_ID VARCHAR, SEGMENT_DES VARCHAR, GBL_SEGMENT_ID VARCHAR, SEGMENT_GROUP_ID VARCHAR, SEGMENT_GROUP_DES VARCHAR, EXTRACTION_TM VARCHAR);
              COMMENT ON TABLE D_Segment IS 'Classifications of the customers, attending to different segmentation criteria, for marketing and management issues, according to OB criteria and its correspondence with the global segment classification';
              COMMENT ON COLUMN D_Segment.OPERATOR_ID IS 'Global Operator Identifier (Operator acting as owner of the information present in the current entity)';
              COMMENT ON COLUMN D_Segment.SEGMENT_ID IS 'Organisational segment of the client, in the OB. FORMAT: Numerical code.';
              COMMENT ON COLUMN D_Segment.SEGMENT_DES IS 'Segment description. This is the actual name of the segment. POSSIBLE VALUES: ''NTT'', ''Residencial'', ''Pymes'', ''Residencial/SC'', ''Autonomos'', ''Operadores'', ''Grandes Clientes'', ''Residencial Prepago'', ''Telefonica'', ''Sin Clasificar'', ''Empresas''';
              COMMENT ON COLUMN D_Segment.GBL_SEGMENT_ID IS 'ID of the global segment classification';
              COMMENT ON COLUMN D_Segment.SEGMENT_GROUP_ID IS 'ID code of the segmentation group';
              COMMENT ON COLUMN D_Segment.SEGMENT_GROUP_DES IS 'Description of the segmentation group. POSSIBLE VALUES: ''0.- OPERADORES'', ''1.- U.N. Empresas'', ''2.-U.N. Gran Público'', ''3.- TELEFONICA'', ''4.- SIN CLASIFICAR''';
              COMMENT ON COLUMN D_Segment.EXTRACTION_TM IS 'Date-time of the record';
          ```

          Some of the former tables contains columns in full-qualified format. For instance, these are some examples of full-qualified columns:
          ```
          record_name.field_name
          TEC_PLAT_REC.DEVICE_ID
          record_name.subrecord_name.field_name
          TEC_PLAT_REC.TEC_PLAT_SUBCOMP_REC.DEVICE_ID
          ...
          ```
          Always use the full-qualified format when referring to columns in the tables. For instance, if you need to use the column 'TEC_PLAT_REC.DEVICE_ID', you should not refer to it as 'DEVICE_ID', but as 'TEC_PLAT_REC.DEVICE_ID'.
          **Explain in detail, step by step, all your decisions**.
          If you need to filter by a higher level geographical such as a region (Comunidad Autónoma) you will need to:
          - join the `GEO_AREA_ID` field of the data table (such as `CBD_HGU_Detail_Daily`) with the `GEO_AREA_ID` field in `D_CBD_Static_Geo_Area` table
          - then join the `CBD_GEO_AREA_LEVEL4_ID` field in the `D_CBD_Static_Geo_Area` with the `CBD_GEO_AREA_LEVEL4_ID` field in the `D_CBD_Static_Geo_Area_Level4` table
          - then compare the `GEO_AREA_LEVEL_DES` field in the `D_CBD_Static_Geo_Area_Level4` table with the name of the region (e.g., 'Cantabria'), since the DESCRIPTION field does contain the actual name of the geographical area.
          **Only perform these joins if explicit filtering or grouping by geographical location is necessary**.

          First, identify which tables are necessary to answer the question. Justify why you selected each of these tables.
          Use the following format:
          ```
          I need the following tables to answer the question:
            - <table_name>: <reasoning>
            - <table_name>: <reasoning>
            ...
          ```
          Then, identify which columns are necessary to answer the question. Justify why you selected each of these columns.
          Write the list of columns you identified, and the reasoning after each column, using the following format:
          ```
          I need the following columns to answer the question:
            - <table name>:
              - <column_name>: <reasoning>
              - <column_name>: <reasoning>
              ...
            - <table_name>:
              - <column_name>: <reasoning>
              - <column_name>: <reasoning>
              ...
            ...
          ```
          Then, tell if the tables and columns you identified are enough to answer the question.
          Write the answer using the following format:
          ```
          Possible to answer the question using the former columns:
            - <reasoning>
            - Result: <Yes|No>
          ```
          Then, explain, step by step, how you would write the SQL query to answer the question, using the columns you identified. **Use the full qualified names of the columns**. **DO NOT USE THE `JSON_OBJECT` FUNCTION IN THE QUERY**.
          Finally, write the SQL query to answer the question, using the columns you identified. **DO NOT USE THE `JSON_OBJECT` FUNCTION IN THE QUERY**.
          Return the result as a unique JSON object, with the following structure:
          {{
              "result": <Write the SQL query here. **MAKE SURE THAT THE STATEMENT `SELECT JSON_OBJECT` is not used in the query and Use the full qualified names of the columns. Generate a valid SQL sentence in a single line without new line characters.**>,
              "status": "OK",
              "reason": <a reasoning explaining the query>
          }}
          If the former table does not contain the necessary data to answer the question, return the following JSON object:
          {{
              "result": null,
              "status": "ERROR",
              "reason": <a reasoning explaining the query>
          }}
          Make sure that the JSON object is correctly formatted, and can be parsed by a JSON parser.

Injection

Default injection configuration for atria-rag-server. It is used to avoid prompt injection.

Injection fields

Parameter	Definition	Type/Default values
`heuristics`	Heuristic sentences. Object, where the key is the language and the value is a list of phrases. Now, by default, the heuristics sentences are defined in the config, the file path is no indicated. It is important to note that the phrases added here will be also added to those defined in the security stage securityStg of the preset configuration.	object

| max_length | (Mandatory) Maximum length |number |

Injection by default

The default configuration is described as follows:

injection:
  heuristics:
    es: 
      - responde como
      - responda como
      - respondeme como
      - respondame como
    en: 
      - answer like
      - forget everything
      - forget your
  max_length: 200

Service

Defaults service configuration for atria-rag-server.

Service fields

Parameter	Definition	Type/Default values
`host`	(Mandatory) Host name	string
`port`	(Mandatory) Port id	number

Service by default

The default configuration is described as follows:

service:
  host: 0.0.0.0
  port: <AUTOCOMPLETED>
  log_level: <AUTOCOMPLETED>

Local Storage

Defaults fields related to the configuration of the local storage for documents

Local Storage fields

Parameter	Definition	Type/Default values
`atria_resources_data_folder`	(Mandatory) Folder name for data resources	string
`atria_shared_data_folder`	(Mandatory) Shared data folder name	string

Local Storage by default

The default configuration is described as follows:

local_storage_manager:
  atria_resources_data_folder: "/opt/atria-rag/data"
  atria_shared_data_folder: "/var/atria-rag-data"

Config API

Field with parameters for atria-rag-server API configuration

Config API fields

Parameter	Definition	Type/Default values
`base_url`	(Mandatory) API Config URL	string
`api_key`	(Mandatory) APIKey	string

Config API by default

The default configuration is described as follows:

aura_config_api:
  base_url: <AUTOCOMPLETED>
  api_key:  <AUTOCOMPLETED>

Retrievers

Retriever are responsible for storing the information that have been generated in the documents. Each retriever is associated with a database in order to feed or retrieve information from it.

Currently, there are three different retrievers defined in ATRIA:
-qdrant
-tfidf
-elasticsearch

Retriever fields

Each retriever type has defined specific fields, as shown below:

Parameter	Subparameters	Definition	Type/Default values
`qdrant`	`host`	(Mandatory) Host service Qdrant	string
	`port`	(Mandatory) Port service Qdrant	number
	`prefix`	(Mandatory) Prefix to collection	string
`tfidf`	`dump_name`	(Mandatory) Dump name of service Tfidf	string
`elasticsearch`	`host`	(Mandatory) Host service Elasticsearch	string
	`ca_crt`	(Mandatory) Path certificate Elasticsearch	string
	`username`	(Mandatory) Username service Elasticsearch	string
	`password`	(Mandatory) Password service Elasticsearch	string
	`index_name`	(Mandatory) Index service Elasticsearch	string

Retrievers by default

The default configuration is described as follows:

retrievers:
  qdrant:
    host: <AUTOCOMPLETED>
    port: 6333
    prefix: <AUTOCOMPLETED>
  tfidf:
    dump_name: /var/atria-rag-data/tfidf/dump/

Metadata

Parameter related to the configuration of metadata in atria-rag-server

It is used to setup how metadata is used when providing responses. The retrieving operation produces a list of candidates, each of which may provide a dictionary of metadata. The metadata is used to filter the candidates and provide additional information in the response.

Metadata fields

Parameter	Subparameters	Definition	Type/Default values
`map`	`filetype`	(Optional) Type of file, typically used to specify the format	string
	`page_number`	(Optional) Page number. It could be used to identify particular pages	string
`group-by`		(Optional) Group by field names.	string
`aggregate`		(Optional) Determines how the values of duplicated fields are consolidated during grouping	string
`output_filter`		(Optional) List of fields to be displayed in the metadata	List of string
`root`		(Optional) Primary fields that will structure the final output of the metadata processing	List of string

Metadata by default

The default configuration for metadata is described as follows:

metadata:
  map:
    filetype: content-type
    page_number: page-number
  group-by: url
  aggregate: page-number
  output_filter:
    - title
    - url
    - content-type
    - page-number
    - _zxcv
  root:
    - title
    - url
    - content-type

Language identification

Parameter related to the configuration of Language Identification in atria-rag-server

It is used to identify the language of the user’s question. The result is a dictionary containing the detected language in ISO 639-3 format and its corresponding conversion.
In addition to language identification, the user’s question is preprocessed at this stage, and special characters that may cause recognition errors are removed. For example, line breaks. In case of error, the default language is returned.

This language identification is calculated through fasttext library.

Language identification fields

Parameter	Definition	Type/Default values
`language_default`	(Optional) Language in ISO 639-3 format (two letters). For example: `es`	string
`score_threshold`	(Optional) Score threshold used to respond in the identified language or in the default language. For example: `0.85`	float
`model_path`	(Mandatory) Model path. For example: `/opt/atria-fasttext/fasttext_model.bin`	string
`chars_to_clean`	(Optional) Characters to be cleaned. By default is `['/n']`	list of string

Language Identification by default

The default configuration for language identification is described as follows:

language_identification:
  score_threshold: <AUTOCOMPLETED>
  language_default: <AUTOCOMPLETED>
  model_path: "/opt/atria-fasttext/fasttext_model.bin"

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

HTML5 attachments

Types of HTML attachments for Microsoft Bot Framework

Introduction

HTML attachments are a set of models whose main property is that the content of the elements to render are composed of HTML5 tags.

Aura’s HTML5 attachment template is used to send HTML5 snippets as a response template.

Custom Attachment Model

The custom attachment model contains a free format model.

Bot Framework Attachment Properties

Properties marked in bold are mandatory.
Properties marked in italics are optional.

Property	Type	Description
contentType	string	Content type name. Value: `application/vnd.telefonica.aura.html.custom`
content	AuraHtmlCustomContent	Model of the object where the HTML5 is
version	string	Attachment model version model
name	string	Attachment name (optional)

Aura HTML Custom Content

Property	Type	Description
containers	HTMLContainer[]	Array of containers where the HTML data is sent

HTML container

The HTML container contains an identifier and the content of HTML.

Content may be self-contained or referenced. If it is self-contained, the property data will contain the HTML. Otherwise, the property url-data will contain the URL to download the HTML.

Property	Type	Description
id	string	Identifier of tag where the content data will be placed.
encoded	EncodedFormat	How the HTML5 code is encoded in `data` properties. Values: `none`, `base64` or `zip`
data	string	HTML5 data.
url-data	string	URL where the HTML to assign to the given container id should be downloaded. The encoded field in this case is ignored.
content-type	string	Type of source: `html`, `javascript`, `css` or `json`. - If url-data has a URL, the AuraSDK will insert: . `<link href="[url-data]" rel="stylesheet" type="text/css" />` for css. . `<script src="[url-data]"></script>` for js. - If you do not use the Aura SDK, you must insert it manually. Default value: `html` Note: Javascript content cannot be unloaded once loaded into the browser, unless you reload the page or iframe.

Encoded Formats

Property	Description
none	The data is sent in HTML format
base64	The data is encoded in Base64
zip	The data is compressed in zip format

Example

{
  "attachments": [
    {
      "contentType": "application/vnd.telefonica.aura.html.custom",
      "version": "1.0.0",
      "content": {
        "containers": [
          {
            "id": "id-background",
            "url-data":"https://telepizza.com/containers/background?id=334"
          },
          {
            "id": "id-footer",
            "encoded": "base64",
            "data":"PGgyPkhUTUwgTGlua3M8L2gyPgo8cD5IVE1MIGxpbmtzIGFyZSBkZWZpbmVkIHdpdGggdGhlIGEgdGFnOjwvcD4KCjxhIGhyZWY9Imh0dHBzOi8vd3d3Lnczc2Nob29scy5jb20iPlRoaXMgaXMgYSBsaW5rPC9hPg=="
          }
        ]
      }
    }
  ]
}

Building Aura response through HTML5

To include HTML content in Aura’s responses, two conditions must be satisfied:

First, generate a response with an attachment whose content has the HTML code.
Second, the client must support the model of this type of attachments.

Check how to add attachments into messages in MS Bot Framework.

Generate Response with an HTML5 attachment

In order to generate responses with HTML content, it is necessary to follow the model created for it: Attachment Models.

To do this, simply generate an message attachment with the new model.

For example, if we want to send the word “Hello World” in HTML format:

Generate the necessary HTML code: Hello World! .
Include this code inside the model and assign a container to it, so that the client knows in which part of the webpage he must go. The assignation of a container is mandatory and needs the target Id of HTML element where the content will be rendered.

var message = new Message(session)
    .addAttachment({
        contentType: "application/vnd.telefonica.aura.html.custom",
	  version: "1.0.0"
        content: {
		containers:[
		{
			id: "aura-body",
			data: "<span> Hello World! <span>"
		}
	     ]
	   }
	});

The content can be encoded to avoid problems with HTML code characters or to compress content if it is large. To inform the client of the type of encoding, use the encoded property.

var message = new Message(session)
    .addAttachment({
        contentType: "application/vnd.telefonica.aura.html.custom",
	  version: "1.0.0"
        content: {
		containers:[
		{
			id: "aura-body",
			encoded: "base64",
			data: "PHNwYW4+IEhlbGxvIFdvcmxkISA8c3Bhbj4="
		}
	     ]
	   }
  });

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Billing Module operation

This document contains:

An overview of Aura Billing Module functional operation
Tasks to be executed by OBs to bring Aura Billing Module into use

Aura Billing Module operational flowchart

Figure 1 schematically shows how Aura Billing Module operates, where three different instances come into play:

Aura: OB managed environment
Aura: Global Team managed environment
Kernel

Figure 1. Aura Billing Module operation

The operational processes executed by the Aura Billing Module are outlined below. In each step, the tasks that must be carried out by the OBs in order to bring it into use, are described.

1. Data generation

This task takes place in Aura’s OB managed environment.

Aura components automatically generate logs every time a user/service interacts with Aura in local environment.
These logs are pre-processed, cleaned and converted into datasets, in Avro format.
These are the required Avro-formatted datasets for the Aura Billing Module:
- Aura_Audit, that stores the minimum information needed for generating the Liceo invoices.
- Aura dimensional entities:
  - D_Aura_App schema definition: List of possible Apps defined in Aura.
  - D_Aura_Channel: List of possible channels defined in Aura.
  - D_Aura_Component: List of possible components defined in Aura.
  - D_Aura_Preset: List of possible presets defined in Aura.
  - D_Aura_Recognizer: List of possible recognizers defined by Aura.
  - D_Aura_Skill: List of possible skills defined in Aura.
- Aura Gateway Message: summary of Aura interactions handled by aura-gateway-api.

2. Data publication in Kernel

The latest versions of the previous Avro-formatted datasets must be published into Kernel productive environment by the Kernel team.

Tasks for OBs

2.1. Ask the Kernel Team to publish the datasets in Kernel productive environment with the latest version.

2.2. When correctly published, you can check them in the repository: 4p-datasets

3. Kernel apps configuration to write/read datasets

Two Kernel applications (clients) must be created/configured by the Kernel team to allow the use of Kernel resources:
- aura-bot-[environment]: already existing app in Kernel
- aura-billing-[environment]: new application
Specifically, the applications must be configured with concrete scopes that provide permissions to write/read the datasets.
The obligation to indicate the exact version in the configuration is removed. Therefore, in the following deployments, the version number indicated in the scope will be eliminated. For example, the configuration of the Brazil OB will have to be updated when a new scope change is made. For example: data:Aura_Audit:6:read —> data:Aura_Audit:read.

Tasks for OBs

3.1. Configure aura-bot Kernel application to write datasets

Ask the Kernel Team to create a list of scopes in the aura-bot application for your intended environment.

- admin:datasets:read
- data:read
- data:write
- data:Aura_Audit:read
- data:Aura_Audit:write
- data:Aura_Gateway_Message:read
- data:Aura_Gateway_Message:write
- data:D_Aura_App:read
- data:D_Aura_App:write
- data:D_Aura_Channel:read
- data:D_Aura_Channel:write
- data:D_Aura_Component:read
- data:D_Aura_Component:write
- data:D_Aura_Preset:read
- data:D_Aura_Preset:write
- data:D_Aura_Recognizer:read
- data:D_Aura_Recognizer:write
- data:D_Aura_Skill:read
- data:D_Aura_Skill:write
- data:D_Gbl_Brand:read
- data:D_Gbl_Contact_Channel:read
- data:D_Gbl_Country:read
The scopes are associated with a specific version of the dataset, that will increase and vary with time.

3.2. Create a new app for Aura Billing Module and configure it to write datasets

Ask the Kernel Team to create a new application aura-billing in Kernel for your intended environment

Ask the Kernel Team to create a purpose for this application. For instance, aura-kpi-data-read-purpose

Ask the Kernel Team to assign to this purpose the following scopes:
- admin:datasets:read
- data:read
- data:write
- data:Aura_Audit:read
- data:Aura_Gateway_Message:read
- data:D_Aura_App:read
- data:D_Aura_Channel:read
- data:D_Aura_Component:read
- data:D_Aura_Preset:read
- data:D_Aura_Recognizer:read
- data:D_Aura_Skill:read
- data:D_Gbl_Brand:read
- data:D_Gbl_Contact_Channel:read
- data:D_Gbl_Country:read

3.3. Access the Kernel applications

Once the Kernel team has created the app with the above-mentioned purposes and scopes, two parameters for securely accessing the app will be provided:
- client_id: unique identifier of the consuming app acting as Kernel API client.
- client_secret: password.
This allows Kernel to securely identify, authenticate and authorize any access requested from this app.

4. Data processing

Data processing is executed with Azure Databricks.

In this process, the information from the Kernel datasets is recovered and read by the Aura Billing Module, that uses algorithms to assign a unitary cost to each concept that composes the invoice to calculate the total amount of this invoice.

Tasks for OBs

4.1. Enable Aura components

Check that Aura KPIs Uploader, the component in charge of the management of KPIs entities and KPIs dimensions in Aura, is in use.

Check that Aura Databricks Jobs, component used to import Avro-formatted files into a Kernel dataset, is enabled in Aura installer.

Configure Azure Common:
- To avoid data files migrations between releases, KPI files are now stored in an Azure common storage that is not release dependent.
- The default value of days for KPIs uploading is changed to 30 days. Due to that, the variable fourth_platform.conversations.days_to_find must be removed from OB deployments, because it will be configured by the installer.

5. Data consumption

This step refers to the generation of the Liceo invoices and its storage in Azure Storage Explorer in xlsx format.

These invoices will be available for download by the Aura Global Team, to be sent to the OBs.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura bot latencies dashboard

Information provided by Aura bot latencies dashboard

Introduction

Aura bot latencies dashboard monitors outbound and inbound latencies on the request and responses handled directly by aura-bot.

The available metrics are defined in the following sections, corresponding to request errors and latency for requests, Microsoft APIs, Kernel APIs, Cognitive APIs, aura-services APIs and other APIs.

Request error

Request error graph shows the number of errors rate, aggregated by one minute.

Graph metrics

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",status=~"4..|500"}[1m]))

Graph visual

Request latency

Request latency graph shows latency rate for outgoing traffic, aggregated by one minute.

Graph metrics

sum by (path,kubernetes_namespace)(rate(outgoing_request_duration_seconds_sum{app="aura-bot"}[1m]))

Graph visual

Microsoft APIs latency

Microsoft APIs latency graph shows mean latency rate for the different Microsoft APIs used.

Graph metrics

Currently, there are three monitored Microsoft endpoints:

Direct Line endpoint

sum by (path,kubernetes_namespace)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"directline.botframework.com"}[1m]))/
sum by (path,kubernetes_namespace)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"directline.botframework.com"}[1m]))

Microsoft auth endpoint

sum by (path,kubernetes_namespace)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"login.microsoftonline.com"}[1m]))/
sum by (path,kubernetes_namespace)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"login.microsoftonline.com"}[1m]))

Blob storage endpoint

sum (label_replace(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"aura.*blob.core.windows.net",path=~"/aura-temporary-resources/.*"},"path_set","$1","path","/aura-temporary-resources/.*")) by (path_set,kubernetes_namespace) / 
sum (label_replace(outgoing_request_duration_seconds_count{app="aura-bot",host=~"aura.*blob.core.windows.net",path=~"/aura-temporary-resources/.*"},"path_set","$1","path","/aura-temporary-resources/.*")) by (path_set,kubernetes_namespace)

Graph visual

Kernel APIs latency

Kernel APIs latency graph shows mean latency rate for the different Kernel APIs used.

Graph metrics

Currently, there are four monitored Kernel endpoints (more can be added if necessary for a given environment):

Kernel auth endpoint

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"auth.*"}[1m]))/
sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"auth.*"}[1m]))

Kernel subscribed products endpoint

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"api.*",path=~"/subscribed_products/.*"}[1m]))/
sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"api.*",path=~"/subscribed_products/.*"}[1m]))

Kernel user profile endpoint

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"api.*",path=~"/userprofile/.*"}[1m]))/
sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"api.*",path=~"/userprofile/.*"}[1m]))

Kernel invoicing enpoint

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"api.*",path=~"/invoicing/.*"}[1m]))/
sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"api.*",path=~"/invoicing/.*"}[1m]))

Graph visual

Cognitive APIs latency

Cognitive APIs latency graph shows mean latency rate for the different cognitive APIs used.

Graph metrics

Currently, there are three monitored Cognitive endpoints:

Domain classifier endpoint

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"api-.*",path=~"/auracognitive/v3/domain_classifier/.*"}[1m]))/
sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"api-.*",path=~"/auracognitive/v3/domain_classifier/.*"}[1m]))

Mplus resolution endpoint

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"api-.*",path=~"/auracognitive/v3/mplus_resolution/.*"}[1m]))/
sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"api-.*",path=~"/auracognitive/v3/mplus_resolution/.*"}[1m]))

Suggestions endpoint

sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_sum{app="aura-bot",host=~"api-.*",path=~"/auracognitive/v3/suggestions/.*"}[1m]))/
sum by (kubernetes_namespace,path)(rate(outgoing_request_duration_seconds_count{app="aura-bot",host=~"api-.*",path=~"/auracognitive/v3/suggestions/.*"}[1m]))

Graph visual

Aura-services APIs latency

Graph metrics

sum by (path,kubernetes_namespace)(rate(outgoing_request_duration_seconds_sum{app="aura-bot", path=~"/aura-services/.*"}[1m]))/
sum by (path,kubernetes_namespace)(rate(outgoing_request_duration_seconds_count{app="aura-bot", path=~"/aura-services/.*"}[1m]))

Graph visual

Other APIs latency

Other APIs latency graph shows mean latency rate for traffic directed to other APIs different from those above, aggregated by one minute.

Graph metrics

Currently, the only API monitored is Genesys API:

sum (label_replace(outgoing_request_duration_seconds_sum{app="aura-bot",path=~"/genesys/.*"},"path_set","$1","path","/genesys/.*")) by (path_set,kubernetes_namespace) / sum (label_replace(outgoing_request_duration_seconds_count{app="aura-bot",path=~"/genesys/.*"},"path_set","$1","path","/genesys/.*")) by (path_set,kubernetes_namespace)

Graph visual

Service API

Service API graph shows mean latency rate for the main endpoint on aura-bridge, that receives requests from Direct Line and aura-bridge. Aggregated by one minute.

Graph metrics

sum by (path,kubernetes_namespace)(rate(http_request_duration_seconds_sum{path=~"/api/messages"}[1m]))/
sum by (path,kubernetes_namespace)(rate(http_request_duration_seconds_count{path=~"/api/messages"}[1m]))

Graph visual

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Bot main dialog

Description of the main dialog, one Aura Bot core dialog that maps the recognized intent with a specific dialog

Introduction

The main dialog is one of the aura-bot core dialogs in charge of routing from the recognized intention of the user to the specific dialog that provides the functionality required in an intended channel.

main dialog extends ComponentDialog, as all the rest of the dialogs. It is an internal dialog that contains all the intents-to-dialog routing map. It is loaded during the AuraBotserver start-up to be injected as a property in aura-bot and used after each intent recognition to execute the selected dialog.

At this stage, it is both instantiated and initialized, through these steps:

First, the whole list of plugins to be loaded in the system are passed to the dialog.
It also counts on the instance of the Aura BotFramework adapter, used during this start-up phase.
Then the WaterfallDialog with all the steps managed by the main dialog is added to the dialog.
After that, it is initialized:
- A RoutingMap is created.
- All the configured plugins are registered:
  - First of all, internal dialogs are included as dialogs: context-filter dialog and suggestions dialog.
  - Then, all the plugins configured in plugins-config are looped to add the routes of all their dialogs in the RoutingMap property of the main dialog, used during the activities processing to map the recognized intent to the corresponding dialog.

During the activity processing, the ActivityHandler calls MainDialog.run method to handle the incoming activity (in the form of a TurnContext), that passes it through the dialog system. If no dialog is active, it starts the default dialog. If there is any error in the TurnContext, the processing stops here and is sent to the channel.

At this stage, the main dialog is in charge of:

Routing the recognized intent to the dialog that handles it for the current channel.
Update Aura Context information of the current activity to include the dialog information.
If the dialog includes a contextFilter that fits the user’s context, then the dialog executed is the internal context-filter dialog.
If the user’s context does not match with the contextFilter of the dialog or the dialog does not have any contextFilter, then the next step of the main dialog is executed to validate if the Kernel accessToken of the user includes the scopes and purposes needed to execute the dialog.
- If the accessToken has no permissions to access it, then an error is returned, notifying the channel that the user has not consented aura-bot to access the specific API.
- If authorization is correct, then the specific dialog is executed.
When it ends, the next step of the main dialog is executed to check whether or not the dialog needs suggestions. If the dialog is configured to send suggestions and the user’s settings support them, then the internal SuggestionsDialog is executed.
When it ends, the main dialog also ends and an outgoing message flow is started.

Find here detailed information regarding the Routing Manager.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura channels factory

Description of the list of Aura channels factory component

Introduction

Aura channels factory is a component that allows an easy integration of aura-bot in web and mobile environments (iOS and Android).

Class diagrams

@telefonica/aura-channels-cli

@telefonica/aura-channels-views

// TODO:…

Communication flow

Request flow of a message to aura-bot from a web container or native app.

sequenceDiagram

web/app ->> container: message
container ->> cli: command(message)
cli -->> aura: request directline
aura -->> cli: response directline
cli ->> container: subscribe(message)
container ->> view: emit message
note over container, view: parser and render message
view ->> container: render view
container ->> web/app: view response

How to use

Here are some examples of use. You can see the documentation of all available commands.

Add webcomponent

Here is an example of how to add the component to your website.

<!-- add this code in body tag of your website -->
<aura-component></aura-component>
<script type="text/javascript" src="http://<end-point>/aura-component.js"></script>

Entry point

It is possible to change position of default entry point. For example:

aura.position.location = 'top-left';

Or generate our own entry point, example:

<!-- add this code inside your html -->
<button onclick="myEntryPoint(event)">Relative to this element</button>

// add this function inside the scripts of your page.
function myEntryPoint(event) {
    aura.position.type = 'fixed';
    aura.position.relativeTo = event;
    aura.position.location = 'bottom-left';
    aura.show = !!aura.show;
}

Setting up a channel

The following is an example of how to set up communication for a channel. For example:

window.onload = () => { // you need to wait until the component is loaded.
    // channel user.
    aura.user = '<user>';
    // channel identifier.
    aura.channel.appId = '<channelId>';
    // directLine token.
    aura.directline.connect('<token>');
    // send an message.
    aura.directline.sendMessage('Hi!');
    // send an command.
    aura.directLine.sendMessage({ title: 'onBoarding', value: { intent: 'intent.getOnboarding' }});
};

aura.user: property to define a user. Otherwise, the system will provide an anonymous user.
aura.channel.appId: property to define a Aura channel. By default, the system will provide with ‘default’.
aura.directline.connect(): function to connect to Aura environment. DirectLine token is required.
aura.directline.sendMessage(): function to send message to aura-bot.

To obtain a DirectLine token, you can use the Aura services. For example:

curl --location --request GET 'https://<environment>.auracognitive.com/aura-services/v1/token' \
--header 'Authorization: <api-key>' \
--header 'Access-Control-Allow-Origin: *'

Messages types:

Type	Value	Description
CLEAN		Clean previus messages.
LARGE.TEXT	string	Used as a title introducing an specific view, brief and direct.
MEDIUM.BOLD.TEXT	string	It is mainly used to format the transcription of what the user says. Always in the top of the screen.
MEDIUM.TEXT	string	Mainly used to format Aura´s responses but can also be found in the onboarding and help preceded by a title component.
SMALL.ITALIC.TEXT	string	It is used when Aura quotes voice commands as no clickable suggestions. Always in between quotation marks.
EXTRA.SMALL.TEXT	string	Different than Aura´s insight, smaller and used to clarify some concepts, within conversation but outside the dialog with Aura.
BUTTONS	object	Used to render buttons.
ADAPTIVECARD	adaptive schema	Used as a rich text card, more information
HEROCARD	coming soon	Used as a rich text card. It allows to have a title, text, image and buttons.
ALFRED	object	Used to render Alfred response.

Rendering clean and text messages

The owner and containers can create messages in the following way:

aura.container.render({ type: 'CLEAN' }); // Clean messages.
aura.container.render({ type: 'MEDIUM.BOLD.TEXT', value: 'hello' }); // User message.
aura.container.render({ type: 'MEDIUM.TEXT', value: 'Hi!' }); // Aura response.

// Or send an array of messages:
aura.container.render([
    { type: 'CLEAN' },
    { type: 'MEDIUM.BOLD.TEXT', value: 'hello' },
    { type: 'MEDIUM.TEXT', value: 'Hi!' }
]);

Rendering buttons

The owner and containers can create buttons in the following way:

aura.container.render({
    type: 'BUTTONS',
    value: [
        {
            type: 'postBack',
            title: 'Suggestion button',
            value: {
                type: 'suggestion',
                intent: 'intent.command',
                entities: []
            }
        },
        {
            type: 'openUrl',
            title: 'xternal link button',
            value: 'https://www.google.com/'
        },
        {
            type: 'imBack',
            title: 'title button',
            value: 'value button',
            channelData: {
                substyle: 'hightlighted'
            }
        }
    ]
});

BUTTON TYPE

Button	Type	Description
Suggestions	postback	Generation of recommended basic suggestions
Actions	imback	Generation of Yes / No actions
External Links	posturl	Link to external page

BUTTON TITLE Text rendered inside the button

BUTTON VALUE On Suggestions and Actions, the message sent to Aura when the user clicks the button On External Links, the url opened when the user clicks the button

BUTTON SUBSTYLE In channelData object, we can add as many properties as we wish. In substyle property, we are indicating if the button has a highlighted style. If we don’t include this substyle indication, the button appearance will be the default.

Rendering alfred response

The owner and containers can create buttons in the following way:

aura.container.render({
    type: 'ALFRED',
    value: {
          greetings: 'Ich kann dir mit diesen Themen helfen',
          elements: [
            {
              text: 'Rechnung',
              display_text: 'Rechnung',
              icon: 'https://auraapcurrent16f444bd7c.blob.core.windows.net/static-resources/libraries/alfred/default/images/xxxhdpi/icn-al-assistant-bill.png?sv=2018-11-09&si=static-resources-policy-ap-current&sr=c&sig=Pam5HyRzlW43cpM/pJTdswam2qAG9zD8xdV641iMtjY%3D',
              is_suggestion: false,
              user_type: [ 'monomsisdn'],
              subscription_type: [ 'postpaid', 'control'],
              type: 'navigation',
              elements: [
                {
                  text: 'Letzte Rechnung',
                  display_text: 'Letzte Rechnung',
                  type: 'button',
                  is_suggestion: true,
                  user_type: [ 'monomsisdn' ],
                  value: {
                    intent: 'intent.billing.check',
                    entities: []
                  },
                  subscription_type: ['postpaid', 'control']
                },
                {
                  text: 'Higher charges, why?',
                  display_text: 'Higher charges, why?',
                  type: 'button',
                  is_suggestion: true,
                  user_type: [ 'monomsisdn'],
                  value: {
                    intent: 'intent.billing.unusual',
                    entities: []
                  },
                  subscription_type: ['postpaid', 'control']
                }
              ]
            },
            {
              text: 'FAQs',
              display_text: 'Puedo ayudarte con',
              icon: 'https://auraapcurrent16f444bd7c.blob.core.windows.net/static-resources/libraries/alfred/default/images/xxxhdpi/icn-al-assistant-faqs.png?sv=2018-11-09&si=static-resources-policy-ap-current&sr=c&sig=Pam5HyRzlW43cpM/pJTdswam2qAG9zD8xdV641iMtjY%3D',
              is_suggestion: false,
              user_type: ['all'],
              subscription_type: ['all'],
              type: AlfredElementType.Navigation,
              elements: [
                {
                  text: 'Wo finde ich den Einzelverbindungsnachweis?',
                  display_text: 'Wo finde ich den Einzelverbindungsnachweis?',
                  type: 'text',
                  is_suggestion: false,
                  user_type: ['all'],
                  subscription_type: ['all']
                },
                {
                  text: 'Aparelho bloqueado',
                  display_text: 'Aparelho bloqueado',
                  type: 'text',
                  is_suggestion: false,
                  user_type: ['all'],
                  subscription_type: ['all']
                }
              ]
            }
          ]
    }
});

ELEMENT TYPE

Element render	Type	Description
NavigationButton	navigation	Navigation button
Button	button	Clickable suggestions
Text	text	Non clickable suggestions

ELEMENT TEXT Test sent to aura

ELEMENT DISPLAY_TEXT Text rendered as title

ELEMENT ICON Icon url rendered as image on navigation button

ELEMENT IS_SUGGESTION Flag to check if is a suggestion

ELEMENT USER_TYPE Type of user

ELEMENT SUBSCRIPTION_TYPE Type of subscription

ELEMENT VALUE On Suggestions and Actions, the message sent to Aura when the user clicks the button

ELEMENT ELEMENTS Array of child elements

STYLES ARQUITECTURE

One of the requirements of the project is the owner must have the chance to change styles like colors, fonts, etc. Some of these styles are on libraries (cli and views) and we have to import them to the containers (web and native) and share them on dist folder.

HOW WE DO THE DISTRIBUTION

The owner will have different ways to modify or add skins, these ways are explained above. To allow these features our sass structure is:

Cli library styles: On CLI library, inside assets folder, we define the different themes of Telefonica: Default, O2, Vivo, Movistar. All these sass files are distributed for their use on containers.

Views library styles: In this library we have defined the aura components such as buttons, text, cards… There are some styles of those components (colors, fonts, backgrounds) allowed to change by the owner. All of these dynamic styles are on assets/skins/skin.sass. If in the future we create more components, we need to include dynamic styles here. Not-dynamic styles (withs, paddings, margins…) are added on the corresponding sass file on each component.

Containers styles (web and native) On containers the organization is very similar to the Views library: Not-dynamic styles are added on the corresponding sass file on each component. Dynamic styles are all on skins/default.sass. In this file, we import as well the default theme from cli library and dynamics styles from views library. The file skin.sass is a skin provided for the owner use.

Further, on containers we save on dist directory different skins files for each theme coming from cli library. On dist/assets/skins we have vivo, movistar, o2, default and skin. These files contain all the styles coming on skin/default.sass but applying the different themes. We also convert them to css. All this process is made on built.ts file.

HOW THE OWNERS CAN CHANGE STYLES

Owner wants to change the main theme When the owner wants to change to another theme like o2 or vivo, they just need to choose the desired theme we provide on dist folder. Right now, these styles are not defined yet and inside there is fake data. But in the future, we will define these themes with the corresponding corporative colors and fonts

Owner wants to change a few styles or colors Owner can modify the CSS provided on dist folder. In this case, they just need to modify the desired styles on default.css file.

Owner wants to create a completely personalized theme and styles Owners can add their own style on dist/assets/skins/skin.css. They can change as well the main font family. Then, they need to execute the function:

aura.skin.change({
  style: 'skin.css',
  fonts:[
    {
      fileName: 'OfficinaSerifITCTTBook.woff',
      family: 'OfficinaSerifITCTTBook',
      weight: 500,
      style: normal
      format: 'woff'
    },
    {
      fileName: 'OfficinaSerifITCTTBold.woff',
      family: 'OfficinaSerifITCTTBold',
      style: italic
      weight: 800,
      format: 'woff'
    }
  ]
});

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Minibot user guide

Guidelines for the installation and configuration of Aura minibot

⚠️ In Aura’s new architecture, Aura minibot works jointly with Aura minigroot

Introduction to Aura minibot

Aura minibot is a tool intended for testing purposes in local environment.

It is highly recommended to use Aura minibot to get familiar with aura-bot when developing use cases.

Pre-requirements

Azure accounts (It can be a free one)
Visual Studio Code (required for the minibot generated by a Docker image)
Remote – Containers extension for Visual Studio Code (required for the minibot generated by a Docker image)
Aura docker registry token (Contact your manager or APE team who will supply it for you)

Register a bot in Azure

The current section explains the steps for the registration of a bot in Azure. Bear in mind that the Azure site and the steps to register a new resource change very often. If any questions arise, please contact APE Team, so they can aid with the registration.

In the Azure portal, create a resource of Azure Bot type.
Type in the search box “bot” and click on “Azure Bot”, the click on “Create”.
Fill in the form fields with the following values:
- Bot handle: unique identifier for your bot, for instance: aura-bot-ape
- Subscription: OB Subscription
- Resource Group: OB Resource Group
- Pricing tier: Free
- Type of App: Multi Tenant
- Creation type: Create new Microsoft App ID
Now click on “Review + create”

⚠️ Currently, with the addition of the aura-groot, it is needed to create 2 bots in Azure (root & skill).

The new Azure Bot resource will be validated, so the next step is to click on “Create” again, so this step will deploy our new resource. A new Microsoft App Id and password will be generated.
Click on “Go to Resource” to see the breakdown of options and configurations available for your bot.
Once the Azure Bot is created, it is required to get two parameters: Microsoft App ID and Microsoft App Password:
- Microsoft App ID is located in Configuration. Copy it in a safe place.
- Get Microsoft App Password by clicking on “Manage”.
- Copy it in a safe place, as you will need it for the bot identification and cannot be visualized afterwards, when requesting a token.
- In case you have lost it, click on “New client secret” and set the expiration date.

Install and configure Aura minibot

The minibot is provided as a Docker image from Aura’s private registry.

From this docker image, follow the next steps for its installation and configuration.

Complementary, the minibot can also be generated through a .tgz file, if the docker cannot be used.

Set all the required environment variables

Firstly, you need to set some environment variables located in:

aura-mini-bot/config.env

In this file, there are the environment variables shared between aura-groot and aura-bot as skill. Also, there are variables for the scripts to set Direct Line endpoint, so in Microsoft variables you should set the ones of the Azure bot that will be configured in aura-groot.

You also have two files with variables for aura-groot and aura-bot as skill. These files are:

aura-mini-bot/config-groot.env
aura-mini-bot/config-bot.env

Bot credentials

Edit the following variables using the values you have in Azure portal for aura-groot and aura-bot:

AURA_MICROSOFT_APP_PASSWORD=<generated secret>
AURA_MICROSOFT_APP_ID=<Microsoft App Id>

As now we have 2 bots, you should set these variables in both files, config-groot.env and config-bot.env. Also, you should set the same AURA_MICROSOFT_APP_ID that you set in config-bot.env in the mocked skills configuration file (mock-configuration/mocks/mock-files/skills-configuration-mock.json), in the appId field, to indicate aura-groot the appId of the skill it has to communicate with.

Access to the database

Minibot requires access to a MongoDB database to be able to store information related to the user session. Those variables can be found here:

AURA_MONGODB_BOT_DATABASE=aura-minibot
AURA_MONGODB_PASSWORD=pass
AURA_MONGODB_URI=mongodb://localhost:27017?authSource=admin
AURA_MONGODB_USERNAME=admin

By default, AURA_MONGODB_USERNAME and AURA_MONGODB_PASSWORD variables are set as “admin” and “pass” in the .env file. These values must match the <user_name> and <password_db> set in the next step.

Run a local database

If you do not have any mongoDB instance, download a Docker image and run docker for storing sessions locally:

docker pull mongo:4.4
docker run -d -p 27017-27019:27017-27019 --name mongodb mongo:4.4

The steps to modify the DB with the default user and password for the minibot are included here as an example, sorted by execution order:

Enter the docker container:
```
docker exec -it mongodb bash
```
Enter in Mongo shell
```
mongo
```

Create the user in admin DB

use admin
db.createUser({user:"<user_name>", pwd: "<password_db>", roles: [{role:"userAdmin", db:"admin"}]})

Create the aura-bot-es-dev DB
```
use aura-bot-es-dev
```
Exit MongoDB console
```
exit
```
Exit docker container
```
exit
```

Run Aura minibot on docker

Minibot is provided as a docker image from a private registry.

To access the private registry, request access to Aura Global (through the APE Team) and set login credentials on docker:

Get registry access

Use the following command:

docker login -u <user-id> -p <user-token> auraregistry.azurecr.io

With azcli:

az login
az acr login --name auraregistry

Pull minibot and minigroot images

Get the minigroot and minibot as skill specific images:

docker pull auraregistry.azurecr.io/aura/aura-mini-groot:<version>
docker pull auraregistry.azurecr.io/aura/aura-mini-bot:<version>

Get all available versions from registry

It is possible to get all available minibot and minigroot images using azcli (native or dockerized version) tool and following these steps:

Login in Azure:
```
az login
```
This message will appear: To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code XXXX to authenticate.
Open the URI an insert the provided code.
To get the available minibot images from registry, the user must use this command.
```
az acr repository show-tags -n auraregistry --repository aura/aura-mini-bot
```
To get the available minigroot images from registry, the user must use this command.
```
az acr repository show-tags -n auraregistry --repository aura/aura-mini-groot
```
These commands will show an array of string with all available versions for each.

Get latest version

To get the latest minigroot and minibot versions, replace <version> by latest in the command of the section Pull minibot and minigroot images.

NOTE: using latest for the second or successive times does not update the image if there is a new latest image in the registry. In this scenario, to make sure the latest image is being retrieved and pulled, execute the following docker commands in that order:

docker compose stop

docker-compose rm -f

docker-compose pull

docker-compose up -d

Launch minibot

To work with the all-in-one solution, five files must be created: docker-compose.yml, config.env, config-groot.env, config-bot.env and ngrok.yml.

The initial scaffolding is located in the repo: https://github.com/Telefonica/aura-mini-bot (Contact your manager or APE team if you do not have access to it) In this case, you can use the command:

docker compose up -d

Example of docker-compose.yml file

version: '3'

services:
  mongodb:
    image: mongo:4.2
    restart: unless-stopped
    env_file:
      - config.env
    ports:
      - "27017:27017"

  aura-minigroot:
    image: auraregistry.azurecr.io/aura/aura-mini-groot:<version>
    volumes:
      - ./mock-configuration/mocks/mock-files/skills-configuration-mock.json:/opt/aura-groot/aura-mini-groot/sources/files/mock-files/skills-configuration-mock.json
    env_file:
      - config.env
      - congif-groot.env
    restart: unless-stopped
    depends_on:
      - mongodb
    ports:
      - "8080:8080"

  aura-minibot:
    image: auraregistry.azurecr.io/aura/aura-mini-bot:<version>
    volumes:
      - ./packages:/tmp/dialogs
      - ./mock-configuration:/opt/aura-bot/aura-mini-bot/mock-configuration
    env_file:
      - config.env
      - config-bot.env
    restart: unless-stopped
    depends_on:
      - mongodb
    ports:
      - "8081:8081" 

  azcli:
    image: mcr.microsoft.com/azure-cli:2.49.0
    depends_on:
      - ngrok
    env_file:
      - config.env
    command: >
      sh -c "
        az login --tenant $$AURA_MICROSOFT_TENANT &&
        az account set --subscription $$AURA_MICROSOFT_SUBSCRIPTION &&
        az bot update -n $$AURA_MICROSOFT_BOT_NAME -g $$AURA_MICROSOFT_RESOURCE_GROUP --endpoint $$(curl --silent http://ngrok:4040/api/tunnels | jq -r '.tunnels | map(.public_url) | .[]' | grep https)/api/messages
      "      
  ngrok:
    image: ngrok/ngrok
    command:
      - "start"
      - "--all"
      - "--config"
      - "/etc/ngrok.yml"
    volumes:
      - ./ngrok.yml:/etc/ngrok.yml
    ports:
      - "4040:4040"

Example of config.env file

# Microsoft Azure
AURA_MICROSOFT_BOT_NAME=<your-aura-bot-name>
AURA_MICROSOFT_RESOURCE_GROUP=<your-azure-resource-group>
AURA_MICROSOFT_TENANT=<your-azure-tenant>
AURA_MICROSOFT_SUBSCRIPTION=<your-azure-subscription>

# MongoDB connection
AURA_MONGODB_BOT_DATABASE=aura-minibot
AURA_MONGODB_URI=mongodb://mongodb:27017?authSource=admin
AURA_MONGODB_USERNAME=admin
AURA_MONGODB_PASSWORD=pass
MONGO_INITDB_ROOT_USERNAME=admin
MONGO_INITDB_ROOT_PASSWORD=pass

# Npm Auth Token
NPM_TOKEN=<your-npm-auth-token>
# NPM_AUTH=<your-optional-local-npm-auth-config>
# NPM_AUTH_SCOPE=<your-optional-local-npm-packages-scope>

# LOCALES
AURA_DEFAULT_LOCALE=<your-locale>
AURA_DEFAULT_TIME_ZONE=<your-time-zone>

AURA_PHONE_COUNTRY_CODE=ES
AURA_SERVICE_ENVIRONMENT=DEV

AURA_HOST_SERVICE_URL=http://aura-minigroot:8080
AURA_KPI_STORE_MODE=file

Example of ngrok.yml file

version: 3
agent:
  authtoken: <your-auth-token>
  web_addr: 0.0.0.0:4040
tunnels:
  minigroot:
    proto: http
    addr: aura-minigroot:8080

Example of config-groot.env file

AURA_MICROSOFT_APP_ID=<your-groot-app-id>
AURA_MICROSOFT_APP_PASSWORD=<your-groot-app-password>

Example of config-bot.env file

AURA_MICROSOFT_APP_ID=<your-bot-app-id>
AURA_MICROSOFT_APP_PASSWORD=<your-bot-app-password>

NOTE: Set all <param> from ngrok.yml, config.env, config-groot.env, config-bot.env and docker-compose.yml to your needs.

The docker-compose.yml file starts MongoDB, azurecli, ngrok, minigroot and minibot containers and exposes minigroot, minibot, MongoDB and ngrok ports (8080, 8081, 27017 and 4040 respectively).

The environments can be started with the command:

docker-compose up -d

Work with Aura minibot and install new dialogs

To work with new dialogs on minibot, follow the steps below:

Place a copy of docker-compose.yml, config-bot.env, config-groot.env, config.env and ngrok.yml in the working directory and create a packages directory to contain the dialogs source code.
Start the environment from shell with the command:
```
docker-compose up -d
```
If VSCode is used, you can connect/attach to the aura-minibot container, so you can work as local minibot version.
Minibot with the new dialog is located at /opt/aura-bot/aura-mini-bot. The current dialog sources (TypeScript files) are located at /tmp/dialogs, so you can work as non-container version.
Azure endpoint must be updated. This can be made by simply right clicking on the azcli container. Then, click on Show Container Log.

This will show in the integrated terminal a message with the URL that must be opened in a web browser and the code needed to authenticate in Azure.

When the URL is opened, an insert code request will appear on web navigator.
If no active session exists, Azure credentials must be inserted.
After credentials are set, a successful message will appear and bot endpoint will be updated.

Install Dialogs

At this stage, you can install a new dialog or an existing one, as well as update or remove dialogs.

Install a new dialog

To install new dialogs on minibot, another run task is included. To use it, click on Run button (#1 on next image), select Install dialogs from dropdown (#2 on next image) and click on on start debugging (#3 on next image).

This action will build and pack the dialogs from its source code and insert them into the minibot, but this action will not start minibot.

Install an existing dialog

Installing one or more than one existing dialog can be useful for developers, as they can use them as a reference. To install an existing dialog on the minibot container, we firstly need to add it to the minibot source code, inside the packages/ folder.

In the following example, we have added three dialog libraries: bill-col, common and factotum-test.

To add the dialogs to the minibot container, follow these steps:

Click on “File” -> “Add Folder to Workspace”
In the “Add Folder to Workspace” input text bar, type in “/tmp/dialogs/”. A list of dialog libraries passed by volume to the container will be shown. Click “Ok” to add them to the minibot container.
At this point, we will be able to see the list of dialogs passed by volume in our VS Code File Explorer.
We can now proceed to install new dialogs, if required, as shown above.

Run Aura minibot

To get minibot running click on Run (#1 on next image) and then click on start debugging (#2 on next image). This action will not install new dialogs from its source (/tmp/dialogs).

This action will start minibot so it can be debugged as normally.

Update a single dialog

⚠️ Before you can update a single dialog, you must perform the task Install dialogs.

To update a dialog independently click on Update Dialog. The task will ask for the name of the dialog folder inside /tmp/dialogs.

Remove a Dialog

To delete a dialog, temporarily you can delete it from the file /opt/aura-bot/aura-mini-bot/sources/plugin-config.json

To permanently remove it you have to delete its folder inside /tmp/dialogs. Then run the Install Dialog or Update Dialog task.

Working with Mocks in Aura minibot

It is possible to use Mocks to simulate external HTTP services. This is done using a tool called Nock.

In order to use custom Mocks we must:

Configure the environment variables that we are going to modify, which are usually the endpoints to the services to impersonate.
Configure the data for Nock.
If necessary, create a custom response file in JSON format.

To work with custom Mocks it is necessary to create this file and directory structure:

Once the container is generated, this folder will be linked to:

mock-configuration/environment.env

It contains the necessary environment variables. These environment variables will replace the ones configured in the libraries (dialogs).

mock-configuration/mocks/nock-items.json

This file contains the configurations for the Nock tool.

The general format is as follows:

       "name": "<NAME>",
       "var": "<ENVIRONMENT VARIABLE WITH ENDPOINT_>,
       "method": "<HTTP METHOD>",
       "regex": "<REGEX TO ACTIVATE>", (Optional. Mandatory if does not exist path),
       "path": <PATH TO ACTIVATE>, (Optional. Mandatory if does not exist regex)
       "reply": {
           "status": <HTTP STATUS>,
           "response": <HTTP RESPONSE> (Optional.  Mandatory if does not exist file),
           "file": <FILENAME> (Optional.  Mandatory if does not exist response),
       }

A general application example is shown below:

Example

[
    {
        "name": "Channels configuration",
        "var": "AURA_CHANNELS_CONFIGURATION_API_ENDPOINT",
        "method": "get",
        "regex":"\/channels",
        "reply": {
            "status": 200,
            "file": "channels-configuration-mock.json"
        }
    },
    {
        "name": "Skills configuration",
        "var": "AURA_CHANNELS_CONFIGURATION_API_ENDPOINT",
        "method": "get",
        "regex": "\/skills",
        "reply": {
            "status": 200,
            "file": "skills-configuration-mock.json"
        }
    },
    {
        "name": "Authorization",
        "var": "AURA_AUTHORIZATION_ENDPOINT",
        "method": "get",
        "regex":"^/.*",
        "reply": {
            "status": 200,
            "file": "authentication-mock.json"
        }
    },
    {
        "name": "FP Terms and conditions API GET",
        "var": "AURA_TERMS_AND_CONDITIONS_ENDPOINT",
        "method": "get",
        "regex": "\/v0",
        "reply": {
            "status": 404,
            "response": {}
        }
    },
    {
        "name": "FP Terms and conditions API POST",
        "var": "AURA_TERMS_AND_CONDITIONS_ENDPOINT",
        "method": "post",
        "regex": "\/v0",
        "reply": {
            "status": 200,
            "response": { "status": "accepted" }
        }
    }
]

mock-configuration/mocks/mock-files

If the configuration of one of the Nock entries requires a file for the response it must be contained in this directory.

Enable Custom Mocks

To enable custom Mocks, run the task “Enable Custom Mocks”.

Disable Custom Mocks

To deactivate the custom Mocks and leave everything with the configuration you have the default dialogs you have to run the task “Disable Custom Mocks”.

Aura minibot start-up messages

The start-up messages of the minibot are the following ones:

Minibot start-up messages

/opt/aura-bot/aura-mini-bot/sources #  /usr/bin/env AURA_LOGGING_LEVEL=DEBUG AURA_LOGGING_FORMAT=dev 'NODE_OPTIONS= --require /root/.vscode-server/bin/dc96b837cf6bb4a
f9cd736aa3af08cf8279f7685/extensions/ms-vscode.js-debug/src/bootloader.js  --inspect-publish-uid=http' 'VSCODE_INSPECTOR_OPTIONS=:::{"inspectorIpc":"/tmp/node-cdp.285
-8c9b4a1b-1.sock","deferredMode":false,"waitForDebugger":"","execPath":"/usr/local/bin/node","onlyEntrypoint":false,"autoAttachMode":"always","mandatePortTracking":tr
ue,"fileCallback":"/tmp/node-debug-callback-0cff3d0edb5d6058"}' /usr/local/bin/node ./lib/index.js 
Debugger attached.
DEBUG No existing CONFIG_FILE (undefined) found, using only process.env {
        module: 'ConfigurationManager',
        corr: 'aura-system',
        version: 'not-reachable',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Environment configuration loaded {
        module: 'ConfigurationManager',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Starting HttpMonkeyPatcher {
        module: 'StartService',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG HttpMonkeyPatcher starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  HttpMonkeyPatcher started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG MiniBotServiceMock starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  MiniBotServiceMock started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG AuraCurrentChannelsConfiguration starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  AuraCurrentChannelsConfiguration started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG AuraChannelsConfiguration starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  AuraChannelsConfiguration started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Connector starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Setting connection with options {
        module: 'connector',
        configuration: { maxPoolSize: 60, ssl: false },
        corr: 'no-correlator',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  Connector started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG KpiHandler starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG KPIFileWriter started {
        module: 'kpi-entity-writer',
        corr: '',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  KpiHandler started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG PluginManager starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  All plugins were loaded successfully {
        module: 'LoadManager',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  PluginManager started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG LocaleManager starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  LocaleManager initialized {
        module: 'locale-manager',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  LocaleManager started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG AuraCacheManagement starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  Module AuraCacheManagement has been started. {
        module: 'aura-cache-management',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  AuraCacheManagement started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG ChannelDataValidator starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  Successfully loaded validator schema /opt/aura-bot/aura-mini-bot/node_modules/@telefonica/aura-models/resources/channel-data/3.1.0/request/channeldata-3.1.0-request.schema.json {
        module: 'channel-data-validator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  Successfully loaded validator schema /opt/aura-bot/aura-mini-bot/node_modules/@telefonica/aura-models/resources/channel-data/3.1.0/response/channeldata-3.1.0-response.schema.json {
        module: 'channel-data-validator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  ChannelDataValidator started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG AuraSessionManager starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Index created: [object Object] {
        module: 'connector',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Index created: [object Object] {
        module: 'connector',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  AuraSessionManager started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG FileManager starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  FileManager started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG PrometheusRegex starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  PrometheusRegex started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG UserProfileManager starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  UserProfileManager started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG AuraBotServer starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  Middleware: BatchOutgoingMessageMiddleware loaded. {
        module: 'aura-bot-server',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG speak processor rules wont be applied, AURA_MIDDLEWARE_SPEAK_PROCESSOR {
        module: 'SpeakMiddleware',
        corr: 'no-correlator',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  Middleware: SpeakMiddleware loaded. {
        module: 'aura-bot-server',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  'suggestionDbCache' has been created with options: [object Object] {
        module: 'aura-cache-management',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG adding trigger conditions {
        module: 'RoutingMap',
        trigger: [ { intent: 'intent.internal.context-filters-send-resource' } ],
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Route intent.internal.context-filters-send-resource related to context-filter:send-resource {
        module: 'RoutingMap',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG adding trigger conditions {
        module: 'RoutingMap',
        trigger: [ { intent: 'intent.internal.context-filters-send-resource.v3' } ],
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Route intent.internal.context-filters-send-resource.v3 related to context-filter:send-resource-v3 {
        module: 'RoutingMap',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG adding trigger conditions {
        module: 'RoutingMap',
        trigger: [ { intent: 'intent.internal.unexpected.file' } ],
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
DEBUG Route intent.internal.unexpected.file related to unexpected-file-core {
        module: 'RoutingMap',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  AuraBotServer started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }
INFO  Server listening to 8081 {
        module: 'aura-bot-server',
        corr: 'aura-system',
        version: '8.30.0',
        app: 'aura-bot',
        host: 'c77f96ee7285'
      }

Once this step is done, developers will have their local Aura instance up and running.

Aura minigroot start-up messages

The start-up messages of the minigroot are the following ones:

Minigroot start-up messages

DEBUG Environment configuration loaded {
        module: 'configuration-manager',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG Starting HttpMonkeyPatcher {
        module: 'start-service',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG AuthenticationApiKey starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  AuthenticationApiKey started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG MiniBotServiceMock starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  MiniBotServiceMock started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG Connector starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG Setting connection with options {
        module: 'connector',
        configuration: { maxPoolSize: 60, ssl: false },
        corr: 'no-correlator',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  Connector started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG LocaleManager starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  LocaleManager initialized {
        module: 'locale-manager',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  LocaleManager started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG AuraCurrentChannelsConfiguration starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  AuraCurrentChannelsConfiguration started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG AuraSkillConfiguration starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  1 skill have been loaded {
        module: 'aura-skill-configuration',
        skillsNames: [ 'aura-bot' ],
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  AuraSkillConfiguration started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG ChannelDataValidator starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  Successfully loaded validator schema /opt/aura-groot/aura-mini-groot/node_modules/@telefonica/aura-models/resources/channel-data/3.1.0/request/channeldata-3.1.0-request.schema.json {
        module: 'channel-data-validator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  Successfully loaded validator schema /opt/aura-groot/aura-mini-groot/node_modules/@telefonica/aura-models/resources/channel-data/3.1.0/response/channeldata-3.1.0-response.schema.json {
        module: 'channel-data-validator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  ChannelDataValidator started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG KpiHandler starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG KPIFileWriter started {
        module: 'kpi-entity-writer',
        corr: '',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  KpiHandler started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG PrometheusManager starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  PrometheusManager started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG AuraGrootCache starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
WARN  AuraGrootCache could not be started, no instance returned at init. {
        module: 'orchestrator',
        error: 'AuraGrootCache could not be started, no instance returned at init.',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG Server starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  Skills have been updated {
        module: 'activity-handler',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG SkillsChannelMap {
        module: 'activity-handler',
        skillsChannelMap: {
          'novum-mytelco': '366de758-14aa-4527-a897-d04f165d80da',
          whatsapp: '366de758-14aa-4527-a897-d04f165d80da',
          'aura-channel-factory-web': '366de758-14aa-4527-a897-d04f165d80da',
          'aura-channel-factory-mobile': '366de758-14aa-4527-a897-d04f165d80da',
          'novum-mytelco-qa': '366de758-14aa-4527-a897-d04f165d80da',
          'movistar-plus': '366de758-14aa-4527-a897-d04f165d80da',
          'set-top-box': '366de758-14aa-4527-a897-d04f165d80da',
          'set-top-box-haac': '366de758-14aa-4527-a897-d04f165d80da',
          'qa-ner': '366de758-14aa-4527-a897-d04f165d80da',
          'qa-gazetteer': '366de758-14aa-4527-a897-d04f165d80da',
          'qa-ner-gazetteer': '366de758-14aa-4527-a897-d04f165d80da',
          'qa-domain-selector': '366de758-14aa-4527-a897-d04f165d80da',
          'qa-disam': '366de758-14aa-4527-a897-d04f165d80da',
          'qa-no-disam': '366de758-14aa-4527-a897-d04f165d80da',
          whatsapp2: '366de758-14aa-4527-a897-d04f165d80da',
          'qa-disam-sugg': '366de758-14aa-4527-a897-d04f165d80da',
          'qa-disam-sugg-black': '366de758-14aa-4527-a897-d04f165d80da',
          'global-video-platform': '366de758-14aa-4527-a897-d04f165d80da',
          'whatsapp-1004': '366de758-14aa-4527-a897-d04f165d80da',
          emulator: '366de758-14aa-4527-a897-d04f165d80da'
        },
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  Module: Server, loaded. {
        module: 'aura-groot-server',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  Server started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
DEBUG HttpMonkeyPatcher starting {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  HttpMonkeyPatcher started. {
        module: 'orchestrator',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  I Am Groot!!! {
        module: 'start-service',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }
INFO  Module: Server, listening to 8080 {
        module: 'aura-groot-server',
        corr: 'aura-system',
        version: '1.23.0',
        app: 'aura-groot',
        host: '12c481794fce'
      }

Test the bot

Now, the bot is ready to receive messages through Microsoft’s Direct Line 3.0 protocol.

POSTMAN can be used as a client to send messages to the bot and check the replies from the bot. To be able to do this task, please use a Microsoft POSTMAN collection for Direct Line.

Create a Direct Line token

Create a Direct Line token to be able to talk with your bot. This can be done in the Azure portal: Firstly, go to the bot service resource, and then to Direct Line channel configuration.

If you click on Direct Line, a new side window will open on the right hand side of the screen where you can see your bot keys. At this stage, click on the eye icon to view they key and copy it, so it can be used later from POSTMAN.

Publish your bot

The Aura instance is running locally in your machine.

Now, you should publish it, so it is available to the world. It can be deployed in Azure or similar clouds, but we recommend to use some applications that allow you to generate an external URL, such as ngrok or Localtunnel. You have to expose the 8080 port of your machine, which is the default port used by Aura.

_> ngrok http 8080
_> lt --port 8080

An URL like this is obtained: https://adf65ab5.ngrok.io https://localtunnel.github.io/www/

This is the URL you have to set in the Configuration section of your bot in Azure portal.

NOTE: This process is already done automatically if you use the all-in-one solution with docker-compose.

Test from POSTMAN

Once the POSTMAN collections provided by Microsoft are downloaded, store them in the same folder and import the folder from POSTMAN (File -> Import -> Import Folder).
Set the DirectLine secret in the POSTMAN environment. Select the right environment file and then click on the Gears icon, both are located on top right.

Select the Direct Line 3.0 POSTMAN environment:
Enter the secret key value copied in previous steps inside the INITIAL VALUE and CURRENT VALUE of directLineSecret variable, so other requests can use it. This secret key is the responsible to tell Microsoft which bot has to reach once we send requests to DirectLine 3.0 endpoints.

Once this information is filled, execute the requests step by step, as shown below:

Start conversation response:

{
  "conversationId": "BZ3zYAXMr1VFzElZ369fbm-a",
  "token": "<token>.ew0KICAiYm90IjogImF1cmEtYm90LWxvY2FsLWFkdmwiLA0KICAic2l0ZSI6ICIwSEwtQjdCLUhqOCIsDQogICJjb252IjogIkJaM3pZQVhNcjFWRnpFbFozNjlmYm0tYSIsDQogICJuYmYiOiAxNTczNjUwMDkwLA0KICAiZXhwIjogMTU3MzY1MzY5MCwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3b3JrLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.GvmD7MI7fBw1mjtSD_bzD2xW9X3G7l-Pd64HvchADls1SuOmYvisR-PKcxGCoVkHN3g2KRsgFw6oyMf93jPT7E0ejM52j-etegl1nOLF2XUkM3TzM9vVig9qDhfAdQFxaxSeAV3zOKdCGbofH4PklscGKrmtEpnD2LpWmc-vHoMlx6gpBQaQaCtwykpEWceJ4cmd8ffkF3aCM1mnMyf-x2TZrH15URmPMPBdZ37y4-8pN_EGmNqLujOtuZgXbZG7s1tksk4LUhMuntRHLq6mwQrTvurd4fUdWOz7rO547RT9DymAQCfcuI0S_7buZN8Ii-4Dcwx0ByiGj932zhQXhA",
  "expires_in": 3600,
  "streamUrl": "wss://directline.botframework.com/v3/directline/conversations/BZ3zYAXMr1VFzElZ369fbm-a/stream?watermark=-&t=<token>.ew0KICAiYm90IjogImF1cmEtYm90LWxvY2FsLWFkdmwiLA0KICAic2l0ZSI6ICIwSEwtQjdCLUhqOCIsDQogICJjb252IjogIkJaM3pZQVhNcjFWRnpFbFozNjlmYm0tYSIsDQogICJuYmYiOiAxNTczNjUwMDkwLA0KICAiZXhwIjogMTU3MzY1MDE1MCwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3b3JrLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.Hcl15E483KyRlD5geEZSX2zWP5ihpnwQAl09Ah3aKLvL5Hl2kkiirllZppSZmxl8KZKb84BOav8MYlQCkrLtbQ5c5BA0s0DYH469-jNAryhQYIwDVwNdep_0OwZvRSnsgxJU4FOqx-0rpvY26W86HrXM4vhSrVYewcRLvm_F3e5dDGekfIDX3krvsqT4tykmI-RTaR20jeErDucoJvW5gLKfk1uduVnCllcNG6Vwn4zsm6hhPy7Q0Xcq9OfQlD17Bc8J3XPmJiv7vzG48ooNA7wr_E1ju2uElgRh5Iore7wjT3H4gQNVXmRDSNKmhACQv6KfU5CJLmtyELjfsRvyAQ",
  "referenceGrammarId": "55db166a-b049-c059-b26c-07296f680752"
}

The conversationId field is extracted automatically from this first request and is included in the rest of the requests.

Send message sends an AuraCommand in order to avoid the NLP process, so the dialog is triggered without NLP. You should edit the body request to be similar to the following one (remember to change the intent name to the one set in your library):
```
  {
    "type": "message",
    "from": {
        "id": "b1a72a34-626e-4c54-b2f7-6b45acf743a2"
    },
    "locale": "es-ES",
    "textFormat": "plain",
    "timestamp": "2019-11-06T17:33:31.319Z",
    "channelData": {
      "auraCommand": {
          "type": "suggestion",
          "value": {
              "intent": "intent.greetings-demo.greetings"
          }
      }
    }
}
```
Where:
- from.id is the user who is going to access the bot. This information can be obtained from the file /sources/files/mock-files/authentication-mock.json, choosing an userAuraId.
- auraCommand.value.intent contains the intent (dialog) to be reached. This information can be obtained in the files located in dev/settings/dialog-config.xx-xx.json (where xx-xx is the locale referred to the country, i.e., es-gb) in the library repository or local development in case of a new one.
```
{
  "dialogs": [
    {
      "triggerConditions": [
        {
          "intent": "intent.greetings-demo.greetings"
        }
      ],
      "id": "greetings",
      "onlyIn": ["movistar-plus", "set-top-box"]
    }
  ],
  "name": "greetings-demo"
}
```
If everything worked fine, once the request is sent, it is shown in the ngrok console. Also, the dialog activation is shown on the bot console.

ngrok:

ngrok example

  HTTP Requests
  -------------

  POST /api/messages             202 Accepted
  	Bot (consola Visual Studio Code):
  INFO  HTTP API request GET authorization-mock/ca9961f9-c6f0-3acd-5c72-ce2719f43ec9 {
      domain: 'authorization-mock',
      method: 'GET',
      path: '/ca9961f9-c6f0-3acd-5c72-ce2719f43ec9',
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG HTTP API response GET authorization-mock/ca9961f9-c6f0-3acd-5c72-ce2719f43ec9 200 {
      domain: 'authorization-mock',
      method: 'GET',
      status: 200,
      path: '/ca9961f9-c6f0-3acd-5c72-ce2719f43ec9',
      drt: 4,
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  HTTP API response GET authorization-mock/ca9961f9-c6f0-3acd-5c72-ce2719f43ec9 200 {
      domain: 'authorization-mock',
      method: 'GET',
      status: 200,
      path: '/ca9961f9-c6f0-3acd-5c72-ce2719f43ec9',
      drt: 4,
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Starting recognizer AuraCommandRecognizer {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'recognizer-middleware',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Intent set {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      intent: {
        intents: { 'intent.common.greetings': [Object] },
        entities: [],
        text: '',
        answers: undefined,
        promptCheck: true,
        utm: { source: 'channel_name', medium: 'text' }
      },
      module: 'aura-context-utils',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  AuraCommandRecognizer:6e204898-9fee-4006-a17e-7e6851fb8fca {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      intent: '{"intent.common.greetings":{"score":1}}',
      module: 'recognizer-middleware',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG End recognizer AuraCommandRecognizer. Result: {"intents":{"intent.common.greetings":{"score":1}},"entities":[],"text":"","promptCheck":true,"utm":{"source":"channel_name","medium":"text"}} {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'recognizer-middleware',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Finalize recognizers. Result: {"intents":{"intent.common.greetings":{"score":1}},"entities":[],"text":"","promptCheck":true,"utm":{"source":"channel_name","medium":"text"}} {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'incoming-message-middleware',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Break prompt {
      topIntent: {
        intent: 'intent.common.greetings',
        score: 1,
        entities: [],
        type: 'suggestion'
      },
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'incoming-message-middleware',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Clear stack evaluation: Prompt Options: No Prompt detected. Score 1, min-score threshold: 0.95 {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'aura-context-utils',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Request received {
      domain: '26eba81ecfb9.ngrok.io',
      method: 'POST',
      path: '/api/messages',
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'AuraBotServer',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Running dialog with Message Activity. {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'aura-bot',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  Recognize this intent pre-contextfilter {
      intent: '{"intent":"intent.common.greetings","score":1,"entities":[],"type":"suggestion"}',
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'main',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG routing resolution {
      recognizer: 'intent.common.greetings',
      result: undefined,
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'RoutingMap',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  There is no dialog to handle this message {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'main',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  Outgoing activity {
      text: 'Vaya, parece que no soy capaz de entenderte. Inténtalo de nuevo',
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'outgoing-message-middleware',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Finalize middlewares pipeline {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'outgoing-message-middleware',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG Dialog undefined finished, NO suggestions. {
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'main',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  Response returned 200 POST /api/messages {
      method: 'POST',
      status: 200,
      path: '/api/messages',
      drt: 35,
      corr: '11efcaff-67fb-46cd-be7f-6a54f68fd926',
      module: 'AuraBotServer',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  HTTP API request POST login.microsoftonline.com/botframework.com/oauth2/v2.0/token {
      domain: 'login.microsoftonline.com',
      method: 'POST',
      path: '/botframework.com/oauth2/v2.0/token',
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG HTTP API response POST login.microsoftonline.com/botframework.com/oauth2/v2.0/token 200 {
      domain: 'login.microsoftonline.com',
      method: 'POST',
      status: 200,
      path: '/botframework.com/oauth2/v2.0/token',
      drt: 1974,
      body: '{"token_type":"Bearer","expires_in":86398,"ext_expires_in":86398,"access_token":"<token>"}',
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  HTTP API response POST login.microsoftonline.com/botframework.com/oauth2/v2.0/token 200 {
      domain: 'login.microsoftonline.com',
      method: 'POST',
      status: 200,
      path: '/botframework.com/oauth2/v2.0/token',
      drt: 1974,
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  HTTP API request POST directline.botframework.com/v3/conversations/IiKY7bzb1Pd5VdtN4FZKmB-a/activities/IiKY7bzb1Pd5VdtN4FZKmB-a%7C0000000 {
      domain: 'directline.botframework.com',
      method: 'POST',
      path: '/v3/conversations/IiKY7bzb1Pd5VdtN4FZKmB-a/activities/IiKY7bzb1Pd5VdtN4FZKmB-a%7C0000000',
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  DEBUG HTTP API response POST directline.botframework.com/v3/conversations/IiKY7bzb1Pd5VdtN4FZKmB-a/activities/IiKY7bzb1Pd5VdtN4FZKmB-a%7C0000000 200 {
      domain: 'directline.botframework.com',
      method: 'POST',
      status: 200,
      path: '/v3/conversations/IiKY7bzb1Pd5VdtN4FZKmB-a/activities/IiKY7bzb1Pd5VdtN4FZKmB-a%7C0000000',
      drt: 185,
      body: '{\r\n  "id": "IiKY7bzb1Pd5VdtN4FZKmB-a|0000001"\r\n}',
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  INFO  HTTP API response POST directline.botframework.com/v3/conversations/IiKY7bzb1Pd5VdtN4FZKmB-a/activities/IiKY7bzb1Pd5VdtN4FZKmB-a%7C0000000 200 {
      domain: 'directline.botframework.com',
      method: 'POST',
      status: 200,
      path: '/v3/conversations/IiKY7bzb1Pd5VdtN4FZKmB-a/activities/IiKY7bzb1Pd5VdtN4FZKmB-a%7C0000000',
      drt: 185,
      corr: 'no-correlator',
      module: 'HttpMonkeyPatcher',
      version: '6.0.0',
      app: 'aura-bot',
      host: 'cc45bbf4b438'
    }
  ```
</details>

Inside POSTMAN, use “Receive activities” request to follow up all the messages sent to and from the bot.

Example

{
"activities": [
  {
    "type": "message",
    "id": "IiKY7bzb1Pd5VdtN4FZKmB-a|0000000",
    "timestamp": "2021-01-28T16:02:49.6587305Z",
    "serviceUrl": "https://directline.botframework.com/",
    "channelId": "directline",
    "from": {
      "id": "ca9961f9-c6f0-3acd-5c72-ce2719f43ec9"
    },
    "conversation": {
      "id": "IiKY7bzb1Pd5VdtN4FZKmB-a"
    },
    "textFormat": "plain",
    "locale": "es-ES",
    "channelData": {
      "auraCommand": {
        "type": "suggestion",
        "value": {
          "intent": "intent.common.greetings"
        }
      }
    }
  },
  {
    "type": "message",
    "id": "IiKY7bzb1Pd5VdtN4FZKmB-a|0000001",
    "timestamp": "2021-01-28T16:02:52.6086472Z",
    "channelId": "directline",
    "from": {
      "id": "bot-antonio",
      "name": "bot-antonio"
    },
    "conversation": {
      "id": "IiKY7bzb1Pd5VdtN4FZKmB-a"
    },
    "text": "Vaya, parece que no soy capaz de entenderte. Inténtalo de nuevo",
    "inputHint": "acceptingInput",
    "channelData": {
      "correlator": "11efcaff-67fb-46cd-be7f-6a54f68fd926"
    },
    "replyToId": "IiKY7bzb1Pd5VdtN4FZKmB-a|0000000"
  }
],
"watermark": "1"
}

Develop a new use case

Once the use case is developed following the guidelines included in the document Use cases development over Aura Bot, it is required to follow the step below:

Run the command npm pack from the library root folder to generate a .tgz with the library packed. Now, the library is ready to be imported and used by the minibot.

Minibot set-up to import and run the library

Copy the path where the .tgz file is located (right click and copy path in VSCode):
Go to root/ folder in your minibot project and run:
```
  npm install <path copied>`
```
Open the plugin-config.json file and set the name of the library inside the array as below (in the sample, the library’s name is test-app):

Add the dialogs in their libraries inside aura-mini-bot/sources/files/mock-files/channels-configuration-mock.json as well:

Example of channels-configuration-mock.json

    {
      "name": "novum-mytelco",
      "prefix": "nov",
      "channel_id": "xxxxxxx",
      "fpa_auth_scopes": "device-catalog:devices-read device-stock:stock-read",
      "fpa_auth_purposes": "customer-self-service detect-abnormal-usage device-recommendations-v3 sim-upgrade-suggestion aura-read-insight-events identify-customer bolt-on-suggestion",
      "batchMessages": true,
      "notifications_enabled": true,
      "notifications_insights_mitigation": true,
      "notification_configuration": {
        "notifications_event_types_enabled": [
          {
            "id": "unusual-data-usage",
            "enabled": true,
            "push_text": "notifications:notifications.unusual-data-usage.pushText",
            "action": "usage.anomaly",
            "subscription_filters": [
              "user_id",
              "phone_number"
            ]
          }
        ],
        "notification_callback": "https://ha42ojf7mb.execute-api.us-east-1.amazonaws.com/prod/callback/xxxxx"
      },
      "dialogLibraries": [
        {
          "name": "my-library",
          "dialogs": [
            {
              "id": "my-dialog",
              "triggerConditions": [
                {
                  "intent": "intent.my-intent"
                }
              ]
            }
          ]
  ]

NOTE: We can do a copy of the content inside of the file dialog-config.json located in our original library development.

Go to dev folder and run npm run makeup-local and wait until it finishes (it will notify us through the console):
Now the library is ready to be used from the minibot. Run the minibot through VSCode debugger (using your launch.json file).

Debugging with Aura minibot

Right now, the best way to debug a dialog is from .js files located into node_modules once our packed library is installed. This is the way to avoid NPM Link dependency issues.

Breakpoints can be set in those dialog files. Once our breakpoint is reached, when we send the request from POSTMAN, the minibot will stop and it will show the debug options in VSCode:

Global use cases debugging example (personalized data)

In the following example it is shown how to debug an existing dialog with personalized data using the intent intent.billing.check. The steps to debug it from scratch are the following:

Set the channel configuration and enable the dialog in that channel.

Go to channels-configuration-mock.json located into the folder: aura-mini-bot/sources/files/mock-files
Once there, check that the dialog is enabled inside the dialogLibraries property of the desired channel:

We use the intent.billing.check name to activate the dialog through POSTMAN in future steps. Let’s see now a screenshot of the full channel configuration for this example:

From the code above, the id property must be copied to a safe place, because it will be used in the next step.

Go to aura-mini-bot/sources/files/mock-files/authentication-mock.json file located into aura-mini-bot/sources/files/mock-files/ folder.

Paste the previous value copied (id) into the id property and check that the name and prefix property fit with the channel information.

The id property is the responsible to link the user to that channel (remember that a user has to be registered on a channel).

Now we have all we need. Pay attention to auraId property, as it will be used on POSTMAN to send messages to Aura.
Go to the root node_modules folder and open the bill-check-dialog.js file in order to set the desired breakpoints:

Go to debug module in VSCode and run the minibot in debug mode.
Go to POSTMAN and send the request to start conversation. In addition, send a request with an aura command to reach bill-check dialog:
We should be able to see our minibot stops in our breakpoints set in previous steps:

As we can see in the console, we have reached the intent.billing.check as a Final recognizer result. It can be noticed that the auraData object includes the information from the authentication-mock.json file mentioned before.

Run Aura minibot against a remote environment

In cases where it is necessary or desired to test use cases against a remote test environment, the following steps should be performed.

Get the environment variables

Using the kubeconfig file that your manager or DevOps Team should provide you with, run the following commands from a Unix terminal which will generate an .env file:

  $ export KUBECONFIG=<path-to-file>
  $ (kubectl -n aura-<environment> get cm aura-bot -o json | jq -r ".data|to_entries|map(\"\(.key)=\(.value|tostring)\")|.[]" ; kubectl -n aura-<environment> get secret aura-bot -o json | jq -r ".data|to_entries|map(\"\(.key)=\(.value|tostring|@base64d)\")|.[]" ) > aura-<environment>.env

NOTE: Set all 3 of <environment> params to your needs.

NOTE: In case the command does not find jq, you must install the library by executing the following:

  $ apt-get update
  $ apt-get install jq

Modify environment file

In order for the minibot to work correctly against a remote environment, the following variables must be added at the beginning of the .env file:

  # REMOTE ENV
  AURA_ACTIVATE_MINI_BOT=false
  AURA_LOGGING_LEVEL=DEBUG
  AURA_LOGGING_FORMAT=dev

Then, we will proceed to modify the following variables:

  AURA_CHANNELS_CONFIGURATION_API_ENDPOINT=http://wiremock:8080
  AURA_COGNITIVE_ENDPOINT=http://host.docker.internal:7000/auracognitive/v3
  AURA_MONGODB_URI=mongodb://host.docker.internal:27017

And comment or delete the subsequent ones:

  # AURA_LOGGING_LEVEL=INFO
  # AURA_MICROSOFT_APP_ID=********
  # AURA_MICROSOFT_APP_PASSWORD=********

Create new docker-compose

For convenience, we will create a new docker-compose file to be able to use the minibot locally and remotely without making modifications each time. This file will be added along with the previous docker-compose.yml file.

docker-compose-remote.yml

version: '3'

services:  
  wiremock:
    image: wiremock/wiremock:2.33.2
    volumes:
      - ./mock-configuration/mocks/mock-files:/home/wiremock/__files:ro
      - ./mappings:/home/wiremock/mappings:ro
    restart: unless-stopped
    expose:
      - "8080"
    ports:
      - "4041:8080"

  mongodb:
    image: mongo:4.2
    restart: unless-stopped
    env_file:
      - config.env
    ports:
      - "27017:27017"

  aura-minigroot:
    image: auraregistry.azurecr.io/aura/aura-mini-groot:<version>
    volumes:
      - ./mock-configuration/mocks/mock-files:/opt/aura-groot/aura-mini-groot/sources/files/mock-files/
    env_file:
      - config.env
      - remote-config.env
      - config-bot.env
    restart: unless-stopped
    depends_on:
      - mongodb
    ports:
      - "8080:8080"
    entrypoint: sh -c "sh -c \"$${@}\""
    command: >
      sh -c "
        set -e
        echo $$(echo $$(nslookup host.docker.internal | grep -o 192.*) aura-bridge-outbound) >> /etc/hosts
        /opt/aura-groot/aura-mini-groot/sources/docker-entrypoint-mini-groot.sh
        sh || exit 0
      "      

  aura-minibot:
    image: auraregistry.azurecr.io/aura/aura-mini-bot:<version>
    volumes:
      - ./packages:/tmp/dialogs
      - ./mock-configuration:/opt/aura-bot/aura-mini-bot/mock-configuration
      - mock-files:/opt/aura-bot/aura-mini-bot/sources/files/mock-files
    env_file:
      - config.env
      - remote-config.env
      - config-bot.env
    restart: unless-stopped
    depends_on:
      - mongodb
    ports:
      - "8081:8081"

  azcli:
    image: mcr.microsoft.com/azure-cli:2.49.0
    depends_on:
      - ngrok
    env_file:
      - config.env
    command: >
      sh -c "
        az login --tenant $$AURA_MICROSOFT_TENANT &&
        az account set --subscription $$AURA_MICROSOFT_SUBSCRIPTION &&
        az bot update -n $$AURA_MICROSOFT_BOT_NAME -g $$AURA_MICROSOFT_RESOURCE_GROUP --endpoint $$(curl --silent http://ngrok:4040/api/tunnels | jq -r '.tunnels | map(.public_url) | .[]' | grep https)/api/messages
      "      
  ngrok:
    image: ngrok/ngrok
    command:
      - "start"
      - "--all"
      - "--config"
      - "/etc/ngrok.yml"
    volumes:
      - ./ngrok.yml:/etc/ngrok.yml
    ports:
      - "4040:4040"

volumes:
  mock-files:

NOTE: Set <version> to your needs.

Mappings for the Channels API

In order to get the configuration of locally installed use cases, and skills, create a mappings folder in the working directory and add these three files:

channels.json

  {
    "request": {
      "method": "GET",
      "urlPattern": "(.*)\/channels(.*)"
    },
    "response": {
      "status": 200,
      "bodyFileName": "channels-configuration-mock.json",
      "headers": {
        "Content-Type": "application/json"
      }
    }
  }

skills.json

{
  "request": {
    "method": "GET",
    "urlPattern": "(.*)\/skills(.*)"
  },
  "response": {
    "status": 200,
    "bodyFileName": "skills-configuration-remote-mock.json",
    "headers": {
      "Content-Type": "application/json"
    }
  }
}

This configuration will use the docker volume created in the docker-compose to be able to serve through the WireMock container the files located in /sources/files/mock-files/.

Start the minibot containers

You must use the following command to raise the containers with the new compose file:

  $ docker-compose -f ./docker-compose-remote.yml up -d

You should also use the following command to shut down the correct containers:

  $ docker-compose -f ./docker-compose-remote.yml down

Docker scaffolding

Below, you can find the complete folder and file structure with links to download them, so you can start using minibot in docker right away:

https://github.com/Telefonica/aura-mini-bot

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura response error messages

Sometimes, Aura could return some errors due to authentication or other APIs errors. This document describes the most common errors and how clients should handle them.

Unauthenticated error

In some channels that require authentication, Aura could return an unauthenticated error if the auraId is invalid. In this cases, the client should authenticate the user again and create a new auraId.

ChannelData v3 example:

        {
            "type": "message",
            "id": "4VJyNMnfcQLHuvOAbXMLAK-fr|0000005",
            "timestamp": "2024-06-27T14:01:24.9377437Z",
            "channelId": "directline",
            "from": {
                "id": "aura-bot-x",
                "name": "aura-bot-x"
            },
            "conversation": {
                "id": "4VJyNMnfcQLHuvOAbXMLAK-fr"
            },
            "text": "Desculpe, não consegui verificar suas informações. Por favor, reinicie o aplicativo e tente novamente.",
            "inputHint": "acceptingInput",
            "channelData": {
                "correlator": "5b25cd4a-aa57-420d-9fb3-8db437df01cf",
                "version": "3",
                "status": {
                    "code": "ERROR.USER.UNAUTHENTICATED",
                    "message": "Invalid aura user",
                    "params": {
                        "auraId": "asdf"
                    }
                }
            },
            "replyToId": "4VJyNMnfcQLHuvOAbXMLAK-fr|0000004"
        }

ChannelData v1 example:

        {
            "type": "message",
            "id": "4VJyNMnfcQLHuvOAbXMLAK-fr|0000003",
            "timestamp": "2024-06-27T14:01:07.7998256Z",
            "channelId": "directline",
            "from": {
                "id": "aura-bot-x",
                "name": "aura-bot-x"
            },
            "conversation": {
                "id": "4VJyNMnfcQLHuvOAbXMLAK-fr"
            },
            "text": "Desculpe, não consegui verificar suas informações. Por favor, reinicie o aplicativo e tente novamente.",
            "speak": "Desculpe, não consegui verificar suas informações. Por favor, reinicie o aplicativo e tente novamente.",
            "inputHint": "acceptingInput",
            "channelData": {
                "hasMoreMessages": false,
                "correlator": "593a44ac-3974-472b-a7e4-610b3c760679",
                "Error": {
                    "code": "UNAUTHENTICATED",
                    "data": "invalidAuraId",
                    "message": "Invalid auraId"
                }
            },
            "replyToId": "4VJyNMnfcQLHuvOAbXMLAK-fr|0000002"
        }

Too many requests error

In some cases, certain APIs could return an error 429 due to quota limits or other reasons. In these scenarios, the client should wait the returned value of the parameter retryAfter and try again after this time.

ChannelData v3 example:

        {
            "type": "message",
            "id": "H2JRTbQW25d6Jyccs7PfEb-fr|0000007",
            "timestamp": "2024-06-27T14:08:26.8101993Z",
            "channelId": "directline",
            "from": {
                "id": "aura-bot-x",
                "name": "aura-bot-x"
            },
            "conversation": {
                "id": "H2JRTbQW25d6Jyccs7PfEb-fr"
            },
            "text": "Lo sentimos, ha ocurrido un error inesperado.",
            "inputHint": "acceptingInput",
            "channelData": {
                "correlator": "9df5cb1b-966c-4db4-9df8-e269c682a58b",
                "version": "3",
                "status": {
                    "code": "ERROR.API.TOO_MANY_REQUESTS",
                    "message": "Too many requests",
                    "params": {
                        "retryAfter": "10"
                    }
                }
            },
            "replyToId": "H2JRTbQW25d6Jyccs7PfEb-fr|0000006"
        }

ChannelData v1 example:

        {
            "type": "message",
            "id": "H2JRTbQW25d6Jyccs7PfEb-fr|0000009",
            "timestamp": "2024-06-27T14:08:45.5260908Z",
            "channelId": "directline",
            "from": {
                "id": "aura-bot-x",
                "name": "aura-bot-x"
            },
            "conversation": {
                "id": "H2JRTbQW25d6Jyccs7PfEb-fr"
            },
            "text": "Lo sentimos, ha ocurrido un error inesperado.",
            "speak": "Lo sentimos, ha ocurrido un error inesperado.",
            "inputHint": "acceptingInput",
            "channelData": {
                "hasMoreMessages": false,
                "correlator": "cd06e100-7783-46e8-8051-ee99e8b72f43",
                "Error": {
                    "code": "TOO_MANY_REQUESTS",
                    "data": {
                        "retryAfter": "10"
                    },
                    "message": "Too many requests"
                }
            },
            "replyToId": "H2JRTbQW25d6Jyccs7PfEb-fr|0000008"
        }

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.27.

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:8.5.21
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:1.9.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Information regarding Aura system components end-of-life (EOL) and next updates is included in the document Scheduled updates in Aura components. Find it in the Aura releases section of your corresponding release.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.27.

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:8.5.21
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:1.9.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.27.

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:8.5.21
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:1.9.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.27.

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.27.

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.29

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.29

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.29

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.29

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.29

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.15.0
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.15.0
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.29

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.29

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.48.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.30

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.30

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.30

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.30

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:2.2.0
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.31

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.31

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.31

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.31

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.31

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.31

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.31

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.26.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.16.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:10.3.3
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.16.1
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.53.1
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.32.5

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.32

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.28.1
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.18.2
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:11.6.3
keda	aura-system	devopstf.azurecr.io/tools/keda:2.17.2
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.18.2
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v3.5.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.11.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.38.0
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.38.0

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

AKS versions

Kubernetes version can be obtained from an already deployed cluster with the following command, reading the information regarding Server version:

$ kubectl version
Client Version: ....
Server Version: version.Info{Major:"1", Minor:"24", GitVersion:"v1.24.6", GitCommit:"6c23b67c202a4cfa7c76c3e1b370bd5f0e654f30", GitTreeState:"clean", BuildDate:"2022-11-09T17:13:23Z", GoVersion:"go1.18.6", Compiler:"gc", Platform:"linux/amd64"}

Kubernetes version: v1.24.6
Nodepools:
- common: v1.24.6
- system: v1.24.6
- management: v1.24.6
- database: v1.24.6
- redis: v1.24.6

Statefulsets

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.23.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:1.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:7.17.6
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:1.7.7
grafana	aura-system	devopstf.azurecr.io/tools/grafana:8.3.4
mongodb	aura-system	devopstf.azurecr.io/tools/mongo:4.4.18
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.32.1
redis	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

Deployments

Name	Namespace	Image deployed
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:1.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.3.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:1.5.0
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:7.17.6
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:1.5.1
prometheus-msteams	aura-system	devopstf.azurecr.io/tools/prometheus-msteams:v1.5.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

EOL

Name	Version	EOL	Info
kubernetes	1.24.6	28/07/23	https://kubernetes.io/releases/#release-history
elasticsearch	7.17.6	02/10/23	https://www.elastic.co/es/support/eol
grafana	8.3.4	N/A	https://community.grafana.com/t/support-policy-for-previous-releases/53350
kibana	7.17.6	02/10/23	https://www.elastic.co/es/support/eol
mongodb	4.4	02/2024	https://www.mongodb.com/support-policy/lifecycles
prometheus	2.32.1	N/A	https://prometheus.io/docs/introduction/release-cycle/

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

AKS versions

Kubernetes version can be obtained from an already deployed cluster with the following command, reading the information regarding Server version:

$ kubectl version
Client Version: ....
Server Version: version.Info{Major:"1", Minor:"26", GitVersion:"v1.26.3", GitCommit:"9e644106593f3f4aa98f8a84b23db5fa378900bd", GitTreeState:"clean", BuildDate:"2023-03-21T00:12:01Z", GoVersion:"go1.19.7", Compiler:"gc", Platform:"linux/amd64"}

Kubernetes version: v1.26.3
Nodepools:
- common: v1.26.3
- system: v1.26.3
- management: v1.26.3
- database: v1.26.3
- redis: v1.26.3

Statefulsets

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.23.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:1.7.7
grafana	aura-system	devopstf.azurecr.io/tools/grafana:8.3.4
mongodb	aura-system	devopstf.azurecr.io/tools/mongo:4.4.18
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.32.1
redis	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

Deployments

Name	Namespace	Image deployed
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:1.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.3.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:1.5.1
prometheus-msteams	aura-system	devopstf.azurecr.io/tools/prometheus-msteams:v1.5.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

EOL

Name	Version	EOL	Info
kubernetes	1.26.3	28/02/24	https://kubernetes.io/releases/#release-history
elasticsearch	8.7.0	10/08/24	https://www.elastic.co/es/support/eol
grafana	8.3.4	N/A	https://community.grafana.com/t/support-policy-for-previous-releases/53350
kibana	8.7.0	10/08/24	https://www.elastic.co/es/support/eol
mongodb	4.4	02/2024	https://www.mongodb.com/support-policy/lifecycles
prometheus	2.32.1	N/A	https://prometheus.io/docs/introduction/release-cycle/

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.32

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.28.1
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.18.2
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:11.6.3
keda	aura-system	devopstf.azurecr.io/tools/keda:2.17.2
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.18.2
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v3.5.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.11.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.38.0
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.38.0

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

Components versions

All components in the table below run over AKS cluster version 1.32

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.28.1
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:2.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.4.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.18.2
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:3.2.2
grafana	aura-system	devopstf.azurecr.io/tools/grafana:11.6.3
keda	aura-system	devopstf.azurecr.io/tools/keda:2.17.2
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.18.2
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:2.1.0
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v3.5.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.11.1
redis	aura-system	devopstf.azurecr.io/tools/redis:6.0.19
redis-exporter	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.38.0
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.38.0

Additional information

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

AKS versions

Kubernetes version can be obtained from an already deployed cluster with the following command, reading the information regarding Server version:

$ kubectl version
Client Version: ....
Server Version: version.Info{Major:"1", Minor:"26", GitVersion:"v1.26.3", GitCommit:"9e644106593f3f4aa98f8a84b23db5fa378900bd", GitTreeState:"clean", BuildDate:"2023-03-21T00:12:01Z", GoVersion:"go1.19.7", Compiler:"gc", Platform:"linux/amd64"}

Kubernetes version: v1.26.3
Nodepools:
- common: v1.26.3
- system: v1.26.3
- management: v1.26.3
- database: v1.26.3
- redis: v1.26.3

Statefulsets

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.23.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:1.7.7
grafana	aura-system	devopstf.azurecr.io/tools/grafana:8.3.4
mongodb	aura-system	devopstf.azurecr.io/tools/mongo:4.4.18
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.32.1
redis	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

Deployments

Name	Namespace	Image deployed
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:1.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.3.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:1.5.1
prometheus-msteams	aura-system	devopstf.azurecr.io/tools/prometheus-msteams:v1.5.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

EOL

Name	Version	EOL	Info
kubernetes	1.26.3	28/02/24	https://kubernetes.io/releases/#release-history
elasticsearch	8.7.0	10/08/24	https://www.elastic.co/es/support/eol
grafana	8.3.4	N/A	https://community.grafana.com/t/support-policy-for-previous-releases/53350
kibana	8.7.0	10/08/24	https://www.elastic.co/es/support/eol
mongodb	4.4	02/2024	https://www.mongodb.com/support-policy/lifecycles
prometheus	2.32.1	N/A	https://prometheus.io/docs/introduction/release-cycle/

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura system components versions

Updated versions of Aura system components for the current Aura Platform release

AKS versions

Kubernetes version can be obtained from an already deployed cluster with the following command, reading the information regarding Server version:

$ kubectl version
Client Version: ....
Server Version: version.Info{Major:"1", Minor:"26", GitVersion:"v1.26.3", GitCommit:"9e644106593f3f4aa98f8a84b23db5fa378900bd", GitTreeState:"clean", BuildDate:"2023-03-21T00:12:01Z", GoVersion:"go1.19.7", Compiler:"gc", Platform:"linux/amd64"}

Kubernetes version: v1.26.3
Nodepools:
- common: v1.26.3
- system: v1.26.3
- management: v1.26.3
- database: v1.26.3
- redis: v1.26.3

Statefulsets

Name	Namespace	Image deployed
alertmanager	aura-system	devopstf.azurecr.io/tools/alertmanager:v0.23.0
elastic-operator	aura-system	docker.elastic.co/eck/eck-operator:2.7.0
elasticsearch-es-aura	aura-system	devopstf.azurecr.io/tools/elasticsearch:8.7.0
fluent-bit-aggregator	aura-system	devopstf.azurecr.io/tools/fluent-bit:1.7.7
grafana	aura-system	devopstf.azurecr.io/tools/grafana:8.3.4
mongodb	aura-system	devopstf.azurecr.io/tools/mongo:4.4.18
prometheus	aura-system	devopstf.azurecr.io/tools/prom/prometheus:v2.32.1
redis	aura-system	devopstf.azurecr.io/tools/redis-exporter:1.6.1
thanos-store-gateway	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

Deployments

Name	Namespace	Image deployed
atlas-logger	aura-system	devopstf.azurecr.io/tools/atlas-logger:1.0.0
azure-logger	aura-system	devopstf.azurecr.io/tools/azure-logger:1.3.1
elasticsearch-exporter	aura-system	devopstf.azurecr.io/tools/elasticsearch_exporter:v1.5.0
kibana-kb	aura-system	docker.elastic.co/kibana/kibana:8.7.0
mongodb-atlas-operator	aura-system	devopstf.azurecr.io/tools/mongodb-atlas-kubernetes-operator:1.5.1
prometheus-msteams	aura-system	devopstf.azurecr.io/tools/prometheus-msteams:v1.5.0
pushgateway	aura-system	devopstf.azurecr.io/tools/pushgateway:v1.4.1
thanos-querier	aura-system	devopstf.azurecr.io/tools/thanos:v0.24.0

EOL

Name	Version	EOL	Info
kubernetes	1.26.3	28/02/24	https://kubernetes.io/releases/#release-history
elasticsearch	8.7.0	10/08/24	https://www.elastic.co/es/support/eol
grafana	8.3.4	N/A	https://community.grafana.com/t/support-policy-for-previous-releases/53350
kibana	8.7.0	10/08/24	https://www.elastic.co/es/support/eol
mongodb	4.4	02/2024	https://www.mongodb.com/support-policy/lifecycles
prometheus	2.32.1	N/A	https://prometheus.io/docs/introduction/release-cycle/

Aura – Docs

Docs:

Request access to Aura repositories in Github

How can L-CDO developers access to Github repositories?

Docs:

account-linking dialog

Introduction

Environment variables

Docs:

Aura NLP Adapters

What are Aura NLP adapters

Description

Path

Files

Configuration

Intent Entity Mapper

Description

Path

Files

Best practices to edit intent_entity_mapper.json

Configuration

None Handler

Description

Path

Files

Configuration

Standard Threshold

Description

Path

Files

Configuration

Entity Tagger Adapter

Description

Path

Files

ner_entity_translation.json

ner_aliases.json

Best practices for the edition of ner_aliases.json

Configuration

Description

Path

Files

Configuration

Intent Disambiguation Adapter

Description

Intent disambiguation with a blacklist of intents

Path

Files

Configuration

Examples of intent disambiguation adapter

Length Adapter

Description

Path

Files

Configuration

Docs:

Aura configuration API admin module

Introduction

Servers definition

Endpoints

Export modules

Export all

Export one or several specific modules

Import modules

How is an import processed?

Result of the import process

Database

Channels collection

Fields

Indexes

skills collection

Fields

Indexes

applications collection

Fields

Types

Indexes

presets collection

Fields

Root

Best practices to edit `intent_entity_mapper.json`

Example of `metadata`: