Aura Configuration API

• 1: Environment variables
• 2: Synchronization by events
• 3: Modules
• 3.1: Admin module
• 3.2: Channel module
• 3.3: Component module
• 3.4: Skill module
• 3.5: Application module
• 4: Plugins
• 4.1: Preset plugin
• 4.2: TV section plugin
• 4.3: Agent base plugin
• 4.4: Agent deployment plugin
• 4.5: Agent plugin
• 4.6: Suggestion Plugin
• 4.7: Engine filter API plugin
• 4.8: Routing filter plugin
• 5: Telefónica brands management
• 6: Contact channels management
• 7: API definition
• 7.1: Aura Configuration API
• 7.2: Agent Deployment API
• 7.3: Aura Configuration API core
• 7.4: Aura Configuration API Engine Filter API
• 7.5: Aura Configuration API preset
• 7.6: Aura Configuration API Routing Filter
• 7.7: Aura Configuration API TV Section
• 7.8: Aura Configuration API Agent
• 7.9: Aura Configuration API Agent base
• 7.10: Aura Configuration API Suggestion

1 - Environment variables

Aura Configuration API environment variables

2 - Synchronization by events

Synchronization by events

Introduction

Event-driven synchronization is a system that allows updating the configuration of any module in the components in real time.

This is done through events, which are emitted when a certain module modifies its configuration data, and allows the Aura components that are subscribed to the events to update their configuration in real time.

The synchronization by events operates as follows:

1. A service updates a certain configuration element.
2. The new updated data is stored in MongoDB.
3. An Event is published by the Event Manager. The current system supports two Event Managers, Redis Pub/Sub and DAPR.
   When the event is issued, the services subscribed to the configuration events receive the Event.
4. The changes are requested through the aura-configuration-api.

Event management can be activated or deactivated in both the event transmission and reception parts. The environment variable that has the aura-configuration-api and the components that support this system is called AURA_CONFIGURATION_EVENTS_ENABLED. The environment variable AURA_CONFIGURATION_EVENTS_MANAGER determines the engine used for event handling, possible values are “REDIS” or “DAPR”.

Using Redis as Event Manager

Publishers and subscribers

In order for a component to update the configuration data that has been modified by another service, two types of elements are required:

• Publishers, which are the ones that notify of the change
• Subscribers, which are the ones that will receive an event indicating that a change has occurred and where it has taken place.

All this is managed through the broadcasting of events in Redis through a specific channel using the Pub/Sub module.

Channel

The name of the channel has the following structure: [AURA_REDIS_DATABASE]__:[AURA_REDIS_CONFIGURATION_PREFIX][ConfigCollectionName]*

This pattern will be used by most of the current components. If any of them need to manage identifiers within the channel, such as Agents, they will be subscribed to the channel: [AURA_REDIS_DATABASE]__:[AURA_REDIS_CONFIGURATION_PREFIX][ConfigCollectionName]:[Id]

Being:

• AURA_REDIS_DATABASE: Environment variable with the number of database in Redis.
• AURA_REDIS_CONFIGURATION_PREFIX: Environment variable whose default value is aura-config.
• ConfigCollectionName: One of the following values: ChannelConfiguration, ApplicationConfiguration, SkillConfiguration, TvSectionsConfiguration, PresetConfiguration, AgentConfiguration.

Example:
1__:aura-config:ChannelConfiguration

Event Message

When the event is sent, it has the following format:

{ 
    collection: [ConfigCollectionName]  
    op:         [OPERATION];
    id:         [IDENTIFIER];
    configData: [CONFIGURATION_DATA]; 
    metadata:   [EVENT_METADATA]                (Dapr)
    pubSubName: [DAPR_PUBSUB_NAME];             (Dapr)
    crc:        [INTEGRITY];                    (Not implemented)
}  

The different types of operations are (EventConfigOperation):

• Create: When a record is created in the configuration. It will carry the identifier of the new record.
• Update: When a record is modified in the configuration. It will carry the identifier of the updated record.
• Delete: When a record is deleted in the configuration. It will carry the identifier of the deleted record.

The configuration data contains the updated or new configuration data. This field is not mandatory, and if the configuration data is empty the subscriptor refreshes its configuration calling directly the configuration API.

Examples:

Without configuration data

{
    "op":Create",
    "id":"88834434"
}

With configuration data
{
    "op":Create",
    "id":"88834434", 
    "configData": 
        {
            "name":"Expample1",
             "id":"88834434",
             .... 
         }
}

Publishers

The publishers are inside the aura-configuration-api.

