LLM Chat Interface

1. Getting Started

The Workflow Builder lets you create automated pipelines visually. Each workflow is a graph of nodes connected by wires. Data flows from left to right — starting at a Trigger node through Action, Logic, and Connector nodes, ending at an Output node.

Creating Your First Workflow

Switch to the Workflows tab above.
The Node Palette on the left lists all available nodes. Drag any node onto the canvas.
Connect nodes by dragging from an output port (right side) to an input port (left side) of another node.
Click a node to configure its properties in the right panel.
Click Save in the toolbar, give your workflow a name, then click Execute to run it.

Tip:

Every workflow needs at least one Trigger node. If you start with an empty canvas, click the "+ Add Trigger Node" button to get started quickly.

2. Canvas & Interactions

Navigation

Pan: Click and drag on empty canvas space.
Zoom: Scroll the mouse wheel, or use the zoom buttons in the bottom-right corner.
Zoom to Fit: Click the fit button to auto-frame all your nodes.

Selecting & Managing Nodes

Select a node: Click it. It will highlight and open its properties panel on the right.
Multi-select: Press Ctrl+A to select all nodes.
Delete a node: Select it and press Delete or Backspace.
Copy & Paste: Ctrl+C / Ctrl+V to duplicate nodes.
Undo / Redo: Ctrl+Z / Ctrl+Y.

Connecting & Disconnecting Wires

Create a connection: Click & drag from an output port (small dot on the right of a node) to an input port (left side of another node). A blue dashed line will follow your cursor and snap to the nearest input port.
Select a wire: Click on any wire connecting two nodes. It turns blue when selected.
Delete a wire: Select a wire and press Delete or Backspace.
Deselect: Click on empty canvas space to deselect everything.

3. Passing Data Between Nodes (Variables)

When a node finishes executing, its output object is passed to the next connected node. You access that output using variable syntax: {{input.path.to.field}}.

The Golden Rule

Every node wraps its output inside a data key. So the most common pattern is:

{{input.data}}            — the entire output object
{{input.data.fieldName}}  — a specific field inside the output

Variable Syntax

Variables use double curly braces and always start with input:

{{input.data.text}}       — a string field
{{input.data.rows}}       — an array field
{{input.data.count}}      — a number field
{{input.conditionMet}}    — a top-level boolean (IF node only)
{{input.triggered}}       — a top-level boolean (triggers)

You can use variables in any text field across nodes — email bodies, LLM prompts, HTTP URLs, SQL parameters, notification messages, and more.

What Each Node Type Outputs

Use this table to know exactly what variables are available after each node.

Node	Output Shape	How to Access
Manual Trigger	`{ data: {}, triggered: true }`	`{{input.data}}` (empty object)
Text Input	`{ data: { text: "..." } }`	`{{input.data.text}}`
Webhook	`{ data: { ...request body } }`	`{{input.data.fieldName}}`
Schedule	`{ data: {}, triggered: true }`	`{{input.data}}` (empty object)
Prompt Match	`{ data: { prompt: "..." } }`	`{{input.data.prompt}}`
Connector Hook	`{ data: { ...event payload } }`	`{{input.data.fieldName}}`
App Event	`{ data: { ...event payload } }`	`{{input.data.fieldName}}`
AI / LLM Call	`{ data: { response: "...", model: "..." } }`	`{{input.data.response}}`
HTTP Request	`{ data: { ...API response } }`	`{{input.data.fieldName}}`
Send Email	`{ data: { sent: true, to: "..." } }`	`{{input.data.sent}}`
Database Query	`{ data: { rows: [...], rowCount: N } }`	`{{input.data.rows}}` `{{input.data.rowCount}}`
Transform Data	`{ data: { ...your return value } }`	`{{input.data.yourField}}`
Delay / Wait	`{ data: { ...pass-through } }`	Same as input — data passes through unchanged
Send Notification	`{ data: { sent: true, channel: "..." } }`	`{{input.data.sent}}`
IF Condition	`{ data: { ...pass-through }, conditionMet: true/false }`	`{{input.data.text}}` (same as input) `{{input.conditionMet}}`
Switch	`{ data: { ...pass-through } }`	Same as input — routed to the matching case output
Loop / Iterate	`{ data: { ...current item }, index: N }`	`{{input.data.fieldName}}` `{{input.index}}`
Code / Script	`{ data: { ...your return value } }`	`{{input.data.yourField}}`
Connectors (Slack, Gmail, Discord, etc.)	`{ data: { ...API response } }`	`{{input.data.fieldName}}`
Agent Call	`{ data: { result: "...", steps: N } }`	`{{input.data.result}}`
Log / Debug	`{ data: { ...pass-through } }`	Same as input — data passes through unchanged
Debug Screen	`{ data: { ...pass-through } }`	Same as input — data passes through unchanged

