Integración de la plataforma Mindful en Flex

Esta guía de implementación te guiará a través de la integración entre Flex y la plataforma Mindful. Con esta integración, puedes respetar el tiempo de tus clientes y darles control permitiéndoles elegir cuándo recibirán una llamada. Ya sea que se trate de dos minutos o dos horas, tus clientes valorarán que pasen menos tiempo esperando en línea.

Mindful ofrece dos tipos de devolución de llamada: Customer-First (Cliente primero) o Agent-First (Agente primero). Estas opciones de experiencia de devolución de llamada se pueden seleccionar por cola. Una devolución de llamada Customer-First llama al cliente primero y se asegura de que esté listo para su devolución de llamada. Si no está preparado, Mindful maneja las desconexiones y el correo de voz, e intentará comunicarse nuevamente con el cliente (si está configurado). Si está listo, la devolución de llamada conectará al cliente con un agente. La devolución de llamada Agent-First llama primero al agente y, una vez conectado, se llama al cliente.

Trasfondo de las devoluciones de llamada

Cuando las colas están llenas y los agentes están muy ocupados, las nuevas llamadas entrantes tendrán tiempos de espera más largos. Esto puede dar lugar a llamadas abandonadas, una mala experiencia del cliente, un aumento en los costos de servicio (a medida que se abordan intentos repetidos por parte de un cliente) y menos oportunidades para ayudar a tus clientes e interactuar con ellos.

Una de las mejores formas de reducir el tiempo de espera es ofrecer a los agentes de llamada la opción de omitir todo esto. Con Mindful, puedes ofrecer a los clientes la opción de volver a llamarlos en un momento más conveniente. Esto funciona muy bien para los contact centers cuyo volumen de llamadas tiene períodos de muy alta y muy baja actividad; tomas el volumen de llamadas que llega durante el tiempo de mayor volumen y se maneja cuando el personal no está tan ocupado.

Configurar la conectividad con Mindful

A continuación, se ofrece una descripción general detallada de la conectividad con Mindful:

Deberás configurar un dominio SIP y un enlace SIP, los cuales se utilizarán para transferir llamadas a Mindful, así como un número de teléfono dedicado que se utilizará para las devoluciones de llamada.

Sigue estos pasos para establecer una conectividad con Mindful:

1. Aprovisionar números de teléfono en Twilio

En la consola de Twilio, ve a Active Phone Numbers (Números de teléfono activos).

Esta solución se basa en dos números de teléfono, uno para las llamadas entrantes de tus clientes y otro para las llamadas entrantes de Mindful. Estos números se dirigirán a flujos de Studio independientes, los cuales se configurarán más adelante en este documento. No olvides actualizar el enrutamiento de estos números de teléfono después de haber completado los flujos de Studio.

2. Configurar una lista de control de acceso IP

1. En la consola de Twilio, ve a IP/CIDR Access Control List (Lista de control de acceso IP/CIDR).

2. Crea una nueva ACL con las siguientes direcciones:

54.165.17.177/32 - VHT SIP Proxy
54.145.183.157/32 - VHT SIP Proxy
54.87.8.161/32 - VHT RTP Proxy
3.223.253.119/32 - VHT RTP Proxy

3. Crear un dominio SIP

1. En la consola de Twilio, ve a Programmable SIP Domains (Dominios SIP programables).

2. Crea un nuevo dominio SIP.

Sugerencia: Usa la lista de control de acceso IP definida en el paso 1.

En este ejemplo, las llamadas entrantes a este dominio SIP se dirigen a un flujo de Studio, el cual se configura más adelante en este documento. También puedes utilizar otras opciones, como una función que devuelve TwiML.

4. Aprovisionar un nuevo destino de llamada

1. En Mindful, ve a Call Targets (Objetivos de llamada), Add New CT (Agregar nuevo CT); o haz clic aquí.

2. Cambia la opción Telephony Type (Tipo de telefonía) a SIP.

3. En Call Center Phone Number (Número de teléfono del call center), ingresa el número de teléfono que utilizas para las llamadas de devolución realizadas desde Mindful.

4. En Callback CID (CID de devolución de llamada), ingresa los números de teléfono de Twilio a los que llaman los agentes de llamada. Se utilizará como ID de agente de llamada al devolver la llamada.

5. Ve a la pestaña Metadata (Metadatos).

6. Agrega un elemento de metadatos denominado x-user-to-user con la siguiente configuración:

