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.

Workspace Manager (Layouts): Bottom bar composed of tabs representing each management view or layout, the manager allows the aggregation, editing, deletion, and auto-sorting of different views of workspaces.

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

Name/Description	Value
CASE_TO_EXECUTE_BEFORE_DELETING_THE_SESSION: Case to execute before deleting the session	Dropdown list with cases created in the Lynn application to execute
CASE_TO_EXECUTE_BEFORE_TIMEOUT_THE_SESSION: Case to execute before the session timeout	Dropdown list with cases created in the Lynn application to execute
CASE_TO_ALWAYS_EXECUTE_AT_THE_END_OF_INTENTS_ACTION_LISTS: Case to always execute at the end of the execution of conversation actions	Dropdown list with cases created in the Lynn application to execute
CHAT_ENGINE: Default Chat Engine (only for invocations from the backend)	Dropdown list containing chat engines created in the Lynn application
INTENT_TO_EXECUTE_WHEN_INTERACTION_VOICE: Intent to execute when the session is initiated from a voice channel	Dropdown list containing intents created in the Lynn application
INTENT_TO_EXECUTE_ON_IN_BOT_FILE: Intent to execute when a file is received while the conversation is established with the Bot	Dropdown list containing intents created in the Lynn application
INTENT_TO_EXECUTE_ON_LOW_CONFIDENCE_IN_EVALUATION: Intent to execute with low confidence in evaluation	Dropdown list containing intents created in the Lynn application
TWITTER_TIMEOUT_SECONDS: Session duration on Twitter channel	Configuration of minimum and maximum duration time for the session
WHATSAPP_TIMEOUT_SECONDS: Session duration on WhatsApp	Configuration of minimum and maximum duration time for the session
PURE_CONNECT_PASSWORD: PureConnect password	Encrypted field allowing entry of PureConnect password
TIMEZONE: Tenant UTM Timezone (Example: -4)	Dropdown list with timezone options (Example: (GMT -3:00) Brazil, Santiago, Buenos Aires)
EMAIL_BEHAVIOR_INACTIVITY_TIMEOUT: Inactivity time for email interactions	Configuration of minimum and maximum time corresponding to inactivity settings
DIALOGUES_OF_THE_DAY: Set to True to enable the widget to display historical dialogues from previous conversations in the webchat

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.