Ctrlk
For the complete documentation index, see llms.txt. This page is also available as Markdown.

Frequently Used Actions

The Actions used most frequently when building workflows with the Aisera AI Workflow Studio are:

This topic will discuss each of these actions and their parameters.

Go back and read general information about building workflows, in a previous topic, if you have never created an Aisera Workflow. Go back and read Using Workflow Actions, if you have never created a workflow that uses Action Nodes.

Execute Rest Call Action

Description: The Execute Rest Call Action executes an outbound REST API call either in the cloud or on-premises through a configured integration. It constructs and dispatches an HTTP request using the provided URL, method, payload, headers, and query parameters, and returns the response body, headers, and HTTP status code.

Supported External Systems include, but are not limited to: ServiceNow, Salesforce, Jira, Zendesk, BMC Helix, Jira Software, Active Directory, Confluence, SharePoint, PagerDuty, Freshservice, Cherwell, Microsoft Dynamics, TeamDynamix, FootPrints, SolarWinds ITSM, Managed Engines, Generic, Datadog, Slack Connector, LumApps, TeamSupport, Microfocus, Kace, Intercom, Ivanti, SAP C4C, Request Tracker, Workday, ConnectWise, Autotask, Igloo, EasyVista, 6sense, Interact, and many more.

Input:

  • Integration (Dropdown, Required): The external system integration through which the REST call will be executed. Select one of the available configured integrations — such as, ServiceNow, Salesforce, Jira, Zendesk, BMC Helix, SharePoint, PagerDuty, Freshservice, Datadog, Workday, Ivanti, or ConnectWise.

  • Url (String, Optional): The full URL that will be invoked during the request. For example, https://myinstance.service-now.com/api/now/table/incident

  • Method (String, Optional): The HTTP method for the request. Allowed values: GET, POST, PUT, PATCH, DELETE

  • Payload (String, Optional): The request body payload, typically a JSON string used for POST, PUT, or PATCH requests. Construct this payload according to the documentation of the external system. – such as, {"short_description": "New incident"}

  • Request Headers (Map, Optional): A map of HTTP request headers to inject into the request. For example, {"Content-Type": "application/json", "Accept": "application/json"}

  • Query Params (Map, Optional): A map of query parameters to append to the URL. For example, {"sysparm_limit": "10", "sysparm_query": "active=true"}

  • Response Type (String, Optional): Specifies what data type the response should be interpreted as, such as Bytes or String.

  • Custom Certificate (String, Optional): A custom server certificate (PEM-encoded) to be injected into the request for SSL/TLS verification. For example:

    -----BEGIN CERTIFICATE-----
MIID...
-----END CERTIFICATE-----

Configuration Parameters:

  • Use Client SSL Cert (Checkbox, Optional, Default: false): Flag to enable two-way (mutual) SSL authentication. When set to true, the client SSL certificate is included in the request for environments that require mutual TLS.

Output:

  • Response (String): The response body of the executed request, encoded as a String.

  • Success (Boolean): A Boolean indicating whether the REST call was executed successfully.

  • Response Headers (Map): The HTTP response headers returned by the target service, useful for pagination tokens or follow-up requests.

  • Response Status Code (Integer): The HTTP status code of the response. For example, 200, 404, 500

Generate RAG Answer

Description: The Generate RAG Answer action sends a user query to Aisera's RAG (Retrieval-Augmented Generation) service to generate an AI-powered contextual answer. The service searches through your organization's knowledge base and returns a relevant, accurate response. Also, response is post-processed to ensure all URLs (images and hyperlinks) are correctly formatted for your tenant, and any disclaimers are automatically appended.

This action connects to an internal Aisera service and does not require an external system integration.

Input:

  • payload (String, Required): A JSON payload containing the user's query and configuration parameters.

Payload Structure

Field

Type

Required

Description

query

String

Yes

The user's question to be answered by RAG

parameters

Object

Yes

Configuration parameters for the request

parameters.tenant

String

Yes

The tenant identifier where the query is executed

parameters.bot

Integer

Yes

The bot ID containing the knowledge base documents to search

Example payload:

Tip: Use a JavaScript node before this action to dynamically construct the payload from existing variables.

  • botId (Long, Optional): The bot identifier. Only used in tenant-level flows when the bot ID is not already available in the execution context – e.g., 50

Configuration Parameters: This action has no configuration parameters.

Output:

  • success (Boolean): Indicates whether the RAG answer generation request was successful.

  • response (String): The generated AI answer, including any appended disclaimers

  • mapResponse (Map): The full response from the RAG service represented as a map, useful for extracting individual response fields programmatically.

Send Notification

Description: The Send Notification action sends notifications to users through multiple channels including email, Aisera platform channels (push notifications), and SMS. This action supports sending messages to one or multiple recipients via comma-separated email addresses. It provides flexible notification delivery options allowing you to send through specific channels only (email-only, channel-only, or SMS) or through multiple channels simultaneously. For SMS notifications, the action integrates with Twilio and can automatically retrieve the recipient's phone number from their user profile or use a manually specified phone number.

Input:

  • Receiver (String, Required): A comma-separated list of recipient email addresses – example: "user1@company.com, user2@company.com" or "admin@example.com"

  • Message (String, Required): The message content to be sent to the receiver(s). This message will be delivered through the selected notification channels – example: "Your service request has been approved" or "Reminder: Your password will expire in 3 days"

  • Subject (String, Optional): The subject line for email notifications. This parameter only affects email notifications and does not apply to channel or SMS notifications – example: "Service Request Update" or "Important System Notification"

  • Channel Only(Boolean, Optional): When set to true, notifications are sent only through Aisera platform channels (push notifications) and not via email. Note: If both channelOnly and emailOnly are set to true, no notification will be sent – example: true false

  • Cell Number (String, Optional): The phone number to send SMS notification to. The user's profile cell phone number is used as fallback if this is not provided. Required format depnds on Twilio requirements and typically include country code. For example +14155551234.

  • Send Sms (Boolean, Optional): When set to true, an SMS notification is sent to the Cell Number. If the Cell Number parameter is not provided, the user's profile cell number will be used. Requires a Twilio external system integration to be configuration.

  • Email Only (Boolean, Optional): When set to true, notifications are sent only via email and not through Aisera platform channels. Note: If both Channel Only and Email Only are set to true, no notification will be sent – example: true or false

  • Bot Id(Number, Optional): Specifies the bot ID to use for sending channel notifications. If not provided, the action uses the universal bot ID from the execution context, or falls back to the standard bot ID from the context – example: 12345 or 67890

  • Sms Integration Id (Number, Optional): The external system ID of the specific Twilio integration to use for sending SMS. If not provided, the action uses the first available Twilio integration configured for the tenant – example: 100 or 250

Configuration Parameters: No configuration parameters are required. However, for SMS functionality to work, a Twilio External System integration must be configured in the Aisera platform

Output: No outputs are returned by this action.

Fetch LLM Chat Answer V2

Description: Sends requests to Aisera's LLM (Large Language Model) Gateway to generate AI-powered responses. This enhanced action supports text-based prompts, conversation history, and image inputs, making it suitable for building advanced conversational AI workflows, chatbots, and intelligent automation scenarios. Use this action when you need to leverage generative AI capabilities within your workflow to answer questions, analyze content, process images, or continue multi-turn conversations.

Recommended action: This is the enhanced version of Fetch LLM Answer Action. Use Fetch LLM Chat Answer V2 for new workflows as it provides advanced capabilities including image processing, conversation history, and granular message control.

Input:

  • systemPrompt (String, Optional): The system-level instruction that sets the behavior, tone, and context for the LLM. This prompt guides how the AI should respond to user requests - example : "You are a helpful IT support assistant" or "You are an expert in analyzing financial data".

  • userRequest (String, Optional): The current user's question or request as plain text. This is the primary input that the LLM will respond to - example : "What is the status of my service request?" or "Explain how to reset my password".

  • imageContent (String, Optional): A single image to be analyzed by the LLM. Can be either a publicly accessible image URL or base64-encoded image data. The LLM will process this image along with text prompts - example : "https://media.istockphoto.com/id/814423752/de/foto/auge-des-modells-mit-bunten-kunst-make-up-close-up.jpg?s=2048x2048&w=is&k=20&c=qPTgbu_LtrwAf6Ee7FjGfGrCxkdVgmQIvaoJNY-lMcI="

  • imageAttachments (List, Optional): Image attachment metadata from a file upload variable. Provide this when users have uploaded images through a file upload action. The action will extract the file URIs and send them to the LLM for analysis. Select the desired attachments to be added from the available variables in the dropdown. - example : attachmentVar1

  • conversationHistory (JSONArray, Optional): A stringified JSON array representing previous conversation turns. Can be found in existing variables under conversationContext. Use this to maintain context across multiple LLM calls - example : '[{"role":"user","content":"Hello"},{"role":"assistant","content":"Hi, how can I help?"}]'

  • extraMessages (JSONArray, Optional): Additional messages to append to the conversation as a stringified JSON array. Each message should include "role" and "content" fields. Use this to inject additional context or instructions that should appear after the main user request - example : '[{"role":"user","content":"Please format as JSON"}]'

  • configParams (Map<String, Object>, Optional): Advanced configuration parameters for the LLM request provided as a Map. Use this to control LLM behavior such as temperature, max tokens, top_p, or other model-specific settings. Lower temperature values (0.2-0.5) in configParams produce more focused, deterministic responses. Higher values (0.7-1.0) produce more creative, varied responses. - example : {"temperature": 0.7, "max_tokens": 500}.

  • botId (Long, Optional): The bot ID to associate with this LLM request. If not provided, use the bot ID from the execution context. Use this to override the default bot configuration for multi-bot scenarios. - example : 5

Configuration Parameters: No configuration parameters are required.

Output:

  • success (Boolean): Indicates whether the LLM request was successful. Returns true if the LLM Gateway returned a valid response (HTTP 200), false otherwise. Use this to branch your workflow based on success or failure.

  • responseMessage (String): The generated response text from the LLM. This contains the AI-generated answer, analysis, or completion based on the provided prompts and context. Use this variable in subsequent actions to display the response to users or process it further. - example : For systemPrompt -> “You are a helpful IT support assistant” and userRequest -> “What is vpn?” , an example response is : “A VPN (Virtual Private Network) is a technology that creates a secure and encrypted connection between your device and a remote server over the internet. It allows you to browse the web privately and securely by masking your IP address and encrypting your internet traffic.

VPNs are commonly used for:

1. **Privacy and Security**: Protecting your online activities from hackers, ISPs, or other third parties, especially when using public Wi-Fi networks.

2. **Accessing Restricted Content**: Bypassing geo-restrictions to access websites, streaming services, or content that may be blocked in your region.

3. **Remote Work**: Allowing employees to securely access company resources and networks from anywhere.

4. **Anonymity**: Hiding your online identity and location to prevent tracking.

VPNs work by routing your internet traffic through a server in a location of your choice, making it appear as though you're browsing from that location. Popular VPN providers include NordVPN, ExpressVPN, and CyberGhost, among others.”

Parse PDF

Description: Parses up to two PDF attachments and extracts their content using the tenant's configured PDF parser. Returns plain text by default; enable enrichedOutput for structured HTML with preserved headings, paragraphs, and tables. All attachments are processed in parallel to minimize latency. Partial success is supported — if one file fails to parse, the other's result is still returned alongside a per-file error map. The action also supports caching for already-processed PDFs on object storage. Use this action to make PDF content available to downstream AI or data-processing actions. Pair it with Fetch File And Store to retrieve and parse a PDF from an external endpoint in a single workflow.

Configuration Parameters:

  • maxFileSizeMB (Number, Optional, Default: 10): Maximum allowed PDF file size in megabytes. Each attachment is checked individually against this limit. Files that exceed it are added to the errors map rather than failing the entire action.

Input:

  • attachments (List<Map<String, String>>, Required): A list of up to 2 file attachments to parse. Each entry must include a uri (the object storage key) and a name (display name). The attachment output of Fetch File And Store can be passed directly here without transformation. Non-PDF files are rejected per file with an error entry rather than failing the entire action. – example: [{"uri": "tenant-123/Attachments/1714000000000_--_contract.pdf", "name": "contract.pdf"}]

  • enrichedOutput (Boolean, Optional): When true, the extracted content is returned as structured HTML including semantic elements such as <p>, <h1>–<h6>, and <table>. When false, plain text is returned. Defaults to false.

Output:

  • extractedTexts (String): A JSON-serialized map of file name to extracted content. Each key is the file's display name from the input attachment; each value is either plain text or HTML depending on enrichedOutput. Files that fail are omitted from this map and appear in errors instead. – example: {"contract.pdf": "AGREEMENT\nThis agreement is entered into...", "appendix.pdf": "Appendix A: Definitions..."}

  • errors (String): A JSON-serialized map of file name to error message for each PDF that could not be processed. Returns an empty object {} when all files succeeded. The special key _action is used for action-level failures not tied to a specific file (e.g., no attachments provided, no parser configured). – example: {"invoice.pdf": "File is not a valid PDF document"}

  • success (Boolean): true only if all provided attachments were parsed without error. false if one or more files failed — even when partial results are available in extractedTexts. Check errors for per-file details when success is false.

At least one PDF parser must be configured for the tenant before this action can execute. Form Recognizer must be set up as an integration when useFormRecognizer is enabled in the parser configuration. The action returns an error if no parser is available.

Fetch File And Store

Description: Executes an HTTP request to any accessible URL, downloads the response as binary data, validates its size, detects the MIME type using Apache Tika, and uploads it to Aisera's object storage. Returns an attachment reference — uri, name, type, and size — in the same format produced by a User Input File Attachment, so downstream actions such as Parse PDF can consume it directly without any transformation. Use this action when a file lives behind an authenticated or public endpoint and needs to be retrieved and made available as a workflow attachment. Common scenarios include fetching PDF reports, exported spreadsheets, or generated documents from third-party APIs before passing them to a parser or storage action.

Configuration Parameters:

  • maxFileSizeMB (Number, Optional, Default: 10): Maximum allowed file size in megabytes. The action rejects any download whose byte count exceeds this threshold before uploading to object storage.

  • useClientSSLCert (Boolean, Optional, Default: false): When true, enables mutual TLS (mTLS) authentication by presenting a client certificate during the TLS handshake. Use this for endpoints that require both parties to authenticate.

Input:

  • url (String, Required): The complete URL of the file to download. Must be a reachable HTTP or HTTPS endpoint. IP-based addresses, non-routable hosts, and blacklisted domains are rejected. – example: https://reports.example.com/exports/monthly_summary.pdf

  • fileName (String, Required): The display name assigned to the downloaded file. Stored alongside the file in object storage and appears in the name field of the returned attachment. – example: monthly_summary.pdf

  • method (String, Optional): The HTTP method to use for the request. Use POST when the endpoint requires a request body to generate or retrieve the file. Defaults to GET.

  • payload (String, Optional): The request body to send with the HTTP request. Only relevant when method is POST or PUT. – example: {"reportId": "RPT-2024-Q1", "format": "pdf"}

  • requestHeaders (Map<String, String>, Optional): HTTP headers to include in the request as key-value pairs. Use this to pass authentication tokens, content-type declarations, or any API-specific headers required by the target endpoint. – example: {"Authorization": "Bearer eyJhb...", "Accept": "application/pdf"}

  • queryParams (Map<String, String>, Optional): URL query parameters to append to the request URL as key-value pairs. These are appended and URL-encoded automatically — do not include them manually in the url parameter. – example: {"version": "latest", "locale": "en-US"}

  • customCertificate (String, Optional): A custom SSL/TLS server certificate in PEM format for validating the endpoint's identity. Required only when the target server uses a certificate not in the standard trust store, such as internal corporate endpoints with a private CA.

Output:

  • attachment (List<Map<String, String>>): A single-element list containing the stored file's metadata. Each entry includes: uri (the object storage key), name (the display name from the input), type (auto-detected MIME type), and size (file size in bytes). The format is identical to User Input File Attachment output, making it directly consumable by Parse PDF and other attachment-aware actions. – example: [{"uri": "tenant-123/Attachments/1714000000000_--_report.pdf", "name": "report.pdf", "type": "application/pdf", "size": 204800.0}]

  • success (Boolean): Indicates whether the file was fetched and uploaded successfully. Returns false if any step failed — including invalid URL, HTTP error, size limit exceeded, or storage failure.

  • errorMessage (String): A human-readable description of what went wrong when success is false. Empty string on success. – example: File size 25MB exceeds maximum 10MB

Generic Event Actions

The Generic Event Action handles the invocation of follow-up flows.

To choose the Generic Event Action:

  1. Open a workflow in the AI Workflow Studio canvas, or start a new workflow.

  2. Drag an Action node onto the canvas.

  3. Select the Action Categories tab at the top of the window.

  4. Search for and then choose Generic Event Action.

  1. Choose the Next button.

The Edit Action window displays the possible options.

Each of the Generic Event Action parameters contains a description that you can read if you select the question mark next to the parameter name.

Variables for Workflow Parameters

The ${options} variable is a HashMap created with a js in a code snippet such as:

In the code above snippet above, you created a HashMap object called var map and added two choices that correspond to two different application/bot skills.

This will cause the sub-flows Test Skill1 and Test Skill2 to be invokable with two buttons choice1 and choice2 as shown below:

which will be sent to the User Email (using the email specified in the Edit Action window - thomas@aisera.com).

In the follow up flows (in this example, Test Skill1 and Test Skill2) declare a variable with the name postVariables which will get the value from the action above (in this example, the value of postVariables will be oneTwoThree).

This allows you to declare and pass variables in different ways. For instance, you can enter the postVariables as a JSON string that can be parsed in the follow up flow, and then you can have a system where you can pass anything to the follow up flows.

The followup button’s context is cached, and has the expiration time configured in the tenant level.

To view the cache expiration setting:

  1. Navigate to Settings > Configuration in the Aisera Admin UI.

  2. Choose the Conversation tab from the left Configuration menu.

  3. Scroll down the parameter settings until you see:

Generic Event Follow Up Cache Expire In Hours

Follow Up Flow Options for Conv2.0 Applications/Bots

As discussed above, the Generic Event Action is passing the follow-up options in the form of a HashMap, including the label of the option as the key and the intent name as value. However, in Conv2.0 apps, intents do not exist and are replaced with the workflow or hyperflow name/description field.

Because 2.0 applications/bot will be missing the intents/value parameter in the Generic Event Action. HashMap, a new action input parameter has been added, called, Follow Up Flow Options. This parameter is used the same way as Follow Up Options, but it expects a HashMap with a follow-up option of label as the key and the workflow or hyperflow name as the value:

PreviousUsing Workflow Actions
NextTicket Management Actions

Last updated

Was this helpful?