5. En Mindful, aprovisionar un nuevo número de teléfono

1. Ve a Phone Numbers (Números de teléfono).

2. Proporciona un nuevo número de teléfono y asígnalo al destino de llamada configurado en el paso 4.

Situación 1: Ofrecer una devolución de llamada antes de que el agente de llamada entre en una cola de tareas

Antes de enviar una llamada entrante a una cola de tareas TaskRouter, llamaremos a una función que utilizará la API de estadísticas de TaskRouter para determinar el tiempo de espera estimado. Si está por encima de un umbral, ofreceremos al agente de llamada la opción de una devolución de llamada en lugar de enviar la llamada a una cola.

La API de estadísticas de TaskRouter no proporciona un verdadero tiempo de espera estimado, pero hay varias formas de calcularlo. En este ejemplo, vamos a simplificar esto y utilizaremos el valor AvgTaskAcceptanceTime, el cual está disponible en TaskRouter durante los cinco minutos anteriores.

En el diagrama anterior, el tiempo de espera estimado se obtiene mediante el widget Run Function (Ejecutar función) de Studio (en el diagrama denominado check_average_wait_time) e invocando una función con el siguiente código:

/**
 * Function to read avgTaskAcceptanceTime statistics from TaskRouter's cumulative statistics.
 * https://www.twilio.com/docs/taskrouter/api/taskqueue-statistics#taskqueue-cumulative-statistics
 *
 * It returns JSON object with following fields:
 * - avgTaskAcceptanceTime - number of seconds
 *
 *
 * Expected variables from context:
 * - Queue_Estimated_Wait_Time - initial value of 0, used by script to cache value of average task acceptance time
 * - Queue_Estimated_Wait_Time_Last_Updated - initial value of 0, used by script to cache timestamp of last update of
 * - Queue_Update_Interval - average time update interval in milliseconds, initial value of 60000
 * - Workspace_SID
 * - Task_Queue_SID
 * - Service_SID
 * - Environment_SID
 * - VAR_QEWTLU_SID - SID of variable Queue_Estimated_Wait_Time_Last_Updated
 * - VAR_QEWT_SID - SID of variable Queue_Estimated_Wait_Time
 *
 * Following twilio-cli calls are useful for setting up environment variables for this script:
 *
 * twilio api:taskrouter:v1:workspaces:list
 *
 * twilio api:taskrouter:v1:workspaces:task-queues:list \
 *     --workspace-sid WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 *
 * twilio api:serverless:v1:services:list
 *
 * twilio api:serverless:v1:services:environments:list \
 *     --service-sid ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 *
 * twilio api:serverless:v1:services:environments:variables:list \
 *     --service-sid ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX \
 *     --environment-sid ZEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 */

exports.handler = function (context, event, callback) {

    const response = new Twilio.Response();
    response.appendHeader('Access-Control-Allow-Origin', '*');
    response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
    response.appendHeader('Content-Type', 'application/json');
    response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');

    get_wait_time(context, event, callback).then(value => {
        response.setBody({
                             'avgTaskAcceptanceTime': value
                         });
        return callback(null, response);
    })

}

async function get_wait_time(context, event, callback) {
    const client = context.getTwilioClient();

    let current_timestamp = new Date().getTime();

    if ((current_timestamp - context.Queue_Estimated_Wait_Time_Last_Updated) > context.Queue_Update_Interval) {

        let average_task_acceptance_time = await get_queue_cumulative_statistics(client, context.Workspace_SID, context.Task_Queue_SID, 'avgTaskAcceptanceTime');

        context.Queue_Estimated_Wait_Time = parseInt(average_task_acceptance_time);

        await client.serverless.services(context.Service_SID)
            .environments(context.Environment_SID)
            .variables(context.VAR_QEWT_SID)
            .update({
                        key: 'Queue_Estimated_Wait_Time',
                        value: average_task_acceptance_time
                    });
        await client.serverless.services(context.Service_SID)
            .environments(context.Environment_SID)
            .variables(context.VAR_QEWTLU_SID)
            .update({
                        key: 'Queue_Estimated_Wait_Time_Last_Updated',
                        value: current_timestamp
                    });

    }

    return context.Queue_Estimated_Wait_Time;
}

async function get_queue_cumulative_statistics(twilio_client, workspace_sid, task_queue_sid, stat_name) {
    return twilio_client.taskrouter.workspaces(workspace_sid)
        .taskQueues(task_queue_sid)
        .cumulativeStatistics()
        .fetch()
        .then(stats => {
            return (stats[stat_name]);
        });
}

