Sessions: an Introduction

Session variables are a valuable feature within the babelforce Manager, enabling efficient call routing, enhanced reporting, the implementation of complex logic, and a reduction in call and automation complexity by storing relevant information about each call.

What is a Session?

Sessions are an important tool and data storage mechanism in the Babelforce ecosystem and are similar to key-value pairs, much like variables in other systems. They serve as containers in which certain information is stored during a call so that users can access, update and reuse this data as needed.

Why do we need Sessions?

Sessions are crucial for several reasons. They store relevant call information, such as brand details or the reason for the call, which can be used to make real-time decisions. This is particularly useful when interacting with external systems, where sessions can be set and updated depending on the evolving context of the call.

Sessions also simplify the creation of call flows by abstracting and storing specific data points that can be reused at different stages of the call. This reduces complexity and increases flexibility, facilitating the development and management of automation processes. For example, more complex triggers can be built based on session data, which can then be saved and reused. Understanding the purpose of each session and how it fits into the overall call flow is essential for optimizing its use.

To summarize, sessions are not only limited to data storage within a call but can be used both locally and globally to manage complex call handling and improve system integrations. By incorporating specific information from the call flow, which is not available through babelforce's standard options, sessions enable the creation of sophisticated triggers and routing rules, enhance reporting capabilities, and streamline communication with external systems via API integration.

A practical insight

First, it's important to note that session variables are not automations themselves, but they can be set through automations or via API by external systems. In the following example, we'll focus on using sessions within a local automation to capture and utilize specific call data.

Example:

Suppose you run an electronics business and want to capture certain information that isn't predefined by babelforce, such as whether a call is made from a mobile number and the reason for the call. Here’s how you can achieve this:

First we create a Speech-to-Text Module:

• Name: "SST Welcome - Electro Shop"
• Text: "Hi, welcome to our Electro Shop."
• Variable name: "callreason"
• Text: “For Billing request press one, for electronics press two and for all other requests stay in the line. 
• After Flow: New Switch Node

The Switch Node for the After Flow can look as follows:

Name: "SN Electro Main Call Reason"

• Create two routing rules with two triggers leading to two additional SST modules.
  • Trigger 1: Contains the variable "callreason" and the value "1" for "Billing" (SST-Module)
  • Trigger 2: Contains the variable "callreason" and the value "2" for "Electronics"  (SST-Module)
• After Flow: The after Flow Main is based on the Information, to stay in the line for "other requests"

The call flow should be structured as follows:

To keep the example simple, we will now only focus on the first routing rule the: Text-to-Speech Module named "Billing Request Handling”

We create a new local automation within the Speech-To-Text module and name it: Session Billing + Mobile

To keep the example simple, we will now only focus on the first routing rule the: Text-to-Speech Module named "Main Reason = Billing”

We create a new local automation within the Speech-To-Text module and name it: Session Billing + Mobile

• The Positon is set as "after"
• The Priority should be high = "100"
• Action: To set a Session we need the option “set session” for the action
• Trigger: The trigger should contain two conditions:
  • For the first condition, we use the variable from the previous STT-module "callreason" and the value 1 for “Biling”
  • For the first condition, we use the variable "Mobile" and the value "is given” Mobile = is given
  • Match all conditions

The trigger "Billing + Mobile" should be configured as follows:

Set Session: Now we create a new session (key) named "callreasonmobile" with the value "Billing"

• This abstracts a new individual data point from the call flow as a session variable that can now be used.

The local automation should be set up as follows:

Result: When a call is made from a mobile number and the caller selects "Billing" as the call reason, the session is activated, and this information is automatically sent to your CRM system.

This example demonstrates how multiple data points from a call flow can be combined into a single session. While you could manually create triggers for each scenario, using sessions simplifies the process and allows for more complex and flexible call handling.

Additional Benefits of Sessions

Sessions are also essential for the creation of voice bots and intelligent IVR systems, as they store the necessary information that controls the bot's interactions. In call modules, sessions form the foundation for intelligent routing and decision-making.

By utilizing sessions, you can implement specific logic to achieve targeted outcomes. This includes capturing and leveraging relevant information throughout the call flow to make informed routing decisions, as demonstrated in the example above.

In summary, sessions are critical for developing advanced automation processes. They enable dynamic and contextual interactions that ultimately enhance the caller experience and optimize operational efficiency.