When one of the configuration models writes to the MongoDB database, the event must be generated through Redis. This is done by instantiating an element of the RedisEventPublisher class. The creation of these update records in Redis has two requirements that must be met:

1. The API must contain an endpoint to obtain all the data from the model named GetAll.
2. The API must contain an endpoint to obtain an element of the model selected by its identifier named GetById.

To write the records in Redis that will generate the events, we will use the DAO of the model, specifically the method writeConfigurationEvent that is in charge of generating the registry for the event in Redis.

    // aura-configuration-api/src/common/dao.ts
    /**
     * Write configuration event.
     * @param {EventConfigOperation} operation Operation type
     * @param {string} id Id of the configuration
     * @param {T} data Data to write
     * @param {KeyValueType} metadata Metadata to write
     */
    protected async writeConfigurationEvent(operation: EventConfigOperation, id?: string, data?: T, metadata?: KeyValueType) {
        this.configurationEventPublish.op = operation;
        this.configurationEventPublish.id = id;
        this.configurationEventPublish.configData = data;
        this.configurationEventPublish.metadata = Object.assign({}, this.configurationEventPublish.metadata, metadata);

        await this.eventPublisher.publish(this.configurationEventPublish);
    }}

The eventPublisher can be one of Redis or DAPR. For Redis, the class with the methods to publish the event is included in /aura-configuration-api/src/utils/event-publishers/redis-event-publisher.ts

Generate events

When an event is generated, the operation that has been performed is indicated with the identifier of the record affected by the change.

    /**
     * Update channel.
     *
     * @throws {NoDataError} When it hasn't been updated
     * @throws {Error} When channel is invalid
     * @param {ChannelConfiguration} channel Channel configuration
     */
    public async update(channel: ChannelConfiguration) {
        channel.metadata = {
            ...(await this.channelCollection.findOne<ChannelConfiguration>(
                { id: channel.id }, { projection: { metadata: 1 } })
            )?.metadata,
            ...channel.metadata
        };
        const updateResult = await this.channelCollection.replaceOne(
            { id: channel.id }, this.prepareChannelToInsert(channel));
        if (updateResult?.modifiedCount === 0) {
            throw new NoDataError(`Channel with id: ${channel.id} cannot be found`);
        } else {
            await this.writeConfigurationEvent(EventConfigOperation.Update, channel.id);
        }
    }

Subscribers

Subscribers are inside the aura-utilities/aura-configuration library, and are the clients of each of the models in the aura-configuration-api.

These subscribers inherit their class from a base class BaseConfiguration that contains the necessary methods to manage the data. Some methods are common to all and others are specific. They include methods to manage the data locally, that is, if we receive the content of the changes in the event itself, we should be able to apply them on the current module without having to call the aura-configuration-api* to obtain them.

An example for the method of point 3 could be the following:

    /**
      * Update channel configuration.
      *
      * @param {Configuration} configuration Configuration object.
      * @param {EventConfigModel} message Event configuration model.
      * @returns {Promise<void>} Promise.
      */
    public async updateConfiguration(message: EventConfigModel<T>): Promise<void> {
        try {
            this.logger.debug({
                msg: 'UpdateChannelConfiguration executed', message,
                corr: CorrelatorUtil.auraSystem
            });

            switch (message.op) {
                case EventConfigOperation.Create:
                    try {
                        await this.createConfigurationById(message);
                    } catch (error) {
                        // if there is an error updating a single channel, update all the config with the current values
                        await this.load();
                    }
                    break;
                case EventConfigOperation.Update: {
                    try {
                        await this.updateConfigurationById(message);
                    } catch (error) {
                        // if there is an error updating a single channel, update all the config with the current values
                        await this.load();
                    }
                }
                    break;
                case EventConfigOperation.Delete:
                    if (this.removeLocal(message.id)) {
                        this.logger.debug({
                            msg: `Channel removed with id: ${message.id}`, corr: CorrelatorUtil.auraSystem
                        });
                    } else {
                        this.logger.warning({
                            msg: `Channel not found to remove with id: ${message.id}`, corr: CorrelatorUtil.auraSystem
                        });
                        await this.load();
                    }
                    break;

                default:
                    this.logger.warning({
                        msg: `Unknown operation: ${message.op} for configuration update: ${message.id}`,
                        corr: CorrelatorUtil.auraSystem
                    });
                    break;

            }
        } catch (error) {
            this.logger.error({
                msg: 'updateChannelConfiguration failed.', error: error.message, stck: error,
                corr: CorrelatorUtil.auraSystem
            });
        }
    }

      

