Skip to content
Log in (opens in a new tab) Start for free (opens in a new tab) Book a demo (opens in a new tab)

Playground

Contents

https://app.supportfast.ai/playground/

The Playground is the section dedicated to customizing the behavior of your chatbot’s Artificial Intelligence. From here, you can modify your chatbot’s instructions, as well as create operational flows to manage specific tasks.

Graph Structure

Supportfast.ai uses a graph-based structure for building and managing chatbots. This allows you to organize operational flows in a visual and intuitive way, making it easier to design, edit, and optimize your chatbot.

The graph structure is made up of two types of elements:

  • Nodes: These represent the operational blocks of the graph — the points where practical actions take place. Each node corresponds to an action within the chatbot’s flows.
  • Edges: Edges are the connections between nodes and define the operational paths, determining the transition from one node to another.

What are Nodes

Nodes represent the operational blocks of the graph — the points where practical actions take place. Each node corresponds to an action within the chatbot’s flows.

The START Node: This is the starting point for all messages received by the chatbot. The START node represents the core of your chatbot — it contains the basic instructions and the Knowledge Base used to answer user questions. Each time the chatbot receives a new message, the START node decides whether to reply using the Knowledge Base or to activate one of the available Tools to handle specific tasks.

The Tool Node: Tool nodes are used to extend the capabilities of your chatbot. Each Tool consists of a description that tells the chatbot what the Tool does and when to use it, and it is connected to the START node via an edge. The chatbot can autonomously decide, based on the provided instructions and the ongoing conversation, how many and which Tools to use to respond to the user’s question or request.

Final and Non-Final Nodes: In the graph structure of Supportfast.ai, nodes are categorized as:

  • Final Nodes: These conclude the operational flow of the current Tool, handing control back to the AI agent (START node).
  • Non-Final Nodes: These represent intermediate actions. They can store variables ({{var}}) to be used in subsequent steps and must be connected to a following node to ensure the flow continues.

Node Operational Flow: An operational flow is a sequence of actions starting from a Tool node and moving through the graph via the connecting edges, eventually reaching a final node that ends the execution of that flow.

All Available Nodes: Below is a list of all available nodes, with references to their specific configuration documentation:

  • START
  • TOOL
  • PROMPT
  • API
  • FORM
  • LIVE CHAT
  • BUTTON
  • MESSAGE

What are Edges

Edges represent the connections between two nodes within the Supportfast.ai graph. Each edge defines a logical and operational transition from one node to another, determining the sequence of actions that the chatbot must execute.

How Edges Work

Edges function like arrows that indicate the direction of the operational flow: they start from one node and point to the next. This allows the chatbot to carry out a well-ordered series of operations.

In the Supportfast.ai graph, two fundamental rules apply to edges:

  • Only one edge can depart from a node: each node can be connected to only one subsequent node, ensuring a clear and unambiguous flow.
  • Only one edge can arrive at a node: each node can receive input from only one preceding node, maintaining a linear sequence in the path.

Special Edges for Tools

A special case involves the edges connecting the START node to TOOL nodes. These edges do not represent an automatic execution flow, but rather conditional instructions that the chatbot’s AI may activate based on the conversation.

In this case, the behavior is as follows:

  • The AI agent receives a message from the user.
  • The START node analyzes the message and, based on the instructions and the Knowledge Base, evaluates whether it can respond directly or if it needs to use a Tool.
  • If one or more Tools are relevant, the AI activates the corresponding edges departing from the START node.
  • Once a Tool is activated, all nodes connected to that Tool via standard edges are executed in order, following the structure of the graph until a final node is reached.

In Summary:

  • Edges determine the direction and sequence of operations.
  • Each node can have only one outgoing edge and only one incoming edge.
  • Edges from START to TOOL are dynamically chosen by the AI based on the conversation.
  • Edges between nodes within a Tool define the sequential execution of the operational flow.

Variables

Supportfast.ai chatbots are designed to handle dynamic values, known as Variables, within operational flows. These values can include:

  • information collected during the conversation with the user
  • results from API calls made by the chatbot
  • data submitted via contact forms
  • data from a user registered on your website/platform

