Node Reference

Build powerful automation workflows by connecting specialized nodes. Each node type serves a specific purpose and can be combined to create complex automation flows.

Quick Navigation

Core Nodes: Start • Agent • Chat • Code • Params • Sticky Notes • DataGrid

Knowledge: Vector Store

Control Flow: Condition • Loop • Fork • Join

Triggers: Trigger • Webhook Response

Actions: Action • Plugin • Response

Visualization: ToVec • 3D • Web • Chart

Vision: Vision — OCR, describe, extract, classify, modify images with Apple Vision or multimodal LLMs

Image Processing: ImgOps — resize, rotate, convert, generate favicon / app-icon sets, watermark, edge-detect (deterministic, no model)

Data: Database — read/write SQLite, Supabase, Postgres, MySQL, SQL Server, Oracle, Snowflake, BigQuery (+ managed clouds like RDS/Cloud SQL/Azure); zero-setup in-browser SQLite (incl. iPad); SQL wizard + database editor

Core Nodes

Essential building blocks for every workflow

Start Node

The entry point for every workflow. Provides initial data to downstream nodes.

Configuration:

• Input Data: JSON data to pass to the workflow
• Trigger Type: Manual, Scheduled, or Webhook

Output: The configured input data

Trigger Node

Initiates workflows based on external events.

Configuration:

• Event Type: Webhook, Schedule, Email, etc.
• Conditions: Filters for when to trigger

Processing Nodes

Agent Node

Processes data using AI language models.

Configuration:

• Model: Select from GPT-5, GPT-4, Claude, or custom models
• Prompt: Instructions for the AI model
• Temperature: Controls creativity (0-2)
• Max Tokens: Maximum response length
• System Message: Optional context for the model

Input: Data from previous node Output: AI-generated response

Chat Node

Interactive conversational AI with persistent memory that works both standalone and in workflows.

Configuration:

• Model: OpenAI GPT-4o, Claude, or local models
• Temperature: Controls response creativity (0-1.0)
• System Prompt: Set AI behavior and personality
• Output Mode: Response (latest reply) or Full History (conversation)
• Message Limit: Enable to control context size for workflows

Features:

• Persistent Memory: Chat history survives page reloads via IndexedDB
• Workflow Integration: Accepts input from upstream nodes as user messages
• Real-time Interface: Live chat with auto-scroll and message timestamps
• Memory Management: Configurable message limits for performance
• Model Flexibility: Support for all AI providers and local endpoints

Usage Scenarios:

• Standalone Chat: Direct user interaction for support or assistance
• Workflow Integration: Memory-enabled AI processing in automation flows
• Customer Service: Persistent conversations with context retention
• Content Generation: Multi-turn creative writing and editing

Input: String message from previous node (in workflows) Output: AI response string or full conversation history array

Params Node

Interactive parameter controls for workflow fine-tuning with real-time adjustments.

Features:

• Visual controls (sliders, toggles, number inputs)
• Live Update mode for automatic downstream execution
• JSON or UI editing modes
• AI-powered parameter generation wizard
• Template variable integration

Use Cases:

• Image processing with real-time preview
• AI model parameter tuning
• Chart visualization controls
• API configuration adjustments
• Interactive workflow demonstrations

→ Complete Params Guide

Sticky Notes

Non-executing documentation nodes for annotating workflows.

Features:

• Rich text editing with formatting (bold, italic, lists)
• 8 color options for visual organization
• Resizable and collapsible
• Dual editing modes (inline and side panel)
• Real-time content synchronization

Use Cases:

• Document workflow logic and decisions
• Add team collaboration notes
• Create section headers and labels
• Track TODOs and known issues

→ Complete Sticky Notes Guide

DataGrid Node

Excel-like spreadsheet interface for viewing and editing tabular data.

Features:

• Interactive spreadsheet powered by react-spreadsheet
• Configurable grid dimensions (rows/columns)
• Pass-thru or Sheet output modes
• CSV export functionality
• Custom column headers
• Edit or read-only modes

Use Cases:

• Display API/database results in table format
• Manual data entry and collection
• Data cleaning and correction
• Simple task tracking
• Report generation

→ Complete DataGrid Guide

Action Node

Performs specific operations like HTTP requests or data transformations.

Common Actions:

• HTTP Request
• Parse JSON
• Transform Data
• Send Email
• Database Query

Configuration: Varies by action type

Code Node

Execute custom JavaScript code for advanced data processing.

Configuration:

• Code: JavaScript code to execute
• Timeout: Maximum execution time

Input: Data from previous node as input variable Output: Whatever the code returns

Example:

// Transform and enrich data
return {
  ...input,
  processed: true,
  timestamp: new Date().toISOString()
}

Control Flow Nodes

Condition Node

Branches workflow execution based on conditions.

Configuration:

• Condition Type: Contains, Equals, Greater Than, etc.
• Field: JSON path to check
• Value: Expected value

Outputs:

• True Branch: Executed when condition is met
• False Branch: Executed when condition is not met

Loop Node

Iterates over arrays or repeats operations.

Configuration:

• Loop Type: For Each, While, Fixed Count
• Array Path: JSON path to array (for For Each)
• Max Iterations: Safety limit

Input: Array or data to iterate over Output: Accumulated results from all iterations

Parallel Processing Nodes

Fork Node

Splits execution into multiple parallel branches.

Configuration:

• Branch Count: Number of parallel paths (2-10)
• Data Distribution: How to split input data