The methods createConfigurationById and updateConfigurationById contain the logic to apply the changes locally or through the aura-configuration-api*.

    /**
     * Create channel configuration by id.
     * @param {Configuration} configuration Configuration object.
     * @param {EventConfigModel<ChannelConfiguration>} message Event configuration model.
     * @returns {Promise<void>} Promise.
     */
    private async createConfigurationById(message: EventConfigModel<T>): Promise<void> {
        // if the message has the configuration data, create the channel directly.
        if (message.configData && this.addLocal(message.configData)) {
            this.logger.debug({
                msg: `Channel added with new configuration: ${message.id}`, corr: CorrelatorUtil.auraSystem
            });
        } else {
            await this.loadById(message.id);
        }
    }

Using DAPR as Event Manager

Publishers and subscribers

In order for a component to update the configuration data that has been modified by another service, two types of elements are required:

• Publishers, which are the ones that notify of the change.
• Subscribers, which are the ones that will receive an event indicating that a change has occurred and where it has taken place.

All this is managed through DAPR Pub/Sub block. The engine selected to manage the PubSub is Redis. Unlike the pure PubSub management in Redis, which has the problem that if a subscriber does not receive the event, it will not be resent, with DAPR this does not happen since it takes care of the Event lifetime internally and manages the retries if needed.

Channel

In the DAPR Pub/Sub block, the concept of a channel is not applicable. In order to subscribe to an event, the name of the Pub/Sub module and the topic to be subscribed are required.

pubsubname: AURA_DAPR_CONFIGURATION_PUBSUB_NAME
topic: ConfigCollectionName

Being:

• AURA_DAPR_CONFIGURATION_PUBSUB_NAME: Name of PubSub module defined in DAPR for Configuration Events.
• ConfigCollectionName: One of the following values: ChannelConfiguration, ApplicationConfiguration, SkillConfiguration, TvSectionsConfiguration, PresetConfiguration, AgentConfiguration.

Event Message

DAPR uses a global event management model called CloudEvents. CloudEvents is a specification for describing event data in common formats to provide interoperability across services, platforms and systems.

For compatibility reasons with the Event Managr in Redis, the name of the model used for Redis has been included within the field data of CloudEvents.

Example CloudEvent
{
  "data": {
    "collection": "ChannelConfiguration",
    "id": "c71dc728-5fe2-4735-927d-0c419b35ec59",
    "metadata": {
      "ttlInSeconds": "60"
    },
    "op": "Update",
    "pubSubName": "pubsub-config-ap-four"
  },
  "datacontenttype": "application/json",
  "expiration": "2025-06-30T08:16:05Z",
  "id": "a8340fb8-9071-4da9-91d6-7a14a409d459",
  "pubsubname": "pubsub-config-ap-four",
  "source": "aura-configuration-api",
  "specversion": "1.0",
  "time": "2025-06-30T08:15:05Z",
  "topic": "ChannelConfiguration",
  "traceid": "00-00000000000000000000000000000000-0000000000000000-00",
  "traceparent": "00-00000000000000000000000000000000-0000000000000000-00",
  "tracestate": "",
  "type": "com.dapr.event.sent"
}

Inside the data property, it has the following format:

{ 
    collection: [ConfigCollectionName]  
    op:         [OPERATION];
    id:         [IDENTIFIER];
    configData: [CONFIGURATION_DATA]; 
    metadata:   [EVENT_METADATA]                (Dapr)
    pubSubName: [DAPR_PUBSUB_NAME];             (Dapr)
    crc:        [INTEGRITY];                    (Not implemented)
}  

The different types of operations are (EventConfigOperation):

• Create: When a record is created in the configuration. It will carry the identifier of the new record.
• Update: When a record is modified in the configuration. It will carry the identifier of the updated record.
• Delete: When a record is deleted in the configuration. It will carry the identifier of the deleted record.

The configuration data contains the updated or new configuration data. This field is not mandatory and if the configuration data is empty, the subscriptor refreshes its configuration calling the aura-configuration-api.

The metadata is used to manage the behavior of the event. In this case it uses a { "ttlInSeconds": "60" } to set the expiration time of the event. The pubSubName contains the AURA_DAPR_CONFIGURATION_PUBSUB_NAME.

Examples:

Without configuration data:

{
    "collection": "ChannelConfiguration",
    "id": "c71dc728-5fe2-4735-927d-0c419b35ec59",
    "metadata": {
      "ttlInSeconds": "60"
    },
    "op": "Update",
    "pubSubName": "pubsub-config-ap-four"
  }

With configuration data:

{
    "collection": "ChannelConfiguration",
    "id": "c71dc728-5fe2-4735-927d-0c419b35ec59",
    "metadata": {
      "ttlInSeconds": "60"
    },
    "op": "Update",
    "pubSubName": "pubsub-config-ap-four",
    "configData": 
        {
            "name":"Expample1",
             "id":"88834434",
             .... 
         }
}

Publishers

The publishers are inside the aura-configuration-api.

When one of the configuration models writes to the MongoDB database, the event must be generated through Redis. This is done by instantiating an element of the RedisEventPublisher class. The creation of these update records in Redis has two requirements that must be met:

1. The API must contain an endpoint to obtain all the data from the model named GetAll.
2. The API must contain an endpoint to obtain an element of the model selected by its identifier named GetById.

To write the records in Redis that will generate the events, we will use the DAO of the model. The method writeConfigurationEvent generates the registry for the event in Redis.

    // aura-configuration-api/src/common/dao.ts
    /**
     * Write configuration event.
     * @param {EventConfigOperation} operation Operation type
     * @param {string} id Id of the configuration
     * @param {T} data Data to write
     * @param {KeyValueType} metadata Metadata to write
     */
    protected async writeConfigurationEvent(operation: EventConfigOperation, id?: string, data?: T, metadata?: KeyValueType) {
        this.configurationEventPublish.op = operation;
        this.configurationEventPublish.id = id;
        this.configurationEventPublish.configData = data;
        this.configurationEventPublish.metadata = Object.assign({}, this.configurationEventPublish.metadata, metadata);

        await this.eventPublisher.publish(this.configurationEventPublish);
    }

The eventPublisher can be Redis or DAPR. For DAPR, the class with the methods to publish the event is in /aura-configuration-api/src/utils/event-publishers/dapr-event-publisher.ts

Generate events

When an event is generated, the operation that has been performed is indicated with the identifier of the record affected by the change.

    /**
     * Update channel.
     *
     * @throws {NoDataError} When it hasn't been updated
     * @throws {Error} When channel is invalid
     * @param {ChannelConfiguration} channel Channel configuration
     */
    public async update(channel: ChannelConfiguration) {
        channel.metadata = {
            ...(await this.channelCollection.findOne<ChannelConfiguration>(
                { id: channel.id }, { projection: { metadata: 1 } })
            )?.metadata,
            ...channel.metadata
        };
        const updateResult = await this.channelCollection.replaceOne(
            { id: channel.id }, this.prepareChannelToInsert(channel));
        if (updateResult?.modifiedCount === 0) {
            throw new NoDataError(`Channel with id: ${channel.id} cannot be found`);
        } else {
            await this.writeConfigurationEvent(EventConfigOperation.Update, channel.id);
        }
    }

Subscribers

Subscribers in DAPR can be created in several ways. In this case, the “Programatic” type is used, that is, we are going to include an endpoint in our components so that DAPR can subscribe them to the PubSub. The endpoint (/dapr/subscribe) must respond with a subscription model that contains the pubSubName, the topic and the endpoint that is going to be in charge of processing the event. This type of subscription forces us to define 2 methods for DAPR.

Example:

    /**
     * Dapr Subscriptions.
     *
     */
    public daprSubscriptions() {
        this.app.get('/dapr/subscribe', (request: express.Request, response: express.Response) => {
            const subscriptions =
                [
                    {
                        pubsubname: ConfigurationManager.instance.environmentConfiguration.AURA_DAPR_CONFIGURATION_PUBSUB_NAME,
                        topic: ConfigCollectionName.ChannelConfiguration,
                        routes: {
                            default: '/dapr/processConfigurationEvents',
                        }
                    }
                ];

            response.status(200).send(subscriptions);
        });
    }

In the previous example, we are going to subscribe to one topic, that will receive the events about the channel configuration collection.

Once the event is received, we can use the same library that we use in Redis, aura-utilities/aura-configuration, since we share the data model.