Variables allow you to store and reuse data in a flexible and personalized way, making the chatbot’s behavior adaptive to the context.

How to use Variables

To use a variable inside messages, prompts, API parameters, or other nodes, simply enclose its name in double curly braces, for example**: {{variable name}}.**
Variables can be used in any node or Prompt of your chatbot.

Where to view Variables

In the Playground, at the top left, there is a “Variables” button. Clicking it opens a sidebar where all Variables currently declared in your chatbot are displayed.

Variables are divided into 3 types:

  • Global: default system-provided variables
  • User: variables associated with the user interacting with the chatbot
  • Tool: variables defined and used within various tools of your chatbot

Global Variables

The Supportfast.ai system provides two predefined variables:

  • {{today}}: contains the current date and time.
  • {{scope}}: identifies the active scope of the chatbot.

Global Variables are automatically provided by the system and cannot be modified.

User Variables

User Variables are data points associated with the person using the chatbot. You can use this data to identify the user when they are registered on your website or platform, and also to pass along any other useful data for use in the Playground.

User Variables use the prefix “user”, for example**: {{user.variable name}}.**

There are three predefined user variables:

  • email: The user’s email address, displayed in Statistics.
  • phone: The user’s phone number, displayed in Statistics.
  • fullName: The user’s full name, displayed in Statistics.

In addition to the default variables, you can create custom variables by adding a name and description, as well as a possible default value that will be assigned to the user at the beginning of the conversation.

Note: Data from Contact Forms is automatically inserted into the Conversation’s user object, populating the standard fields email, phone, and fullName.

Tool Variables

In the Tool section of the Variables panel, you can view the list of tools you have created for the chatbot, and for each tool, you can see the variables defined within its flow. You can create additional variables in the Tool configuration. Some nodes, like the API node, automatically become variables that can be used in subsequent nodes.

Example Tool 1:

Imagine you want to create a Tool to handle restaurant reservations. You define the following variables within the Tool:

  • name: the user’s name
  • people: number of people
  • date: reservation date
  • time: requested time

Once these values are collected, you can use them in the following nodes. For example, in an API node that sends the reservation to a booking system.

Example Tool 2:

Imagine you want to create a tool to get the weather forecast. If you use an API node called get weather, the result of the call will automatically be saved in the variable {{get weather}}. You can then use it in a following Prompt node to generate a dynamic response based on the weather data retrieved from the API.

Save and Publish

For each chatbot, the Playground manages two distinct versions of the graph:

  • Private Version: This is your working environment where you can make changes and test new configurations without affecting real users. This version opens by default when you access the Playground.
  • Public Version: This is the official version of the chatbot currently used to respond to messages from users through external channels (website chatbot, WhatsApp, integrations, etc.).

When working in the Playground, you are editing the private version of your chatbot. Any changes you make are saved only in this version and do not affect the public version until you decide to publish them.

After making changes, you can save the graph to preserve your progress and continue with internal conversation testing. Once you’re satisfied with the changes, you can publish the chatbot to make those updates effective for all real users.

Live Mode: By entering Live Mode, you can view the public version of your chatbot. In Live Mode, modifications are not allowed, but you can view all existing nodes and their configurations. You can also run internal tests directly on the public chatbot.

Conversation Testing

In the Playground, you can test your chatbot’s behavior in both the test version and the published version. Select Live Mode if you want to chat with the public version of the chatbot, or save your changes and fix any configuration errors to test the private (draft) version instead.

To start a test conversation, click the “Run” button in the top-right corner. All interactions carried out in the Playground will be logged in the Statistics section with the label “Playground”.

Note: In the Playground chat, the initial contact Form is not displayed, even if it is enabled in the Settings page. This allows you to test the chatbot without having to fill out the form for each new conversation.

Error Management

While editing your chatbot in the Playground, you’ll see an error button appear in the page header whenever there are issues in the graph. An “error” refers to an incorrect or incomplete configuration in one or more nodes within the Playground, preventing you from using or publishing your chatbot.