Input: Data to distribute across branches Outputs: Multiple output ports for parallel execution

Join Node

Merges results from parallel branches.

Configuration:

• Merge Strategy:
  • Array: Combine into array
  • Object: Merge as object properties
  • Custom: JavaScript function for merging

Inputs: Multiple input ports from Fork branches Output: Merged data

Knowledge Nodes

Vector Store Node

A knowledge container that AI agents can read from. Ingest PDFs, Markdown, notes, manuals, FAQs, code, or any textual document — the store chunks and indexes them for retrieval. Drop docs in, ask questions through the linked editor's chat, or wire the store into an agent so its answers are grounded in your material.

Features:

• Ingest PDFs, Markdown, text, and most plain-text formats
• Linked editor for browsing docs + chatting against just those docs (with citations)
• Closed-book vs open-book testing toggle in the editor
• Three wiring modes to agents: auto-tool (LLM decides), template variable (always retrieve), pipeline step (chunks as data)
• Workflow-local or global scope (sharable across all your workflows)
• Multi-runtime embedding: Browser (WASM), OpenAI, EServer Python, Apple Intelligence
• Cross-device sync via Supabase Storage; offline-friendly via project-folder cache

Configuration (per-node):

• Top-K: Chunks per query (default 5)
• Max Tokens Injected: Hard cap on retrieved content (default 4000)
• Query Template: Custom query expression (default {{input}})
• Output Format: with-titles / flat / json

Configuration (store-level, in the linked editor):

• Name, Description (what the AI sees), Runtime, Chunk size, Overlap, Scope (workflow / global)

Inputs: Query string from upstream node (or the per-node Query Template) Outputs: { context, chunks, storeName, truncatedToTokenCap } — context is the formatted top-K block ready for an agent; chunks are the structured array for downstream processing.

Use Cases:

• Customer-support chatbot grounded in your product FAQ
• Compliance assistant over regulation documents
• Research assistant over a corpus of PDFs
• Internal-handbook Q&A
• Personal NotebookLM-style document chat

→ Complete Vector Store Guide · → Knowledge Base feature guide

Visualization Nodes

ToVec (Image to Vector) Node

Converts raster images (PNG, JPG) into scalable vector graphics (SVG).

Features:

• Advanced edge detection and tracing algorithms
• Real-time preview with adjustable parameters
• Configurable quality settings (threshold, blur, colors)
• Bitmap preview for performance
• Direct SVG download

Configuration:

• Threshold (0-255): Edge detection sensitivity
• Blur Amount: Smoothing before tracing
• Colors (Posterize): Number of color levels (2-16)
• Stroke Width: Line thickness in pixels
• Scale Factor: Output size multiplier
• Filter Small Lines: Remove tiny segments
• Number of Colors: Palette size (2-64)

Use Cases:

• Convert logos to scalable SVG format
• Create vector art from photos
• Generate custom icons from images
• Prepare graphics for print (infinite resolution)
• Transform screenshots into editable vectors

Input: Image data from Image node or AI image generation Output: SVG vector graphics (scalable, editable)

→ Complete ToVec Guide

Chart Nodes

Visualize data with Chart (Matplotlib), DataViz (Plotly), and StatPlot (Seaborn) nodes.

Features:

• Multiple charting libraries
• Interactive plots
• Statistical visualizations
• Export to image formats

3D Node

Create and display Three.js 3D scenes and animations.

Features:

• Vanilla Three.js for animations
• React Three Fiber for interactive viewing
• AI-powered scene generation
• Orbit controls and camera manipulation

→ Complete 3D Guide

Web Node

Display HTML/CSS content with AI-powered generation.

Features:

• Widget vs. page detection
• CSS framework integration
• Interactive form data output
• Live URL loading

→ Complete Web Guide

Working with Nodes

Adding Nodes

1. Drag from the sidebar onto the canvas
2. Or right-click canvas and select "Add Node"
3. Use keyboard shortcuts (see Shortcuts)

Connecting Nodes

1. Click and drag from an output port
2. Drop on an input port of another node
3. Connections show data flow direction

Configuring Nodes

1. Click on a node to select it
2. Use the right panel to configure settings
3. Test configurations with sample data

Node States

During execution, nodes display their current state:

• Idle: Gray - Not yet executed
• Running: Blue with spinner - Currently processing
• Success: Green - Completed successfully
• Error: Red - Execution failed
• Skipped: Gray striped - Skipped due to conditions

Best Practices

1. Name your nodes descriptively for clarity
2. Test incrementally as you build
3. Use conditions to handle edge cases
4. Leverage parallel processing for performance
5. Add error handling with condition nodes
6. Document complex logic in node descriptions

Advanced Features

Dynamic Configuration

Use {{variable}} syntax to reference data from previous nodes:

{{input.userName}}
{{previousNode.output.result}}

Custom Scripts

Some nodes support custom JavaScript:

// Transform data in Action node
return {
  ...input,
  timestamp: new Date().toISOString(),
  processed: true
}

Examples

Simple AI Processing

Start → Agent (GPT-5) → Action (Save Result)

Conditional Branching

Start → Condition → [True] → Agent A
                 → [False] → Agent B

Parallel Processing

Start → Fork → [Branch 1] → Agent → Join → Action
            → [Branch 2] → Action ↗
            → [Branch 3] → Loop ↗

Related Topics

• Creating Workflows
• Plugin Nodes
• Debugging Workflows