Example:

    /**
     * Process configuration events.
     *
     */
    public processConfigurationEvents() {
        this.app.post('/dapr/processConfigurationEvents', async (request: express.Request, response: express.Response) => {
            try {
                const event = HTTP.toEvent({ headers: request.headers, body: request.body.toString() });
                const cloudEvent = (event || {}) as CloudEvent;
                const configModel = (cloudEvent.data || {}) as EventConfigModel<ChannelConfiguration>;
                switch (configModel.collection) {
                    case ConfigCollectionName.ChannelConfiguration:
                        // Update current channels configuration
                        this.logger.debug({
                            msg: 'Processing channel configuration events',
                            corr: CorrelatorUtil.auraSystem
                        });
                        await AuraCurrentChannelsConfiguration.instance
                            .updateConfiguration(configModel as EventConfigModel<ChannelConfiguration>);
                        break;
                    default:
                        this.logger.warning({
                            msg: `Unknown collection in configuration event: ${configModel.collection}`,
                            corr: CorrelatorUtil.auraSystem
                        });
                }
                response.status(200).send({ status: DaprResponseStatus.SUCCESS });
            } catch (error) {
                this.logger.error({
                    msg: 'Error processing configuration events',
                    error: error.message,
                    corr: CorrelatorUtil.auraSystem
                });
                response.status(500).json({ status: DaprResponseStatus.DROP, error: 'Internal Server Error' });
            }
        });
    }

It is important to indicate in the reponse that the event has been successfully processed.

3 - Modules

Aura Configuration API modules

Introduction

Currently, aura-configuration-api contains the following modules:

Administration module

Module in charge of administration tasks:

• Export of complete server information.
• Export of information by modules.
• Import of complete server information.
• Import of information by modules.

Access detailed information about Administration module.

Channel module

Module responsible for managing all the information related to channels, including the configuration of each Aura channel as well as the libraries associated with each channel (replacement for the bot-response.json configuration file).

• Add channel
• Delete channel by id
• Get channel by id
• Get all channels
• Get changed channels
• Modify channel
• Update channel

Access detailed information about Channel module.

Component module

Module responsible for managing all the information related to components, including the configuration of each Aura component.

• Add new components
• Delete component by name
• Get component by name
• Get all components
• Update component by name
• Modify component by name

Access detailed information about Component module.

Skill module

Module responsible for managing all the information related to skills, defining the following operations:

• Add skill
• Delete skill by id
• Get skill by id
• Get all skills
• Get changed skills
• Modify skill
• Update skill

Access detailed information about Skill module.

Application module

Module responsible for managing all the information related to applications, defining the following operations:

• Add application
• Delete application by id
• Get application by id
• Get all applications
• Get changed applications
• Modify application
• Update application

Access detailed information about Application module.

Library

Module responsible for managing all the information related to libraries, defining the following operations:

• Add library by channel id
• Delete all libraries by channel id
• Delete library by id and channel id
• Get library by id and channel id
• Update library by channel id

From the functional point of view, this module depends on the aura-configuration-api channel module: server definition.

Prometheus

Module responsible for exposing metrics for monitoring and observability of Aura Configuration API using Prometheus. It provides metrics such as:

• Aura component version (gauge)
• Unhandled server errors (counter)
• Outgoing message duration (summary)
• Outgoing request duration (summary)

These metrics help track the health, performance, and errors of the API. Paths in metrics are normalized for aggregation. For more details, see the Prometheus metrics registration source code.

Access detailed information about Prometheus module.

3.1 - Admin module

Aura configuration API admin module

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

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

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

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

Types

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

Types

Action

Session

Generative

RAG

Metadata

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

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

Example of metadata:

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

communication object (HTTP)

metadata object

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

database object

filterCollection object

metadata object

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

3.2 - Channel module

Aura Configuration API channel module

Channel module

The channel module defines services associated with channel management in aura-configuration-api server.

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

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/channels/
• aura-services/v2/configuration/channels/{channelId}/libraries

Endpoints

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

Retrieving information from channels

Retrieving only some fields in channel information

It is possible to get only a specific list of fields for channel information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/channels?includeFields=name,prefix' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "45494a5b-835a-4fff-a813-b3d2be529dbe",
        "name": "novum-mytelco",
        "prefix": "nov"
    }
]

Excluding fields in channel information

It is also possible to exclude channel information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/channels?excludeFields=dialogLibraries,nlp,requestOptions,responseOptions' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "45494a5b-835a-4fff-a813-b3d2be529dbe",
        "name": "novum-mytelco",
        "prefix": "nov",
        "security": {
            "authPurposes": "customer-self-service identify-customer aura-technical-problems-purpose",
            "authScopes": "",
            "channelId": "novum-mytelco"
        },
        "metadata": {
            "updatedAt": "2022-09-06T09:58:19.543Z",
            "version": "7.4.0",
            "createdAt": "2022-09-06T09:58:19.543Z"
        }
    }
]

Database

The complete definition of the data model can be found in the channels collection section in the Administration module.

3.3 - Component module

Aura configuration API component module

Introduction

The component module defines services associated with components management in aura-configuration-api server.

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

Components will be automatically loaded with Aura deployments.

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/components/
• aura-services/v2/configuration/components/{name}