Si el tiempo de espera estimado es superior a 120 segundos, la llamada se transfiere a Mindful a través del enlace SIP. De lo contrario, la llamada se envía a Flex a través de una cola de tareas TaskRouter.

En el paso toolstep llamado transfer_to_vht, definimos el punto final SIP al que transferimos la llamada. Este es el número de teléfono que configuraste antes en el paso 5, con el siguiente formato: sip:+1xxxxxxxxxx@sip-callback.mindful.cx:5566?x-user-to-user={{trigger.call.From}}

También enviamos a Mindful el número de teléfono del agente de llamada a través del encabezado SIP de usuario a usuario.

Situación 2: Ofrecer una devolución de llamada mientras el cliente está en espera en una cola de tareas

En este ejemplo, la llamada entrante llega a la cola de tareas de TaskRouter en el flujo de Studio.

La comprobación del tiempo de espera promedio se realiza en el widget Send to Flex (Enviar a Flex) (send_to_flex1 en el diagrama anterior) mediante el parámetro URL de TwiML Hold Music (Música en espera). En lugar de apuntar a Hold Music de TwiML, puedes señalar a una función personalizada denominada hold_treatment(), la cual, a su vez, llama a otra función personalizada, transfer_to_vht().

Código para hold_treatment:

/**
 * This function expects the same environment variables as the wait_time.js
 *
 * Expected variables from context:
 * - Queue_Estimated_Wait_Time - initial value of 0, used by script to cache value of average task acceptance time
 * - Queue_Estimated_Wait_Time_Last_Updated - initial value of 0, used by script to cache timestamp of last update of
 * Queue_Estimated_Wait_Time
 * - Queue_Update_Interval - average time update interval in milliseconds, initial value of 60000
 * - Workspace_SID
 * - Task_Queue_SID
 * - Service_SID
 * - Environment_SID
 * - VAR_QEWTLU_SID - SID of variable Queue_Estimated_Wait_Time_Last_Updated
 * - VAR_QEWT_SID - SID of variable Queue_Estimated_Wait_Time
 */
exports.handler = function(context, event, callback) {
    let twiml = new Twilio.twiml.VoiceResponse();

    get_wait_time(context).then(avg_wait_time => {
        let action_url = "https://" + context.DOMAIN_NAME + '/' + 'transfer_to_vht';
        if (avg_wait_time > 120) {
            twiml.gather({action: action_url})
                .say(`Your call will be routed to an agent in approximately ${avg_wait_time / 60} minutes. Press 1 if you want to be called back`);
        }
        return callback(null, twiml);
    });

};

Código para transfer_to_vht:

exports.handler = function(context, event, callback) {
    let response = new Twilio.twiml.VoiceResponse();

    let gathered_digits = 0;
    if (event['Digits']) {
        gathered_digits = parseInt(event['Digits']);
    }
    if (gathered_digits && (gathered_digits === 1)) {
        // leave Flex queue and continue with next node connected to Task completed
        response.leave();
    }

    return callback(null, response);

};

Cuando el tiempo de espera estimado excede el umbral (en este caso, 120 segundos), la función devuelve <Leave> en TwiML, lo cual devuelve el control a Studio y continúa con el siguiente widget.

En la condición Task Created, Studio utilizará el widget Connect Call To y redirigirá a Mindful.

Enrutamiento de la devolución de llamada

El último paso de esta Guía de implementación es dirigir las devoluciones de llamadas de Mindful directamente a Flex, pero con una prioridad más alta. Esto se debe utilizar como seguimiento para cualquiera de las dos situaciones anteriores.

Podemos hacerlo con el siguiente flujo de Studio:

Este flujo tomará el encabezado SIP x-user-to-user y lo establecerá como un atributo para la tarea TaskRouter. También cambia la prioridad de un valor predeterminado de 0 a 5 para dar a estas llamadas entrantes una prioridad mayor. Según la configuración de TaskRouter de la empresa, es posible que tengas que cambiar este valor por uno que esté clasificado adecuadamente.

Una vez que hayas conectado todos los flujos de Studio a los números de teléfono adecuados, la solución de devolución de llamada debería estar lista para funcionar. Bien hecho: tus clientes te agradecerán que les ahorres esos largos tiempos de espera.