There are two types of errors that may appear:

  • Configuration Errors: These are related to the nodes you’ve added to your chatbot. They indicate the presence of nodes with incorrect or missing settings. You won’t be able to send messages to the chatbot until these errors are resolved.
  • Subscription Errors: These relate to subscription limits that have been exceeded for the chatbot, or to the lack of a valid OpenAI API key. You can still run conversation tests, but you won’t be able to publish your chatbot until these issues are fixed.

Configuration Errors

If configuration errors are present, a red error icon will appear. Since there are incorrect or missing configurations, testing the chatbot is disabled — these issues could affect the proper functioning of the bot.
You can choose to save a chatbot with configuration errors, preserving your current setup in the internal test graph and returning later to complete it.

In the error sidebar, you can browse the list of configuration issues, grouped by node. Clicking on an error will open the specific node and section where the issue can be resolved.

Subscription Errors

If only subscription-related errors are present, they’ll be indicated by an orange error icon. In this case, you can still run internal chatbot tests, but since your setup exceeds the limits of your subscription, you won’t be able to publish the chatbot for end users.

Subscription errors fall into two categories:

  • Tool limit exceeded: You’re using more Tools than your subscription allows per chatbot.
  • OpenAI API key usage: By using your own OpenAI key, you can choose the AI model and set the number of previous messages the chatbot considers. If no key is provided, the chatbot defaults to the “gpt-4o-mini” model with a memory limit of 5 previous messages.

START NODE

The START node is the entry point for all messages received by the chatbot. This node represents the core of the chatbot, as it defines the basic instructions and how user requests are handled.

Each time the chatbot receives a new message, the START node decides whether to respond using the Knowledge Base or to trigger one or more available Tools to handle specific operations.

Within the START node, four main settings can be configured.

1) PROMPT

The Prompt is the set of instructions that defines your chatbot’s behavior, establishing its role, tone of voice, and area of expertise. Within the Prompt, you can also specify targeted behaviors, such as:

  • Suggesting a goal for the chatbot, such as lead profiling.
  • Providing specific instructions on how to use the Tools.
  • Defining the tone of voice to ensure consistency in communication.
  • And much more, customizing the chatbot based on your business needs.

A well-structured Prompt helps the chatbot correctly interpret user questions and respond in the most appropriate way. For more details on how to write an effective Prompt, refer to the dedicated Prompt guide.

2) SCOPE

The chatbot’s scope is a sentence that describes the activity and area of expertise for which the chatbot has been designed. This field provides the model with clear context regarding its role and the topics it should cover.

The scope is automatically set during the chatbot creation process, based on the information provided, but it can be modified at any time.

Within your custom Prompts, you can use the variable {{scope}} to reference the scope value. This ensures your chatbot is always aware of its task and can generate more coherent and targeted responses.

3) AI MODEL

The AI model is the artificial intelligence engine that powers your chatbot.

Supportfast.ai offers several AI models to choose from. The default model is gpt-4o-mini. To use more advanced models, you need to connect your own OpenAI key. Learn how by consulting the OpenAI API Key guide.

Choosing the right model depends on your performance needs and associated costs. Using advanced models like GPT-4o or higher provides more accurate responses and deeper reasoning, but comes with higher API usage costs.

4) NUMBER OF MESSAGES

The number of previous messages indicates how many past interactions the chatbot considers when generating a response to a new user message. The available range is from 5 to 30 messages:

  • 5 messages: Lower token consumption, ideal for chatbots that provide short, independent answers and do not require prior context.
  • 30 messages: Higher consistency in conversation context, but at a higher cost due to increased token usage.

A higher number of messages helps the chatbot maintain conversation context and remember any information previously gathered from the user. However, it also increases AI token consumption. The choice depends on the balance between contextual accuracy and cost optimization.

5) TOOL SELECTION

With this option, you can customize how your chatbot triggers tools before responding to messages. Several options are available:

  • Auto: gives your chatbot full autonomy to decide when and how many tools to use, based on the instructions and the conversation with the user
  • None: prevents your chatbot from using any tools. In this case, the chatbot will respond only based on the Prompt instructions.
  • Required: makes it mandatory to use at least one tool before replying to the user.
  • Knowledge Base: a special Supportfast value that forces the chatbot to use at least the Knowledge Base tool before replying to the user, if no other specialized tools are available.