Endpoints

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

Retrieving information from components

Retrieving only some fields in component information

It is possible to get only a specific list of fields for component information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/components?includeFields=name,prefix' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "ab09f8af-18e2-46ed-b103-934df78277c0",
        "name": "aura-bot",
    }
]

Excluding fields in components information

It is also possible to exclude components information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/components?excludeFields=dialogLibraries,nlp,requestOptions,responseOptions' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "ab09f8af-18e2-46ed-b103-934df78277c0",
        "name": "aura-bot"
    }
]

Database

The complete definition of the data model can be found in components collection section within the Administration module.

3.4 - Skill module

Aura configuration API skill module

Introduction

The skill module defines services associated with skills management in aura-configuration-api server.

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

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/skills/
• aura-services/v2/configuration/skills/{skillId}

Endpoints

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

Retrieving information from skills

Retrieving only some fields in skill information

It is possible to get only a specific list of fields for skill information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/skills?includeFields=name,skillEndpoint' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "45494a5b-835a-4fff-a813-b3d2be529dbe",
        "name": "aura-bot-skill-1",
        "skillEndpoint": "http://localhost:8081/api/messages"
    },
    {
        "id": "71b626d0-099f-4184-8abb-b035d3aa4b16",
        "name": "aura-bot-skill-2",
        "skillEndpoint": "http://localhost:8082/api/messages"
    }
]

Excluding fields in skills information

It is also possible to exclude skills information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/skills?excludeFields=skillEndpoint,metadata' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "45494a5b-835a-4fff-a813-b3d2be529dbe",
        "name": "aura-bot-skill-1",
        "apiId": "45494a5b-835a-4fff-a813-b3d2be529asd",
        "channels": ["whatsapp"]
    },
    {
        "id": "71b626d0-099f-4184-8abb-b035d3aa4b16",
        "name": "aura-bot-skill-2",
        "appId": "71b626d0-099f-4184-8abb-b035d3aa4f45",
        "channels": ["novum"]
    }
]

Database

The complete definition of the data model can be found in skills collection section within the administration module.

3.5 - Application module

Aura configuration API application module

Introduction

The application module defines services associated with the management of applications in aura-configuration-api server. Applications are external services that consume Aura services.

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

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/applications/
• aura-services/v2/configuration/applications/{applicationId}

Endpoints

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

Application model

Below are the main fields of the application model according to the swagger:

Note: The agents field is an array of strings containing the identifiers of the agents associated with the application. The agents referenced must exist in the system to be inserted. If an agent is deleted, all applications referencing it will be updated accordingly.

Example response (GET /applications/{applicationId})

{
  "id": "962fedef-ee1b-470f-b460-b2a78e02bb36",
  "name": "aura-sql",
  "brand": "Movistar",
  "agents": [
    "agent-1",
    "agent-2"
  ],
  "suggestions": [
    {
      "id": "1",
      "category": "suggestions.number-of-households-per-province-category",
      "value": "suggestions.number-of-households-per-province-value"
    }
  ]
}

Example request (POST /applications)

{
  "id": "new-app-id",
  "name": "new-app",
  "brand": "Movistar",
  "agents": ["agent-1", "agent-2"]
}

Retrieving information from applications

Retrieving only some fields in application information

It is possible to get only a specific list of fields for application information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/applications?includeFields=name,brand' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

    {
        "id": "8832550f-f03c-4e18-bdbe-7c6fc7adf5ff",
        "name": "app",    
        "brand": "Movistar",
    },
    {
        "id": "8832550f-f03c-4e18-bdbe-7c6fc7adf5fg",
        "name": "app2",    
        "brand": "O2",
    }

Excluding fields in applications information

It is also possible to exclude applications information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/applications?excludeFields=metadata' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

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

Database

The complete definition of the data model can be found in applications collection section within the administration module.

4 - Plugins

Aura Configuration API plugins

Introduction

Currently, aura-configuration-api contains the following plugins:

Preset plugin

Plugin responsible for managing all the information related to channels, including the configuration of each Aura preset, as well as the libraries associated with each preset.

• Add preset
• Delete preset by id
• Get preset by id
• Get all presets
• Modify preset
• Update preset

Access detailed information about the preset plugin.

TV section plugin

Plugin responsible for managing all the information related to TV Sections.

• Add TV section
• Delete TV section by id
• Get TV section by id
• Get all TV sections
• Modify TV section
• Update TV section

Access detailed information about the TV section plugin.

Agent plugin

Plugin responsible for the management of agents.

Access detailed information about the agent plugin.

Agent base plugin