Where You Can Use Variables

Variables work in any text or textarea field in the properties panel. Common examples:

Node Field	Example Value	What It Does
Email Body	`Hi! The AI said: {{input.data.response}}`	Inserts the LLM response into the email
LLM User Prompt	`Summarize this: {{input.data.text}}`	Passes user text to the LLM
HTTP URL	`https://api.example.com/users/{{input.data.userId}}`	Builds a dynamic API URL
SQL Parameters	`{"id": "{{input.data.userId}}"}`	Passes dynamic values to a SQL query
Slack Message	`New order from {{input.data.name}}`	Sends a dynamic Slack message
IF Condition Field	`{{input.data.status}}`	Evaluates the status field from the previous node
IF Condition Value	`{{input.data.expected}}`	Compares against another dynamic value
Notification Message	`Alert: {{input.data.response}}`	Sends a dynamic notification

Step-by-Step: Text Input → IF Condition → Email

Here’s how to build a common debug workflow:

Drag a Text Input trigger onto the canvas. Type hello in the text box on the node.
Drag an IF Condition node and connect the Text Input output to its input.
Click the IF node. In the properties panel, set:
- Field: {{input.data.text}}
- Operator: is not empty
This checks if the text input had any text. It will be True because you typed "hello".
Drag a Send Email node and connect the IF node’s True output to it. In the email Body field, type:
The user said: {{input.data.text}}
Click ▶ Run on the Text Input node (or Execute in the toolbar).

Common Mistakes & How to Fix Them

Mistake 1: Wrong path depth

Using {{input.text}} instead of {{input.data.text}}. The output is always wrapped in data, so you need the extra level.

Mistake 2: Confusing "equals" with truthiness

Setting IF field to {{input.data.text}}, operator to equals, value to true. This does a string comparison — it checks if the text literally says "true". If you just want to check the text exists, use is not empty instead.

Mistake 3: Forgetting curly braces

In email Body or LLM prompts, you must write {{input.data.text}} with the double curly braces. Without them, the literal text "input.data.text" appears instead of the value.

Mistake 4: Using {{data.text}} instead of {{input.data.text}}

Variables must always start with input. The input prefix refers to "the data coming in from the previous node."

Using Variables in the IF Condition

The IF node has two fields that accept variables:

Field — the value to evaluate: {{input.data.text}}
Value — what to compare against. You can type a literal (like hello) or another variable: {{input.data.expected}}

The operator determines how the comparison works:

Operator	What it does	Example
`is not empty`	True if the field has any value	Field: `{{input.data.text}}` — true if text was entered
`is empty`	True if the field is blank or missing	Field: `{{input.data.email}}` — true if no email
`equals`	Exact text match (case-sensitive)	Field: `{{input.data.status}}`, Value: `active`
`not equals`	True if the values differ	Field: `{{input.data.role}}`, Value: `admin`
`contains`	True if the text includes the value	Field: `{{input.data.text}}`, Value: `urgent`
`greater than`	Numeric comparison (field > value)	Field: `{{input.data.rowCount}}`, Value: `0`
`less than`	Numeric comparison (field < value)	Field: `{{input.data.score}}`, Value: `50`
`regex match`	Regular expression test	Field: `{{input.data.email}}`, Value: `@gmail\.com$`

Debugging with the Debug Screen Node

If you’re unsure what data a node is actually sending, drop a Debug Screen node between two nodes. It displays the full JSON payload on the canvas and passes the data through unchanged.

Drag a Debug Screen node from the Output category.
Connect it between the source node and the destination node.
Run the workflow — the debug screen shows every field and its value.
Use the field names you see in the JSON to write your {{input.data.fieldName}} variables.

Quick Cheatsheet:

{{input.data}} = entire output • {{input.data.text}} = text field • {{input.data.response}} = LLM response • {{input.data.rows}} = database rows • {{input.data.rowCount}} = row count • {{input.conditionMet}} = IF result • {{input.index}} = loop index

