# Altegio
Source: https://docs.monobot.ai/actions/altegio/altegio
The **Altegio integration** allows your AI agent to manage appointments, services, and staff using the Altegio platform.
It enables automation of booking flows, availability checks, and appointment management directly within your conversations.
***
## Adding Altegio Action
Click the **+ Add Element** button on the canvas to create a new element in your flow:
* select **Action**
* choose **Altegio**
* select the required tool
***
## Integration Setup
To use Altegio actions, you must configure the integration (navigate to the **Integration** tab). See [Altegio Integration](../../agent-settings/integrations)
for the details.
## Available Actions
Creates a new appointment in Altegio.
### Required
* **Staff ID**\
Type: `string`\
Identifier of the selected staff member
* **Service ID**\
Type: `string`\
Identifier of the selected service
* **Client Name**\
Type: `string`\
Full name of the client\
*Example:* `John Doe`
* **Client Phone**\
Type: `string`\
Client phone number\
*Example:* `+380XXXXXXXXX`
* **Appointment Time**\
Type: `string`\
Date and time (ISO 8601)\
*Example:* `2026-03-03T10:00:00+02:00`
### Optional
* **Client Email** — for notifications
* **First Cost / Cost** — override price
* **Discount** — apply discount
* **Session Length** — duration
* **Comment** — notes
* **SMS Reminder** — enable SMS
* **Email Reminder** — enable email
* **Save If Busy** — allow booking if slot is busy
* **Send SMS** — send confirmation
Updates an existing appointment.
### Required
* **Appointment ID**\
Type: `string`
* **Appointment DateTime**\
Type: `string`\
New date and time
* **Staff ID**\
Type: `string`
* **Service ID**\
Type: `string`
* **Seance Length**\
Type: `string`
* **Initial Cost**\
Type: `string`
* **Final Cost**\
Type: `string`
* **Client Name**\
Type: `string`
* **Client Phone**\
Type: `string`
### Optional
* **Client Email** — for notifications
* **Discount** — applied discount
* **Comment** — notes
Cancels an existing appointment.
### Required
* **Appointment ID**\
Type: `string`\
Unique identifier of the appointment\
*Example:* `123456789`
Retrieves appointment data.
### Optional
* **Client ID**\
Type: `string`
* **Start Date**\
Type: `string`\
*Example:* `2026-03-01`
* **Staff ID**\
Type: `string`
Returns available time slots.
### Required
* **Start Date**\
Type: `string`\
*Example:* `2026-03-01`
* **End Date**\
Type: `string`\
*Example:* `2026-03-07`
Retrieves staff by service.
### Required
* **Service Name**\
Type: `string`\
Name of the service\
*Example:* `Massage`
Retrieves services.
### Optional
* **Staff ID**\
Type: `string`\
Use `0` to include all staff
* **Category ID**\
Type: `string`\
Use `0` to include all categories
Retrieves service categories.
Retrieves staff members.
***
## Optional Parameters (General)
Some parameters are optional and provide flexibility:
* **Staff ID = 0** — apply to all staff
* **Category ID = 0** — include all categories
* **Client ID** — filter appointments
* **Start Date / End Date** — limit results
***
## Dynamic Values
Parameters can use values collected during node execution.
Examples:
* `Tools.create_appointment.parameters.name`
* `Tools.create_appointment.parameters.phone`
* `Tools.create_appointment.parameters.time`
***
## How It Works
* User requests a booking or service
* Flow collects required data
* Altegio action is triggered
* Request is sent using integration credentials
* Response is returned and used in the conversation
***
## Usage
Altegio integration is commonly used for:
* booking appointments
* checking availability
* managing reservations
* retrieving services and staff
* updating or canceling bookings
***
## Best Practices
* configure integration before using tools
* collect all required data before triggering
* validate date and time formats
* ensure correct service and staff selection
* handle unavailable slots gracefully
***
## Notes
* tools require valid credentials
* required fields must always be provided
* optional fields improve flexibility
* trigger tools only when sufficient data is collected
# API Call
Source: https://docs.monobot.ai/actions/api/api-call
The **API Call** action allows your AI assistant to interact with external systems, services, or databases by sending HTTP requests. It supports all major HTTP methods and allows for custom pre/post-processing logic in Python.
This action is ideal for dynamic integrations like sending data, retrieving external information, triggering backend processes, or interacting with third-party APIs.
***
## What It Does
When triggered, this action performs a direct HTTP request to the specified API endpoint. You can define the method, payload, and optionally include pre-processing and post-processing logic to manipulate the request or handle the response.
> Use this for real-time data exchange or logic branching based on external API responses.
***
## Action Interface
***
## Configuration Options
**Type**: `string`
The complete URL of the API endpoint to call.
*Example:* `https://api.example.com/users`
**Type**: `string`
HTTP method used for the request. Choose from:
* `GET`
* `POST`
* `PUT`
* `DELETE`
*Default:* `GET`
**Type**: `object`\
Key-value pairs sent with the request to provide metadata such as authentication, content type, or API configuration.
*Example:*
```json theme={null}
{
"Authorization": "Bearer YOUR_TOKEN",
"Content-Type": "application/json"
}
```
**Type**: `object`
Key-value pairs to include in the request body or query params.
*Example:*
```json theme={null}
{
"email": "@userEmail",
"status": "active"
}
```
**Type**: `python`
Python function that runs **before** the API call. Useful for preparing parameters or transforming data.
*Example:*
```python theme={null}
def preprocess(params):
return {"email": params["email"].lower()}
```
**Type**: `python`
Python function that runs **after** receiving the API response. Use this to extract data or format it for the next step.
*Example:*
```python theme={null}
def handle(response):
return response.get("data", {})
```
**Type**: `boolean`
When checked, the next action will only execute if this API call completes successfully.
***
## Tips
* Use `@parameter` in the endpoint, payload, or code for dynamic inputs.
* Chain this with message generation or conditional actions based on response data.
* Return JSON or structured data to power follow-up tools like decision branches or summaries.
Let us know if you'd like ready-to-use API templates!
# Cal.com
Source: https://docs.monobot.ai/actions/cal-com/calcom
The Cal.com integration allows AI assistants to search availability, create bookings, update appointments, and manage scheduling workflows directly through Cal.com.
This integration is commonly used for:
* Appointment scheduling
* Consultation booking
* Calendar automation
* Meeting management
* Rescheduling workflows
# Available Actions
Searches available booking slots in Cal.com for the selected event type and date range.
This action retrieves free time slots based on connected calendar availability and event configuration.
## Parameters
| Parameter | Required | Description |
| --------------- | -------- | -------------------------------------------------- |
| Event Type ID | Yes | Cal.com event type used for slot search. |
| Start Date Time | Yes | Start date and time for availability search range. |
| End Date Time | Yes | End date and time for availability search range. |
| Timezone | No | Timezone used during slot search and display. |
## Output
Returns a list of available booking slots within the selected date range.
### Example
```json theme={null}
{
"success": true,
"slots": [
"2026-05-20T10:00:00Z",
"2026-05-20T10:30:00Z",
"2026-05-20T11:00:00Z"
]
}
```
## Use Cases
* Find free appointment times
* Suggest available meeting slots
* Validate booking availability
* Prepare booking workflows
* Synchronize scheduling systems
## Notes
* Valid Cal.com integration credentials are required.
* Returned slots depend on connected calendar availability.
* Availability is generated dynamically in real time.
* Timezone affects displayed slot times.
* Available slots may change during the conversation.
Creates a new booking in Cal.com using the selected event type, date, and client information.
This action automatically schedules a calendar event and synchronizes it with connected calendars and workflows.
## Parameters
| Parameter | Required | Description |
| --------------- | -------- | ----------------------------------------------------------------------------- |
| Event Type ID | Yes | Cal.com event type used for the booking. |
| Start Date Time | Yes | Booking start date and time. |
| Client Name | Yes | Name of the client for the booking. |
| Client Email | Yes | Client email address used for booking confirmation. |
| Timezone | No | Timezone used during booking creation. |
| Async | No | Executes the action in the background without blocking the conversation flow. |
## Output
Returns confirmation that the booking was successfully created.
### Example
```json theme={null}
{
"success": true,
"message": "New calendar event has been created."
}
```
## Use Cases
* Schedule appointments
* Create consultation meetings
* Book support calls
* Reserve calendar slots
* Automate scheduling workflows
## Notes
* Valid Cal.com integration credentials are required.
* Selected event type must exist and be available.
* Booking creation depends on real-time slot availability.
* Connected calendars and notifications may update automatically.
* Client email may receive booking confirmation from Cal.com.
Retrieves existing Cal.com bookings within the selected date range and event type.
This action can be used to search scheduled appointments, validate reservations, and retrieve upcoming or historical booking information.
## Parameters
| Parameter | Required | Description |
| --------------- | -------- | ---------------------------------------------- |
| Event Type ID | Yes | Cal.com event type used for booking filtering. |
| Start Date Time | Yes | Start date and time for booking search range. |
| End Date Time | Yes | End date and time for booking search range. |
| Timezone | No | Timezone used during booking retrieval. |
## Output
Returns a list of bookings matching the selected filters and time range.
### Example
```json theme={null}
{
"success": true,
"bookings": [
{
"booking_id": "12345",
"client_name": "John Doe",
"start_time": "2026-05-20T10:00:00Z",
"end_time": "2026-05-20T10:30:00Z"
}
]
}
```
## Use Cases
* Retrieve upcoming appointments
* Validate booking existence
* Search reservations by date range
* Prepare booking reschedule workflows
* Display scheduled events to clients
## Notes
* Valid Cal.com integration credentials are required.
* Returned bookings depend on selected event type and date range.
* Timezone affects booking filtering and displayed event times.
* Historical and future bookings may both be returned depending on the selected range.
Updates an existing Cal.com booking with a new date and time.
This action automatically moves the existing appointment to a new available slot and synchronizes connected calendars.
***
## Parameters
| Parameter | Required | Description |
| ------------------- | -------- | ---------------------------------------- |
| Event Type ID | Yes | Cal.com event type used for the booking. |
| Booking ID | Yes | Unique booking identifier to reschedule. |
| New Start Date Time | Yes | New booking start date and time. |
| Timezone | No | Timezone used during rescheduling. |
***
## Output
Returns confirmation that the booking was successfully rescheduled.
### Example
```json theme={null}
{
"success": true,
"message": "The calendar event has been rescheduled."
}
```
***
## Use Cases
* Change appointment time
* Move meetings to another slot
* Resolve scheduling conflicts
* Update customer reservations
* Synchronize calendar updates
***
## Notes
* Valid Cal.com integration credentials are required.
* Original booking must exist before rescheduling.
* New selected slot must be available.
* Connected calendars and notifications may update automatically.
* Rescheduling may trigger confirmation emails from Cal
Cancel an existing Cal.com booking using the selected event type and booking identifier.
This action can be used to remove scheduled appointments, free reserved slots, and update connected calendars automatically.
***
## Parameters
| Parameter | Required | Description |
| ------------- | -------- | ----------------------------------------------------------------------------- |
| Event Type ID | Yes | Cal.com event type used for the booking. |
| Booking ID | Yes | Unique booking identifier to cancel. |
| Timezone | No | Timezone used during booking processing. |
| Async | No | Executes the action in the background without blocking the conversation flow. |
***
## Output
Returns confirmation that the booking was successfully canceled.
### Example
```json theme={null}
{
"success": true,
"message": "Existing calendar event has been deleted."
}
```
Use Cases
Cancel customer appointments
Remove outdated bookings
Free occupied calendar slots
Handle reschedule workflows
Synchronize external calendars
# Communication
Source: https://docs.monobot.ai/actions/communication/communication
The **Communication Actions** allows your AI agent to send outbound messages to users or team members through supported channels.
These actions are commonly used for confirmations, reminders, alerts, follow-ups, escalations, and other automated notifications triggered during the flow.
Communication actions can be used after collecting required contact details such as email address or phone number, and they may run either synchronously or in the background depending on the selected configuration.
## Supported Actions
This section includes:
* **Send Email**
* **Send SMS**
Both actions are designed for direct communication and can be used in booking flows, support flows, operational notifications, and post-interaction automations.
***
## Integration Requirements
Before using communication actions, ensure all required configurations are set up.
* **Email (SMTP)** requires a configured SMTP integration in the **Integrations** tab. See [Send Email (SMTP)](../../agent-settings/integrations)
* **SMS** requires a phone number assigned to the bot on **General** tab
Without proper configuration, the actions will not execute successfully.
***
## General Configuration
Each communication action includes general configuration fields before the action-specific parameters.
### Action Name
Defines the internal action identifier.
Examples:
* `smtp_send_email`
* `send_sms`
### Description
Defines the purpose of the action and how it should be used in the flow.
Examples:
* `Send an email via SMTP to a specified recipient (subject + body) to communicate with clients or partners.`
* `Send an SMS message to a specified phone number to notify or communicate with clients.`
### Async
If enabled, the action runs in the background and the bot continues the conversation without waiting for the result.
Use async mode when the delivery result is not needed immediately in the next step of the flow.
***
## Send Email
The **Send Email** action sends an email via SMTP to one or more recipients.
This action is useful for confirmations, booking summaries, follow-ups, internal notifications, escalation emails, and other automated communication scenarios.
To use Email actions, you must configure the integration (navigate to the **Integration** tab). See [Send Email (SMTP)](../../agent-settings/integrations)
for the details.
### Parameters
**Type**: `string`\
Preconfigured SMTP authentication preset used to send the email.
This field defines which SMTP credentials and connection settings will be used for delivery.
**Type**: `string`\
Email address of the sender.\
*Example:* `sender@mail.com`
This field defines the email address that appears as the sender.
**Type**: `string`\
Primary recipient email address.\
*Example:* `recipient@mail.com`
This field is required and defines the main destination for the email.
**Type**: `string`\
Comma-separated list of CC recipients.\
*Example:* `cc1@mail.com, cc2@mail.com`
Use this field when additional recipients should receive a visible copy of the email.
**Type**: `string`\
Comma-separated list of BCC recipients.
Use this field when additional recipients should receive a hidden copy of the email.
**Type**: `string`\
Subject line of the email.
This field is required and should clearly describe the purpose of the message.
**Type**: `string`\
Additional required parameters used by the action, if configured.
This field can be used when the action expects extra structured values before execution.
**Type**: `string`\
URL to a file that will be attached to the email.
Use this field when the action should include an external file as an attachment.
**Type**: `string`\
Custom success message returned after sending.\
Default: `Email has been successfully sent.`
This value can be used in the flow after the action completes successfully.
**Type**: `string`\
Email body content.
This field contains the actual message sent to the recipient and may support rich text formatting depending on the editor configuration.
**Type**: `boolean`\
Runs the action only if all previous steps were completed successfully.
Use this option when email delivery should depend on successful completion of earlier flow logic.
***
## Send SMS
The **Send SMS** action sends a text message to a specified phone number.
This action is useful for quick confirmations, reminders, short alerts, booking updates, status notifications, and other direct mobile communication scenarios.
### Parameters
**Type**: `string`\
Recipient phone number.\
*Example:* `+15551234567`
This field is required and defines the destination number for the SMS message.
**Type**: `string`\
SMS message content.
This field is required and contains the text that will be sent to the recipient.
**Type**: `string`\
Custom success message returned after sending.\
Default: `SMS has been successfully sent.`
This value can be used in the flow after successful message delivery.
**Type**: `boolean`\
Runs the action only if all previous steps were completed successfully.
Use this option when SMS sending should depend on successful completion of earlier actions or validations.
***
## How Communication Actions Are Used
Communication actions are usually triggered after the flow has already collected the required delivery data.
Typical examples:
* send an email after creating a reservation
* send an SMS reminder before an appointment
* send a follow-up email after a support request
* send an alert to a manager or operator
These actions can be connected to booking flows, support flows, lead flows, or internal automation logic.
***
## Best Practices
* validate email addresses and phone numbers before sending
* ensure all required message content is prepared in advance
* use async mode only when immediate result handling is not needed
* keep SMS content short and clear
* use email for detailed communication and SMS for short notifications
* define output messages clearly when they are used in later flow steps
***
## Notes
* Email delivery requires a valid SMTP preset
* SMS delivery requires a valid phone number in the expected format
* Async mode allows the bot to continue the conversation without waiting
* Communication actions should be triggered only after all required data is available
# Custom Conditions
Source: https://docs.monobot.ai/actions/conditions/custom_conditions
## Overview
Custom conditions allow you to route the flow based on the result of a previous action or function.
They are useful when an action returns a specific value and the next step should depend on that result.
For example, a function can evaluate whether a request is urgent and return:
* `True`
* `False`
The next action can then be triggered depending on which value was returned.
## How It Works
A custom condition compares:
* the **result of an action or function**
* with a **defined value**
* using a selected **operator**
If the condition matches, the corresponding branch is triggered.
***
## Example
A function called `time_evaluation` checks whether the request is urgent.
The function returns:
* `True` — urgent request
* `False` — non-urgent request
You can then create separate branches:
* if result `=` `True` → go to urgent handling step
* if result `=` `False` → go to non-urgent handling step
## Use Case
Example flow:
1. Run `time_evaluation`
2. Check returned value in a custom condition
3. Route the flow depending on the result
Possible logic:
time\_evaluation `=` True → urgent request\
time\_evaluation `=` False → non-urgent request
***
## Condition Structure
A custom condition consists of three parts:
* **Left value** — result of the previous action or function
* **Operator** — comparison rule
* **Right value** — expected value to compare against
Example:
Actions.time\_evaluation `=` True
***
## Supported Operators
The condition builder supports comparison operators such as:
| Operator | Meaning |
| -------- | ---------------- |
| `=` | Equals |
| `!=` | Not equals |
| `>` | Greater than |
| `>=` | Greater or equal |
| `<` | Less than |
| `<=` | Less or equal |
* `IN`
* `NOT IN`
* `STARTS WITH`
* `ENDS WITH`
* `MATCHES REGEX`
* `CONTAINS`
***
## Passing Action Results
You can pass the result of a previous action or function into the condition.
Example:
Actions.time\_evaluation
Then compare it against the expected value:
True
So the full condition becomes:
Actions.time\_evaluation `=` True
***
## Typical Scenarios
Custom conditions are commonly used for:
* urgent vs non-urgent request routing
* success vs failure handling
* matching specific function results
* checking flags like True / False
* branching based on calculated values
***
## Example: Urgent Request Routing
Condition 1:
Actions.time\_evaluation `=` True
Next step:
* trigger urgent request prompt
* escalate to priority handling (e.g., send an email to the support team)
Condition 2:
Actions.time\_evaluation `=` False
Next step:
* continue regular flow
* send standard response
* route to non-urgent branch
***
## Best Practices
* make sure the function returns a clear and predictable value
* compare values using the correct type and format
* use simple conditions when possible
* create separate branches for different expected outcomes
* test returned values before using them in production flows
***
## Notes
* custom conditions depend on the result of a previous action
* the compared value can be boolean, text, number, or structured output
* conditions are useful for building flexible and dynamic branching logic
***
## Summary
Custom conditions allow you to evaluate the result of an action or function and decide what should happen next.
This makes it possible to build flows where the next action depends on specific returned values, such as True or False.
# Pass / Fail Conditions
Source: https://docs.monobot.ai/actions/conditions/pass_fail_conditions
## Overview
Pass / Fail conditions define how your flow continues after an action is executed.
Each action can have two pre-configured outcomes:
* **Pass** — the action completed successfully
* **Fail** — the action failed (error, validation issue, external service failure, etc.)
These outcomes allow you to build **controlled, reliable, and fault-tolerant flows**.
## How It Works
When an action is executed:
* If it succeeds → the **Pass path** is triggered
* If it fails → the **Fail path** is triggered
Each path can lead to a different next step in your flow.
***
## Basic Logic
Action → Pass → Next Step A\
→ Fail → Next Step B
***
## Example: Summary → Email
### Flow:
1. Summarize Conversation
2. If successful → send email
### Logic:
* If summary is generated → proceed to email
* If summary fails → stop or handle separately
***
## Example: Email with SMS Fallback
### Flow:
1. Generate summary
2. Send email
3. If email fails → send SMS
### Logic:
Summary → Pass → Email\
Email → Pass → End\
Email → Fail → Send SMS
***
## Real Use Case
### Scenario:
* Primary communication: Email
* Backup channel: SMS
### Behavior:
* If email is delivered → flow ends
* If email fails → SMS is sent automatically
***
## Why Use Pass / Fail
### Reliability
Handle failures gracefully instead of breaking the flow.
### Flexibility
Different outcomes can trigger different logic paths.
### Better UX
Users still receive communication even if one channel fails.
***
## Best Practices
* Handle Fail paths
* Use fallback channels (Email → SMS)
* Keep flows simple
***
## Common Patterns
### Success Chain
Step 1 → Pass → Step 2 → Pass → Step 3
### Fallback Handling
Email → Fail → SMS
### Conditional Recovery
API Call → Fail → Alternative
### Silent Failure
Optional Step → Fail → Continue
***
## Notes
* Pass/Fail depends on action execution result
* Design flows assuming failures can happen
***
## Summary
Pass / Fail conditions allow you to:
* control execution flow
* handle errors properly
* build resilient automations
# Google Actions
Source: https://docs.monobot.ai/actions/google/google
## Overview
The **Google Actions** integration allows your AI agent to interact with Google services such as Calendar, Maps, and Analytics.
It enables automation of:
* scheduling and managing calendar events
* retrieving routes and distances
* searching locations and places
* tracking analytics events
***
## Supported Services
This integration covers the following Google services:
* Google Calendar
* Google Maps
* Google Analytics
***
## Integration Setup
To use Google tools, navigate to the 'Integration' and connect your account.
Tools will not work without an active Google integration.
***
## Available Actions
### Calendar
Creates a new event in the user’s connected Google Calendar.
This action can be used to automate scheduling for meetings, appointments, reminders, or internal events. It supports rich event configuration including attendees, reminders, recurrence, and location details.
***
### Required data
* **title**\
Type: `string`\
The name of the event.\
*Example:* `Product Demo with Client`
* **start time**\
Type: `string`\
Event start date and time in ISO 8601 or valid datetime format.\
*Example:* `2025-04-10T15:00:00`
***
### Optional data
* **duration**\
Type: `number`\
Duration of the event in minutes.\
Default: `60`
* **calendar identifier**\
Type: `string`\
Target calendar. If not provided, the default calendar is used.\
Default: `primary`
* **description**\
Type: `string`\
Additional details or notes for the event.
* **timezone**\
Type: `string`\
Timezone used for the event.
* **repeat**\
Type: `string`\
Recurrence rule for the event.\
Options: `None`, `Daily`, `Weekly`, `Monthly`, `Yearly`, `Weekdays`
* **location**\
Type: `string`\
Physical or virtual location of the event.
* **Google Meet link**\
Type: `string`\
Video meeting link associated with the event.
* **reminders (email)**\
Type: `string`\
Comma-separated minutes before the event for email reminders.\
*Example:* `1440,60`
* **reminders (popup)**\
Type: `string`\
Comma-separated minutes before the event for popup reminders.\
*Example:* `30,10`
* **attendees**\
Type: `string`\
Comma-separated list of attendee emails.\
*Example:* `client@example.com, sales@example.com`
* **all-day flag**\
Type: `boolean`\
Marks the event as an all-day event.
Searches for events in the user’s connected Google Calendar based on keywords, time range, and filters.
This action is useful for checking availability, retrieving existing bookings, or validating scheduled events before creating or updating them.
***
### Required data
* **query**\
Type: `string`\
Keyword(s) used to search event titles and descriptions. Can also be passed dynamically via `@param`.\
*Example:* `demo`, `@customerName`
***
### Optional data
* **calendar identifier**\
Type: `string`\
Calendar to search in.\
Default: `primary`
* **timezone**\
Type: `string`\
Timezone used to interpret date and time filters.\
Default: system / UTC
* **start time**\
Type: `string`\
Start of the time range (ISO 8601 or valid datetime).\
*Example:* `2025-04-01T00:00:00`
* **end time**\
Type: `string`\
End of the time range (ISO 8601 or valid datetime).\
*Example:* `2025-04-30T23:59:59`
* **number of events to consider**\
Type: `number`\
Maximum number of events to scan.\
Default: `100`
* **single event flag**\
Type: `boolean`\
When enabled, recurring events are expanded into individual instances.\
Default: `true`
Updates an existing event in the user’s connected Google Calendar using its unique event ID.
This action is useful for rescheduling meetings, updating attendees, or modifying event details such as time, location, or description.
***
### Required data
* **event ID**\
Type: `string`\
Unique identifier of the event to update.\
*Example:* `5pq7fc8gc0d3qqln42v2a2ab50`
***
### Optional data
* **title**\
Type: `string`\
Updated event title.\
*Example:* `Updated: Onboarding Call with Sarah`
* **description**\
Type: `string`\
Updated event description.
* **calendar identifier**\
Type: `string`\
Calendar where the event is stored.\
Default: `primary`
* **start time**\
Type: `string`\
New start date and time (ISO 8601 or valid datetime).\
*Example:* `2025-04-15T14:30:00`
* **duration**\
Type: `number`\
Updated duration in minutes.\
Default: `60`
* **timezone**\
Type: `string`\
Timezone for the updated event.
* **location**\
Type: `string`\
Updated physical or virtual location.
* **Google Meet link**\
Type: `string`\
Video meeting link associated with the event.
* **attendees**\
Type: `string`\
Comma-separated list of attendee emails.\
*Example:* `alice@example.com, bob@example.com`
Deletes an existing event from the user’s connected Google Calendar using its unique event ID.
This action is useful for handling cancellations, cleanup flows, or removing outdated events before creating updated ones.
***
### Required data
* **event ID**\
Type: `string`\
Unique identifier of the event to delete. This value is returned when the event is created.\
*Example:* `5pq7fc8gc0d3qqln42v2a2ab50`
***
### Optional data
* **calendar identifier**\
Type: `string`\
Calendar where the event is stored.\
Default: `primary`
***
### Maps
Calculates the distance between two locations using Google Maps.
This action is useful for logistics, delivery estimation, route planning, and travel calculations.
***
### Required data
* **point A**\
Type: `string`\
Origin address or coordinates (latitude,longitude).\
*Example:* `1600 Amphitheatre Parkway, Mountain View, CA`
* **point B**\
Type: `string`\
Destination address or coordinates.\
*Example:* `1 Infinite Loop, Cupertino, CA`
Retrieves route information between two locations using Google Maps.
This action is useful for navigation, travel planning, and estimating distance and duration between points.
***
### Required data
* **point A**\
Type: `string`\
Origin address or coordinates (latitude,longitude).\
*Example:* `1600 Amphitheatre Parkway, Mountain View, CA`
* **point B**\
Type: `string`\
Destination address or coordinates.\
*Example:* `1 Infinite Loop, Cupertino, CA`
* **distance measurement format**\
Type: `string`\
Unit system used for distance calculation.\
Default: `metric`
***
### Optional data
* **region code**\
Type: `string`\
State or region code to refine routing results.
* **country code**\
Type: `string`\
Country code to localize routing behavior.
* **travel mode**\
Type: `string`\
Mode of transportation.\
Default: `driving`
Searches for locations using Google Maps based on a query and optional filters.
This action is useful for finding places, validating addresses, or retrieving location data for further use in flows.
***
### Required data
* **query**\
Type: `string`\
The search string for Google Maps. Can be a full address, business name, or general location phrase.\
*Example:* `Starbucks near 94103`, `1600 Amphitheatre Parkway`
***
### Optional data
* **latitude and longitude**\
Type: `string`\
Coordinates used to bias the search results.\
*Example:* `37.4224764,-122.0842499`
* **radius**\
Type: `number`\
Search radius in meters around the provided coordinates.\
*Example:* `5000` (5 km)
* **country**\
Type: `string`\
Country filter for the search.
* **state**\
Type: `string`\
State or region filter.
* **city**\
Type: `string`\
City filter for more precise results.
* **marks**\
Type: `string`\
Types of locations to search for (e.g., restaurant, hospital).
* **result pattern name**\
Type: `string`\
Variable name used to store results.\
Default: `search_result`
* **add coordinate flag**\
Type: `boolean`\
Includes coordinates in the result output.
* **hide action result flag**\
Type: `boolean`\
Hides the action result from being displayed to the user.
Provides location suggestions using Google Autocomplete based on partial input and optional filters.
This action is useful for building dynamic address inputs, improving user experience, and storing structured location data for further use in flows.
***
### Required data
* **value**\
Type: `string`\
Partial input used to generate autocomplete suggestions.\
*Example:* `New Yor`
***
### Optional data
* **label name**\
Type: `string`\
Label used to identify or display the selected result.
* **latitude and longitude**\
Type: `string`\
Coordinates used to bias suggestions toward a specific area.\
*Example:* `37.4224764,-122.0842499`
* **radius**\
Type: `number`\
Search radius in meters around the provided coordinates.
* **country**\
Type: `string`\
Country filter for suggestions.
* **state**\
Type: `string`\
State or region filter.
* **city**\
Type: `string`\
City filter for more precise suggestions.
* **marks**\
Type: `string`\
Additional filters or tags applied to suggestions.
* **state variable name**\
Type: `string`\
Variable name used to store the selected result for later use in the flow.
***
### Analytics
Sends a custom event to Google Analytics (GA4) for tracking user actions and interactions.
This action is useful for analytics, conversion tracking, user behavior monitoring, and event-based reporting.
***
### Required data
* **measurement ID**\
Type: `string`\
Google Analytics Measurement ID.\
*Example:* `G-XXXXXXXXXX`
* **API secret**\
Type: `string`\
API secret used for secure event tracking.
* **event name**\
Type: `string`\
Name of the event to be tracked.\
*Example:* `booking_completed`, `button_click`
***
### Optional data
* **debug mode**\
Type: `boolean`\
Enables debug mode for testing events in Google Analytics DebugView.
***
## Best Practices
* Always validate input before triggering actions
* Use correct time formats (ISO 8601 for calendar events)
* Avoid duplicate event creation
* Handle API errors gracefully
* Ensure location inputs are well formatted
***
## Notes
* Supports use of `@parameters` for dynamic route calculations.
* Some actions require additional permissions depending on the Google service
* Rate limits may apply depending on API usage
* Ensure API keys and tokens are securely stored
***
# Knowledge Base
Source: https://docs.monobot.ai/actions/knowledge-base/knowledge_base
Store, retrieve, search, and update structured data using Knowledge Base actions.
## Overview
Knowledge Base actions allow your bot to work with structured data (categories, CSV, text files) for dynamic responses and data storage.
Adds a new row to a category (CSV file).
### Parameters
* **Category name** — target category (CSV file)
* **Delimiter** — separator used in the CSV (e.g., `comma (,)`)
* **CSV Row** — row data to insert (must match column structure)
### Output
```
New csv row successfully added.
```
Returns all content from a selected category.
### Parameters
* **Category Name** — category to retrieve data from
Searches for relevant results across categories.
### Parameters
* **Query** — search input text
* **CSV filtering** — filter results using conditions
* **CSV sorting** — sort results
### Advanced
* **K-Num** — number of results to return
* **Threshold** — similarity threshold (0–1)
Lower values return more results (less strict).\
Higher values return fewer, more relevant matches.
* **Search in output** — include output field in search
* **Include** — include specific fields
* **Exclude** — exclude specific fields
Search multiple queries across selected categories.
### Parameters
* **Queries** — search input text
* **Categories** — categories to search in
### Advanced
* **K-Num for each category** — number of results per category
* **Number of page** — pagination control
* **Threshold** — similarity threshold (0–1)
Controls how closely results must match the query.\
Higher values = stricter matching.
Search within selected categories using a single query.
### Parameters
* **Query** — search input
* **Categories** — selected categories
### Advanced
* **K-Num** — number of results
* **Threshold** — similarity threshold (0–1)
* **Search in output** — include output field
* **Only the most relevant category** — restrict results to best match
* **Include** — include specific fields
* **Exclude** — exclude specific fields
Updates category content.
### Parameters
* **Category Name** — target category
* **Data / File Content** — new content to replace existing data
Updates multiple records in a category.
### Parameters
* **Category Name** — target category
* **File Content** — new data to apply
### Options
* **Extension** — file format (e.g., `txt`)
* **Append File Content** — add content instead of replacing
### Output
```
Knowledge Base was successfully updated.
```
## How It Works
```
User → Flow → Knowledge Base Action → Result → Response
```
***
## Notes
Categories behave like structured datasets (CSV or text-based).
Use **Threshold + K-Num together** to control result quality and volume.
# Others
Source: https://docs.monobot.ai/actions/others/other_actions
## Overview
Other actions provide utility functions that help control flow logic, store values, and manage data during a conversation.
Use these actions when you need to save information, reuse values later, or support custom flow behavior.
Adds or updates a global state variable during the conversation.
This action is used to store a value that can be reused later in the flow.
***
### Required data
* **Name**\
Type: `string`\
Name of the global state variable.
*Example:* `customer_name`
* **Value**\
Type: `string`\
Value to save into the state variable.
Supports both static values and dynamic variables.
*Example:* `John Smith`\
*Example:* `@name`
***
### Notes
* Stores data globally for the duration of the flow.
* Can be accessed in other nodes, tools, and actions.
* If the variable already exists, its value will be overwritten.
* Use meaningful names to keep flows readable.
* Use `@variable_name` to pass dynamic values
* If the same state variable already exists, the value will be overwritten
### When to use
* Save user input for later steps
* Store intermediate data between actions
* Pass values into tools or API calls
***
### Best practices
* Use clear variable names (`user_name`, `phone_number`)
* Avoid overwriting important values unintentionally
* Store only necessary data for later use
Returns the current number of messages in the conversation in real time.
***
### Description
Retrieves the total number of messages exchanged in the current interaction.
Useful for controlling conversation flow, applying limits, or triggering logic based on message count.
### Async mode
* **Async**\
Type: `boolean`
If enabled, the action runs in the background and the bot continues the conversation without waiting for the result.
***
### Output
Returns:
```
6
```
Finds the most relevant HS (commodity) code based on a product name or description using an LLM-powered classification search.
### Required data
* **Product**\
Type: `string`
Product name or short description used to identify the correct commodity code.
*Example:* `Wooden dining table`
***
### Optional parameters
* **Language**\
Type: `string`
Language used for the search and response.
*Options:* `en`, `ro`, `ru`, `xx`\
*Default:* `en`
Write a custom function in the built-in code editor and return structured output for later steps in the flow.
### Required data
* **Function**\
Type: `code`
Custom function written in Python that processes input data and returns structured output.
*Example:*
```python theme={null}
def _foo(tool_params: dict, interaction_data: dict):
# do something here
return {"result": "ok"}
```
### Optional parameters
* **TTL**\
Type: `number`
Time-to-live for cached results (in seconds).
*Example:* `30`
### Async mode
* **Async**\
Type: `boolean`
If enabled, the action runs in the background and the bot continues the conversation without waiting for the result.
### Output
Returns structured data defined by the function.
```json theme={null}
{
"key": "value"
}
```
## Debug Logging
Custom logs can be added inside the function and viewed later in the bot Debug Mode.
This is useful for troubleshooting, inspecting API responses, validating variables, or debugging function execution flow.
### Example
```python theme={null}
interaction_data.get("_LOGGING").warning("LOG api_call_response type:")
interaction_data.get("_LOGGING").warning(type(api_call_response).__name__)
interaction_data.get("_LOGGING").warning("LOG api_call_response content:")
interaction_data.get("_LOGGING").warning(api_call_response)
```
## Supported Logging Methods
* `warning()`
* `info()`
* `error()`
* `debug()`
## Where to View Logs
Logs can be viewed in:
`Bot Configuration → Debug Mode`
### Notes
* Use `tool_params` to access input parameters.
* Use `interaction_data` for conversation context.
* Define response schemas if needed for structured outputs.
* Logging is useful for debugging custom functions and integrations.
* Logs can help inspect API responses, variables, and execution flow.
* Excessive logging may produce large debug outputs.
* Sensitive information should not be logged.
Filters CSV data by specific column values based on defined conditions.
### Required data
* **Column Name**\
Type: `string`\
Name of the column used for filtering.\
*Example:* `status`
* **CSV Category Name**\
Type: `string`\
Name of the CSV dataset (category).\
*Example:* `orders`
* **Filter Value**\
Type: `string`\
Value used to filter rows.\
*Example:* `completed`
### Optional parameters
* **Comparison Operator**\
Type: `string`
Defines how values are compared.
*Options:*
* `Equal`
* `Not Equal`
* `Greater Than`
* `Less Than`
* `Greater Than or Equal`
* `Less Than or Equal`
* `Contains`
* `Does Not Contain`
* `Starts With`
* `Ends With`
*Default:* `Equal`
### Async mode
* **Async**\
Type: `boolean`
Runs in background without waiting for result.
### Output
Returns filtered rows:
```json theme={null}
[
{
"column": "value"
}
]
```
### Notes
* Column names must match CSV exactly
* Operators depend on data type (text vs number)
* Use `Contains` / `Starts With` for text filtering
* Use numeric operators for numbers
Retrieves relevant information from a vector store and generates a response using a selected model.
This action combines search (retrieval) and reasoning to produce answers based on your knowledge base.
### Use cases
* Answer questions based on internal knowledge
* Search through documentation or FAQs
* Provide contextual responses from stored data
* Combine retrieval with AI-generated output
### Required data
* **Vector store ID**\
Type: `string`\
Identifier of the vector database used for retrieval.
* **Instruction**\
Type: `string`\
Defines how the model should behave and format the response.
* **Query**\
Type: `string`\
Search input used to retrieve relevant data.
### Optional data
* **Model name**\
Type: `string`\
Model used for response generation.
*Example:* `gpt-5 nano`
* **Reasoning level**\
Type: `string`\
Controls depth of reasoning.
*Example:* `None`, `Low`, `Medium`, `High`
* **Web search**\
Type: `boolean`\
Enables fallback to web data if needed.
### Output
* Returns a generated response based on retrieved data
* Combines vector search results with model reasoning
### Notes
* Quality depends on the vector store content
* Better queries improve retrieval accuracy
* Higher reasoning increases latency but improves results
* Use clear instructions to control tone and structure
Returns a user-defined value to the LLM, which the assistant uses to generate its response.
### Use cases
* Pass calculated or processed data to the model
* Override or enrich the assistant response
* Inject dynamic values into the conversation
* Control final output of a flow
### Required data
* **Custom value**\
Type: `string`\
Value returned to the model.
*Example:* `Your appointment is confirmed for tomorrow at 3 PM`
### Optional data
* **Async**\
Type: `boolean`\
Runs the action in the background without waiting for the result.
### Output
* Returns the defined value to the LLM
* Used by the assistant to generate or modify the response
### Notes
* Value should be clear and ready for direct use
* Avoid unnecessary formatting or extra text
* Use when you need full control over what the model receives
Navigates to a specific conversation step by setting the active flow.
This action allows you to redirect the conversation to another flow or node within the workflow.
### Use cases
* Redirect user to another flow
* Split logic between different workflows
* Handle fallback or escalation scenarios
* Reuse existing flows
### Required data
* **Set current flow**\
Type: `string`\
Name of the target flow or node.
*Example:* `booking_flow`
### Optional data
* **Make as transition**\
Type: `boolean`\
Treats the action as a transition between nodes.
* **Incognito call**\
Type: `boolean`\
Executes the flow without affecting visible conversation state.
* **Only if everything was successful**\
Type: `boolean`\
Executes only if previous actions completed successfully.
* **Async**\
Type: `boolean`\
Runs the action in the background without waiting for completion.
### Output
* Redirects the conversation to the specified flow
* Updates the current execution context
### Notes
* Target flow must exist in the system
* Use clear and consistent naming for flows
* Avoid circular flow transitions
Displays multiple selectable hints in the chat widget to guide user interaction.
This action presents predefined options that users can click instead of typing, improving usability and flow control.
### Use cases
* Provide quick reply options
* Guide users through predefined flows
* Reduce typing effort
* Improve conversion in structured scenarios
### Required data
* **List of hints**\
Type: `string`\
List of options displayed to the user, one per line.
*Example:*
```
Book an appointment
Check availability
Contact support
```
### Optional data
* **Async**\
Type: `boolean`\
Runs the action in the background without waiting for completion.
### Output
* Displays clickable hints in the widget
* User selection is returned as input to the conversation
### Notes
* One hint per line
* Keep hints short and clear
* Limit the number of options to avoid overload
* Ensure options match available flow paths
Uses the LLM to generate relevant hint options and display them as selectable choices in the widget chat.
This action dynamically creates suggestions based on context, improving user guidance without predefined options.
### Use cases
* Generate dynamic quick replies
* Suggest next steps based on user input
* Adapt hints to conversation context
* Improve engagement without hardcoded options
### Required data
* **Custom prompt**\
Type: `string`\
Instruction for the LLM to generate hints.
*Example:*
```
Generate 3 short options a user might choose next for booking a service.
Keep them concise and action-oriented.
```
### Optional data
* **Async**\
Type: `boolean`\
Runs the action in the background without waiting for completion.
### Output
* Displays generated hints in the widget
* Each hint is returned as selectable user input
### Notes
* Keep prompts clear and specific
* Limit number of generated hints (e.g., 3–5)
* Ensure hints are short and easy to understand
* Avoid vague or overly long suggestions
Generates a concise summary of the conversation between the client and the AI assistant based on a custom instruction.
This action analyzes the chat and returns structured insights such as key points, conclusions, and important details.
### Use cases
* Generate conversation summaries
* Extract key facts and decisions
* Prepare reports for team review
* Send summaries via email or integrations
### Required data
* **Instruction**\
Type: `string`\
Defines how the summary should be structured and what to include.
*Example:*
```
Summarize the conversation. Include:
- Main request
- Key details
- Final outcome
```
### Optional data
* **Cut conversation**\
Type: `boolean`\
Clears or resets the conversation after summary is generated.
* **Run immediately**\
Type: `boolean`\
Executes the action instantly when triggered.
* **Only if everything was successful**\
Type: `boolean`\
Runs only if previous actions completed successfully.
* **Async**\
Type: `boolean`\
Runs the action in the background without waiting for completion.
### Output
* Returns a structured summary of the conversation
* Can be used in further actions (email, CRM, logs, etc.)
### Notes
* Keep instructions clear and structured
* Avoid overly long prompts
* Output format depends on the instruction
* Useful for automation and reporting workflows
Pauses the conversation flow for a specified amount of time before continuing.
This action introduces a delay, allowing you to control timing between messages or actions.
### Use cases
* Add delay between messages
* Simulate human-like response timing
* Wait before triggering next action
* Control pacing in workflows
### Required data
* **Timeout**\
Type: `number`\
Number of seconds the assistant should wait before continuing.
*Example:* `5`
### Optional data
* **Async**\
Type: `boolean`\
Runs the action in the background without blocking the conversation.
### Output
* Delays execution of the next step in the flow
* Continues automatically after the specified time
### Notes
* Value is in seconds
* Use short delays to avoid poor user experience
* Async mode allows conversation to continue without waiting
Adds or updates Call Attached Data (CAD) values during the interaction.
This action allows storing custom key-value data that can later be used by SIP integrations, external systems, APIs, workflows, or reporting tools.
CAD values can contain static values, tool parameters, action results, or dynamic interaction variables.
### Use Cases
* Store tool execution results in CAD
* Attach custom interaction metadata
* Pass values to external SIP providers
* Save routing or workflow information
* Add reporting or analytics fields
## Configuration
Before using this action, configure Dynamic Values in:
`Bot Configuration → Integrations → SIP Integration → Call Attached Data`
See [Call Attached Data](../../actions/telephony/call_attached_data)
## Parameters
| Parameter | Description |
| ----------------------- | ----------------------------------------------------------------------------- |
| Key | CAD field name configured in SIP Integration. |
| Value | Static value or dynamic interaction value assigned to the field. |
| Append to existing data | Appends new values instead of overwriting existing CAD data. |
| Async | Executes the action in the background without blocking the conversation flow. |
## Supported Value Sources
Values can contain:
* Static text
* Tool parameters
* Action results
* Interaction variables
* Bot variables
* Dynamic Values
## Example
| Key | Value |
| -------------------- | ------------------ |
| `int_dynamic_value1` | `Interaction Type` |
| `summary` | `Tool Result` |
| `status` | `finished` |
## Notes
* CAD values become available for downstream SIP integrations and APIs.
* Configured keys must exist in SIP Integration CAD settings.
* Existing values may be overwritten unless "Append to existing data" is enabled.
* Async mode allows the bot to continue the conversation without waiting for action completion.
# Speech and Voice
Source: https://docs.monobot.ai/actions/speech_voice/speech_voice
This page describes available actions used to control call behavior, voice interaction within your bot.
Actions are building blocks of your flow. Each action performs a specific function — such as capturing user input, playing messages or transferring calls.
Configure actions by defining required parameters and optional settings based on your use case.
Captures keypad input from the caller during a call.
### Required data
* **DTMF Value**\
Type: `string`\
Variable used to store the pressed key.
*Example:* `%dtmf%`
* **Output**\
Type: `string`\
Message returned after input is received.
*Example:* `DTMF signal %dtmf% was received.`
### Notes
* Used for IVR menus (Press 1 / Press 2)
* Can be used in conditions to route calls
Terminates the active call.
***
### Optional data
* **Answer**\
Type: `string`\
Message played before the call ends.
*Example:* `Thank you for calling. Goodbye.`
***
### Notes
* Immediately ends the call after execution
Switches language and voice processing during the call.
***
### Required data
* **Language**\
Type: `string`\
Language for recognition and responses.
*Example:* `English`
***
### Optional data
* **STT Processor**\
Type: `string`\
Speech-to-text engine.
*Example:* `Flux General`
* **VAD Model**\
Type: `string`\
Detects when user starts/stops speaking.
*Example:* `None`
* **EOT Model**\
Type: `string`\
Detects end of user speech.
*Example:* `None`
* **TTS Processor**\
Type: `string`\
Text-to-speech engine.
*Example:* `Deepgram Aura 2`
* **TTS Voice ID**\
Type: `string`\
Voice configuration.
*Example:* `aura-2-andromeda-en`
***
### Notes
* Affects both input (STT) and output (TTS)
* Use for multilingual flows
Transfers the call to another destination.
***
### Required data
* **Transfer To**\
Type: `string`\
Phone number, extension, or SIP URI.
*Examples:*\
`+14155551234`\
`222222`\
`sip:222222@example.com`
***
### Optional data
* **Is SIP**\
Type: `boolean`\
Enable if destination is SIP.
* **Introduction**\
Type: `string`\
Message before transfer.
***
### Notes
* Works only if a phone number is attached to the bot
Plays a voice message to the caller.
***
### Required data
* **Announcement Text**\
Type: `string`\
Text to be spoken.
*Example:* `Please hold while I connect you.`
***
### Optional data
* **Terminate LLM answer**\
Type: `boolean`\
Stops current AI response.
* **Incognito call**\
Type: `boolean`\
Prevents storing/logging message.
***
### Notes
* Used for system messages and prompts
# Send TG message
Source: https://docs.monobot.ai/actions/telegram/tg-send-msg
The **Telegram: Send message** action allows your AI assistant to send a message directly to a connected Telegram account. This is ideal for alerting users, admins, or staff about important events, summaries, or updates.
> To use this action, you must first connect a Telegram account via the **Integrations** tab in your dashboard.
***
## What It Does
This action sends a single Telegram message to the linked account. You can dynamically compose the message using parameters like `@userName`, `@orderStatus`, etc.
> 🔧 Use this for reminders, alerts, confirmations, or short summaries.
***
## Action Interface
***
## Configuration Options
**Type**: `string`
The text message to be sent to Telegram. Can include dynamic content via parameters.
*Example:*
> "Hey @userName, your delivery status is: @deliveryStatus."
**Type**: `boolean`
When enabled, this message will only be sent if all prior actions were completed successfully.
***
## Tips
* You can reference parameters like `@summary`, `@email`, or any output from earlier tools.
* Keep messages short and useful. Telegram bots support markdown formatting.
* Make sure the Telegram integration is active before using this action.
Let us know if you’d like example automations using Telegram alerts!
# Call Attached Data
Source: https://docs.monobot.ai/actions/telephony/call_attached_data
Call Attached Data (CAD) allows you to configure key-value pairs that are attached to calls and passed to downstream integrations and APIs.
CAD fields can be configured in two places:
* **Platform settings** — CAD fields applied across the tenant.
* **Bot configuration** — CAD fields applied only to interactions for the current bot.
All interactions in this tenant will use the CAD fields configured in Platform settings.
## Platform-level CAD configuration
`Platform Settings → System & Access → Call Attached Data`
## Configure CAD for a bot
`Agent Configuration → Integrations → SIP Integration → Call Attached Data`
To configure CAD fields for a specific bot:
1. Open **Bot configuration**.
2. Go to **Integrations**.
3. Open **SIP Integration**.
4. Select the **Call Attached Data** tab.
5. Click **New Field**.
6. Add the **Field Name**.
7. Select or enter the **Value**.
8. Click **Save**.
Only interactions in the current bot will use the CAD fields configured in the bot's SIP Integration settings, together with CAD fields from Platform settings.
## Field Name
The **Field Name** is the key that will be sent with the call.
Use clear and consistent names so downstream systems can recognize the data correctly.
Examples:
* `status`
* `summary`
* `csat`
* `int_bot_name`
* `int_bot_voice`
* `int_dynamic_value1`
## Value
The **Value** is the data attached to the field.
You can use available variables from the selector, such as:
* **Interaction** variables
* **Bot** variables
* **Dynamic Value** variables
Examples:
* `Interaction.status`
* `Interaction.Summary`
* `Interaction.CSAT`
* `Bot.name`
* `Bot.voice`
* `Dynamic Value`
## Example
| Field Name | Value |
| --------------- | --------------------- |
| `status` | `Interaction.status` |
| `summary` | `Interaction.Summary` |
| `csat` | `Interaction.CSAT` |
| `int_bot_name` | `Bot.name` |
| `int_bot_voice` | `Bot.voice` |
## Read CAD Fields
Call Attached Data (CAD) fields attached to interactions can be retrieved using API endpoints.
Supported response formats:
* JSON
* XML
***
## Read CAD in JSON Format
```http theme={null}
GET https://platform.monobot.ai/api/chatbot/interactions/{interactionId}/cad
```
### Path Parameters
| Parameter | Type | Description |
| ------------- | ------ | ------------------------------ |
| interactionId | string | Unique interaction identifier. |
### Response Example
```json theme={null}
{
"status": "finished",
"summary": "The customer requested to be redirected to an agent.",
"csat": 5,
"int_bot_name": "Support Bot",
"int_latency": 0.96
}
```
***
## Read CAD in XML Format
```http theme={null}
POST https://platform.monobot.ai/api/chatbot/interactions/read-cad-by-interaction-id
```
### Body Parameters
| Parameter | Type | Description |
| --------- | ------ | ------------------------------- |
| call\_id | string | Interaction or call identifier. |
| token | string | Authentication token. |
### Request Format
`x-www-form-urlencoded`
### Response Example
```xml theme={null}
```
***
## Notes
* CAD fields are returned based on interaction-level and bot-level CAD configuration.
* Returned fields may vary between interactions depending on configured dynamic variables.
* JSON format is recommended for API integrations and external systems.
* XML format is primarily used for SIP and telephony workflows.
* Empty or undefined CAD fields may be omitted from the response.
# External SIP Trunk
Source: https://docs.monobot.ai/actions/telephony/external_sip_trunk
The **External SIP Trunk** feature allows you to connect third-party telephony providers (e.g., Zadarma) to your AI voice agents.
This enables handling inbound and outbound calls using your own SIP infrastructure instead of built-in telephony services.
***
## Overview
External SIP Trunks are used when:
* you already have a telephony provider
* you want to route calls through your own SIP server
* you need flexibility in call handling and infrastructure
***
## How It Works
1. A phone number is configured on your SIP provider (e.g., Zadarma)
2. Calls are forwarded to your system via SIP (URI)
3. The system processes the call using the assigned AI agent
4. Responses are returned through the same SIP connection
***
## Provider Configuration (Example: Zadarma)
### 1. Open Phone Number Settings
* Navigate to: **Settings → Virtual Phone Number**
* Select your number
### 2. Enable External Server (SIP URI)
* Enable **External server (SIP URI)**
* Set the server address in the following format:
```
@:
```
**Example:**
```
13478979600@34.200.57.215:5080
```
**Where:**
* `13478979600` — your phone number
* `34.200.57.215:5080` — your system SIP endpoint
***
## System Configuration
### 3. Create External SIP Trunk
* Navigate to: **Phone Numbers → External SIP Trunks**
* Click **New External SIP Trunk**
### 4. Configure Fields
Fill in the following parameters:
* **Phone Number**\
Phone number from your provider
* **Termination URI**\
SIP endpoint of the provider\
*Example:* `sip.zadarma.com`
* **User Name**\
SIP login from the provider
* **Password**\
SIP password
* **Name**\
Internal label (any convenient name)
* **Enabled**\
Must be turned on
> SIP credentials are provided by your telephony provider.
***
### 5. Create Trunk
Click **Create** to save the configuration.
***
## Assign SIP Trunk to Agent
You can attach the SIP trunk in two ways:
### Option 1 — Agent Settings
* Open the AI agent configuration ('General' tab)
* Click the **Phone Number** dropdown
* Choose your External SIP Trunk
### Option 2 — Assignment Section
* Navigate to 'Phone numbers' --> 'External SIP Trunks' -- > Open your External SIP Trunk
* Assign an agent from the dropdown
## Result
Once configured:
* Incoming calls are routed through your SIP provider
* Calls are handled by the assigned AI agent
* Responses are processed in real time
***
## Best Practices
* Ensure SIP credentials are correct
* Verify that your provider allows external routing
* Keep the trunk **enabled**
* Test the setup with a real call
* Use clear and descriptive naming for trunks
***
## Notes
* External SIP Trunks require an active SIP provider
* Incorrect URI or credentials will prevent calls
* Ensure network/firewall allows SIP traffic
***
## Use Cases
* Connecting Zadarma, Twilio SIP, Asterisk
* Using custom VoIP infrastructure
* Enterprise call routing setups
* Multi-provider telephony environments
# Overview
Source: https://docs.monobot.ai/actions/telephony/overview
The **Voice Communication** section covers how your AI agent connects to and interacts with voice communication systems.
It enables handling inbound calls, integrating with telephony providers, and managing voice-based interactions through different protocols and infrastructures.
***
## What You Can Do
With telephony integrations, your system can:
* receive incoming calls
* route calls between agents or systems
* connect to external telephony providers
* handle voice-based customer interactions
* integrate with SIP and traditional phone networks
***
## Key Concepts
Telephony is built on several core technologies and standards:
* **SIP (Session Initiation Protocol)** — used for establishing and managing voice sessions
* **SIP Trunk** — connects your system to telephony providers over the internet
* **PSTN (Public Switched Telephone Network)** — traditional phone network
Each of these is explained in detail in the subpages.
***
## How It Works
A typical telephony flow:
1. A call is received or initiated
2. The system connects through a telephony provider
3. Voice interaction is handled by the AI agent
4. The call can be routed, transferred, or processed
***
## Use Cases
Telephony is commonly used for:
* call center automation
* voice assistants
* inbound customer support
* outbound notifications and campaigns
* call routing and forwarding
***
## Best Practices
* configure integrations before enabling call flows
* validate phone numbers and routing rules
* handle fallback scenarios (e.g., transfer to human)
* monitor call quality and connection stability
***
## Notes
* telephony behavior depends on your provider
* SIP and PSTN may have different limitations
* proper configuration is required for reliable operation
# PSTN
Source: https://docs.monobot.ai/actions/telephony/phone_number
The **PSTN (Public Switched Telephone Network)** allows your system to handle real phone calls and SMS using purchased phone numbers.
***
## Overview
Use PSTN when you need:
* inbound calls from real users
* SMS notifications and messaging
***
## Phone Numbers
All PSTN functionality is based on phone numbers.
Each number can:
* receive calls
* send SMS (See [SMS Usage](../communication/communication))
* be assigned to a specific agent
***
## Buy Phone Number
To start, you need to purchase a number.
### Steps
1. Go to **Phone Numbers**
2. Click **New Phone Number**
3. Select a **Country**
4. (Optional) Filter by digits using **"Phone number starts with"**
5. Choose from available numbers
6. Click **Buy Now**
### Notes
* Available numbers depend on country and provider
* Pricing and renewal are shown before purchase
* Some countries may have limited availability
***
## Connect Number to Bot
After purchasing, assign the number to an agent.
### How it works
* Incoming calls to the number → routed to the assigned agent
* The agent handles the conversation in real time
### Setup
* Open the phone number
* Select **Attached Agent**
* Save changes
> Only one agent handles incoming calls per number.
***
## SMS Usage
SMS can be used for notifications and communication.
### Supported actions
* send SMS to users
### Requirements
* correct country configuration
* valid recipient number
***
## Management
In **Phone Numbers**, you can:
* view all numbers
* check status and pricing
* see assigned agents
* manage renewals
***
## Best Practices
* use dedicated numbers per use case (support, sales, etc.)
* assign clear ownership (one agent per number)
* test both call and SMS flows
***
## Notes
* PSTN requires an active telephony provider
* pricing varies by country
# SIP Digest Authentication
Source: https://docs.monobot.ai/actions/telephony/sip_authentication
Secure access to your SIP endpoint using username and password authentication.
## Overview
SIP Digest Authentication is a security mechanism that verifies access to your SIP endpoint using a **username and password**.
This method uses a secure challenge-response mechanism, meaning the password is not sent in plain text.
***
## Why It’s Needed
Digest Authentication protects your system from:
* Unauthorized access
* Fraudulent outbound calls
* Unknown SIP connections
Only systems with valid credentials can connect.
***
### How It Works
SIP Digest Authentication uses a challenge-response mechanism to securely verify credentials.
***
#### Step-by-step flow
1. Client sends initial request (without authentication)
2. Server responds with:
* `401 Unauthorized`
* a **nonce** (challenge value)
3. Client generates a secure response using:
* SIP Username
* SIP Password
* Server-provided nonce
4. Client sends the request again with the computed response
5. Server validates the response:
* If valid → access granted
* If invalid → access denied
```
Client → REGISTER → Server
Server → 401 Unauthorized + nonce → Client
Client → REGISTER (with auth response) → Server
Server → 200 OK → Client
```
***
#### Important
The password is never sent directly. Instead, a hashed value is calculated using the password and server challenge.
Each authentication request uses a unique nonce, which prevents replay attacks.
## Configuration
Provide the following credentials:
* **SIP Username** — unique identifier for authentication
* **SIP Password** — secure password used for verification
These credentials must match the configuration on your SIP provider or PBX.
***
## When to Use
Use SIP Digest Authentication when:
* Your SIP provider requires **credential-based authentication**
* IP Whitelisting is not available or sufficient
* You need an additional layer of security
***
## Example
```
Username: sip-user-001
Password: ********
```
***
## Best Practices
Use strong, unique passwords and avoid sharing credentials publicly.
Incorrect credentials will result in failed call connections.
For maximum security, combine Digest Authentication with **IP Whitelisting** when possible.
# SIP Connection
Source: https://docs.monobot.ai/actions/telephony/sip_connection
Configure SIP integration to enable inbound voice calls, routing, and call transfers.
## Overview
SIP (Session Initiation Protocol) allows your bot to connect to telephony systems and handle voice calls.
With SIP integration, you can:
* Receive incoming calls
* Transfer calls to agents or external systems
## Configure SIP Integration
### 1. Open SIP Settings
1. Go to **AI Agents**
2. Open your bot
3. Navigate to **Integrations**
4. Click **Configure** in the **SIP Integration** block
### 2. SIP URI
The system generates a SIP URI automatically:
```
sip:@:
```
**Example:**
```
sip:34313580@34.200.57.215:5080
```
### 3. Extension
* Can be generated automatically
* Used as an internal routing identifier
### 4. Enable Integration
Enable the **Enabled** checkbox to activate SIP.
### 5. Method
| Method | Description |
| ------ | -------------------------------------------- |
| REFER | Standard SIP transfer (recommended) |
| INFO | Alternative method if REFER is not supported |
### 6. Target URI
Defines the destination for SIP call routing.
The Target URI tells the system where to send the call (typically your SIP provider or PBX).\
The `${extension}` placeholder is automatically replaced with the configured extension during the call.
```
sip:${extension}@
```
**Example:**
```
sip:${extension}@44.207.193.100
```
### 7. Save
Click **Save** to apply changes.
# SIP Extensions
Source: https://docs.monobot.ai/actions/telephony/sip_extension
Before configuring SIP routing, you can create an extension manually.
Creating an extension is **optional**.\
An extension can be **automatically generated** when configuring the SIP Integration.
***
### Create Extension (Optional)
1. Go to **Phone Numbers**
2. Open the **Extensions** tab
3. Click **+** to create a new extension
### Configuration
Fill in the required fields:
* **Number** — internal extension (e.g., `222222`)
* **Description** — optional label (e.g., `Support`, `Sales`)
* **Enabled** — must be active
***
### Example
```
Number: 222222
Description: Support
Enabled: true
```
### Usage
Extensions are used for:
* Call transfers via **Redirect Call**
* SIP routing (`sip:${extension}@...`)
* Connecting bot ↔ PBX ↔ agents
***
If you do not create an extension manually, the system will generate one automatically during SIP Integration setup.
# IP Whitelisting
Source: https://docs.monobot.ai/actions/telephony/whitelisting
Restrict SIP access to trusted IP addresses for secure communication.
## Overview
IP Whitelisting is a security feature that controls which IP addresses are allowed to access your SIP endpoint.
This feature is available for **Enterprise plans only**.
***
## How It Works
Whitelisting behavior depends on whether IPs are configured:
* **No IPs added** → all incoming calls are allowed
* **At least one IP added** → only calls from listed IPs are allowed
Once you add an IP address, all non-listed IPs will be blocked.
***
## Why It’s Important
Whitelisting helps protect your system from:
* Unauthorized access
* SIP scanning and attacks
* Toll fraud
***
## Configure IP Whitelisting
### 1. Open SIP Settings
1. Click your **Profile icon**
2. Select **Platform Settings**
3. Navigate to **SIP**
***
### 2. Add IP Address
* Enter the desired IP address, range, or pattern
* Click **Add**
Supported formats:
* Single IP: `88.214.8.230`
* Wildcard: `88.214.8.*`
* Range: `88.214.8.230-88.214.8.240`
* IPv6: `2001:db8::1`
***
### 3. Apply Configuration
* Changes take effect immediately after adding IPs
***
## Example
```
No whitelist configured:
→ All incoming calls are accepted
Whitelist configured:
88.214.8.230
→ Only this IP is allowed
→ All others are blocked
```
***
Make sure to whitelist all IP addresses used by your SIP provider or PBX.
# AI Agent Templates
Source: https://docs.monobot.ai/agent-settings/agents_templates
AI Agent Templates provide ready-made bot configurations for common business scenarios.
Templates help users quickly create an AI agent with predefined behavior, industry-specific conversation logic, and suggested setup structure.
## Template Library
The template library is available from the **AI Agents** page.
Users can:
* Search templates by name
* Browse templates by category
* Preview available use cases
* Create a new agent from a selected template
## Categories
Templates are grouped by business category, such as:
* Healthcare
* Restaurants
* Beauty Industry
* Transfers
* Career
* Traveling
* Sport
* Automotive
* Others
## Using a Template
To create an agent from a template:
1. Open **AI Agents**
2. Click **New Agent**
3. Browse or search available templates
4. Select the needed template
5. Click **Use Template**
6. Review and customize the generated bot configuration
Templates provide a starting point. After creating an agent, users can edit flows, prompts, knowledge base, integrations, and voice settings.
## Available Templates
Examples of available templates include:
| Template | Use Case |
| -------------------------- | -------------------------------------------------- |
| Taxi | Ride booking and reservation support |
| Outsourcing Company | Company information and customer assistance |
| Modular Home Manufacturing | Modular housing consultations and lead collection |
| Reality Capture Company | Service information and project-related assistance |
| Sushi Restaurant | Restaurant questions and delivery orders |
| Pizza Delivery and Pickup | Pizza menu, hours, delivery and pickup support |
| Sport Club | Gym, pool, spa, and class guidance |
| Barber Shop | Appointment booking and customer preferences |
| Mercedes-Benz Service | Vehicle maintenance and service scheduling |
| VET | Veterinary appointments and pet service questions |
| Interview Agent | Interview automation and candidate screening |
| Dental Clinic | Clinic information and appointment scheduling |
| Limo Service | Limo quotes and reservations |
| Global Health | Healthcare information and appointment support |
| Dining Reservations | Restaurant table reservation assistant |
| Real Estate | Property questions and viewing requests |
| Travel Agency | Travel bookings and itinerary assistance |
| Job Search | Job matching and application assistance |
| Moving Company | Moving quotes and customer support |
# Debug Mode
Source: https://docs.monobot.ai/agent-settings/debug_mode
Debug Mode allows developers and operators to monitor the internal bot execution process in real time directly from the platform interface.
While the assistant processes user requests, logs are streamed into the **Live Debug Feed**, showing step-by-step execution details including tool calls, actions, execution time, responses, warnings, and errors.
## Enabling Debug Mode
Debug Mode can be enabled directly from the bot Flow editor.
Navigate to:
```txt theme={null}
Bot Configuration → Flow
```
Enable the **Debug mode** checkbox in the top-right corner of the Flow editor interface.
Debug logs will start appearing in the Live Debug Feed only after Debug Mode is enabled.
## What is Debug Mode
Debug Mode is a real-time debugging interface that helps monitor:
* Active flows
* Tool execution
* Action execution
* LLM requests and responses
* Errors and warnings
* Custom logs from Function actions
* Execution timing and performance
Logs are streamed directly from the backend and displayed live without refreshing the page.
## Why Use Debug Mode
| Scenario | What Debug Mode Provides |
| ---------------------------------- | ----------------------------------------------------------- |
| Bot gives unexpected response | Shows active flows, tools, and passed arguments |
| Action works slowly | Shows execution time for every action |
| Need to inspect action result | Shows full JSON result returned by actions |
| LLM behaves unexpectedly | Shows model name, API version, and full response |
| Tool or action error | Shows `[ERROR]` and `[WARNING]` messages |
| Developing custom Function actions | Shows custom logs created through `interaction["_LOGGING"]` |
# Live Debug Feed
The **Live Debug Feed** displays all interaction logs in chronological order.
Each log entry contains:
| Field | Description |
| ---------- | ------------------------------------------- |
| Timestamp | Time in `HH:MM:SS.mmm` format |
| Level | `[INFO]`, `[WARNING]`, `[ERROR]`, `[DEBUG]` |
| Event Type | `[CHAT]`, `Action`, `Tool`, or system event |
| Message | Short description of the event |
Clicking a log entry opens additional details including full JSON payloads, arguments, and execution results.
## Session Start Example
```txt theme={null}
16:37:02.024 [INFO] [CHAT] Session started
16:37:02.029 [INFO] Active flow: "Root Flow"
```
Shows the interaction start and currently active flow.
## User Request Example
```txt theme={null}
16:37:12.196 [INFO] [CHAT] Request "propan"
Tools (1): "commodity_code_search"
```
Shows the incoming user request and available tools provided to the model.
## Tool Execution Example
```txt theme={null}
16:37:13.589 [INFO] [CHAT] Tool Running tool "commodity_code_search"
Arguments: product_name: Liquefied propane...
Tool description: Use this tool to search for...
```
Displays:
* Tool name
* Arguments passed by the LLM
* Tool description
* Tool execution start
## Action Execution Example
```txt theme={null}
16:37:13.946 [INFO] Action Action "reasoning_rag"
Condition: "PASS"
Execution time: 14.106 sec
Result: {"answers": [...], "found_digit_code": null}
```
Each action execution contains:
| Field | Description |
| -------------- | ----------------------------------------------------- |
| Condition | Whether execution condition passed (`PASS` or `SKIP`) |
| Execution time | Time spent executing the action |
| Result | Full JSON response returned by the action |
***
## Tool Completion Example
```txt theme={null}
16:37:28.294 [INFO] Tool execution finish: 14.705 sec
```
Shows total execution time for the entire tool execution chain.
## Bot Response Example
```txt theme={null}
16:37:29.183 [INFO] [CHAT] Response "Which best describes..." in 16.982 sec
API version: Responses
Model name: Openai "gpt-5.2 Chat"
```
Displays:
* Final assistant response
* Total generation time
* API provider version
* Model name
# Custom Logs in Function Actions
Function actions can send custom logs directly into Debug Mode using `interaction["_LOGGING"]`.
## Example
```python theme={null}
def my_function(tool_params, interaction):
interaction["_LOGGING"].info("Starting product lookup")
interaction["_LOGGING"].warning("Product not found, using fallback")
interaction["_LOGGING"].error("External API returned 500")
interaction["_LOGGING"].debug("Raw response: " + str(raw))
```
These logs appear together with system logs inside Live Debug Feed.
## Logging Levels
| Level | Description |
| ------- | ---------------------------------------- |
| INFO | Standard execution information |
| WARNING | Non-critical issue or fallback |
| ERROR | Critical execution problem |
| DEBUG | Detailed developer debugging information |
# Full Debug Flow Example
```txt theme={null}
16:37:02.024 [INFO] [CHAT] Session started
16:37:02.029 [INFO] Active flow: "Root Flow"
16:37:12.196 [INFO] [CHAT] Request "propan"
Tools (1): "commodity_code_search"
16:37:13.589 [INFO] [CHAT] Tool Running tool "commodity_code_search"
16:37:13.946 [INFO] Action Action "reasoning_rag"
Condition: "PASS"
Execution time: 14.106 sec
16:37:28.294 [INFO] Tool execution finish: 14.705 sec
16:37:29.183 [INFO] [CHAT] Response "Which best describes your propane shipment?"
Model name: Openai "gpt-5.2 Chat"
```
# Technical Details
* Logs are streamed through Redis pub/sub.
* Events are stored in `events:{interaction_uuid}` queue with TTL.
* Each log contains:
* `id`
* `timestamp`
* `level`
* `message`
* optional `details`
* optional nested `children`
* Nested logs are displayed in UI as expandable trees.
* Logs remain available during TTL lifetime after interaction completion.
# Notes
* Debug Mode is intended for development and troubleshooting.
* Full responses and action results may contain sensitive information.
* Excessive debug logging may affect readability during large interactions.
* Custom Function logs are supported only inside Function-type actions.
# Custom Tool
Source: https://docs.monobot.ai/agent-settings/flow/custom-tool
The **Custom Tool** configuration allows you to define how the AI agent interacts with external systems, APIs, or internal logic.
A tool represents an action the agent can execute during a flow, such as retrieving data, sending requests, or performing operations.
## Adding a Custom Tool to a Node
Click the **+** button under the node to add a tool.
The tool will be executed based on the node logic and tool configuration. Multiple tools can be added if needed.
## General Configuration
* **Tool Name**:\
Unique identifier used in flows (e.g., `create_lead_record`).
* **Use Tool (Enabled)**:\
Enables or disables execution of the tool.
* **Global Tool**:\
Makes the tool available in the global configuration canvas.
* **Use For**:\
Defines where the tool can be used:
* **Call**
* **Chat**
* **Call and Chat**
***
## Description
Defines **when and how the tool should be triggered**.
This is critical because the system uses this text to understand:
* when to call the tool
* under which conditions it should run
* whether it should be triggered silently or as part of a visible interaction
Example:
```text theme={null}
Silently trigger this function as soon as the client has provided their full name and phone number.
```
***
## Announcement
The **Announcement** is a message shown to the user before the tool is executed.
Example:
```text theme={null}
Let me check that for you.
```
***
## Parameters
Parameters define the values the tool will use during execution.
Each parameter represents a piece of data passed into the tool.
### Parameter Fields
* **Name**:\
Parameter key used in the request (e.g., `name`, `pickup_location`)
* **Description**:\
Explains what the parameter represents.
Examples:
```text theme={null}
Client's name.
Pickup location address or place where the ride should start.
```
* **Possible Values**:\
Defines allowed values for the parameter.\
Values should be provided as a comma-separated list (e.g., `SEDAN, SUV, VAN`).\
This acts like an enum and helps guide valid inputs.
* **Required**:\
Indicates whether the parameter must be collected before the tool can be executed.\
If enabled, the system will ensure the value is provided before triggering the tool.
***
## Using Values Collected in a Node
Tool parameters can use values collected during node execution:
* first name
* last name
* phone number
* email
* addresses
* other user-provided data
***
## Tool Usage in Nodes
Tools are assigned to nodes.
* One node can trigger one or multiple tools
* Tools use data collected in the node
***
## Execution Flow
1. Node is reached
2. Parameters are checked
3. Missing data collected
4. Announcement (optional)
5. Tool executes
6. Result used in flow
***
## Notes
* Tools depend on node data
* Parameters connect user input with actions
# Node
Source: https://docs.monobot.ai/agent-settings/flow/node
The **Flow** tab defines how your AI agent behaves by organizing the interaction into a sequence of **connected nodes**.
A **flow** is a visual and logical structure where each step of the conversation is represented by a node. Nodes are connected together to control how the interaction progresses based on user input, system state, and predefined logic.
The flow always starts from an **entry node** and dynamically moves between nodes until the interaction is completed.
## Adding Elements to the Flow
Click the **+ Add Element** button on the canvas to create a new element in your flow.
Available element types:
* **Node** — handles conversation logic
* **Action** — executes tools or system operations
To start building a flow, add a **Conversation** node.\
This node is used to send messages, ask questions, and collect user input.
All elements must be connected using transitions to define how the flow progresses.
***
## Node-Based Architecture
Each flow is composed of interconnected nodes that define how the interaction progresses.
A **node** is a configurable step in the flow. Depending on its setup, a node can be used to:
* collect user input (e.g., name, phone, address)
* send messages or prompts to the user
* apply logic or conditions
* trigger tools, APIs, or integrations
* process or transform data
* route the interaction to the next step
Nodes are flexible and can perform different roles depending on configuration.
***
## Node Configuration
Each node contains settings that control its behavior and interaction logic.
### Flow Name
* Defines the name of the current flow
* Used for identification and organization
***
### Instruction
Defines how the agent should behave within this node.
This is the core logic that controls:
* how the agent communicates
* what data should be collected
* how the conversation progresses
Example:
```mdx theme={null}
# Introduction
Follow these steps in order. One question per message. Do not combine steps. Do not proceed to the next step until the user answers the current one. If info is already known, briefly confirm it and move on.
1. Start without a greeting.
2. Ask the following three details ONLY:
- First name;
- Last name;
- Phone Number;
(only if not already provided earlier in the conversation).
Trigger "create_lead_record" as soon as data provided.
```
# Transitions
Source: https://docs.monobot.ai/agent-settings/flow/transitions
Transitions define how the flow moves from one node to another.
They control what happens next based on user input, context, or defined conditions.
## What is a Transition
A **transition** is a connection between nodes that determines the next step after a node is executed.
Each node can have one or multiple transitions, enabling dynamic and flexible conversation paths.
***
## Transition Settings
Each transition can be configured using the following fields:
***
### Transition
Defines **when this transition should be triggered**.
* Written as natural language instruction
* Interpreted by the AI to decide routing
Example:
The client wants to book a vehicle for a special event (e.g., prom, wedding).
***
### Announcement
Message sent to the user **before moving to the next node**.
Use this when:
* you want to confirm understanding
* you want to guide the user
* you need a smoother transition
Example:
```text theme={null}
Great, I’ll help you with that.
```
If left empty, the transition happens silently.
***
### Extract Variables
Defines which values should be extracted from the user input during the transition.
This allows the system to capture structured data while routing to the next node.
Extracted variables can be reused later in the flow or passed into tools.
Examples of extracted values:
* event type
* location
* date
* time
* customer name
* phone number
* any other user-provided data
***
#### Extract Variable Fields
* **Name**:\
Variable key used in the flow (e.g., event\_type, pickup\_location)
* **Description**:\
Explains what value should be extracted
Examples:
```text theme={null}
Type of event the client is booking for.
Pickup location address or place where the ride should start.
```
* **Possible Values**:\
Comma-separated list of allowed values (e.g., wedding, prom, birthday, corporate)
* **Required**:\
Indicates whether the value must be extracted before the transition proceeds
* **Remove**:\
If enabled, the value will not be stored after extraction
***
## How It Works
1. Node finishes execution
2. Transition conditions are evaluated
3. Matching transition is selected
4. Variables are extracted (if configured)
5. Announcement is sent (if configured)
6. Flow moves to the next node
***
## Multiple Transitions
* A node can have multiple transitions
* The first matching transition is used
***
## Default Behavior
If no condition matches:
* use a fallback transition
* prevent dead ends in the flow
***
## Best Practices
* Keep conditions clear and specific
* Avoid overlapping logic
* Always define a fallback path
* Extract only necessary variables
* Use announcements only when needed
* Keep naming consistent across the flow
***
## Notes
* Transitions define the routing logic between nodes
* Extracted variables allow structured data to persist across the flow
* Proper configuration ensures stable and predictable behavior
# General
Source: https://docs.monobot.ai/agent-settings/general
The **General** tab allows you to configure the core settings of your AI agent, including identity, behavior, and default interaction parameters.
## Basic Settings
* **Agent Title**: Defines the name of your AI agent as it appears across the platform and in interactions.
* **Organization**: Assigns the agent to a specific organization for management, billing, and access control.
## Location & Contact Settings
* **Timezone**: Sets the default timezone used for all date and time-related operations (e.g., scheduling, timestamps, availability).
* **Phone Number**: Assigns a phone number to enable voice interactions and call handling for the agent.
## Large Language Model Settings
* **Large Language Model**: Selects the AI model that powers the agent’s responses and reasoning capabilities.
* **Temperature**: Adjusts response creativity (higher = more creative and varied responses, lower = more consistent and deterministic).
## Welcome Message
* **Welcome Message**: Defines the first message users see when starting an interaction with the agent.
## Prompt Instruction
* **Prompt Instruction**: Defines the core behavior, personality, and rules of the AI agent.
* Controls how the agent communicates, what it is allowed to do, and how it handles different scenarios.
* Used to enforce constraints (e.g., no hallucination, use only provided data).
* Guides data collection, conversation flow, and response style.
### Dynamic Variables (@)
You can use **dynamic variables** inside the prompt by typing `@` and selecting from the available options. These variables allow you to inject real-time data into the prompt.
Examples of commonly used variables:
* **@Full Date**: Inserts the current date.
* **@Time 12-hour / @Time 24-hour**: Inserts the current time in the selected format.
* **@Current Day of Week**: Inserts the current weekday.
* **@Conversation Type**: Provides the current interaction type (Chat, Call).
* **@Timezone**: Returns the configured timezone.
* **@Language / @Language Code**: Provides the user’s language settings.
These variables help make the agent more context-aware and enable dynamic, time-sensitive behavior.
***
## Notes
* The **Prompt Instruction** is the most important setting and directly impacts agent performance.
* The **Temperature** setting should be lower for structured tasks (e.g., booking) and higher for creative conversations.
* Dynamic variables (`@`) should be used when the agent needs real-time context (e.g., date, time, or interaction type).
* Ensure the **Timezone** is correctly set to avoid issues with scheduling and time-based logic.
# Integrations
Source: https://docs.monobot.ai/agent-settings/integrations
The **Integrations** tab allows you to connect your AI agent with external services, APIs, and platforms to extend its capabilities and automate workflows.
## Available Integrations
You can connect a variety of services to enable different features:
# Integrations
Integrations connect your assistant with external platforms and services.\
They allow the assistant to access data, trigger actions, manage bookings, send messages, handle calls, and automate workflows across different systems.
Use integrations when your assistant needs to interact with third-party tools such as calendars, email, telephony, booking platforms, e-commerce systems, or customer communication channels.
Google integration allows the assistant to work with Google services such as scheduling, emails, calendars, maps, and connected workspace tools.
It can be used to manage calendar events, search or update information, send emails, calculate routes, and interact with connected Google Workspace services.
## Authentication
To connect Google integration:
1. Open the Integration configuration
2. Click **Connect Google**
3. You will be redirected to the Google authorization page
4. Sign in with your Google account
5. Grant the requested permissions
6. After successful authorization, the integration becomes available for actions and tools
Google authentication uses OAuth authorization flow and may require additional permissions depending on enabled actions.
## Supported Features
* Google Calendar management
* Gmail integration
* Google Maps actions
* Route and distance calculations
* Address autocomplete
* Calendar event search
* Calendar event creation and updates
* Email sending
* Workspace synchronization
## Notes
* Valid Google authorization is required before using Google actions.
* Some features may require Google Workspace permissions.
* Access permissions depend on the connected Google account.
Instagram integration allows the assistant to automate replies and interactions with your Instagram audience.
It can be used to respond to messages, support customer conversations, automate communication workflows, and manage communication through Instagram Direct Messages.
## Authentication
To connect Instagram integration:
1. Open the Integration configuration
2. Enter the required Instagram integration credentials
3. After successful setup, Instagram actions and automations become available
Instagram integration requires a properly configured Instagram Business or Creator account.
## Supported Features
* Instagram Direct Message automation
* Automated replies
* Customer communication workflows
* AI assistant conversations
* Message handling and routing
* Lead collection and engagement
## Notes
* Valid integration configuration is required before using Instagram actions.
* Personal Instagram accounts may not be supported.
* Available features depend on connected account permissions.
SIP integration enables voice calls through your telephony system.
It allows the assistant to connect with external SIP providers, route calls, and support voice-based communication workflows.
### SIP URI
The system generates a SIP URI automatically:
```
sip:@:
```
**Example:**
```
sip:34313580@34.200.57.215:5080
```
### Extension
* Can be generated automatically
* Used as an internal routing identifier
### Enable Integration
Enable the **Enabled** checkbox to activate SIP.
### Method
| Method | Description |
| ------ | -------------------------------------------- |
| REFER | Standard SIP transfer (recommended) |
| INFO | Alternative method if REFER is not supported |
### Target URI
Defines the destination for SIP call routing.
The Target URI tells the system where to send the call (typically your SIP provider or PBX).\
The `${extension}` placeholder is automatically replaced with the configured extension during the call.
```
sip:${extension}@
```
**Example:**
```
sip:${extension}@44.207.193.100
```
Genesys integration helps manage customer interactions and support workflows.
It can be used to connect the assistant with contact center processes, customer service flows, and support routing logic.
WooCommerce integration allows the assistant to access e-commerce data such as products, orders, and customer information.
It can be used for order checks, product-related questions, customer support, and store automation workflows.
## Configuration
To connect WooCommerce integration, configure the following fields:
| Field | Description |
| --------------- | ------------------------------------- |
| Base URL | Base URL of your WooCommerce store. |
| Consumer Key | WooCommerce REST API consumer key. |
| Consumer Secret | WooCommerce REST API consumer secret. |
### Example
```txt theme={null}
Base URL:
https://your-store.com
Consumer Key:
ck_xxxxxxxxxxxxxxxxx
Consumer Secret:
cs_xxxxxxxxxxxxxxxxx
```
WooCommerce REST API credentials can be generated in WooCommerce → Settings → Advanced → REST API.
## Supported Features
* Product search
* Product information lookup
* Order management
* Customer information retrieval
* Store automation workflows
* AI-powered customer support
* Order status tracking
## Notes
* Valid WooCommerce REST API credentials are required.
* WooCommerce REST API must be enabled on the store.
* Permissions depend on generated API key access rights.
* HTTPS is recommended for production stores.
EverTransit integration allows the assistant to manage ride and transportation data.
It can be used for transportation workflows, reservation details, ride updates, booking-related automation, and dispatch operations.
## Configuration
To connect EverTransit integration, configure the following fields:
| Field | Description |
| ------- | ---------------------------------------------------------------------------------- |
| API Key | API key used to authenticate requests and securely connect to the EverTransit API. |
### Example
```txt theme={null}
API Key:
xxxxxxxxxxxxxxxxxxxxxxxx
```
The API key is provided by EverTransit and is required for all transportation and reservation actions.
## Supported Features
* Ride reservation management
* Reservation status lookup
* Transportation workflows
* Ride updates and automation
* Dispatch-related operations
* Customer ride information retrieval
* Booking management
## Notes
* Valid EverTransit API credentials are required.
* API permissions depend on your EverTransit account configuration.
* Some features may depend on enabled EverTransit modules.
* Incorrect or expired API keys may cause request failures.
Cal.com integration allows the assistant to handle scheduling, availability, and bookings.
It can be used to check available time slots, create bookings, reschedule appointments, cancel meetings, and manage appointment-based workflows.
## Configuration
To connect Cal.com integration, configure the following fields:
| Field | Description |
| ------- | ------------------------------------------------------------------------------ |
| API Key | API key used to authenticate requests and securely connect to the Cal.com API. |
### Example
```txt theme={null}
API Key:
cal_xxxxxxxxxxxxxxxxx
```
The API key can be generated from your Cal.com account settings and is required for all booking and scheduling actions.
## Supported Features
* Search available slots
* Create bookings
* Cancel bookings
* Reschedule bookings
* Retrieve booking information
* Appointment automation workflows
* Calendar synchronization
## Notes
* Valid Cal.com API credentials are required.
* Calendar availability depends on connected calendars inside Cal.com.
* Timezone handling may affect returned availability slots.
* Incorrect or expired API keys may cause request failures.
Send Email integration allows the assistant to send emails directly from your system using SMTP.
It can be used for confirmations, notifications, summaries, follow-ups, and internal team updates.
### Configuration
To use SMTP email, you need to configure at least one connection.
### Required fields
* **Connection Name**\
Type: `string`\
Internal name for the SMTP connection.
*Example:* `Gmail SMTP`
* **SMTP Host**\
Type: `string`\
Address of your email provider’s SMTP server.
*Examples:*
* `smtp.gmail.com`
* `smtp.office365.com`
* **SMTP Port**\
Type: `number`\
Port used for SMTP connection.
*Common values:*
* `465` — SSL
* `587` — TLS
* `25` — (not recommended)
* **SMTP Authorization**
Credentials used to authenticate with the SMTP server.
* **Username**\
Type: `string`\
Usually your email address
* **Password**\
Type: `string`\
Email password or app-specific password
### Multiple connections
You can configure multiple SMTP connections.
Use this when:
* Sending emails from different addresses
* Supporting multiple clients
* Separating environments (e.g., staging / production)
### Notes
* Use app passwords for providers like Gmail
* Ensure SMTP is enabled in your email provider settings
* Incorrect credentials will prevent email delivery
* Port and security type must match provider requirements
Emails will not be sent without a valid SMTP configuration.
Syrve integration allows the assistant to access restaurant data and integration settings.
It can be used for restaurant workflows, operational data management, reservation handling, order tracking, and connected service automation.
## Configuration
To connect Syrve integration, configure the required API credentials and restaurant settings.
Valid Syrve integration configuration is required before using Syrve actions and restaurant workflows.
## Supported Features
* Restaurant operational workflows
* Reservation and table management
* Order status retrieval
* Restaurant section management
* Table availability lookup
* Connected restaurant automation
* Customer support workflows
## Notes
* Valid Syrve API credentials are required.
* Available features depend on enabled Syrve modules.
* Restaurant-specific permissions may affect accessible data.
* Incorrect configuration may prevent actions from working properly.
G-Net integration allows you to configure integration settings using API tokens.
It can be used to connect the assistant with G-Net services and enable related automation workflows.
## Configuration
To connect G-Net integration, configure the following fields:
| Field | Description |
| ----------- | ------------------------------------------------------------------------------- |
| G-Net Token | API token used to authenticate requests and securely connect to G-Net services. |
### Example
```txt theme={null}
G-Net Token:
xxxxxxxxxxxxxxxxxxxxxxxx
```
Valid G-Net API credentials are required before using G-Net actions and automation workflows.
## Supported Features
* G-Net service integration
* Automation workflows
* Connected service operations
* API-based communication
* Assistant interaction workflows
* External service synchronization
## Notes
* Valid G-Net token is required.
* Permissions depend on the provided API token.
* Incorrect or expired tokens may prevent actions from working.
* Available features may depend on enabled G-Net services.
Altegio integration allows the assistant to access service categories and booking-related data.
It can be used for appointment scheduling, service selection, staff availability, and booking management.
**Required fields:**
* **Location ID** — your Altegio location identifier
* **Partner Token** — API access token
* **User Token** — user authorization token
Tools will not work without valid integration configuration.
### How to get Altegio credentials
To configure the Altegio integration, you need to obtain the required values from your Altegio account.
### Location ID
The unique identifier of your business location in Altegio.
**Where to find:**
* Open Altegio dashboard
* Go to **Settings → General**
* Locate your **Location ID** (may also appear in the URL or API section)
### Partner Token
Used for API access to Altegio services.
**Where to get:**
* Go to **Settings → Integrations / API**
* Generate or copy your **Partner Token**
### User Token
Represents the authorized user for API requests.
**Where to get:**
* In **API / Integrations settings**, generate a **User Token**
* Alternatively, obtain it via authentication flow if required
### Notes
* All fields are required for the integration to work
* Tokens must have proper permissions enabled
* Keep tokens secure and do not expose them publicly
* If tokens are invalid or expired, tools will not function
***
## Connecting an Integration
* Click **Connect** to authorize and link an external service.
* Follow the authentication steps required by the provider.
* Once connected, the integration becomes available for use in your agent.
For some integrations:
* **Configure** may be required after connection (e.g., SMTP, SIP).
* Additional credentials such as API keys or tokens may be needed.
***
## Integration States
* **Connected**: Integration is active and ready to use.
* **Disconnected**: Integration is not active or has been removed.
* **Configure**: Additional setup is required.
* **Coming Soon**: Integration is not yet available.
***
## How It Works
* Integrations extend the agent’s capabilities beyond basic conversations.
* They can be triggered within flows or used by tools to perform actions.
* The agent can retrieve, send, or update external data in real time.
Examples:
* Create bookings via **Cal.com**
* Send emails via **SMTP**
* Retrieve products from **WooCommerce**
* Handle calls via **SIP**
***
## Best Practices
* Connect only the integrations you need to keep the system clean and secure.
* Ensure all credentials and tokens are valid and up to date.
* Test integrations after setup to verify correct behavior.
* Use integrations together with **Flows** for automation.
***
## Notes
* Some integrations require external accounts and permissions.
* Missing or incorrect configuration may cause failures in flows.
* Integration availability and features may vary depending on provider.
# Interactions
Source: https://docs.monobot.ai/agent-settings/interactions
The **Interactions** page shows conversations between users and AI Agents.
It helps review user messages, assistant responses, interaction metadata, sentiment, CSAT, topics, and technical details for each conversation.
## Overview
Use the Interactions section to:
* Review chat and voice transcripts
* Check interaction status
* See the assigned AI Agent
* View model and usage details
* Analyze sentiment and CSAT
* Review topics, summaries, and keywords
* Inspect customer environment details
## Interaction Transcript
The transcript displays the full conversation between the user and the assistant.
Each message includes:
| Field | Description |
| --------- | ------------------------------------------------------------ |
| Role | Shows whether the message was sent by the user or assistant. |
| Timestamp | Shows when the message happened inside the interaction. |
| Message | Full text of the user or assistant message. |
| Sentiment | Displays detected user sentiment when available. |
## Interaction Details
The details panel contains metadata about the selected interaction.
| Field | Description |
| ----------------- | ---------------------------------------------------- |
| Agent | AI Agent used in the interaction. |
| Organization | Organization where the interaction belongs. |
| LLM Model | Model used to generate assistant responses. |
| Type | Interaction type, such as Text Chat or Voice Call. |
| Status | Current interaction status, for example Finished. |
| Messages Count | Total number of messages in the interaction. |
| Billable Messages | Number of messages counted for billing. |
| Start Time | Date and time when the interaction started. |
| Duration | Total interaction duration. |
| Browser | User browser. |
| OS | User operating system. |
| IP Address | User IP address. |
| Country | Detected user country. |
| City | Detected user city. |
| URL | Page or platform URL where the interaction happened. |
| Total Costs | Estimated interaction cost. |
| CSAT | Customer satisfaction score. |
| CSAT Description | Explanation of the detected satisfaction score. |
## Topics Summary
The Topics Summary section provides an AI-generated overview of the interaction.
It may include:
| Field | Description |
| --------------------- | --------------------------------------------------- |
| Topic | Main conversation topic. |
| Summary | Short summary of the interaction. |
| Sentiment | Detected customer sentiment. |
| Sentiment Description | Explanation of the detected sentiment. |
| Keywords | Important keywords extracted from the conversation. |
## Sentiment
Sentiment helps understand the customer’s emotional tone during the interaction.
Possible sentiment values may include:
* Positive
* Neutral
* Negative
Sentiment is generated automatically and should be used as a support signal, not as the only source of evaluation.
## Notes
* Interaction details may vary depending on chat, voice, or integration type.
* Some fields may be empty if the data was not available.
* Costs are calculated based on platform billing logic.
* CSAT, sentiment, topics, and summaries are generated automatically.
# Knowledge Base
Source: https://docs.monobot.ai/agent-settings/knowledge-base
The **Knowledge Base** tab allows you to manage structured data sources used by your AI agent to generate accurate and context-aware responses.
## Knowledge Categories
* **Knowledge Categories**: Organize information into separate categories (e.g., FAQ, Vehicles, Pricing).
* Each category represents a specific type of data the agent can use during conversations.
* Categories can contain structured or unstructured data.
### Creating a Category
* Enter a name in **Category Name**.
* Click to create the category.
* Add files to the category using supported formats.
***
## Supported File Types
You can create or upload different types of files depending on your use case:
* **CSV**: Structured data (e.g., pricing tables, vehicles, services).
* **TXT**: Plain text content (e.g., FAQs, company info, policies).
* **JSON**: Structured data with flexible schema for advanced use cases.
* **Web Page**: Import content directly from a URL.
* **PDF (upload only)**: Documents such as manuals or policies.
### Importing Files
* Drag and drop files into the upload area or click to upload.
* Supported formats: **PDF, JSON, TXT, CSV**.
* Maximum file size: **50MB**.
***
## Preview Data
* **Preview Data** allows you to view the uploaded content inside a category.
* For **CSV files**, data is displayed in a table format (rows and columns).
* For **text-based files**, content is shown as plain text.
Use this section to:
* Verify that data is uploaded correctly
* Check column structure and values
* Ensure formatting is clean and usable by the agent
***
## Instructions
* **Instructions** define how the agent should interpret and use data from this category.
* You can provide additional guidance to improve how the model retrieves and responds with this data.
Examples:
* Explain what the data represents (e.g., “This file contains vehicle types and capacity”)
* Add constraints (e.g., “Use only exact matches for vehicle type”)
* Guide response formatting (e.g., “Always include capacity and luggage in the answer”)
This helps improve accuracy and reduces incorrect interpretations.
***
## Category Configuration
* **Category Name**: Defines how the category is labeled and referenced inside the agent.
* **Data Source**: Upload and manage files associated with the category.
* **CSV Structure**:
* Columns represent attributes (e.g., vehicle type, capacity, luggage)
* Rows represent individual records
* Used for precise lookups and filtering
***
## Advanced Category & Document Settings
The Knowledge Base provides additional configuration options to fine-tune how data is processed and retrieved.
### Search Configuration
* **Chapter Count**:\
Defines how many relevant data chunks are returned per request.\
Higher values increase context but may introduce noise.
* **Threshold**:\
Controls how strictly results are filtered by relevance.\
Higher = stricter matching (more precise results), lower = broader results (less strict).
***
### CSV Splitter Configuration
Used to control how structured data (CSV) is interpreted and returned.
* **Use Custom Config**:\
Enables manual control over how CSV data is processed.
#### Chapter Search Template
* Defines which fields are used to **search and match** data.
* Example:
* Capacity
* Luggage
These fields are used to filter and find relevant records.
#### Chapter Output Template
* Defines how the data is **formatted and returned** to the model.
* Example:
* Vehicle
* Capacity
* Luggage
* Vehicle type code
This controls what the agent receives and uses in responses.
***
## How It Works
* User sends a request
* The system searches the Knowledge Base
* Data is filtered using **Threshold**
* Top results are selected using **Chapter Count**
* CSV data is processed using **Search Template**
* Final output is formatted using **Output Template**
***
## Best Practices
* Use **CSV or JSON** for structured, filterable data.
* Use **TXT or PDF** for descriptive content.
* Keep categories **focused and well-organized**.
* Use **Chapter Count (1–3)** for precise results.
* Use **Threshold (0.7–1)** for strict matching.
* Add **Instructions** to guide the model behavior.
* Always verify data using **Preview Data** before deploying.
***
## Notes
* The Knowledge Base is the agent’s **source of truth**.
* The agent should rely only on this data when strict instructions are used.
* Poorly structured or outdated data may lead to incorrect responses.
* Advanced settings significantly impact response accuracy and relevance.
# Event Tools
Source: https://docs.monobot.ai/agent-settings/tools/event_tools
Event tools allow you to execute actions automatically based on specific interaction events.
They are used to trigger logic without requiring explicit user input or manual conditions.
## Adding Event Tools to a Node
Click the **+** button under the node to add a tool:
* select **Node**
* select an **Event Tool** from the list
Event tools are attached to a node and executed automatically when the corresponding event occurs.
***
## Available Event Types
* **On Start Event** — triggered when the interaction begins
* **On Query Event** — triggered when the user sends a message
* **On Answer Event** — triggered when the assistant responds
* **On Finish Event** — triggered when the interaction ends
* **On Schedule Event** — triggered at a scheduled time
***
## How It Works
* The event occurs during the interaction
* The corresponding event tool is triggered
* The configured action is executed
***
## Usage
Event tools are typically used for:
* logging or analytics
* triggering background processes
* sending notifications
* executing integrations
* handling lifecycle events
***
## Best Practices
* Use event tools only when automatic execution is required
* Avoid adding unnecessary event triggers
* Keep event logic simple and predictable
* Test event behavior across different scenarios
***
## Notes
* Event tools run automatically and do not require manual triggering
* Multiple event tools can be attached to a single node
* Proper configuration ensures correct timing and execution of actions
# Global Tools
Source: https://docs.monobot.ai/agent-settings/tools/global_tools
The **Global Tools** section allows you to manage tools that can be reused across your flows.
Global tools are configured once and then made available for use in different nodes and flows, depending on their setup.
## Using Global Tools in Flow
Click the **+ Add Element** button on the canvas to create a new element in your flow:
* select **Node**
* choose the required tool under the **Global Tools** section
Global tools can be attached to a node and executed based on its logic and configuration.
All global tools are available in the flow and can be triggered by any node.
***
## What are Global Tools
A **global tool** is a reusable tool defined at the project level instead of being limited to a single node or flow.
This makes it easier to:
* reuse the same tool across multiple flows
* centralize tool configuration
* maintain consistent behavior
* reduce duplicate tool definitions
Examples of global tools:
* custom global tools
* spam detection
* call termination
* call redirection
***
## How It Works
Global tools are available in the global configuration area and can be assigned where needed.
Depending on the tool configuration, a global tool can:
* be available for calls
* be available for chats
* be available for both
* be triggered from a node
* be used automatically as part of flow behavior
***
## Tool States
A global tool may appear in different states depending on configuration:
* **Enabled** — the tool is ready to be used
* **Disabled** — the tool exists but is not currently active
***
## Typical Global Tools
### Custom Global Tool
A reusable custom tool that can be configured and applied across multiple flows.
### Terminate Call
Ends the call when the configured condition is met.
### Spam Detect
Used to identify spam or unwanted interactions.
### Redirect Call
Transfers the call to another destination or handling path.
***
## Relationship to Flows and Nodes
Global tools are configured centrally, but they are typically executed within the context of a node or flow.
This means:
* the tool can be defined once globally
* the flow decides when it should be used
* the node provides the context, collected values, or trigger conditions
***
## Best Practices
* Use global tools for actions shared across multiple flows
* Keep tool names clear and specific
* Avoid creating duplicate tools for the same purpose
* Review whether a tool should be global or node-specific
* Test global tools in the flows where they are used
***
### Configuration
Some tools include specific settings depending on their functionality.
Examples:
* **Answer**:\
Defines the message sent before the action is executed\
(e.g., what the assistant says before terminating the call)
* **Description**:\
Defines when and how the tool should be triggered
Used by the system to determine:
* when to execute the tool
* under which conditions it should be applied
* **Announcement**:\
Defines an optional message sent before the tool is executed
Used to:
* inform the user about the upcoming action
* provide a smoother interaction
* **Parameters**:\
Defines the values the tool expects during execution
* may be empty for built-in tools
* used when structured input is required
* supports dynamic values collected during the flow
***
### Redirect Call Configuration
Defines specific settings for transferring a call to another destination.
* **Transfer To**:\
Defines the phone number used for call transfer
* **Is SIP**:\
Defines whether the destination is a SIP address instead of a phone number
* **Silent Call Summarization**:\
Defines whether the call summary is generated without notifying the user
* **Introduction**:\
Defines the message said before initiating the call transfer
* **Declined**:\
Defines the message used if the call transfer is declined
***
## Notes
* Built-in tools may have predefined configuration fields
* Tool behavior depends on both configuration and description
* Proper setup ensures correct and predictable execution
* Global tools improve reusability and consistency across the project
* Not every tool needs to be global
* Tools that are highly specific to one step are often better configured directly in the relevant node
# Voice Settings
Source: https://docs.monobot.ai/agent-settings/voice
The **Voice Settings** tab allows you to configure how your AI agent handles voice interactions, including speech synthesis, speech recognition, and call behavior.
## Text to Speech (TTS)
Controls how the agent generates voice responses.
* **Voice Processor**: Selects the provider used for speech synthesis.
* **Voice**: Defines the voice style used for audio responses.
* **Language**: Sets the language for speech output.
* **Phoneme**: Allows custom pronunciation adjustments for specific words or phrases.
***
## Speech to Text (STT)
Controls how user speech is converted into text.
* **STT Processor**: Selects the speech recognition provider.
* **VAD Model (Voice Activity Detection)**: Detects when a user starts and stops speaking.
* **EOT Model (End of Turn)**: Determines when the user has finished speaking.
* **Boosted Keywords**: Improves recognition accuracy for specific words (e.g., names, locations, services).
* **Save Voice Recordings**: Enables saving of call recordings for later review.
* **EOU Timeout (End of Utterance)**: Defines how long the system waits before considering speech complete.
* **Pause After Transcription**: Adds a delay after transcription before processing continues.
***
## Inactivity Settings
Controls how the system handles user inactivity during voice interactions.
* **Hang-up Timeout (ms)**:\
Defines how long to wait before ending the call due to inactivity.
* **Reask Timeout (ms)**:\
Time before the system prompts the user again after no response.
* **Reask Phrases**:\
Messages used to re-engage the user (e.g., “Could you repeat that?”).
***
## Environment Settings
* **Environment Sound**:\
Adds background audio (or silence) to the interaction.
***
## How It Works
* User speaks → STT converts speech to text
* System processes input using Flow logic
* Response is generated
* TTS converts response to voice
* Audio is played back to the user
***
## Best Practices
* Use **Boosted Keywords** for domain-specific terms (e.g., vehicles, locations).
* Set **EOU Timeout** carefully to avoid cutting users off too early.
* Use clear and natural **Reask Phrases** to improve user experience.
* Keep **Hang-up Timeout** balanced to avoid premature call termination.
* Test voice quality and recognition accuracy in real scenarios.
***
## Notes
* Voice quality and recognition accuracy depend on the selected providers.
* Incorrect timeout settings may interrupt conversations.
* Background noise and accents may affect speech recognition performance.
# White Labeling
Source: https://docs.monobot.ai/agent-settings/whitelabel
White Labeling allows organizations to customize the platform appearance and branding to match their company identity.
This feature helps create a fully branded experience for customers, operators, and internal teams.
White Labeling features may require additional configuration and activation by our Platform team.
After activation, organization administrators can manage branding settings independently through Platform Settings, including:
* Brand colors
* Logos
* Widget appearance
* Custom domains
* Platform branding elements
Some advanced white label capabilities depend on subscription plan, infrastructure configuration, or domain setup requirements.
## What Can Be Customized
White Labeling may include:
* Company name
* Logo
* Brand colors
* Favicon
* Platform URL or custom domain
* Login page appearance
* Widget appearance
* AI assistant branding
## Common Use Cases
Organizations use White Labeling to:
* Deliver a branded customer experience
* Hide third-party platform branding
* Match company visual identity
* Provide a custom client portal
* Create partner or reseller environments
## Branding Elements
### Logo
Organizations can upload custom logos used across the platform interface.
Examples:
* Sidebar logo
* Login page logo
* Chat widget logo
### Colors
Custom brand colors can be applied to:
* Buttons
* Navigation elements
* Widgets
* Accent colors
* Interface highlights
### Custom Domain
White Labeling may support custom domains such as:
```text theme={null}
ai.company.com
support.company.com
```
This allows users to access the platform under the organization’s own domain.
## Widget Branding
The AI widget can also be customized with:
* Assistant name
* Welcome message
* Widget colors
* Avatar or icon
* Position and appearance
## Benefits
| Benefit | Description |
| ----------------------- | -------------------------------------------------- |
| Brand Consistency | Keeps the platform aligned with company identity |
| Professional Appearance | Creates a polished customer-facing experience |
| Customer Trust | Users interact with a familiar branded environment |
| Partner Enablement | Supports reseller and agency workflows |
## Notes
* Some White Labeling features may depend on subscription or organization settings.
* Custom domains may require DNS configuration.
* Branding changes can take several minutes to apply across the platform.
# Widget Configuration
Source: https://docs.monobot.ai/agent-settings/widget
Configure chat, call, demo, and styled voice widgets for your AI agent.
Widget Configuration allows you to customize how the AI assistant appears and behaves on websites and external platforms.
The configuration is divided into several sections:
* Chat Widget
* Call Widget
* Demo Page
* Styled Call Widget
Each section provides separate appearance, behavior, and embedding settings.
## Accessing Widget Configuration
Widget Configuration settings can be accessed from the AI Agents list using the three-dots menu in the **Actions** column.
1. Open **AI Agents**
2. Find the required agent
3. Click the **three-dots menu**
4. Select **Widget Configuration**
This menu provides access to chat, call, demo, and styled widget settings for the selected agent.
The Chat Widget allows users to interact with the assistant using text conversations directly on a website.
## Logo
Upload a custom widget logo.
Supported formats typically include:
* PNG
* JPG
* SVG
The logo appears inside the chat widget interface.
## Widget Settings
### Use Appear Schedule
Enables scheduled widget visibility.
Useful for:
* Business hours
* Time-based support availability
* Regional schedules
### Open Chat Automatically
Automatically opens the chat window when the page loads.
Useful for:
* Lead generation
* Sales funnels
* Support onboarding
### Widget Position
Defines where the widget appears on the page.
Available options:
* Left Bottom
* Right Bottom
### Margins
* Vertical Margin: Controls spacing from the bottom edge of the screen.
* Horizontal Margin: Controls spacing from the left or right side of the screen.
### Widget Size
* Width: Defines widget width in pixels.
Example:
```text theme={null}
350px
```
* Height: Defines widget height in pixels.
Example:
```text theme={null}
600px
```
### Round Corners
Controls border radius of the widget.
Higher values create more rounded UI elements.
* Header Background: Defines the header background color.
* Header Text Color: Defines text color inside the widget header.
* Close Button Color: Controls close button appearance.
* Title Font Size: Defines title text size inside the header.
### Dialog Settings
* Background Color: Defines the main widget background color.
* Font Size: Controls overall text size inside the widget.
### Message Colors
* Agent Message Background Color: Defines assistant message bubble color.
* Agent Message Text Color: Defines assistant message text color.
* User Message Background Color: Defines user message bubble color.
* User Message Text Color: Defines user message text color.
### Input Settings
* Text Placeholder: Placeholder text displayed inside the message input field.
Example:
```text theme={null}
Write a message...
```
* Enable Typing Label: Displays typing indicator while the assistant generates a response.
* Typing Text: Custom typing indicator text.
Example:
```text theme={null}
Typing...
```
### Labels
* Start New Chat Button Text: Custom text for starting a new conversation.
Example:
```text theme={null}
Start new chat
```
* Connecting To Agent Text: Displayed while connecting to the assistant.
Example:
```text theme={null}
Connecting to Agent...
```
### Input Colors
* Input Background Color: Defines background color of the message input field.
* Input Text Color: Defines text color inside the message input.
### Send Button Settings
* Button Background Color: Defines send button background.
* Button Text Color: Defines send button text color.
* Round Corners: Controls send button border radius.
* Shadow: Enables shadow effect around the button.
* Disable "Powered by..." Link: Removes branding link from the widget.
### Reset Design
Restores widget appearance settings to default values.
### Chat Embed Script
The generated embed script allows the chat widget to be added to external websites.
Example:
```html theme={null}
```
Use the **COPY** button to copy the script.
The Call Widget enables voice conversations directly from a website.
### Voice Selector
The platform generates a unique `data-voice` selector attribute.
Example:
```html theme={null}
```
This selector can be attached to:
* Buttons
* Custom HTML elements
* Classes
* External UI components
### Call Widget Script
The generated script initializes the voice widget.
Example:
```html theme={null}
```
Use the **COPY** button to copy the full embed script.
### Supported Selectors
The voice widget can be attached to:
* ID selectors
* CSS classes
* Custom HTML elements
* Existing website buttons
Examples:
```html theme={null}
#button
```
```html theme={null}
.call-button
```
```html theme={null}
data-custom
```
### Common Use Cases
* Website call buttons
* Voice sales assistants
* Customer support voice access
* Embedded voice experiences
* Landing page call widgets
The Demo tab allows creation of a public demonstration page for the assistant.
* Upload Background Image: Uploads desktop background image for the demo page.
* Upload Mobile Background Image: Uploads mobile-specific background image.
* Chat Widget On Demo: Displays the chat widget on the demo page.
* Voice Widget On Demo: Displays the voice widget on the demo page.
### Preview
Opens a preview of the configured demo page.
The preview simulates how the widget appears to website visitors.
### Copy Demo URL
Copies the generated demo page URL.
The demo page can be shared externally for:
* Presentations
* Sales demos
* Internal testing
* Customer previews
### Desktop Preview
Displays a desktop preview of the configured demo page.
### Mobile Compatibility
The demo page supports mobile-specific background images for responsive layouts.
### Best Practices
* Use optimized background images
* Verify mobile responsiveness
* Keep background visuals clean
* Avoid visually overloaded layouts
* Test both chat and voice widgets
The Styled Call Widget allows advanced customization of the voice orb appearance.
## Widget Style
Defines the visual layout of the voice widget.
Available styles may include:
* Extended widget
* Floating orb
* Embedded widget
### Selector ID
Defines where the widget should be inserted on the webpage.
Example:
```html theme={null}
```
### Embed Script
The generated script allows the styled voice widget to be embedded into websites.
Use the **COPY** button to copy the script.
### Live Preview
Displays a real-time preview of the styled voice widget.
### Reset To Defaults
Restores all voice widget styles to default settings.
## Call Widget Sphere
Controls appearance and animation of the voice orb.
### Sphere Size
Defines orb size in pixels.
### Show Caption Below Sphere
Displays helper text below the orb.
### Default Caption
Default caption below the orb.
Example:
```text theme={null}
Ask me anything...
```
### Hover Caption
Caption displayed on hover.
Example:
```text theme={null}
Start a voice conversation
```
### Caption Text Color
Defines caption text color.
## WebGL Animation Colors
Controls animated orb colors.
### Swirl Primary
Primary animation color.
### Swirl Secondary
Secondary animation color.
### Swirl Accent
Accent animation color.
### Center Core
Center orb color.
### Center Highlight
Highlight color inside the orb.
## CSS Colors
### Outer Glow (CSS)
Defines outer glow around the sphere.
Supports transparency using RGBA values.
Example:
```text theme={null}
rgba(126, 155, 255, 0.4)
```
## Mic Icon
Controls microphone icon appearance.
### Gradient Top
Top microphone gradient color.
### Gradient Bottom
Bottom microphone gradient color.
### Stroke
Microphone icon border color.
### Common Use Cases
| Use Case | Description |
| --------------------- | --------------------------------- |
| Voice sales assistant | Add branded voice experiences |
| AI website greeter | Interactive voice orb |
| Product demos | Public voice assistant previews |
| Customer support | Instant voice communication |
| Landing pages | Interactive call-to-action widget |
### Best Practices
* Use consistent brand colors
* Keep captions short and readable
* Avoid excessive glow intensity
* Test across browsers
* Validate responsive behavior
### Troubleshooting
| Issue | Possible Cause |
| ----------------------- | --------------------------- |
| Widget not visible | Incorrect selector ID |
| Orb animation missing | Browser WebGL limitations |
| Script not working | Script inserted incorrectly |
| Colors appear incorrect | Invalid HEX/RGB format |
# My First Agent
Source: https://docs.monobot.ai/get-started/my-first-agent
# User Registration and AI Agent Creation
This guide explains how to register on Monobot CX, create and run your first AI agent.
## Registration Process
1. **Go to the Registration Page**
* Visit [Monobot CX](https://dev.monobot.ai/sign-up).
2. **Enter Your Details**
* Fill in your email and password.
* Confirm your password.
* Agree to the Terms and Conditions.
3) **Verify Your Email**
* After submitting the registration form, you will receive a verification link in your email.
* Click the link to verify your email address.
## Creating an Organization
1. **Log in to Your Account**
* After verifying your email, log in to Monobot CX.
2. **Create a New Organization**
* Navigate to the **Organizations** section in the sidebar.
* Click **Create New Organization**.
* Enter a name for your organization and click **Create**.
## Creating an AI Agent
1. **Navigate to AI Agents**
* Click on the **AI Agents** tab in the left sidebar.
* Click the **New Agent** button.
2) **Choose a Template or Create a Custom Agent**
* Select from pre-built templates or create a custom AI agent based on your needs.
## Running the AI Agent
1. **Configure Your AI Agent**
* Set up the agent title.
* Provide a welcome message and prompt instructions.
2. **Start a Conversation**
* Click the **Play** button to test your AI agent.
* Use the **Chat** option to run the chat widget.
* Use the **Web Call** option to start a call interaction.
## Next Steps
* [Customize your AI agent settings.](/agent-settings/general)
* [Customize your Agent's Voice](/agent-settings/voice)
* [Work with Knowledge Base](/agent-settings/knowledge-base)
# Trial Period
Source: https://docs.monobot.ai/policies/free-trial
# About free voice and chat units.
Monobot offers **free units** to help you start building and testing your agents without any upfront commitment.
No credit card required
You get 100 bot responses and 10 voice minutes absolutely free!
***
## What Are Free Units?
Free units are resources you can use to test your bot inside the Monobot Admin Panel.
* **1 Chat Unit = 1 Bot Response**
* **1 Voice Unit = 1 Minute of Call**
You can use them to:
* Test chat conversations directly in the Admin Panel
* Make and receive voice calls to evaluate voice agent performance
***
## Usage Limitation
Free units **can only be used inside the Admin Panel**.
> **Allowed**: Testing agents in the Monobot dashboard
> **Not allowed**: Using widgets on public websites or connecting to phone numbers
To deploy on a website or phone number, you’ll need to **upgrade to a subscription**.
***
## Where to Find Your Free Units
In your Monobot Admin Panel, your remaining free units are visible in the **bottom left corner**:
They’ll show how many **chat responses** and **voice minutes** you still have available.
***
## Related topics
* [Create first AI agent](/get-started/my-first-agent)
* [Publish Chat Widget](/widgets/chat)
* [Publish WebCall Widget](/widgets/web-call)
* [Publish Phone Agent](/widgets/phone-call)
# Pricing
Source: https://docs.monobot.ai/policies/pricing
Monobot provides flexible pricing plans for AI chat, voice, workspace, SMS, and enterprise automation features.
Plans are designed for businesses of different sizes, from small deployments to enterprise-scale operations.
| Feature | Starter | Growth | Business | Enterprise |
| ---------------------- | ---------------------- | ---------------------- | ---------------------- | --------------- |
| Monthly Price | \$200/mo | \$500/mo | \$1000/mo | Custom |
| Chat Interaction | \$0.125/reply | \$0.075/reply | \$0.04/reply | Volume based |
| Voice Interaction | \$0.27/min | \$0.25/min | \$0.22/min | Volume based |
| Workspace | \$0.05/min | \$0.04/min | \$0.03/min | Custom |
| Workspace Seats | 1 included + \$10/seat | 3 included + \$10/seat | 5 included + \$10/seat | Custom |
| SMS | \$0.035/sms | \$0.03/sms | \$0.025/sms | Custom |
| Import Call Recordings | \$0.05/min | \$0.04/min | \$0.03/min | Custom |
| Phone Number | \$2.5 | \$2.5 | \$2.5 | Custom |
| Professional Services | 8h included | 24h included | 48h included | 240h+ included |
| Infra SLA | — | — | — | 99.99% |
| Support SLA | Mon–Fri, 48h | Mon–Fri, 24h | Mon–Fri, 12h | 24x7 Custom SLA |
| Dedicated Support Team | — | — | — | Included |
| HIPAA Add-on | \$1000/mo | \$1000/mo | \$1000/mo | \$1000/mo |
# Enterprise
Custom pricing and features tailored to business needs.
Enterprise plans may include:
* Dedicated support
* Custom SLA
* Flexible usage allocation
* Custom integrations
* Private infrastructure
* High-volume scaling
For enterprise pricing and onboarding, contact the Monobot sales team.
***
# Notes
* AI usage and Workspace usage are billed separately.
* Enterprise pricing depends on deployment scale and infrastructure requirements.
* Volume discounts may be available for large-scale usage.
* Pricing and included limits may change over time.
Monobot pricing [https://monobot.ai/pricing/](https://monobot.ai/pricing/)
# Branding
Source: https://docs.monobot.ai/tenant/branding
Configure your platform branding, logos, white-label settings, and feature visibility.
# Branding
The Branding section allows administrators to customize the platform appearance, white-label settings, logos, documentation visibility, and feature availability.
Global Branding controls how the platform appears across all pages, widgets, and user interfaces.
### Brand Name
Type: `string`
Display name shown throughout the platform.
Example:
```text theme={null}
My Company
```
### Admin Panel Meta Title
Type: `string`
Browser tab title displayed for the admin panel.
Example:
```text theme={null}
My Company Admin Portal
```
### Admin Panel Meta Description
Type: `string`
Description used by browsers and search engines.
Example:
```text theme={null}
Manage AI agents, integrations, and platform settings.
```
### Logo
Type: `image`
Primary logo displayed throughout the platform.
Supported sources:
* Upload File
* URL
### Logo Alt Text
Type: `string`
Alternative text used for accessibility and SEO.
Example:
```text theme={null}
Company Logo
```
### Logo Link URL
Type: `url`
URL opened when users click the platform logo.
Example:
```text theme={null}
https://mycompany.com
```
### Favicon
Type: `image`
Browser tab icon displayed when users access the platform.
Supported sources:
* Upload File
* URL
Recommended size:
```text theme={null}
32x32 px
```
### Widget Icon
Type: `image`
Custom icon displayed in chat and voice widgets.
Supported sources:
* Upload File
* URL
## Platform Visibility
### Enable Onboarding Tour
Type: `boolean`
Displays onboarding guidance for new users.
### Disable Bot Templates
Type: `boolean`
Hides bot templates from the platform.
### Enable Documentation
Type: `boolean`
Displays the Documentation section in the platform.
### Documentation Link
Type: `url`
URL used when Documentation is enabled.
Example:
```text theme={null}
https://docs.mycompany.com
```
### Enable Integrations Tab
Type: `boolean`
Displays the Integrations tab within the platform.
### Disable Widget Settings
Type: `boolean`
Prevents users from accessing Widget Configuration pages.
### Disable Phone Number Purchase
Type: `boolean`
Hides phone number purchasing functionality.
## Powered By Branding
### Disable "Powered By" Link
Type: `boolean`
Removes the Powered By branding link from widgets.
### Powered By Brand Name
Type: `string`
Custom brand name displayed in Powered By sections.
Example:
```text theme={null}
My Company
```
### Powered By Link URL
Type: `url`
Destination URL opened when users click the Powered By branding.
Example:
```text theme={null}
https://mycompany.com
```
## Features
### Enable Billable Units Feature
Type: `boolean`
Enables billable unit tracking and usage calculations.
### Show Billable Units on Dashboard
Type: `boolean`
Displays billable unit statistics on dashboards.
Login Branding allows administrators to fully customize the login, registration, and password recovery pages.
### Login Page Logo
Type: `image`
Logo displayed at the top of the login page.
Supported sources:
* Upload File
* URL
### Login Page Logo Alt Text
Type: `string`
Alternative text for accessibility and SEO.
Example:
```text theme={null}
Company Logo
```
### Logo Link URL
Type: `url`
URL opened when users click the logo.
Example:
```text theme={null}
https://company.com
```
### Side Image
Type: `image`
Large image displayed beside the authentication form.
Supported formats:
```text theme={null}
JPEG, PNG, SVG, MP4
```
Recommended size:
```text theme={null}
960 × 1080 px
```
### Sign In Image
Type: `image`
Image displayed on the Sign In page.
Supported formats:
```text theme={null}
JPEG, PNG, SVG
```
## Metadata
### Login Page Meta Title
Type: `string`
Browser tab title for the login page.
Example:
```text theme={null}
Welcome to Platform
```
### Login Page Meta Description
Type: `string`
Description used by browsers and search engines.
Example:
```text theme={null}
Sign in to access your workspace.
```
### Terms & Conditions URL (Registration)
Type: `url`
Terms and Conditions page shown during registration.
Example:
```text theme={null}
https://company.com/terms
```
## Authentication Settings
### Enable Sign Up
Type: `boolean`
Allows new users to register accounts.
### Require Multi-Factor Authentication (OTP)
Type: `boolean`
Requires users to verify login using a one-time password.
## Sign In Page Content
### Sign In Title
Type: `string`
Main heading displayed on the login form.
Example:
```text theme={null}
Sign in
```
### Credentials Text
Type: `string`
Supporting text displayed below the title.
Example:
```text theme={null}
Enter your credentials
```
### Button Text
Type: `string`
Text displayed on the Sign In button.
Example:
```text theme={null}
Sign In
```
## Forgot Password Page
### Forgot Password Image
Type: `image`
Image displayed on the password recovery page.
### Forgot Password Title
Type: `string`
Main heading displayed on the password recovery form.
Example:
```text theme={null}
Forgot Password
```
### Forgot Password Description
Type: `string`
Description displayed below the title.
Example:
```text theme={null}
Enter your email address and we'll send you a reset link.
```
### Forgot Password Button Text
Type: `string`
Button text shown on the password recovery form.
Example:
```text theme={null}
Reset Password
```
## Registration Page
### Registration Image
Type: `image`
Image displayed on the registration page.
### Registration Title
Type: `string`
Main heading displayed on the registration form.
Example:
```text theme={null}
Create Account
```
### Registration Description
Type: `string`
Description shown below the registration title.
Example:
```text theme={null}
Create your account to get started.
```
### Registration Button Text
Type: `string`
Text displayed on the registration button.
Example:
```text theme={null}
Create Account
```
## Form Styling
### Button Color
Type: `color`
Primary authentication button background color.
Example:
```text theme={null}
#1F1F1F
```
### Button Border
Type: `string`
CSS border value applied to authentication buttons.
Example:
```text theme={null}
1px solid #1F1F1F
```
### Button Hover Color
Type: `color`
Button background color on hover.
Example:
```text theme={null}
#333333
```
### Button Text Color
Type: `color`
Text color displayed on buttons.
Example:
```text theme={null}
#FFFFFF
```
### Button Shadow (Static)
Type: `string`
Shadow applied to buttons by default.
Example:
```text theme={null}
0px 4px 11px rgba(27,27,27,0.5)
```
### Button Shadow (Hover)
Type: `string`
Shadow applied when hovering over buttons.
Example:
```text theme={null}
0px 6px 14px rgba(0,0,0,0.6)
```
### Button Disabled Color
Type: `color`
Color used when buttons are disabled.
Example:
```text theme={null}
#C9C9C9
```
### Form Background Gradient
#### Start Color
Type: `color`
Starting color of the authentication form gradient.
Example:
```text theme={null}
#ECECFE
```
#### End Color
Type: `color`
Ending color of the authentication form gradient.
Example:
```text theme={null}
#BDBDFA
```
### Image Column Color
Type: `color`
Background color used behind side images.
Example:
```text theme={null}
#F5F5F5
```
UI Elements allow administrators to customize the appearance of buttons, tabs, sliders, and other interface elements across the platform.
A live preview is displayed on the right side of the page, so changes can be checked before saving.
## Primary Buttons
Configure the default appearance for primary action buttons across the platform.
### Background Color
Type: `color`
Default background color for primary buttons.
Example:
```text theme={null}
#1f1f1f
```
### Hover Background
Type: `color`
Background color displayed when users hover over a primary button.
Example:
```text theme={null}
#ffffff
```
### Text Color
Type: `color`
Default text color for primary buttons.
Example:
```text theme={null}
#ffffff
```
### Hover Text Color
Type: `color`
Text color displayed when users hover over a primary button.
Example:
```text theme={null}
#1f1f1f
```
### Disabled Color
Type: `color`
Background color used for disabled buttons.
Example:
```text theme={null}
#c9c9c9
```
### Button Border
Type: `string`
CSS border value applied to primary buttons.
Example:
```text theme={null}
1px solid #1f1f1f
```
## Test Agent Button
Customize the glow effect for the **Test Your Agent** button.
### Neon Glow Color
Type: `color`
Color used for the glow effect around the Test Your Agent button.
Example:
```text theme={null}
#D394F1
```
## Tabs
Customize tab appearance across the platform.
### Active Tab Color
Type: `color`
Color used for the active selected tab.
Example:
```text theme={null}
#5479F7
```
## Volume Control
Customize the volume slider appearance in Speech Settings.
### Slider Color
Type: `color`
Color used for the active part of the volume slider.
Example:
```text theme={null}
#fa1e60ff
```
## Live Preview
The live preview shows how UI element settings will look across common platform components, including:
* Agent configuration tabs
* Test Agent button
* Primary buttons
* Disabled buttons
* Volume control slider
Use the live preview to validate color contrast and visual consistency before saving changes.
Branding changes are applied across the selected tenant and may affect all users immediately after saving.
# Configuration
Source: https://docs.monobot.ai/tenant/configuration
Configure platform structure, menus, templates, and visibility settings.
# Configuration
The Configuration section controls platform content and available functionality.
## Available Sections
Control which menu items are visible in the platform navigation and customize their appearance.
Administrators can enable or disable specific navigation items and configure active, hover, and submenu styling globally.
## Menu Items Visibility
Select which menu items are available in the left navigation menu.
### Available Menu Items
Depending on platform configuration, the following menu items may be available:
* Dashboard
* AI Agents
* Interactions
* Workspace
* AI Chats
* Call Center
* Contacts
* Contacts
* Lists
* Companies
* Settings
* Billing
* Usage Report
* Organizations
* Phone Numbers
### Visibility Toggle
Type: `boolean`
Enable or disable a menu item.
When disabled, the menu item is hidden from users.
Example:
```text theme={null}
Enabled
```
or
```text theme={null}
Disabled
```
## Active State Background
Customize the appearance of the currently selected menu item.
### Background Gradient Start
Type: `color`
Starting color of the active menu item gradient.
Example:
```text theme={null}
#8f40ceff
```
### Background Gradient End
Type: `color`
Ending color of the active menu item gradient.
Example:
```text theme={null}
#5F52F3
```
## Hover State Background
Customize the appearance when users hover over a menu item.
### Background Gradient Start
Type: `color`
Starting color of the hover gradient.
Example:
```text theme={null}
#7615c3ff
```
### Background Gradient End
Type: `color`
Ending color of the hover gradient.
Example:
```text theme={null}
#b71794ff
```
## Submenu Background
Customize the appearance of expanded submenu containers.
### Background Gradient Start
Type: `color`
Starting color of the submenu background.
Example:
```text theme={null}
#1414cacf
```
### Background Gradient End
Type: `color`
Ending color of the submenu background.
Example:
```text theme={null}
#D394F11A
```
## Icon Styling
Customize the appearance of menu icons across the platform.
### Hue Rotate
Type: `number`
Applies hue rotation to all navigation icons.
Value is measured in degrees.
Example:
```text theme={null}
0°
```
### Saturation
Type: `number`
Controls icon color intensity.
Higher values create more vibrant icons.
Example:
```text theme={null}
1.2
```
## Preview
The page provides a real-time preview showing:
* Menu item visibility
* Active menu state
* Hover state
* Expanded submenu appearance
* Icon styling adjustments
Changes made in Menu Items affect the navigation experience across the entire platform.
Manage system email templates used for platform notifications, billing alerts, user invitations, security events, and operational communications.
Templates support dynamic variables that are automatically replaced with actual values when emails are sent.
## Available Templates
### User Added to Organization
Sent when a user is added to an organization.
**Variables**
* `organizationName`
* `senderName`
* `userName`
### User Invitation
Sent when a user is invited to join an organization.
**Variables**
* `userName`
* `organizationName`
* `senderName`
* `inviteUri`
* `password`
### Confirmation
Sent during account confirmation workflows.
**Variables**
* `url`
### MFA Password
Sent when multi-factor authentication (OTP) is enabled.
**Variables**
* `userName`
* `organizationName`
* `OTP`
### Reset Password
Sent when a user requests a password reset.
**Variables**
* `email`
* `token`
## Billing & Payments
### Balance Alert
Sent when an organization balance falls below the configured threshold.
**Variables**
* `organization`
* `amount`
### Balance Topup Succeeded
Sent after a successful balance top-up.
**Variables**
* `organization`
* `amount`
* `invoiceUrl`
### Balance Topup Failed
Sent when a balance top-up transaction fails.
**Variables**
* `organization`
* `amount`
* `reason`
* `invoiceUrl`
### Subscription Charge Succeeded
Sent when a subscription payment is processed successfully.
**Variables**
* `organization`
* `productName`
* `price`
* `invoiceUrl`
### Subscription Charge Failed
Sent when a subscription payment cannot be processed.
**Variables**
* `organization`
* `productName`
* `reason`
* `price`
* `invoiceUrl`
## Usage & Units Monitoring
### Units Alert
Sent when usage approaches plan limits.
**Variables**
* `organization`
* `plan_name`
* `percent_left`
### Units Over Alert
Sent when usage exceeds the plan limit.
**Variables**
* `organization`
* `plan_name`
### Units Over Alert (No Balance)
Sent when usage exceeds plan limits and account balance is insufficient.
**Variables**
* `organization`
* `plan_name`
## Phone Number Notifications
### Phone Disabled
Sent when a phone number subscription becomes inactive.
**Variables**
* `organization`
* `number`
### Phone Disabled Days
Sent after a phone number has been disabled for a specified period.
**Variables**
* `organization`
* `number`
* `days_ago`
### Phone Lost
Sent when a phone number is removed from the organization.
**Variables**
* `organization`
* `number`
## Support & Requests
### Hire an Expert
Sent when a user submits a "Hire an Expert" request.
**Variables**
* `name`
* `email`
* `phone`
* `company`
* `website`
* `industry`
* `userEmail`
* `organizationName`
* `userId`
* `organizationId`
### Support Team Message
Sent to support staff when a support request is submitted.
**Variables**
* `email`
* `message`
## Editing Templates
Click **Edit** on any template card to customize:
* Email subject
* Email body
* Dynamic variables
* Formatting and branding
Variables must remain unchanged to ensure data is inserted correctly when emails are generated.
### Variable Syntax
Use double curly braces:
```text theme={null}
{{organization}}
{{userName}}
{{amount}}
{{invoiceUrl}}
```
Example:
```text theme={null}
Hello {{userName}},
You have been added to {{organizationName}} by {{senderName}}.
```
Removing or modifying template variables may cause notification emails to display incomplete information.
Manage legal and compliance text displayed throughout the platform.
Disclaimers allow administrators to define legal notices, cookie consent information, and regulatory content that may be shown to users across branded experiences.
## Legal Disclaimer Text
Main legal notice displayed to users of the platform.
This disclaimer typically defines:
* Terms of platform usage
* Liability limitations
* Service availability notices
* Warranty disclaimers
* User responsibilities
* Legal obligations
### Content Type
Type: `rich text`
Supports formatted content including:
* Bold text
* Italic text
* Headers
* Lists
* Links
* Tables
* Code blocks
### Example
```text theme={null}
This Legal Disclaimer governs your access to and use of the platform.
By accessing or using the Service, you acknowledge that you have read,
understood, and agreed to these terms.
```
## Admin Cookie Consent Text
Cookie policy and consent notice displayed to platform users.
This content explains how cookies and tracking technologies are used within the platform.
### Content Type
Type: `rich text`
Supports formatted content including:
* Hyperlinks
* Lists
* Tables
* Text formatting
* Embedded legal references
### Example
```text theme={null}
This website uses cookies and similar tracking technologies
to improve user experience and platform functionality.
By continuing to use the platform, you consent
to the use of cookies.
```
## Rich Text Editor
Both disclaimer sections use a rich text editor with support for:
### Text Formatting
* Bold
* Italic
* Underline
* Headings
* Horizontal separators
### Content Structure
* Ordered lists
* Unordered lists
* Tables
* Blockquotes
### Links & References
* External URLs
* Internal links
Example:
```markdown theme={null}
[Privacy Policy](https://example.com/privacy)
```
### Advanced Formatting
* Code blocks
* Inline code
* HTML-compatible content
## Best Practices
### Legal Disclaimer
Include:
* Terms of service references
* Liability limitations
* Intellectual property statements
* User obligations
* Service availability notices
### Cookie Consent
Include:
* Cookie usage explanation
* Analytics disclosure
* Tracking technology details
* Third-party integrations
* Consent requirements
* Privacy policy references
## Saving Changes
After modifying disclaimer content:
1. Update the text in the editor.
2. Review formatting and links.
3. Save changes.
4. Verify content is displayed correctly in the user-facing experience.
Disclaimer content is displayed exactly as configured. Administrators are responsible for ensuring all legal and compliance text meets their organization's requirements and applicable regulations.
Disabling features only hides them from users. Existing configurations remain unchanged unless explicitly removed.
# Platform Settings
Source: https://docs.monobot.ai/tenant/general_info
Customize branding, platform behavior, access controls, and feature availability for your white-label platform.
Platform Settings allows administrators to customize how the platform looks and behaves for their organization.
The settings are grouped into three main sections:
Configure logos, colors, branding assets, and white-label appearance.
Manage menu items, templates, disclaimers, and platform visibility options.
Configure SMTP, user management, access control, SIP, API settings, and more.
### Accessing Platform Settings
To access Platform Settings:
1. Click your profile avatar in the top-right corner of the platform.
2. Open the user menu.
3. Select **Platform Settings**.
The Platform Settings page will open, allowing you to manage branding, configuration, system settings, and access controls.
Only users with the required permissions can access Platform Settings. If you do not see this option in the menu, contact your administrator.
# System & Access
Source: https://docs.monobot.ai/tenant/system_access
Manage integrations, users, permissions, communication settings, and APIs.
# System & Access
The System & Access section contains administrative settings related to platform operations, security, and integrations.
## Available Sections
Configure SMTP settings used for outgoing platform emails, including invitations, password reset emails, MFA codes, billing alerts, and system notifications.
### SMTP Host
Type: `string`
Hostname of the outgoing mail server.
Example:
```text theme={null}
smtp.gmail.com
```
### SMTP Port
Type: `number`
Port used for SMTP communication.
Common values:
```text theme={null}
465
587
25
```
## Connection Options
### Use Secure Connection
Type: `boolean`
Enables SSL/TLS encrypted connection to the SMTP server.
### Disable TLS Certificate Validation
Type: `boolean`
Disables TLS certificate verification.
Use this option only for testing or internal SMTP servers.
## Authentication
### SMTP Username
Type: `string`
Username used to authenticate with the SMTP server.
Example:
```text theme={null}
platform@example.com
```
### SMTP Password
Type: `password`
Password or application-specific password used for SMTP authentication.
The value is hidden in the interface.
## Email Sender Settings
### Mail From
Type: `string`
Sender address used for outgoing emails.
Must be a valid email address or use the following format:
```text theme={null}
Name
```
Examples:
```text theme={null}
no-reply@example.com
```
```text theme={null}
Monobot
```
### Notification BCC
Type: `string`
Optional email address that receives copies of outgoing platform notifications.
Example:
```text theme={null}
bcc@example.com
```
### Support Email
Type: `string`
Email address displayed or used for support-related communication.
Example:
```text theme={null}
support@example.com
```
## Test Settings
Use **Test Settings** to verify SMTP connection, credentials, and email delivery configuration before saving or using the setup.
SMTP configuration is required for system emails such as invitations, password resets, MFA codes, billing alerts, and notification templates.
Manage platform users and their access to the current tenant.
The Members section provides a list of all users associated with the selected tenant and allows administrators to manage user access.
## Members List
The table displays all users currently registered within the tenant.
### First Name
Type: `string`
User's first name.
Example:
```text theme={null}
John
```
### Last Name
Type: `string`
User's last name.
Example:
```text theme={null}
Doe
```
### Email
Type: `string`
User's email address used for authentication and notifications.
Example:
```text theme={null}
john.doe@example.com
```
## User Management
Administrators can use the Members section to:
* View all tenant users
* Verify user information
* Manage platform access
* Monitor active users
* Review organization membership
Manage role-based permissions and advanced platform access settings.
The Access Control section allows administrators to define what actions users can perform within the platform by assigning privileges to specific roles.
## Bot Change Control
### Enable switching bots to Production mode
Type: `boolean`
Allows users assigned to the selected role to publish bots to the Production environment.
When enabled:
* Bots can be promoted from Draft to Production
* Published bots become available for live usage
* Future changes require a commit message before publishing
After a bot is published, every subsequent change requires a commit message describing the modification.
## RBAC Settings
Role-Based Access Control (RBAC) determines which resources a role can access and what actions can be performed.
### Role
Type: `select`
Select the role whose permissions you want to configure.
Example:
```text theme={null}
Tenant Administrator
Agent Manager
Operator
Viewer
```
## Privileges
Configure permissions for each platform entity.
Each entity supports the following permissions:
| Permission | Description |
| ---------- | ---------------------------- |
| Can Read | View records and information |
| Can Update | Modify existing records |
| Can Delete | Remove records |
| Can Create | Create new records |
### Available Entities
#### Organization
Manage organizations and tenant-level configuration.
#### Interaction
Manage interaction history, transcripts, and conversations.
#### Usage
Access usage statistics and consumption reports.
#### Agent
Manage AI agents and bot configurations.
#### Billing
Access invoices, subscriptions, and payment information.
#### Language
Manage supported languages and localization settings.
#### Phone
Manage phone numbers and telephony resources.
#### Sub Organization
Manage child organizations and organizational hierarchy.
#### Template
Manage notification, email, and message templates.
## Bot Advanced Access
Grant advanced permissions for bot configuration and administration.
### Change Voice Processor
Type: `boolean`
Allows users to modify the Voice Processor used by the bot.
Examples:
* OpenAI Voice
* ElevenLabs
* Azure Speech
### Change STT Processor
Type: `boolean`
Allows users to change the Speech-to-Text (STT) engine.
Examples:
* Deepgram
* OpenAI Whisper
* Google Speech-to-Text
### Change LLM
Type: `boolean`
Allows users to modify the Large Language Model used by the bot.
Examples:
* GPT-4o
* Claude
* Gemini
### Full Access to Integrations
Type: `boolean`
Provides access to the Integrations tab and allows management of connected services.
Examples:
* Google Calendar
* SMTP
* SIP
* Altegio
* WooCommerce
### Read Interaction Metrics
Type: `boolean`
Allows viewing interaction analytics and performance metrics.
Examples:
* Conversation statistics
* Call duration
* Resolution rate
* Usage metrics
* Interaction transcripts
Changes made in Access Control take effect immediately for all users assigned to the selected role.
Configure SIP authentication and network access settings for inbound SIP and SIPS connections.
## IP Whitelist
Type: `list`
Defines which IP addresses are allowed to connect to the platform through SIP or SIPS.
Supported formats:
```text theme={null}
88.214.8.230
88.214.8.*
88.214.8.230-88.214.8.240
2001:db8::1
```
### Examples
#### Single IP
```text theme={null}
88.214.8.230
```
Allows connections only from the specified IP address.
#### Wildcard Range
```text theme={null}
88.214.8.*
```
Allows all IPs within the specified subnet.
#### IP Range
```text theme={null}
88.214.8.230-88.214.8.240
```
Allows all addresses within the defined range.
#### IPv6 Address
```text theme={null}
2001:db8::1
```
Allows a specific IPv6 endpoint.
If no IP addresses are configured, connections are allowed from any IP address.
## SIP Username
Type: `string`
Username used for SIP Digest Authentication and SIP REGISTER requests.
The connecting SIP client must provide this username when authenticating with the platform.
### Example
```text theme={null}
sip_test_user
```
## SIP Password
Type: `password`
Password associated with the SIP Username.
The platform validates incoming SIP authentication requests using this password.
### Example
```text theme={null}
StrongPassword123!
```
Store SIP credentials securely and rotate them regularly to prevent unauthorized access.
## Authentication Flow
1. SIP provider or PBX sends a SIP REGISTER or INVITE request.
2. Platform validates the supplied SIP Username.
3. Platform verifies the SIP Password using Digest Authentication.
4. If an IP Whitelist is configured, the source IP is validated.
5. Connection is accepted only when all validation checks pass.
SIP Username and SIP Password are required only when SIP Digest Authentication is enabled on the call initiator side.
Configure custom key-value pairs that are attached to interactions and can be consumed by external systems, integrations, APIs, or downstream workflows.
Call Attached Data (CAD) allows you to expose interaction metadata in a structured format for third-party systems.
## Field Name
Type: `string`
Defines the custom field key that will be included in the interaction payload.
Field names should be unique and descriptive.
### Examples
```text theme={null}
tenant_field_org_id
tenant_field_status
customer_id
ticket_number
```
## Value
Type: `variable`
Defines the interaction variable or system value that will populate the field.
Values are selected from available interaction variables.
### Examples
#### Organization ID
```text theme={null}
Interaction.organizationId
```
Stores the organization identifier associated with the interaction.
#### Interaction Status
```text theme={null}
Interaction.status
```
Stores the current interaction status.
Examples:
```text theme={null}
active
completed
failed
transferred
```
## Creating a New Field
Click **New Field (+)** to create an additional CAD entry.
For each field:
1. Enter a unique Field Name.
2. Select a Value from the available variables.
3. Save the configuration.
## Managing Existing Fields
### Edit Field
Update either the field name or the mapped value.
### Delete Field
Remove a CAD field using the delete icon.
Deleting a field removes it from all future interaction payloads but does not affect historical interaction data.
## Example Configuration
| Field Name | Value |
| ---------------------- | -------------------------- |
| tenant\_field\_org\_id | Interaction.organizationId |
| tenant\_field\_status | Interaction.status |
Example output:
```json theme={null}
{
"tenant_field_org_id": "12345",
"tenant_field_status": "completed"
}
```
## Common Use Cases
* CRM integration
* Ticketing systems
* Custom reporting
* External workflow automation
* Webhook enrichment
* Customer data synchronization
Configured CAD fields are automatically attached to interactions and can be accessed by supported APIs and integrations.
Manage API keys used to authenticate external applications, services, and integrations with the platform.
API keys provide secure access to platform APIs without requiring interactive user authentication.
## Create API Key
Generate a new API key for a specific service or integration.
### Key Name
Type: `string`
A human-readable name used to identify the API key.
Choose a descriptive name that reflects its purpose.
### Examples
```text theme={null}
Production SIP Integration
CRM Connector
Webhook Service
Analytics API
```
### Service Type
Type: `select`
Select the service or feature that the API key will be authorized to access.
Example:
```text theme={null}
SIP
```
Additional options may be available depending on enabled platform features.
### Generate
Creates a new API key using the specified name and service type.
The generated API key should be stored securely. Depending on your deployment, the full key may only be shown once.
## API Keys
Displays all active API keys created within the tenant.
### Name
Type: `string`
The user-defined name assigned during key creation.
Example:
```text theme={null}
Production SIP Integration
```
### Creator Email
Type: `email`
Email address of the user who generated the API key.
Example:
```text theme={null}
admin@company.com
```
### Created At
Type: `datetime`
Date and time when the API key was created.
Example:
```text theme={null}
2026-01-15 14:30 UTC
```
### Valid Until
Type: `datetime`
Expiration date of the API key.
If no expiration policy exists, the platform may display an extended validity period.
Example:
```text theme={null}
2027-01-15 14:30 UTC
```
### API Key
Type: `secret`
Displays the generated API credential.
Depending on platform configuration, keys may be partially masked for security purposes.
Example:
```text theme={null}
sk_live_xxxxxxxxxxxxxxxxx
```
### Delete
Type: `action`
Revokes and permanently removes the API key.
After deletion:
* API requests using the key will immediately fail
* Existing integrations using the key must be updated
* The key cannot be recovered
Deleting an API key immediately revokes access for all systems using that credential.
## Typical Use Cases
* SIP authentication
* External integrations
* Webhook authorization
* CRM synchronization
* Internal automation services
* Custom API clients
## Security Best Practices
* Create separate keys for each integration
* Rotate keys regularly
* Remove unused keys immediately
* Never share API keys publicly
* Store credentials in a secure secrets manager
API keys inherit the permissions associated with the selected service and tenant configuration.
Changes made in System & Access settings can affect platform functionality, integrations, and user access.
# Chat
Source: https://docs.monobot.ai/widgets/chat
# Configuring and Publishing the Chat Widget
This guide explains how to configure and publish the Monobot CX chat widget on your website.
## Accessing the Widget Configuration
1. **Navigate to AI Agents**
* Click on the **AI Agents** tab in the left sidebar.
* Find the agent for which you want to configure the chat widget.
2. **Open Widget Settings**
* Click the three-dot **Actions** menu next to your agent.
* Select **Widgets** from the dropdown.
## Configuring the Widget
1. **Chat Settings**
* Upload a custom logo.
* Enable or disable **Auto Open Chat**.
* Set the **Widget Position** (Left or Right Bottom).
* Adjust size, margins, and round corners.
2) **Design Customization**
* Customize header background, text, and close button color.
* Change message background and text colors.
* Modify input field colors and placeholder text.
## Generating and Embedding the Widget
1. **Copy the Embed Code**
* Scroll down to the **Script Section**.
* Click **Copy** to copy the widget embed code.
2) **Paste it on Your Website**
* Open the HTML file of your website.
* Paste the copied script before the closing `
` tag.
* Save and deploy your website.
## Testing the Chat Widget
1. Open your website and verify that the chat widget appears.
2. Test interactions to ensure responses are working correctly.
# Phone
Source: https://docs.monobot.ai/widgets/phone-call
# Configuring and Publishing the Call Widget
This guide explains how to configure and publish the Monobot CX call widget on your website.
## Accessing the Call Widget Configuration
1. **Navigate to AI Agents**
* Click on the **AI Agents** tab in the left sidebar.
* Find the agent for which you want to configure the call widget.
2. **Open Widget Settings**
* Click the three-dot **Actions** menu next to your agent.
* Select **Widgets** from the dropdown.
* Click on the **Call** tab.
## Configuring the Call Widget
1. **Copy the Call Widget Identifier**
* Locate the `data-voice` attribute on the page.
* Use this attribute in your custom button or HTML element.
```html theme={null}