TOOL NODE

The Tool node is used to expand your chatbot’s capabilities. Each Tool consists of a description that tells the chatbot what the Tool does and when to use it. It is connected to the START node via an arc. Based on the instructions provided and the user’s conversation, the chatbot will be able to autonomously understand how many and which tools to use in order to respond to the user’s new question or request.

Let’s now look at the different configuration options.

1) Node Name

Assign a recognizable name to your Node. The name of the Tool node is very important to ensure your chatbot doesn’t get confused. It is recommended to assign names that are simple yet clearly explain the Tool’s purpose. Some example names include:

  • Book Restaurant
  • Activate Live Chat
  • Quote Generator
  • Order Status

2) When to Use the Tool

Enter a short description to explain to the chatbot what this Tool is for and when it should be used, with a limit of 1000 characters. If you need to provide a more detailed explanation of the Tool, you can do so by adding instructions in the Prompt of the START node.

3) Variabiles

Variables are dynamic pieces of information that the chatbot collects during the conversation when using a Tool. This information can be gathered implicitly through reasoning or explicitly by directly asking the user. Once collected, variables can be used in subsequent nodes to insert dynamic values into the operational flow.

Examples of variable collection:

  • Explicit: A Tool for checking the weather requires the “city” parameter. If the user asks for the weather, the chatbot will first ask which city they are in before calling the Tool.
  • Implicit: If a user says, “Tomorrow I have a flight to London, what will the weather be like?”, the chatbot can automatically recognize “London” as the city and “tomorrow” as the date, using this data without needing to ask for it directly.

To configure variables, you need to define a few essential parameters:

  • Name: Choose a simple and intuitive name.
  • Description: Provide a short explanation to help the chatbot understand how to populate the variable.
  • Select the Variable Type from the available options.

Available data types include:

  • Number: Can be an integer or decimal. The chatbot can infer the type of number from context, but you can specify it in the description.
  • String: Any textual value, with no limitations.
  • Boolean: A true or false
  • Date: A calendar date, with or without a specific time. The chatbot can decide whether to include the time automatically, though you can also specify it in the description.
  • Enum: A predefined list of string values from which the chatbot selects the most appropriate one based on the conversation.
  • List: A list of strings that gathers multiple values into a single variable.

Using Enum

The Enum variable type allows you to predefine a set of string values from which the chatbot will select the correct one based on the conversation. If you are using Enum with complex values, it’s helpful to include instructions in the Prompt to guide the chatbot in assigning the correct values.

Example: If you want to collect the user’s gender and store it as “M” or “F”, you can create an Enum with these two values. The chatbot will automatically associate terms like “male”, “man”, “female”, “woman”, and related variations with the corresponding values “M” or “F”.

Using List

The List variable type is useful when the chatbot needs to collect multiple similar values within a single variable. For example, if the user lists several items in a response, the chatbot can store them in a structured list.

To configure the list, you need to enter:

  • List Description: Explain to the chatbot what kind of elements to collect and how many.
  • Element Description: Provide a general description to clarify what values the list will contain.

Example: Suppose you want to ask the user which cities they would like to visit. If the user says:
“I’d like to travel to Rome, Paris, and London.” then the chatbot will collect these values in the variable: [“Rome”, “Paris”, “London”]

List Description: the list of cities the user wants to visit.
Element Description: the name of one of the cities the user intends to visit.

PROMPT NODE

The Prompt node is used to execute an AI prompt independently from the rest of the chatbot. This node takes in the user’s conversation and any variables, generates a response based on a custom prompt, and returns the result to the user as a message.

Some examples of how the Prompt node can be used include:

  • A quote generator embedded in the chatbot.
  • Responding with a specific result retrieved from an API.
  • Generating a custom summary of user inputs.

To insert a Prompt node, you must first create and configure the Tool for this flow and then connect it to the Prompt node via an arc. The Prompt node is a final node, which means it ends the current Tool flow and can be placed after other non-final nodes.