4. Using Workflows with Verse AI

Workflows integrate directly into your Verse AI chat experience. Here's how they connect:

Prompt Match Trigger

Use the Prompt Match trigger to fire a workflow when you type something specific in chat. For example, set the pattern to summarize my emails and Verse AI will automatically run that workflow when it detects a match.

AI / LLM Call Node

This node sends a prompt to Verse AI or any of your Versonas (custom AI personas). You can chain it with other nodes to build intelligent pipelines — for instance, have Verse AI analyze data from an HTTP Request, then email you the summary.

Active Workflows

Toggle a workflow Active using the switch in the toolbar. Active workflows run automatically based on their triggers. The green badge on the Chat tab shows how many workflows are currently active.

Webhook Integration

Each workflow can receive external HTTP calls via its Webhook URL. Share this URL with third-party services (e.g., Zapier, GitHub webhooks) to trigger your workflows from anywhere.

Tip:

Combine a Prompt Match trigger with an AI / LLM Call and a Send Email node to create a chat command like "email me a summary of today's tasks" that actually works.

5. Trigger Nodes

Trigger nodes start your workflow. Every workflow must have at least one trigger. They have no input port — only outputs.

Manual Trigger

Starts the workflow when you click Execute. Best for testing or one-off tasks.

Webhook

Fires when an external HTTP request hits your workflow's webhook URL. Configure the HTTP method (GET, POST, etc.), authentication type, and response code.

The webhook URL appears in the node properties after saving the workflow.
Supports Basic Auth, Header Auth, and JWT authentication.

Schedule

Triggers on a recurring timer. Use Simple mode for interval-based scheduling (e.g., every 60 minutes) or Cron Expression for advanced patterns like 0 9 * * 1-5 (weekdays at 9 AM).

Prompt Match

Fires when a user's chat message matches a pattern. Supports four match types:

Contains: Keyword matching (simplest)
Regex: Regular expression patterns
Intent (AI): AI-powered semantic matching with confidence threshold
Exact: Verbatim match only

Connector Hook

Triggers when an event fires from a connected service (Gmail, Slack, Discord, GitHub, or a Custom API). Select the connector and the event type (New Message, Updated, Deleted, etc.).

Text Input

A manual trigger with a built-in text box and ▶ Run button directly on the node. Type test data and click Run to send it downstream. The text is available as {{input.data.text}} in the next node.

Great for testing and debugging workflows with different inputs.
Optionally set Default Text in the properties panel.

App Event

Listens for internal events from Verse AI apps:

General: user.login, chat.message, file.upload, etc.
Verse Link: Messages sent/received, DMs, room joins
Verse Circuit: Circuit generated, exported, template loaded
Verse Desktop: App launched/closed, filesystem saved
Versona Hub: Versona created/updated/deleted, task created
Custom: Define your own event names

6. Action Nodes

Action nodes do work — they make requests, send messages, transform data, or call AI models.

HTTP Request

Makes an HTTP request to any URL. Configure the method (GET, POST, PUT, PATCH, DELETE), headers as JSON, request body, and timeout. Perfect for calling external APIs.

Use {{input.data}} in the URL or body to inject dynamic values.
The response (JSON parsed) flows to the next node.

AI / LLM Call

Sends a prompt to Verse AI or one of your Versonas. Configure a system prompt, user prompt (with {{input.data}} for dynamic content), temperature, and max tokens.

The model dropdown dynamically loads your Versonas.
Chain it with other nodes: HTTP → AI / LLM → Email to fetch data, analyze it, and send a summary.

Send Email

Sends an email via Gmail SMTP. Fill in the recipient, subject, and body. Toggle HTML Body for rich formatting. Use {{input.data}} in any field to insert dynamic content.

Database Query

Executes a SQL query against the default database or a custom connection string. Supports Execute Query, Insert, Update, and Delete operations. Use parameterized queries with {{input.userId}} syntax.

Transform Data

Reshapes data between nodes using JavaScript. Choose a mode:

Expression: A simple JavaScript return statement: return { summary: input.data.response };
JavaScript: Full function body with access to the input variable.

Delay / Wait

Pauses execution for a specified duration. Useful for rate limiting, waiting for external processes, or sequencing timed actions.

Send Notification

Pushes a notification via In-App, Browser Push, Email, or SMS. Set a title, message body, and priority level (Low, Normal, High, Urgent).

7. Logic & Flow Control

Logic nodes let you branch, loop, merge, and code custom behavior.

IF Condition

Branches the workflow into True and False paths based on a condition. Specify a field, operator (equals, contains, greater than, regex match, etc.), and comparison value.

Example: {{input.status}} equals success

Switch

Routes data to one of four outputs (Case 1, Case 2, Case 3, Default) based on a field's value. Like a multi-way IF statement.

Merge

Combines data from two separate branches back into one. Supports Append, Merge By Key, Wait For All, and Multiplex modes.

Loop / Iterate

Iterates over an array of items. For each item, data flows out the Each Item port. When iteration is complete, data flows out Done. Configure batch size and max iterations for safety.

Code / Script

Execute custom JavaScript (or Python server-side) code. Access the incoming data via the input variable and return a new object.

Example: const result = input.data.toUpperCase(); return { data: result };

8. Connector Nodes

Connector nodes integrate with third-party services.

Slack

Send messages, update messages, get channel info, or list channels. Specify a channel name or ID and your message content.

Discord

Send messages, send embeds, or get messages from a Discord channel. Provide the channel ID and content.

Gmail

Read, send, search, or label Gmail messages. For sending, provide the recipient, subject, and body. For searching, use Gmail search query syntax.

GitHub

Create issues, list issues, create pull requests, get repo info, or list commits. Provide the owner and repository name.

Custom API

Connect to any REST API. Configure the base URL, authentication type (Bearer Token, API Key, Basic Auth, OAuth2), endpoint, method, and request body.

9. AI & Agent Nodes

Advanced AI capabilities beyond simple LLM calls.

Agent Call

Invoke a Verse AI agent with a task description. The agent can autonomously perform multi-step operations. Set max steps and a timeout to control execution bounds.

Skill Execute

Execute a registered skill (like summarize, translate, or extract) with parameters. Enable Retry on Failure for resilience.

Tool Call

Call an external tool or function. Supports MCP Server, REST API, JavaScript Function, and Server-Side tool types. Provide configuration as JSON.

Generate Embedding

Generate vector embeddings from text for semantic search or similarity matching. Choose between embedding models or a local option.

AI Classifier

Classify input text into categories using AI. Define comma-separated categories and the classifier will output the best match along with a category routing output.

10. Output Nodes

Output nodes determine what your workflow produces.

Workflow Response

Defines the final output of the workflow. Choose the response type (JSON, Text, HTML, File) and provide a template. Use {{input.data}} to inject the last node's output.

Log / Debug

Logs data to the Execution Log panel at the bottom of the workflow builder. Set the log level (Info, Warning, Error, Debug) and a message template. Pass Data Through is enabled by default so it doesn't break your chain.

Debug Screen

Displays the full JSON payload of incoming data directly on the node canvas. Unlike Log / Debug (which only writes to the log panel), the Debug Screen shows everything visually on the node itself.

Data passes through unchanged — chain it anywhere to inspect what’s flowing.
Use it to discover the exact field names for your {{input.data.fieldName}} variables.

11. Example Workflows

Example 1: Daily Summary Email

Schedule trigger → fires every day at 9 AM
HTTP Request → fetches data from your project management API
AI / LLM Call → summarizes the data. User prompt: Summarize these tasks: {{input.data}}
Send Email → sends the summary. Body: {{input.data}}

Example 2: Chat Command to Query Database

Prompt Match trigger → pattern: show active users
Database Query → SELECT TOP 10 * FROM Users WHERE IsActive = 1
AI / LLM Call → formats the results into readable text
Workflow Response → returns the formatted response to chat

Example 3: GitHub Issue to Slack Notification

Webhook trigger → receives GitHub webhook payload
IF Condition → checks {{input.action}} equals opened
Transform Data → extracts title and URL from the payload
Slack connector → sends New issue: {{input.data}} to #dev-alerts

Remember:

Toggle your workflow Active for triggers to fire automatically. Inactive workflows can only be run manually with the Execute button.

Available Widgets

Nodes

Build Your Workflow

Node Properties

Execution Log

My Workflows

🔌 Connector Settings

Verse AI Workflow Builder Tutorial

Contents