Plugin responsible for the management of agents base.

Access detailed information about the agent base plugin.

Agent deployment plugin

Plugin responsible for managing the deployment of agents.

Access detailed information about the agent deployment plugin.

Routing filter plugin

Plugin responsible for managing the routing filters.

Access detailed information about the routing filter plugin.

Filter engine plugin

Plugin responsible for managing the engine routing filters.

Access detailed information about the engine filter plugin.

4.1 - Preset plugin

Preset plugin

Introduction

The preset plugin defines services associated with the management of presets in aura-configuration-api server.

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

Servers definition

By default, the servers defined in the swagger include the base path (for v1): /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/presets
• aura-services/v2/configuration/presets/{presetId}

Endpoints

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

Retrieving information from presets

Retrieving specific fields from preset information

It is possible to get only a specific list of fields for preset information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/presets?includeFields=id,name,generative' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "ab744582-c5a6-48e1-95bb-f509bdb55512",
        "name": "preset_2",
        "generative": {
            "model": {
                "id": "gpt-4o-mini",
                "parameters": {
                    "top_p": 1,
                    "max_tokens": 250,
                    "temperature": 1
                }
            },
            "prompts": {
                "template": "string",
                "preamble": {
                    "text": "Hola.",
                    "args": {
                        "brand": "Movistar",
                        "country": "Spain",
                        "year": "2024"
                    }
                },
                "promptMaxLength": 1500
            }
        }
    }
]

Excluding fields in presets information

It is also possible to exclude presets information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/presets?excludeFields=generative,metadata' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "ab744582-c5a6-48e1-95bb-f509bdb55512",
        "name": "preset_2",
        "session": {
            "window": 8
        }
    }
]

Database

The complete definition of the data model can be found in presets collection section within the administration module.

4.2 - TV section plugin

TV section plugin

Introduction

The tv-section plugin defines services associated with the management of TV sections in aura-configuration-api server.

All these services are defined in the tv-sections namespace (/tv/sections).

Servers definition

By default, the servers defined in the swagger include the base path (for v1): /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/tv/sections
• aura-services/v2/configuration/tv/sections/{tvSectionId}

Endpoints

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

Retrieving information from TV sections

Retrieving specific fields from TV section information

It is possible to get only a specific list of fields for TV section information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/tv/sections?includeFields=id,name,canon' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "ab744582-c5a6-48e1-95bb-f509bdb55512",
        "name": "tv-section-pid-1",
        "canon": "tv-section-canon"
    }
]

Excluding fields in TV sections information

It is also possible to exclude TV section information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/tv/sections?excludeFields=metadata,name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "ab744582-c5a6-48e1-95bb-f509bdb55512",
        "pid": "tv-section-pid-1"
    }
]

Database

The complete definition of the data model can be found in TV section collection section within the administration module.

4.3 - Agent base plugin

Agent base plugin

Introduction

The agent-base plugin defines services associated with the management of agents base in aura-configuration-api server.

All these services are defined in the agents-base namespace (/agents-base).

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/agents-base
• aura-services/v2/configuration/agents-base/{agentBaseId}

Endpoints

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

Retrieving information from agents base

Retrieving specific fields from agent base information

It is possible to get only a specific list of fields for agent base information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents-base?includeFields=id,name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "cd2b534c-16c3-4d89-a87e-ec45d3939232",
        "name": "device-recommender-agent",
    }
]

Excluding fields in agent base information

It is also possible to exclude agent base information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents-base?excludeFields=metadata,name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "cd2b534c-16c3-4d89-a87e-ec45d3939232",
        "description": "An AI agent built with langgraph that provides personalized recommendations about devices by querying and analyzing data stored in a MongoDB database.",
        "language": "python",
        "version": "1.0.0"
    }
]

Filtering agent base information

It is possible to filter agent base information using the filter query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents-base?filter=language:python' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Database

The complete definition of the data model can be found in agent base collection section within the administration module.

4.4 - Agent deployment plugin

Agent deployment plugin

Introduction

The agent-deployment plugin defines services associated with the management of agents base in aura-configuration-api server.

All these services are defined in the _agents-deployment namespace (/agents-deployment).

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/agents-deployment
• aura-services/v2/configuration/agents-deployment/{agentDeploymentId}

Endpoints

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

Retrieving information from agents base

Retrieving specific fields from agent deployment information

It is possible to get only a specific list of fields for agent deployment information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents-deployment?includeFields=id,name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "cd2b534c-16c3-4d89-a87e-ec45d3939232",
        "name": "mongo-device-recommender-agent",
    }
]