Let’s now look at the different settings available in the Prompt node.

1) Node Name

Assign a recognizable name to the node. The name does not affect AI behavior; it is only used to distinguish this node from others in the flow configuration.

2) Prompt

The Prompt is the set of instructions that guides the behavior of the AI executed within this node. It defines how the chatbot interprets the user’s request and generates a response. To make this node work correctly, you must write a proper Prompt that fits your use case. For guidance on writing an effective prompt, refer to the dedicated Prompt guide.

3) AI Model

The AI model is the artificial intelligence engine that generates the chatbot’s responses.

Supportfast.ai offers several AI models to choose from. The default model is gpt-4o-mini, but you can use more advanced models like GPT-4o and higher by connecting your own OpenAI API key. Learn how by checking the OpenAI API Key guide.

Choosing the right model depends on your performance needs and cost considerations. Advanced models like GPT-4o and above provide more accurate answers and deeper reasoning, but with higher API usage costs.

4) Number of Messages

The number of previous messages refers to how many past interactions the chatbot considers when generating a response to a new user message. The available range is from 5 to 30 messages:

  • 5 messages: Lower token consumption, ideal for chatbots with short, independent responses that don’t require past context.
  • 30 messages: Greater coherence in conversation context, but with a higher cost due to more tokens being processed.

A higher message count allows the chatbot to better maintain context and remember previously collected user information, but also increases token usage. The choice depends on balancing contextual accuracy with cost optimization.

API NODE

The API node is used to perform an API call to an external software system. This allows the chatbot to read from or send data to other systems, enabling dynamic integration.

Supportfast chatbots can connect to any software that provides REST APIs—interfaces that allow programs to communicate with each other over the internet. REST APIs use the JSON format to exchange information, a standard that is both human-readable and machine-readable.

Some examples of how the API node can be used include:

  • Sending lead data to a CRM or business management system.
  • Retrieving the status of an order from an e-commerce website.
  • Managing an appointment calendar by checking availability and booking open time slots.

To insert an API node, you must first create and configure the Tool for this flow and then connect it to the API node via an edge. The API node is a non-final node, meaning you must draw two additional arcs from it: One for a Successful API call, One for a Failed API call.

Definition of a REST API

A REST API (Representational State Transfer) is a standard way for two systems to communicate over the web. It works through HTTP calls—just like when we browse a website—but instead of displaying a web page, the system sends or receives data.

For example, a chatbot might ask an e-commerce site for the status of order number 12345. The site would respond with a JSON-formatted message, such as:

{“order_id”: 12345, status”: “spedito”}

Let’s now look at the different settings available in the API node.

1) API TAB

The API tab is where you enter the details for the API call settings, such as the method, parameters, and data to be sent.

Node Name: Assign a recognizable name to the node. The name does not affect AI behavior, but is used to distinguish this node from others in the flow configuration.

API Call: Set the type of HTTP request (GET, PUT, POST, DELETE) and the API URL. Only enter the base URL here—do not include additional parameters or dynamic data, as these will be configured in the dedicated fields.

Parameters: If the API call requires query parameters, you can add them in this section. Parameters are additional pieces of information sent in the URL after the “?” symbol.
Example: To call the API https://example.com/user/?name=test, set the base URL as https://example.com/user/ and add the parameter:

  • Key: name
  • Value: test

Headers: Headers are additional pieces of information sent along with the API request, such as to authenticate the user or specify the data format. You can add them by providing a Key and a Value.
Common header examples:

  • Authorization: used to send an access token (e.g., Bearer abc123).
  • Content-Type: indicates the format of the data being sent, which in our case should always be application/json.

Body: The body is the content of the API request and must be in JSON format. This is where you can insert the data that will be sent to the external system.

2) RESPONSE TESTING

In this tab, you can test your API call to verify that it works correctly and to obtain a sample response. The data received from the API call can then be used in subsequent nodes to create dynamic responses in the chatbot. For example, if the API returns the status of an order, the chatbot can use that value in a following node to return the order information to the user.

You have two options for completing this tab:

  • Live Response: simulates a real-time API call.
  • Sample Response: allows you to paste a sample JSON response from the API call.

Live Response: To simulate a real API call, the first step is to insert test values into the variables used in the API request. For example, if the API URL is configured with a dynamic parameter like https://example.com/order/{{order_id}}, you will need to enter an actual value for the {{order_id}} variable before running the test.

If the API call doesn’t use any variables, this section will not appear and you can proceed directly to the test. Once ready, click “Run Test”: the system will send the request and display the received JSON response.

Sample Response: If you don’t want to perform a real API call, you can manually paste a sample JSON into the designated field. The system will automatically check that the JSON is valid before saving it.

3) DATA ACCESS

In this tab, you can define which and how many pieces of data from the API response should be saved for use in later interactions. To access this tab, you must first complete the API test in the previous section.

You have two options for completing this tab:

  • Full Access: saves the entire API response JSON into a single variable, making all data available for the following steps.
  • Restricted Access: allows you to select only specific fields from the API response JSON. The saved variable will include only the selected data, excluding everything else.

In the case of Restricted Access, you will need to choose from a displayed table which values to keep from the API response JSON. Selecting at least one value is mandatory. This helps to hide any keys or codes that you do not want to expose to the AI in subsequent steps.

You will be shown a table listing all fields in the received JSON. From here, you can select:

  • Individual fields: pick only the necessary information and ignore the rest.
  • Entire objects: if you select all fields within an object, the full object will be saved.
  • List elements: you can select the entire list or individual elements within a list.

FORM NODE

The Form node is used to insert a contact form into the chat that users can fill out with their personal information. The data submitted by users through the form will be visible in the Statistics section.

Let’s take a closer look at how the Form flow works:

  • First, you need to create a Tool and write its description. For example: “Trigger this tool when the user agrees to be contacted by our sales team.”
  • Then, create and configure the Form node, and connect it to the relevant Tool using an edge.
  • When the user expresses the desire to be contacted (or the chatbot persuades them to do so), the Tool calls the Form node, which will display the form as the last message in the chat.
  • The user can then fill out and submit the Form, or continue chatting with the bot. The Form will remain visible in the chat even while the user keeps interacting with the chatbot.

When the user decides to fill out and submit the Form, the chatbot receives the submitted data and resumes the flow starting from the Form node, then continues executing the nodes connected to it. The chatbot will ignore all other tools and instructions, focusing solely on executing the flow related to the submitted Form.

The Form node is not a final node, so it requires other nodes after it to complete the flow. The data submitted by the user will be saved in a variable that can be used in the next steps, for example, to send the information to a CRM via API.

Let’s now look in detail at the settings of the Form node.

Node Name: Assign a recognizable name to the node. The name does not affect the AI’s behavior but is useful for distinguishing this node from others in the flow configuration.

Description: Enter a descriptive text to explain the purpose of this Form to the chatbot. The chatbot will use this information to understand the context and explain to the user why they should complete this contact form.

Form Fields: Enable the fields you want to include in the contact form. At least one field must be selected for the Form to function properly. All enabled fields will always be mandatory for the user.

Form Result: After the user fills out a Contact Form from your chatbot, the data entered in the form will automatically be applied to the user’s data from the Conversation.

Note: Currently, the available fields are: Email, Full Name, Phone Number. Custom fields will soon be available, allowing you to tailor Forms to your specific needs.

LIVE CHAT NODE

The Live Chat node is used to request the intervention of a human agent. It is a final node, meaning it interrupts the current Tool flow and places the conversation in a “waiting for operator” state. When triggered, the chatbot responds to the user with a custom message.

The Live Chat node can be combined with other nodes to define the conditions for accessing human support. Some examples include:

  • Based on date and time: You can use the variable {{today}} in the START node’s Prompt to allow the chatbot to recognize the current date and time. This way, it can manage access to Live Chat only on the days and at the times when human support is available.
  • Subscription verification: Before activating Live Chat, the chatbot can make an API call to check the user’s plan. If the user has a PRO plan, access to Live Chat is granted; otherwise, the flow is redirected to another node that will respond to the user.
  • Contact form: You can require the user to fill out a form before being connected to a human agent.

You can also instruct the chatbot to prioritize solving the issue by trying to help the user before activating Live Chat. To do this, customize the START node’s Prompt so the AI attempts to respond autonomously before escalating to a human.

What happens when the chatbot activates Live Chat?

  • The user is placed in a queue for a human agent, but can continue asking the chatbot questions, which will keep responding as usual.
  • Email notification (if enabled): If the option is activated in the settings, an email alert will be sent. If the user filled out a contact Form before the Live Chat, the submitted data will be included in the notification email.
  • Managed from the Statistics area: A human agent can take control of the conversation from the chatbot’s Statistics section. From that moment on, the chatbot will stop responding, and the conversation will be managed exclusively by the agent.

Let’s now look at the details of the Live Chat node configuration.

Node Name: Assign a recognizable name to the node. The name does not affect the AI’s behavior but is useful for distinguishing this node from others in the flow setup.

Message Content: Enter the instructions for the chatbot, specifying what it should say to the user after Live Chat has been triggered. Typically, this message informs the user that a human agent will join shortly, and that they can continue interacting with the chatbot in the meantime.

BUTTON NODE

The Button node is used to insert a clickable button into the chat that links to an external URL. This can be useful for directing the user to a specific page on your website, such as a detailed article or a contact form.

The Button node is not a final node. After it, you must connect another node that explains the presence of the button and provides a suitable response to the user.

Let’s take a closer look at how the Button flow works:

  • First, you need to create a Tool and write its description. For example: “Trigger this tool when the user asks about the pricing of our services.”
  • Next, create the button and connect it to the Tool. Fill in the Button node settings by entering the button’s text and URL.
  • Finally, define the ending node of the current flow, as explained below.

As for the next node after the Button, you have two options:

  • Message Node: Add a Message node to give simple instructions to the chatbot, which will explain the presence of the button to the user.
  • Prompt Node: If you want to customize the chatbot’s response, insert a Prompt that handles this case. In the pricing example above, you could insert a Prompt with some pricing information and direct the user to click the button.

Remember: the chatbot must be aware of the Button’s presence in the chat. To ensure this, include a clear reference to the Button and its purpose in the Prompt or Message.

How does the Button appear in the chat?
The Button is displayed directly below the message generated by the chatbot. The user can read the message and, if interested, click the Button to visit the external link.

Let’s now look at the details of the Button node configuration.

Node Name: Assign a recognizable name to the node. The name does not affect the AI’s behavior but is useful for distinguishing this node from others in the flow setup.

Language: You can customize the button text and URL based on the user’s language. Languages can be enabled from the Settings tab.

Button Text: For each enabled language, enter the text that will appear on the button. It’s recommended to use short yet descriptive texts.

Button Link: For each enabled language, enter the URL the button should link to. Make sure the link corresponds to the user’s language, if your website supports multilingual pages.

MESSAGE NODE

The Message node is a final node that concludes the current Tool flow by providing the chatbot with simple instructions on how to continue the conversation with the user.

You can think of it as a mini-prompt designed to inform the chatbot about what happened during the flow triggered by the Tool. This way, the AI will have context awareness and will be able to carry on the conversation naturally, without losing continuity.

Being a final node, it can be used to wrap up any flow. Here are some practical examples:

  • After a FORM node: To thank the user for submitting their contact information and inform them that a consultant will be in touch shortly.
  • After an API node (successful call): To confirm to the user that their booking was completed successfully.
  • After an API node (failed call): To notify the user that the service is currently unavailable.
  • Directly connected to a Tool: To thank the user when the Tool is used to gather information without sending it to an API or other systems.

Let’s now look at the details of the Message node configuration.

Node Name: Assign a recognizable name to the node. The name does not affect the AI’s behavior but is useful for distinguishing this node from others in the flow setup.

Message Content: Enter the mini-prompt that will instruct the chatbot on what happened in the current flow. This helps the AI maintain context and continue the conversation coherently. You can also use dynamic variables ({{var}}) to personalize the message with data collected in previous steps.