Flow Designer

Flow Designer Resources (Elements)

Workspace: Gray work desk containing the development and elements that make up Lynn's bot solutions and activities.

Toolbar Top toolbar containing essential tools for accessing, creating, and managing Lynn Designer elements.

Functionality in the toolbar

Session Viewer
Lynn Simulator
Report Desktop Editor
Entity Manager
Element Search
Quick Access to Routes
Workspace Element Manager (Layout)
Application Stability Checker
Capture/Save Generator
Capture/Save Importer
Application Element Summary Generator
Cognitive Engine Manager

Designer Properties: Right sidebar containing configuration buttons, allowing the configuration of information flags for design elements, access to the development channel manager (Channel Sandbox), and direct access to Lynn Copilot for manual mode.

Work View (Layout) Manager: The bottom bar consists of tabs that represent each management view or layout. Each user can create and manage layouts, as well as import a copy from another user to structure or modify from a functional development state. Lynn has a base limit of 15 to 20 simultaneous layouts per user, and each of these has a maximum limit of 400 elements.

When creating a layout, the user has access to the editing, deletion, and auto-sorting of the various views of the work desktops, as well as to horizontal and vertical separation.

Note: The limit of simultaneous layouts per user can be extended upon evaluation by our support team.

Design Elements: These are all the elements that make up the design of the solutions within the model: channel, entity, intent, case, and action.

Icon	Process
	Channels: Aggregation interfaces typically represented by an oval with a channel icon. They allow the editing and configuration of channel or interface connection attributes and provide guidance on the connection and environment they are being managed in.Configuration fields
	Intents: An element inherited from the entity and intent model of the cognitive classification model, typically represented by a yellow strip. It represents the action or intention behind an evaluated phrase and also gives rise to the concept of conversation expressed in Lynn's logical aggregation model. The relationships between intents and cases can contain entity conditionals, implying that an intent can have more than one associated case.
	Entities: An element inherited from the entity and intent model of the cognitive classification model. It represents the predicate or context of the intention behind an evaluated phrase and can also be recognized as variables within Lynn's logical model. There are three types of entities in Lynn: System, Global or Session, and Local or Conversational.Configuration fields
	Cases: Typically represented in the element search as a diamond, this element allows the connection and rearrangement of associated actions. They can be used to implement reusable complex structures by enforcing cases. The relationships between cases and actions can contain conditions that validate the execution or non-execution of an action.
	Relations (links): Represented by cables that connect elements within Lynn's designer, these elements can contain conditions that restrict or enable the execution of a particular action. If a relation contains a condition, it will be reflected as a green-colored cable. Details of relationships
	Actions: Actions are how Lynn expresses execution functionalities within the integrator, typically represented in red. They are responsible for performing various types of actions, from routing to chat engines to executing local scripts and making calls to web services in the cloud.
	Special Actions: Special actions do not differ greatly from common actions; their main characteristic is that they are represented in a different color in their element. Currently, only conversation closure and session termination special actions are available.

Consult the documentation for actions and extension modules to learn more about implementing actions in Lynn.

Other Resources in Lynn Designer

This tool, located within the webchat channel element, allows for editing and creation of themes, as well as the ability to retrieve page insertion scripts.

Lynn Channel Management Tool

It is an interface that allows us to select and add channels to Lynn. The service editor is also included as part of the features of this tool. If you want to connect a channel that is not available in the channel configuration management interface, please contact our support team to verify its availability.

Element Deployment Tool between Environments

This tool is embedded in the configuration options of each element and allows the user to add target elements to a list for deployment to other environments, such as the production environment (PaP). This feature also enables individual element deployment and hierarchical deployment of elements to production (Elements already contained in a hierarchy will be highlighted in yellow). See Element Deployment Manager.

The Flow Designer Element Signaling Tool

Within the Link Flow Designer, you will be able to place signage within each channel, entities, and intentions element, allowing you to determine the status of each of these elements. For more details, please refer to Signaling of Flow Designer Elements

Routes