Excluding fields in agent deployment information

It is also possible to exclude agent deployment information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents-deployment?excludeFields=metadata,name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "1870fa4a-bcc4-4a7c-88fc-c0194555a076",
        "config": {},
        "secrets": {},
        "image": "auraregistry.azurecr.io/aura/atria-agent-mongo-devices-recommender",
        "tag": "1.0.0"
    }
]

Filtering agent deployment information

It is possible to filter agent deployment information using the filter query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents-deployment?filter=tag:1.0.0' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Database

The complete definition of the data model can be found in agent deployment collection section within the administration module.

4.5 - Agent plugin

Agent plugin

Introduction

The agent plugin defines services associated with the management of agents in aura-configuration-api server.

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

Servers definition

By default, the servers defined in the swagger include the base path (for v1):
/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/agents
• aura-services/v2/configuration/agents/{agentId}

Endpoints

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

Retrieving information from agents

Retrieving specific fields from agent information

It is possible to get only a specific list of fields for agent information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents?includeFields=id,name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: XXX'

Response example:

[
    {
        "id": "ab744582-c5a6-48e1-95bb-f509bdb55512",
        "name": "agent-pid-1"
    }
]

Excluding fields in agent information

It is also possible to exclude agent information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v2/configuration/agents?excludeFields=metadata,name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "ab744582-c5a6-48e1-95bb-f509bdb55512",
        "name": "agent-pid-1"
    }
]

Database

The complete definition of the data model can be found in Agent collection section within the administration module.

4.6 - Suggestion Plugin

Aura Configuration API Suggestion plugin

suggestion plugin

The suggestion plugin defines services associated with suggestions management in aura-configuration-api server.

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

Servers definition

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

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

Examples:

• aura-services/v1/configuration/suggestions/

Endpoints

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

Getting suggestions

Getting only some fields in suggestion information

It is possible to get only a specific list of fields for suggestion information, reducing the amount of data transmitted when necessary, using the includeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v1/configuration/suggestions?includeFields=name' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id": "29d80c0e-dbe8-4e40-882b-fef148748cf2",
        "name": "intent-tv-question_time_loc-ent-audiovisual_sports_team-valencia",
    }
]

Excluding fields in suggestion information

It is also possible to exclude suggestion information fields using the excludeFields query parameter.

curl --location --request GET 'http://aura-configuration-api:8999/aura-services/v1/configuration/suggestions?excludeFields=entities' \
--header 'correlator: urn:uuid:c8a604ee-29f8-7cda-2979-d2ae6189c360' \
--header 'Accept: application/json' \
--header 'Authorization: APIKEY XXX'

Response example:

[
    {
        "id" : "29d80c0e-dbe8-4e40-882b-fef148748cf2",
        "intent" : "intent.tv.question_time_loc",
        "name" : "intent-tv-question_time_loc-ent-audiovisual_sports_team-valencia",    
        "entities" : [
            {
                "canon" : "valencia",
                "entity" : "Valencia",
                "label" : "",
                "score" : 1,
                "type" : "ent.audiovisual_sports_team"
            }
        ],
        "resources" : [
            {
                "name" : "tv.searchSportContentByChannel.suggestion.title",
                "params" : {
                    "teams" : "Valencia"
                },
                "type" : "title"
            },
            {
                "name" : "tv.searchSportContentByChannel.suggestion.button",
                "params" : {
                    "teams" : "Valencia"
                },
                "type" : "button"
            }
        ]
    }  
]

Database

The complete definition of the data model can be found in suggestions collection section in the Administration plugin.

4.7 - Engine filter API plugin

Aura configuration API engine filter plugin

Introduction

The engine filter plugin defines services associated with the management of engine filter in aura-configuration-api server.

All these services are defined in the routing-filters namespace (/routing-filters).

Servers definition

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

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

Examples:

• aura-services/v2/configuration/routing-filters/summary/{filterType}
• aura-services/v2/configuration/routing-filters/{filterId}/items/{itemId}

Endpoints

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

Engine filters steps

When a filter has been created, it is associated to one or more entities. Each time data is uploaded from a service for one of these entities, this data is also uploaded to the dataFilterCollection via the /routing-filters/entities/files endpoint.
This data is stored in the filter’s raw data collection and is periodically processed to obtain the summaries that are stored in the filter’s dataSummaryCollection.
This processing period is defined by the AURA_ROUTING_FILTER_SUMMARY_GENERATION_INTERVAL environment variable which defaults to 30 seconds. Note that data that has been summarized in previous processes is no longer processed again. An example of raw data could be the following: