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
WebChat Theme Customization Tool (Widget)
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
Flow Designer Signage Tool
| Icon | Name | Detail |
|---|---|---|
 |
Simulator | Button allowing access to Lynn's embedded chat simulation. |
 |
Graphs | Button displaying a list of pre-existing graphical dashboards; configuration button available to manage the graphics. |
 |
Entities | Button displaying the prompt for selecting existing entities. |
 |
Elements | Button displaying the prompt for visualization or search of elements within the active layout. |
 |
Default Routing | Button allowing visualization of configured routes in Lynn. |
 |
Elements Outside My Layout | Button allowing viewing of all elements not added in the current layout, indicated by a number on the right side of the icon. |
 |
Tenant Validation | Button showing controls to generate an error status report. |
 |
Download Snapshot | Button allowing local download of an image or snapshot of the current flow. |
 |
Upload Snapshot | Button displaying a window with controls for the flow restoration process. |
 |
Download Tenant Summary | Button initiating the download process for an application summary, generating a zip file and sending a successful notification upon correct download. |
 |
Campaign | Button allowing visualization of proactive management tools. |
 |
General Connections | Button to Display a Window with Details of Existing General Connections or Create New Ones |
 |
Cognitive Context Evaluator | Button allowing visualization of the active cognitive engine; when pressed, grants access to the cognitive engine manager. |
 |
Environment Switch | Button allowing the switch between Testing-Production environments. |
 |
Home | Button allowing return to the initial page where the user can view the tenants accessible within the Lynn application. |
 |
Users | Displays a list of users with a table showing name and description. |
 |
API Security | Displays a table listing API credentials. |
 |
Service Status | Displays a table detailing service, update date, status, description. |
 |
Profile | Button displaying information about the profile used to access the Lynn application; allows profile modification and session logout. |
 |
Language | Button allowing language selection (PT, ES, EN, HI) for viewing Lynn's designer. The interface updates text automatically. |
 |
Notifications | Button displaying notifications for processes performed within Lynn. |
 |
Properties | Button displaying elements: Properties and associated checkbox controls for element visualization, Channel Sandbox and checkboxes for user enablement and registration, Text Channels and definition of code for enrolling new users, Voice Channels and code definition for enrolling new users, Registered Users and a list of current contacts. |
 |
Lynn Copilot | Button displaying a chat presenting interaction with the Copilot assistant included in Lynn; the assistant guides the conversation and displays available action options, enabling chat controls for user interaction when required. |
 |
Division Selector | Button allowing selection of a billable division among those configured for this application; by default, at least 1 billable division must exist. |
 |
Time Zone Viewer | Displays the current time and time zone configured within the Lynn application. |
You can access more details about actions within the flow designer. The link will allow you to locate signage within each element (channel, entities, intentions) that will help you understand the status of each of these elements. For more details, please see Signage 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.