Routes in Lynn are special configurations associated with intentions that specify the behavior of Lynn in defined situations. To configure or define a route, the routing purpose must be specified in an intention. An intention can be the target of multiple routing effects.

The defined routes in Lynn are:

Execute at the beginning when there is no cognitive context.
Execute when an error occurs in cognitive evaluation.
Execute when a client is redirected to Lynn.
Execute when identifying a client for deflection is desired.
Execute when a general error occurs.
Execute when the intention is not configured in Lynn.
Execute at the beginning when the interaction is voice-based.
Execute when there is low confidence in cognitive evaluation.
Intention to be executed in the bot file.

To access the route configurations, you must access the editing of an intention by right-clicking on it and then selecting the option from the dropdown menu Default Routing.

Integrations

Integrations in Lynn are the fundamental basis of the development framework for structures, bots, or automata. Typically, integrations are expressed through Extension Modules, channels, human management routers, and cognitive integrations. All of them are expressed according to their purpose in Lynn's designer. Explore our integration section to learn more about the integrations available in Lynn.

Environment Management

Lynn Designer is available in different environments; however, only the development environment is available for flow editing and creation.

In Lynn's development environment, you can observe elements between environments. The synchronization status of these elements between environments is also represented with labels. An application deployed in multiple environments will display synchronization information and the existing channel elements between environments. This allows editors to design consistent strategies across environments and maintain consistency in manipulating elements and variables.

Yellow environment labels indicate the existence of an element that is not updated in other environments, while a green label denotes that the element is synchronized or updated with the same configuration in both environments.

Configure Tenant

In Lynn's flow designer, when creating a new layout, the user will be able to visualize the representation of the tenant they have logged into, along with its enabled environments and connected channels for the corresponding interaction.

Upon accessing the settings of the element representing the application, it will refer to the existing configuration keys for the tenant. In this window, the user can edit existing configurations or add new ones through the "Add" button.

Name	Description
ENABLE_CREATE_SESSION_HIGH_TMO	Allows authorization to create a session with a timeout greater than 7200 seconds, up to a maximum of 86400 seconds.
ENABLE_AZCS	Enables the functionality to escalate a Kyubo interaction to a video call.
AZCS_ENDPOINT	Specifies the connection string to the service configured in Azure, obtained from the Azure portal.
AZCS_VOICE_CALL_CLIENT_NOTIFICATION_MESSAGE	Defines the notification message to be sent to the client when initiating a voice call.
AZCS_VOICE_CALL_AGENT_NOTIFICATION_MESSAGE	Specifies the notification message to be sent to the Kyubo agent when initiating a voice call.
AZCS_VIDEO_CALL_CLIENT_NOTIFICATION_MESSAGE	Sets the notification message to be sent to the client when initiating a video call.
AZCS_VIDEO_CALL_AGENT_NOTIFICATION_MESSAGE	Defines the notification message to be sent to the Kyubo agent when initiating a video call.
AZCS_SCREEN_SHARE_CLIENT_NOTIFICATION_MESSAGE	Specifies the notification message to be sent to the client when sharing the screen.
AZCS_SCREEN_SHARE_AGENT_NOTIFICATION_MESSAGE	Sets the notification message to be sent to the Kyubo agent when sharing the screen.
API_CONNECT_BASE_URL	Provides the base URL for the connection with Pure Connect.
API_CONNECT_CHAT_SERVICE	Indicates the service associated with the Pure Connect group.
API_CONNECT_CLIENT_ID	Defines the client account ID in Pure Connect.
API_CONNECT_CLIENT_SECRET	Specifies the client account secret key in Pure Connect.
API_LEVENSHTEIN_DISTANCE_THRESHOLD	Sets the threshold for the approximation algorithm for interactions through the API.
BASE_URL	Provides the base URL of the Lynn environment referenced.
BUSINESS_ATTRIBUTES_VALIDATION	Defines the entities to be mapped as user data during a transfer to a Kyubo agent.
CASE_TO_EXECUTE_BEFORE_DELETING_THE_SESSION	Indicates the case to be executed before deleting the session.
CASE_TO_EXECUTE_BEFORE_TIMEOUT_THE_SESSION	Sets the case to be executed before the session times out.
CASE_TO_ALWAYS_EXECUTE_AT_THE_END_OF_INTENTS _ACTION_LISTS	Specifies the case to be executed always at the end of the intent action lists of a conversation.
CHAT_CONVERSATIONID_VARIABLE	Provides the conversation ID for the chat.
CHAT_DYNAMIC_WORKGROUP_VARIABLE	Defines the entity related to the workgroup at the moment of referral to an agent.
CHAT_ENGINE	Indicates the default chat engine (only for backend invocations).
CHAT_URL_DEFLECTION	Provides the deflection URL for the conversation.
DEFLECTION_MESSAGE	Specifies the message to be displayed when performing a deflection.
DEFLECTION_TIMEOUT	Sets the timeout for performing the deflection.
GMS_BASE_URL	Provides the GMS URL for the Pure Engage engine (only for backend invocations).
GMS_CHAT_SERVICE	Indicates the service associated with the Pure Engage GMS group.
GMS_CHAT_TRANSFER_MESSAGE	Defines the message to be displayed when performing a transfer to an agent from Engage.
GMS_ENABLE_ASYNCHRONIC_CHAT	Enables asynchronous chat in GMS Engage.
INTENT_TO_EXECUTE_WHEN_INTERACTION_VOICE	Specifies the intent to be executed when the session starts from a voice channel.
INTENT_TO_EXECUTE_DUE_NON_COGNITIVE_ABILITY	Indicates the intent to be executed in case there is no configured cognitive engine.
INTENT_TO_EXECUTE_ON_COGNITIVE_EVALUATION _ERROR	Defines the intent to be executed when a cognitive evaluation error is detected.
INTENT_TO_EXECUTE_ON_IN_BOT_FILE	Specifies the intent to be executed when a file is received during a conversation with the bot.
INTENT_TO_EXECUTE_ON_DEFLECTION	Indicates the intent to be executed in case of deflection.
INTENT_TO_EXECUTE_ON_DEFLECTION_CLIENT _IDENTIFICATION	Defines the intent to be executed in the identification of the deflected client.
INTENT_TO_EXECUTE_ON_INTENT_NOT_FOUND _ERROR	Sets the intent to be executed in case of intent not found error.
INTENT_TO_EXECUTE_ON_LOW_CONFIDENCE_IN _EVALUATION	Indicates the intent to be executed when there is low confidence in the evaluation.
LOGS_SERVICE	Provides the URL of the logging service.
LOGS_SERVICE_ENABLED	Enables the logging service.
LOGS_SERVICE_INDEX	Specifies the index of the logging service in Kibana.
LOGS_SERVICE_KIBANA	Provides the URL of the logging service in Kibana.
LOGS_SERVICE_KIBANA_DASHBOARD	Defines the logging service for Kibana graphs.
LOGS_SERVICE_KIBANA_PASSWORD	Sets the password for the logging service in Kibana.
LOGS_SERVICE_KIBANA_USER	Specifies the user for the logging service in Kibana.
LOGS_SERVICE_PASSWORD	Defines the password for the logging service.
LOGS_SERVICE_READ	Provides the read URL of the logging service.
LOGS_SERVICE_READ_PASSWORD	Sets the read password for the logging service.
LOGS_SERVICE_READ_USER	Defines the read user for the logging service.
LOGS_SERVICE_USER	Specifies the user for the logging service.
LOGS_SERVICE_VERBOSE	Defines the level of detail for the logs.
LYNN_CHAT_AGENT_CONNECTED_MESSAGE _EXPRESSION	Provides the message displayed when a Kyubo agent connects to the interaction (only for backend invocations).
LYNN_CHAT_BUSSINESS_ATTRIBUTES	Defines the business attributes for Lynn chat.
LYNN_CHAT_CALL_QUALIFICATION_OPTIONS	Specifies the qualification options to be displayed on the Kyubo console at the end of the interaction (only for backend invocations).
LYNN_CHAT_CALL_QUALIFICATION_STATEMENT _EXPRESSION	Defines the qualification statement expression for Lynn chat.
LYNN_CHAT_CLIENT_DISCONECTED_MESSAGE _EXPRESSION	Provides the message displayed when the client disconnects from a Kyubo interaction (only for backend invocations).
LYNN_CHAT_GOODBYE_MESSAGE_EXPRESSION	Sets the message displayed when the interaction with a Kyubo agent ends (only for backend invocations).
LYNN_CHAT_INACTIVITY_TIMEOUT_CLOSE_MESSAGE _EXPRESSION	Defines the inactivity timeout close message for Kyubo interactions (only for backend invocations).
LYNN_CHAT_INACTIVITY_TIMEOUT_CLOSE_SECONDS _EXPRESSION	Specifies the inactivity timeout in seconds for Kyubo interactions (only for backend invocations).
LYNN_CHAT_INACTIVITY_TIMEOUT_WARNING_MESSAGE _EXPRESSION	Provides the inactivity timeout warning message for Kyubo interactions (only for backend invocations).
LYNN_CHAT_INACTIVITY_TIMEOUT_WARNING_SECONDS _EXPRESSION	Sets the inactivity timeout warning time in seconds for Kyubo interactions (only for backend invocations).
LYNN_CHAT_TRANSFER_TO_GROUP_MESSAGE	Defines the message displayed when performing a group transfer in Kyubo (only for backend invocations).
LYNN_CHAT_TRANSFER_TO_SKILL_MESSAGE	Specifies the message displayed when performing a skill transfer in Kyubo (only for backend invocations).
LYNN_CHAT_WELCOME_MESSAGE_EXPRESSION	Provides the welcome message displayed at the start of a conversation in Kyubo (only for backend invocations).
LYNN_CHAT_WORK_GROUP	Defines the workgroup for Kyubo transfers (only for backend invocations).
NEXMO_TOKBOX_API_KEY	Specifies the Nexmo Tokbox API key.
NEXMO_TOKBOX_API_SECRET	Defines the Nexmo Tokbox API secret.
PL_AGENT_NO_ANSWER_TIMEOUT_SECONDS	Sets the timeout in seconds for an agent to respond.
PURE_CLOUD_CHAT_AGENT_CONNECTED_MESSAGE	Provides the message displayed when a PureCloud agent connects to the interaction (only for backend invocations).
PURE_CLOUD_CHAT_TRANSFER_MESSAGE	Defines the message displayed when performing a PureCloud transfer in the interaction (only for backend invocations).
PURE_CLOUD_CLIENT_ID	Specifies the PureCloud client ID (Oauth) (only for backend invocations).
PURE_CLOUD_DEPLOYMENT_ID	Defines the PureCloud deployment ID (Oauth) (only for backend invocations).
UPLOAD_NOT_IN_CHAT_CONVERSATION_ERROR _MESSAGE	Sets the error message displayed if a user attempts to upload a file outside of a chat conversation.
PURE_CONNECT_AGENT_NO_ANSWER_TIMEOUT _SECONDS	Defines the timeout in seconds for a Pure Connect agent to respond.
PURE_CONNECT_BASE_URL	Provides the base URL for the connection with Pure Connect.
PURE_CONNECT_CHAT_AGENT_CONNECTED_MESSAGE	Specifies the message displayed when a Pure Connect agent connects to the interaction (only for backend invocations).
PURE_CONNECT_CHAT_END_REASON_VARIABLE	Defines the variable indicating the reason for ending the Pure Connect session.
PURE_CONNECT_CHAT_TRANSFER_MESSAGE	Provides the message displayed when performing a Pure Connect transfer in the interaction (only for backend invocations).
PURE_CONNECT_INACTIVITY_TIMEOUT_CLOSE _SECONDS	Specifies the inactivity timeout for session closure in Pure Connect.
PURE_CONNECT_INACTIVITY_TIMEOUT_WARNING _SECONDS	Sets the inactivity timeout warning time in Pure Connect.
PURE_CONNECT_STATS_CLIENT_ID	Defines the Pure Connect statistics client ID.
PURE_CONNECT_STATS_SECRET	Provides the Pure Connect statistics client secret.
PURE_CONNECT_STATS_QUEUES	Specifies the Pure Connect statistics queues.
PURE_ENGAGE_CHAT_AGENT_CONNECTED_MESSAGE	Provides the message displayed when a Pure Engage agent connects to the interaction (only for backend invocations).
PURE_ENGAGE_CHAT_END_REASON_VARIABLE	Defines the variable indicating the reason for ending the Pure Engage session.
PURE_ENGAGE_CHAT_TRANSFER_MESSAGE	Sets the message displayed when performing a Pure Engage transfer in the interaction (only for backend invocations).
PURE_ENGAGE_INACTIVITY_TIMEOUT_CLOSE _SECONDS	Specifies the inactivity timeout for session closure in Pure Engage.
PURE_ENGAGE_INACTIVITY_TIMEOUT_WARNING _SECONDS	Defines the inactivity timeout warning time in Pure Engage.
PURE_ENGAGE_VIRTUAL_QUEUE	Provides the Pure Engage virtual queue.
PURE_ENGAGE_STATS_CLIENT_ID	Defines the Pure Engage statistics client ID.
PURE_ENGAGE_STATS_SECRET	Provides the Pure Engage statistics client secret.
PURE_ENGAGE_STATS_QUEUES	Specifies the Pure Engage statistics queues.
PYTHON_DEFAULT_ERROR	Defines the default error message for Python.
SESSION_END_BY_ERROR_INTENT	Indicates the intent to be executed when the session ends due to an error.

Development Channel Management

Development channels are aimed at facilitating design testing between transactional channels. They implement a unique code subscription system where the user selects the channel from the available channels in the development channel tool. From there, they are assisted by a bot in the configuration process.

The currently available channels for management in a development environment are:

WebChat
WhatsApp Gupshup
MS Teams
Skype
Twitter Directs (Blocked)
Telegram
Messenger FB
Messenger Instagram
Voice Lynn

Lynn encompasses the management of dialogues aimed at TTS (Text-to-Speech) playback using the SSML standard. If your development includes voice channel playback, please consider configuring the text in the SSML boxes and take into account the compatibility score described in the Sandbox section of the properties bar.

In special cases, it is possible to request the enablement of a GW for testing purposes in prototype channels, non-conversational channels, or external integrations. For more information, please consult with our sales team.

Flow Debugger (Debug)

The Flow Debugger is a design tool that is also useful in case of troubleshooting errors. Essentially, it allows us to explore a session by stepping through Lynn's execution actions and entity manipulations. Error messages or associated alerts generated at runtime can be viewed in the activity panel. Refer to the section on how to work with the Flow Debugger for more information.

Sessions that are being debugged will be notified of this state, and proactive notifications will also be sent to subscribed application administrators to notify them of the start of the debugging activity.

Correspondence of Logical Elements with the Development Model

The flow development model in Lynn is inspired by the cognitive phrase evaluation model commonly known as the entity-intent model, which many cognitive engines adhere to. In this model, the intent represents the action or intention of the phrase, and the entities represent the predicate, context, or subject on which these actions are performed. Lynn implements this model by adding some elements to expand its functional purpose, with recognizable elements in Lynn encompassing message reception and action execution based on their manipulation.

The recognizable elements in the development model, which are also explicitly present in Lynn's design model, include channels, intents, entities, cases, and actions.

Types of Developments

Based on the capabilities of a flow, they can be categorized into the following types:

Linear Flows

These flows recreate the behavior of a visual IVR (Interactive Voice Response), defining an intent that is executed when there is no connection to a cognitive engine. They guide the user through menus and inputs that represent the desired self-service experience.

Cognitive Flows

These flows fully implement cognitive capabilities by connecting one or more trained cognitive engines under a model that represents or corresponds to the attention model desired for self-service. This type of development allows the creation of complete conversational experiences that can evolve and improve through continuous enhancement and analytics data provided by Lynn regarding intents. Additionally, other compatible cognitive resources such as OpenAI, QnA Maker, and other compatible resources can be implemented in the design.

Hybrid Flows

Hybrid flows combine the guided experience of a linear flow with the ability to also support structured cognitive queries. Typically, an initialization intent is used to greet the user, present some self-service resources, and then transition to more generic conversational spaces where cases are handled cognitively.

Best Practices for Lynn Flow Developer

Consider the following suggestions as best practices for design:

Consider channel analysis in the design of automation proposals.
Use work visualizations or layouts to organize functionalities or sets of functionalities into more manageable views that are easy to audit.
Use simulation and debugging tools during testing and design.
Segment and reuse functionalities by using cases as subroutines.
Document and use a development naming convention to classify elements, facilitating search and quick understanding of the design components.
Configure business notifications to keep editors and administrators informed of application changes.
Use the application checker to identify potential application errors.
Remember to save code backups before progressing changes between environments.
Manage users with access to the Channel Sandbox tool.
Configure SSML messages similar to those intended for chat, as this can save time during voice testing.
Verify conditions that may generate recursive cycles and limit their triggering to a maximum of 5 levels.
When using CodeBlock to execute JavaScript (JS) code, avoid delegating extensive code blocks to a single action. This is primarily to prevent memory overload, which can affect runtime performance.
When transferring elements from one environment to another, ensure that the intentions referenced forcefully in an action or case exist in the production context so that the correspondence exists in both environments. The same concept applies to entities that handle lists or special values, which must be declared in advance before progressing the flow between environments.
When working with intentions that invoke themselves as part of a menu reset or similar operation, consider removing memory variables. + Otherwise, Lynn will assume that new values should not be requested for those entities.
Enable reports as a final step in the development of your flow. Check reports and survey tables to fine-tune any presentation or measurement details before going into production.
Remember that you can generate user marks anywhere in the flow. With these, you can establish breadcrumb metrics to generate indicators or classify functional branches.

Dialogue Manipulation

Dialogue manipulation in Lynn is a natural process of the message orchestrator, where all logical aspects and hierarchies within Lynn's communication model are structured and considered. Dialogue manipulation refers to all processes that encompass the handling of dialogues from their arrival in Lynn until their closure in memory.

Primarily, dialogue manipulation consists of:

Data ingestion stage Channel concentrators, connectors, gateways, service bus, messaging APIs.

Dialogue processing stage Resources dedicated to managing the message containing dialogues, involving cognitive engines, approximation algorithms, advanced dialogue processing languages, analysis and event generation, among others.

Logging stage When enabled, dialogue logs, events, custom indicators, and other various resources are generated to support a reporting model.

Dialogue Input and Output

Dialogues are managed across various channels using the following basic structures:

Input Dialogues: These are primarily generated by users interacting through a channel. An initial dialogue is referred to as "userStartMessage," which triggers a chain of events in Lynn, starting with the identification of Criteria-CriteriaValue pairs that identify a user and immediately generate a Session ID, which fully identifies a session in Lynn's memory.

Simple Input Request: It is a data request message generated by Lynn, proposing a data query dialogue and expecting a user-assigned response. In this condition, Lynn will be in an "AwaitingTextMessage" state to assign a value to an entity.

Menu Input Request: It is a data request message generated by Lynn, proposing a data query dialogue and presenting options as a menu. It expects the user to select, press, or identify a valid option as a response. In this condition, Lynn will be in an "AwaitingMenuMessage" state to assign a value to an entity.

Media Dialogue: In this transaction, Lynn can identify an incoming media message or send a previously loaded media message. It is a transaction that does not qualify for cognitive manipulation within the message orchestrator.