Workflow Nodes

Workflow nodes are the building blocks of your automation pipelines. The Strongly platform provides 255 node types across 11 categories, covering data ingestion, transformation, AI processing, control flow, evaluation, and output delivery.

Node Categories Overview

Category	Count	Purpose
Sources	121	Read data from external systems and services
Transform	33	Parse, extract, reshape, and process data
Destinations	23	Write data to external systems and services
Control Flow	20	Manage execution paths, loops, and branching
Agents	15	Orchestrate multi-step AI reasoning and task execution
Triggers	11	Initiate workflow execution from events or schedules
Evaluation	10	Assess AI output quality and enforce guardrails
Memory	8	Store and retrieve context, conversation history, and knowledge
AI	7	Connect to language models, embeddings, vision, and speech
Tools	6	General-purpose utilities for code execution, API calls, and search
Operators	1	Infrastructure-level integration providers

---

Sources

Source nodes read data from external systems and services. Configure connection credentials once in Data Sources and reuse them across multiple workflows.

Common Configuration:

• Connection credentials (via Data Sources)
• Query or filter parameters
• Response data mapping
• Error handling and retries

Databases -- Relational

Node ID	Display Name	Description
clickhouse	ClickHouse	Real-time analytics database operations on ClickHouse
cockroachdb	CockroachDB	Execute queries on CockroachDB
cratedb	CrateDB	Execute queries on CrateDB distributed databases
greenplum-source	Greenplum	Query data from Greenplum MPP database
mssql	Microsoft SQL Server	Execute queries on Microsoft SQL Server databases
mysql-source	MySQL	Query data from MySQL database
oracle	Oracle	Execute queries on Oracle databases
postgresql-source	PostgreSQL	Query data from PostgreSQL database
questdb	QuestDB	Execute queries on QuestDB time-series databases
singlestore	SingleStore	Execute queries on SingleStore distributed databases
snowflake	Snowflake	Execute queries on Snowflake data warehouse
timescaledb	TimescaleDB	Execute queries on TimescaleDB time-series databases

Databases -- NoSQL and Document

Node ID	Display Name	Description
arangodb	ArangoDB	Execute operations on ArangoDB multi-model databases
couchbase	Couchbase	Execute operations on Couchbase databases
couchdb	CouchDB	Execute operations on Apache CouchDB
dynamodb	DynamoDB	AWS NoSQL database operations on DynamoDB
faunadb	FaunaDB	Execute operations on FaunaDB serverless databases
firestore	Firestore	Execute operations on Google Cloud Firestore
mongodb-source	MongoDB	Document database operations on MongoDB
surrealdb-source	SurrealDB	Query data from SurrealDB

Databases -- Graph

Node ID	Display Name	Description
neo4j-source	Neo4j	Query data from Neo4j graph database
neptune	Neptune	Execute queries on Amazon Neptune graph databases
tigergraph	TigerGraph	Execute operations on TigerGraph graph databases

Databases -- Vector

Node ID	Display Name	Description
chroma	Chroma	Vector database operations on Chroma
lancedb	LanceDB	Serverless vector database operations on LanceDB
marqo	Marqo	Execute operations on Marqo tensor search engines
milvus-source	Milvus	Vector similarity search with Milvus
pgvector	pgvector	Vector operations using PostgreSQL pgvector extension
pinecone	Pinecone	Vector database operations on Pinecone
qdrant	Qdrant	Vector database operations on Qdrant
vespa	Vespa	Execute operations on Vespa search engines
weaviate	Weaviate	Vector database operations on Weaviate

Databases -- Search and Cache

Node ID	Display Name	Description
elasticsearch	Elasticsearch	Search and analytics on Elasticsearch
memcached	Memcached	Execute operations on Memcached caching systems
redis-source	Redis	In-memory database operations on Redis

Databases -- Low-Code and Spreadsheet

Node ID	Display Name	Description
airtable	Airtable	Database operations on Airtable
baserow	Baserow	Execute operations on Baserow tables and databases
grist	Grist	Execute operations on Grist documents and tables
nocodb	NocoDB	Execute operations on NocoDB tables and databases
seatable	SeaTable	Execute operations on SeaTable bases and tables
supabase	Supabase	Execute operations on Supabase databases

Cloud Storage and File Systems

Node ID	Display Name	Description
dropbox	Dropbox	Execute operations on Dropbox files and folders
ftp	FTP	Execute file operations on FTP and SFTP servers
google-cloud-storage	Google Cloud Storage	Execute operations on Google Cloud Storage buckets
google-drive	Google Drive	Execute operations on Google Drive files and folders
minio	MinIO	Execute operations on MinIO and S3-compatible storage
onedrive	OneDrive	Execute operations on Microsoft OneDrive files and folders
s3-source	Amazon S3	List or download files from Amazon S3
sftp	SFTP	Download files from SFTP server. Supports file patterns, recursive downloads, and file filtering
sharepoint	SharePoint	Execute operations on Microsoft SharePoint sites and lists

CRM and Sales

Node ID	Display Name	Description
dynamics	Microsoft Dynamics 365	Interact with Microsoft Dynamics 365 CRM
freshdesk	Freshdesk	Interact with Freshdesk support platform
hubspot	HubSpot	Interact with HubSpot CRM
pipedrive	Pipedrive	Interact with Pipedrive Sales CRM
salesforce	Salesforce	Interact with Salesforce CRM
zendesk	Zendesk	Interact with Zendesk support

Project Management and Productivity

Node ID	Display Name	Description
asana	Asana	Interact with Asana project management
clickup	ClickUp	Interact with ClickUp project management
jira	Jira	Interact with Jira project management
linear	Linear	Interact with Linear project management
monday	monday.com	Interact with monday.com boards
notion	Notion	Execute operations on Notion workspaces
trello	Trello	Interact with Trello boards

Communication and Messaging

Node ID	Display Name	Description
discord-source	Discord	Interact with Discord servers
gmail	Gmail	Interact with Gmail API
microsoft-outlook	Microsoft Outlook	Interact with Microsoft Outlook via Graph API
microsoft-teams	Microsoft Teams	Interact with Microsoft Teams
ms-exchange-source	Microsoft Exchange	Read emails from Microsoft Exchange and save as .eml files with embedded attachments
slack-source	Slack	Interact with Slack workspaces
telegram	Telegram	Interact with Telegram Bot API
twilio	Twilio	Send SMS, make calls, and interact with Twilio
whatsapp	WhatsApp	Send and receive messages via WhatsApp Business Cloud API

Social Media

Node ID	Display Name	Description
facebook	Facebook	Interact with Facebook Graph API for pages and ads
linkedin	LinkedIn	Interact with LinkedIn professional network
twitter	Twitter/X	Interact with Twitter/X API
youtube	YouTube	Interact with YouTube Data API

Analytics and Monitoring

Node ID	Display Name	Description
google-ads	Google Ads	Manage Google Ads campaigns and reporting
google-analytics	Google Analytics	Interact with Google Analytics 4
grafana	Grafana	Interact with Grafana monitoring
metabase	Metabase	Interact with Metabase BI platform
posthog	PostHog	Interact with PostHog product analytics
segment	Segment	Interact with Segment customer data platform
sentry	Sentry	Interact with Sentry error tracking

Google and Microsoft Workspace

Node ID	Display Name	Description
excel-online	Excel Online	Execute operations on Microsoft Excel 365 workbooks
google-calendar	Google Calendar	Interact with Google Calendar
google-docs	Google Docs	Interact with Google Docs
google-forms	Google Forms	Interact with Google Forms
google-meet	Google Meet	Interact with Google Meet
google-sheets	Google Sheets	Read and write data to Google Sheets

DevOps and CI/CD

Node ID	Display Name	Description
cloudflare	Cloudflare	Interact with Cloudflare infrastructure
github	GitHub	Interact with GitHub repositories
gitlab	GitLab	Interact with GitLab repositories
jenkins	Jenkins	Interact with Jenkins CI/CD

Identity and Access Management

Node ID	Display Name	Description
entra-id	Microsoft Entra ID	Interact with Microsoft Entra ID (Azure AD)
ldap	LDAP	Query and manage LDAP directories
okta	Okta	Interact with Okta Identity Management

Message Queues and Streaming

Node ID	Display Name	Description
amqp-source	AMQP	Execute operations on AMQP brokers like RabbitMQ
kafka	Kafka	Execute operations on Apache Kafka topics
mqtt	MQTT	Execute operations on MQTT brokers
nats	NATS	Execute operations on NATS messaging system
pulsar	Pulsar	Execute operations on Apache Pulsar
rabbitmq-source	RabbitMQ	Consume messages from RabbitMQ
sns-source	AWS SNS	Execute operations on AWS Simple Notification Service
sqs	AWS SQS	Execute operations on AWS Simple Queue Service

E-Commerce and Payments

Node ID	Display Name	Description
paypal	PayPal	Interact with PayPal payments
quickbooks	QuickBooks	Interact with QuickBooks Online accounting
shopify	Shopify	Interact with Shopify stores
stripe	Stripe	Interact with Stripe payments
woocommerce	WooCommerce	Interact with WooCommerce stores

IT Service Management

Node ID	Display Name	Description
pagerduty	PagerDuty	Interact with PagerDuty incident management
servicenow	ServiceNow	Interact with ServiceNow ITSM platform
workday	Workday	Interact with Workday HR and Finance platform

APIs and General Connectivity

Node ID	Display Name	Description
bigquery	BigQuery	Execute queries on Google BigQuery
exec	Exec	Execute shell commands and scripts
graphql	GraphQL	Execute GraphQL queries and mutations
rest-api	REST API	Fetch data from REST API endpoints with authentication and flexible configuration
ssh	SSH	Execute commands and transfer files via SSH

Other Integrations

Node ID	Display Name	Description
intercom	Intercom	Interact with Intercom customer messaging platform
typeform	Typeform	Interact with Typeform forms and surveys
wordpress	WordPress	Interact with WordPress REST API
zoom	Zoom	Interact with Zoom video conferencing

Data Sources

Configure connection credentials once in Data Sources and reuse across multiple workflows. This avoids embedding secrets in workflow definitions.

---

Transform

Transform nodes parse, extract, reshape, and process data between source and destination nodes. They handle format conversion, aggregation, filtering, and custom logic.

Node ID	Display Name	Description
aggregate	Aggregate	Aggregate data with sum, average, count, and more
ai-transform	AI Transform	Transform data using AI
code	Code	Execute custom Python code for data transformation
compare	Compare	Compare two datasets to find differences
compression	Compression	Compress and decompress data
crypto	Crypto	Encryption, hashing, encoding, and cryptographic operations
data-aggregator	Data Aggregator	Aggregate, flatten, filter, and transform array data from loop results
data-lookup	Data Lookup	High-performance in-memory lookup. Supports cached mode (O(1) hash lookups from file) or inline mode (reference array). Perfect for database lookups in row loops.
datetime	Date/Time	Date and time parsing, formatting, and arithmetic
dedupe	Dedupe	Remove duplicate items from arrays
email-parser	Email Parser	Parse email files and extract content, attachments, and metadata
excel-parser	Excel Parser	Parse Excel files and extract data as structured JSON
file-extractor	File Extractor	Extract files from ZIP, TAR, GZ, and other archive formats. Supports nested archives and file filtering
filter	Filter	Filter data based on conditions and rules
html-extract	HTML Extract	Extract data from HTML content
jwt	JWT	Create, verify, and decode JSON Web Tokens
limit	Limit	Limit the number of items in an array
markdown	Markdown	Parse and convert Markdown content
merge-data	Merge Data	Merge data from multiple sources using various strategies like concatenation, object merge, or combine
pdf-generator	PDF Generator	Generate PDF documents from templates, data, or HTML/markdown content
pdf-parser	PDF Parser	Extract data from PDF files
pdf-redactor	PDF Redactor	Redact or obfuscate sensitive content in PDF documents. Supports row-based redaction and keyword/pattern modes with S3-cached indexing for faster processing
redaction-list-builder	Redaction List Builder	Build a list of values to redact from all rows EXCEPT the current/matched row. Perfect for creating per-row redacted PDFs
rename-keys	Rename Keys	Rename object keys and transform naming conventions
report-builder	Report Builder	Generate formatted reports (HTML, PDF, Markdown) with tables, sections, grouping, and master-detail layouts
set-fields	Set Fields	Set, edit, rename, and delete data fields
sort	Sort	Sort arrays of data by specified fields
summarize	Summarize	Create statistical summaries of data
table-parser	Table Parser	Extract structured data from tables with optional filtering, validation, and repair
text-chunker	Text Chunker	Split text into chunks for embedding and RAG pipelines. Supports multiple chunking strategies with overlap
to-file	To File	Convert data to file format
totp	TOTP	Generate and verify Time-based One-Time Passwords
xml-parser	XML Parser	Parse XML to JSON or convert JSON to XML

---

Destinations

Destination nodes write processed data to external systems and services.

Common Configuration:

• Destination credentials (via Data Sources)
• Data mapping and field selection
• Success/failure handling
• Delivery confirmation

Node ID	Display Name	Description
amqp-dest	AMQP	Publish messages via AMQP (RabbitMQ)
chat-response	Chat Response	Send response to chat interface
discord-dest	Discord	Send messages and interact with Discord
greenplum-dest	Greenplum	Write data to Greenplum MPP database
mailchimp	Mailchimp	Email marketing and automation with Mailchimp
milvus-dest	Milvus	Store vectors in Milvus
mongodb-dest	MongoDB	Save data to MongoDB
ms-exchange-dest	Microsoft Exchange	Send emails via Microsoft 365/Exchange with attachments support
mysql-dest	MySQL	Save data to MySQL database
neo4j-dest	Neo4j	Store data in Neo4j graph database
notification	Notification	Send multi-channel notifications (email, Slack, webhook, SMS)
postgresql-dest	PostgreSQL	Save data to PostgreSQL database
rabbitmq-dest	RabbitMQ	Publish messages to RabbitMQ
redis-dest	Redis	Write data to Redis
s3-dest	Amazon S3	Upload files to S3 bucket
sendgrid	SendGrid	Send email via SendGrid API with support for templates, attachments, and scheduling
slack-dest	Slack	Send messages and interact with Slack
smtp	SMTP	Send email via SMTP server with support for HTML, attachments, and templates
sns-dest	AWS SNS	Send notifications via AWS Simple Notification Service
streaming-response	Streaming Response	Stream data chunks to clients
surrealdb-dest	SurrealDB	Write data to SurrealDB
teams	Microsoft Teams	Send messages to Microsoft Teams
webhook-response	Webhook Response	Send HTTP response to webhook caller

---

Control Flow

Control flow nodes manage execution paths, looping, branching, and data routing within workflows.

Node ID	Display Name	Description
backtrack	Backtrack	Checkpoint and restore workflow state for backtracking
conditional	Conditional	If/Else conditional branching
consensus	Consensus	Multi-agent voting and decision-making
event-wait	Event Wait	Wait for events from multiple sources before continuing
goal-loop	Goal Loop	Loop until LLM determines the goal is achieved
human-checkpoint	Human Checkpoint	Pause workflow for human review, approval, or input. Essential for AI safety and human oversight in agentic workflows
human-feedback	Human Feedback	Collect structured human input mid-workflow
loop	Loop	Iterate over arrays or repeat actions
map	Map	Process array items in parallel using visual scope boxes
merge	Merge	Merge data from multiple workflow branches
noop	No-Op	Pass-through node that does nothing
parallel-branch	Parallel Branch	Execute multiple branches in parallel with configurable join strategies (all, any, first-N, majority)
priority-queue	Priority Queue	Queue items and process in priority order
retry	Retry	Implement retry logic for failed operations with configurable backoff strategies
split	Split	Split arrays into individual items for separate processing
stop-error	Stop/Error	Stop workflow execution with an error
sub-workflow	Sub-Workflow	Execute another workflow
switch-case	Switch/Case	Multi-way branching based on value matching with support for patterns, ranges, and multiple cases
wait	Wait	Pause workflow execution for a duration or until a condition is met
while-loop	While Loop	Execute a branch repeatedly while a condition is true, with configurable limits and break/continue support

Conditional Node

Execute different branches based on conditions:

// Condition examples
{{ input.status }} === "approved"
{{ input.amount }} > 1000
{{ input.tags }}.includes("urgent")

Supported Operators:

• Comparison: ==, !=, >, >=, <, <=
• String: contains, starts_with, ends_with, regex
• Null checks: is_null, is_not_null, is_empty, is_not_empty
• List: in, not_in
• Boolean: is_true, is_false

Loop Node

Iterate over array data with accumulator support:

// Loop over items
items: {{ apiResponse.data.users }}

// Access current item in loop
{{ loop.item.name }}
{{ loop.index }}

// Accumulator collects results from each iteration
// Access via final_results when loop completes

Map Node

Transform each item in an array with parallel processing:

// Input array
{{ source.products }}

// Transform expression
{
  "id": {{ item.id }},
  "price": {{ item.price * 1.1 }}
}

Data Aggregator

Process loop results with multiple operations:

// Operations
[
  {"type": "extract", "field": "pdfPath", "outputField": "allPdfs"},
  {"type": "flatten", "field": "errors", "outputField": "allErrors"},
  {"type": "filter", "condition": {"field": "status", "operator": "==", "value": "failed"}},
  {"type": "count", "outputField": "totalCount"}
]

---

Agents

Agent nodes orchestrate complex, multi-step AI workflows using specialized reasoning patterns for autonomous task execution.

Node ID	Display Name	Description
agent-handoff	Agent Handoff	Package and transfer context between agent nodes
agent-loop	Agent Loop	Configurable autonomous think-act-observe agent loop
column-mapper	Column Mapper	Uses LLM to intelligently map source columns to a target schema. Handles varying column names across different data sources by understanding semantic meaning. Supports database caching for known mappings
data-cleanup	Data Cleanup	Uses LLM to validate and fix malformed data rows from PDF extraction. Detects shifted columns, merged values, and data type mismatches
debate-agent	Debate Agent	Multi-agent debate pattern for reaching consensus through structured argumentation, critique, and synthesis
document-classification	Document Classification	Intelligent document classification agent
entity-extraction	Entity Extraction	Intelligent entity extraction agent
function-calling	Function Calling	Orchestrates function calls from AI responses, extracting and managing tool calls
multi-agent-chat	Multi-Agent Chat	Multiple AI personas collaborate on a shared discussion thread
planner	Planner	Decompose complex goals into ordered sub-tasks with dependencies
rag	RAG	Retrieval Augmented Generation agent that combines retrieved documents with AI generation
react-agent	ReAct Agent	Autonomous AI agent using the ReAct (Reasoning + Acting) pattern. Iteratively thinks, acts using tools, and observes results until the goal is achieved
reflection	Reflection	Self-review and iterative content improvement via critique-revise cycles
supervisor-agent	Supervisor Agent	Orchestrates multiple sub-agents to accomplish complex tasks. Creates execution plans, delegates work, and synthesizes results
tool-router	Tool Router	LLM-based dynamic tool selection for a given task

Agent Patterns:

• ReAct: Autonomous reasoning and acting loop with tool use
• Debate: Multiple AI perspectives argue and converge on conclusions
• Supervisor: Hierarchical task delegation and result synthesis
• RAG: Knowledge-grounded generation with document retrieval
• Function Calling: Tool use orchestration for AI actions
• Reflection: Self-critique and iterative improvement
• Multi-Agent Chat: Collaborative discussion between AI personas
• Planner: Goal decomposition into ordered sub-tasks

Learn more about AI Agents

---

Triggers

Triggers initiate workflow execution. Every workflow must start with exactly one trigger node.

Node ID	Display Name	Description
chat-trigger	Chat Trigger	Trigger workflows from chat/conversational interfaces
email-trigger	Email Trigger	Trigger workflows when new emails arrive via IMAP
error-trigger	Error Trigger	Trigger workflows from error events in other workflows
file-trigger	File Trigger	Trigger workflows based on local file system changes
form	Form	Accept public form submissions with file uploads and CAPTCHA protection
multi-modal-input	Multi-Modal Input	Accept mixed media types as workflow input (text, image, audio, file)
rest-api-trigger	REST API Trigger	Expose workflow as authenticated REST API endpoint
rss-trigger	RSS Trigger	Trigger workflows when new RSS/Atom feed items appear
schedule	Schedule	Trigger workflow on a schedule
sse-trigger	SSE Trigger	Trigger workflow on Server-Sent Events
webhook	Webhook	Receive webhooks from external services with maximum security

Learn more about triggers

---

Evaluation

Evaluation nodes assess AI output quality, detect hallucinations, enforce guardrails, and enable systematic testing of AI workflows. All LLM-based evaluation nodes connect to an AI Gateway for assessment.

Node ID	Display Name	Description
answer-quality	Answer Quality	Evaluates overall answer quality using a composite of metrics: correctness, completeness, helpfulness, and coherence. Provides a holistic assessment of LLM response quality
cost-tracker	Cost Tracker	Track token usage and estimated costs with budget limits
faithfulness-checker	Faithfulness Checker	Detects hallucinations by checking if the generated response is grounded in the provided context. Essential for RAG systems to ensure answers do not contain fabricated information
guardrails	Guardrails	Content validation with PII detection, toxicity checking, and custom rules
llm-as-judge	LLM as Judge	Uses an LLM to evaluate outputs based on configurable criteria. Supports single scoring, multi-criteria evaluation, and chain-of-thought reasoning for reliable assessments
output-parser	Output Parser	Parse and validate LLM output into structured formats
pairwise-comparator	Pairwise Comparator	Compares two outputs/responses and determines which is better. Ideal for A/B testing, model comparison, prompt optimization, and relative quality assessment
rag-metrics	RAG Metrics	Comprehensive RAG pipeline evaluation with context precision, context recall, answer relevancy, and faithfulness metrics. Essential for optimizing retrieval-augmented generation systems
rate-limiter	Rate Limiter	Enforce rate limits with token bucket or sliding window
relevance-grader	Relevance Grader	Evaluates whether retrieved documents or context are relevant to the query. Essential for RAG pipeline evaluation and retrieval quality assessment

Use Cases:

• RAG pipeline quality monitoring
• Hallucination detection and prevention
• A/B testing prompts and models
• Automated quality gates in production
• Continuous evaluation of AI outputs
• Cost tracking and budget enforcement
• Content safety and PII detection

Configuration:

• Select evaluation criteria
• Configure scoring scales (0-1, 1-5, 1-10, binary)
• Set pass/fail thresholds
• Enable chain-of-thought reasoning
• Connect to AI Gateway for judge model

Metrics Logging

Evaluation nodes automatically log metrics (scores, pass rates) that can be viewed in the Workflow Monitor's execution trace and compared across runs.

---

Memory

Memory nodes store and retrieve conversation context, knowledge, and workflow state for multi-turn and agent-based workflows.

Node ID	Display Name	Description
context-buffer	Context Buffer	Manage working memory and context windows
conversation-memory	Conversation Memory	Store and retrieve conversation history
episodic-memory	Episodic Memory	Store and retrieve past workflow experiences via MongoDB
knowledge-base	Knowledge Base	Store and query structured knowledge
memory-retriever	Memory Retriever	Query multiple memory sources and merge/rank results
semantic-memory	Semantic Memory	Vector store with embedding-based retrieval via Milvus
shared-blackboard	Shared Blackboard	Cross-agent shared key-value state via MongoDB
working-memory	Working Memory	Short-term key-value scratchpad with TTL support

Use Cases:

• Multi-turn conversations with context retention
• Context-aware AI responses
• RAG (Retrieval Augmented Generation) knowledge stores
• Long-term memory for autonomous agents
• Cross-agent state sharing in multi-agent workflows

---

AI

AI nodes connect to language models for inference, embeddings, vision, and speech processing.

Node ID	Display Name	Description
ai-gateway	AI Gateway	Process with AI models
embeddings	Embeddings	Generate vector embeddings via AI Gateway
image-generation	Image Generation	Generate images via AI Gateway with async job-based processing
llm	LLM	Text and chat completion via AI Gateway
speech-to-text	Speech to Text	Transcribe audio to text
text-to-speech	Text to Speech	Generate speech audio from text via AI Gateway
vision	Vision	Analyze images and visual content with AI models

Configuration:

• Select model from AI Gateway
• Set prompt template
• Configure parameters (temperature, max tokens)
• Define response format
• Token usage tracking

Advanced Features:

• Streaming responses
• Function calling
• Multi-turn conversations
• Prompt engineering
• Cost tracking

Learn more about AI in workflows

---

Tools

Tool nodes provide general-purpose utilities for code execution, HTTP calls, file operations, and web interaction.

Node ID	Display Name	Description
api-caller	API Caller	Make dynamic HTTP API calls with optional datasource authentication
calculator	Calculator	Safe mathematical expression evaluator (no eval, uses AST)
code-interpreter	Code Interpreter	Execute Python or JavaScript code in a sandboxed subprocess
file-manager	File Manager	Read, write, and copy files via workflow storage
web-browser	Web Browser	Chromium-based browser with full JS rendering, screenshots, and PDF generation
web-search	Web Search	Search the web using SerpAPI, Brave Search, Tavily, or a generic search API endpoint

---

Operators

Operators are infrastructure-level nodes that provide integration capabilities to other nodes in the workflow.

Node ID	Display Name	Description
mcp-tools-provider	MCP Tools Provider	Provides MCP server tools to agents. Connect to an agent's 'tools' connector

MCP (Model Context Protocol) servers provide 139 pre-integrated tools that can be exposed to agent nodes through this operator.

Learn more about MCP Tools

---

Node Configuration

Common Settings

All nodes share these basic settings:

Identity

• Name: Display name on canvas
• Description: Purpose and notes
• Enabled: Toggle execution on/off

Execution

• Retry Count: Number of retry attempts
• Retry Delay: Wait time between retries
• Timeout: Maximum execution time

Error Handling

• On Error: Continue, stop workflow, or branch
• Fallback Value: Default value on failure
• Error Output: Capture error details

Data Mapping

Reference data from previous nodes:

// Simple field reference
{{ triggerNode.userId }}

// Nested fields
{{ apiCall.response.data.items[0].name }}

// Conditional mapping
{{ condition ? value1 : value2 }}

// Array operations
{{ array }}.map(item => item.id)
{{ array }}.filter(item => item.active)

Variable Context

Each node has access to:

Context	Description
{{ trigger }}	Trigger node output
{{ nodeName }}	Output from specific node
{{ env }}	Environment variables
{{ workflow }}	Workflow metadata
{{ execution }}	Current execution details

Best Practices

Node Organization

1. Left-to-Right Flow: Arrange nodes to show progression
2. Vertical Spacing: Group related processing paths
3. Descriptive Names: Use clear, purpose-driven names
4. Documentation: Add notes to complex nodes

Performance Optimization

1. Minimize Sequential Chains: Use parallel execution where possible
2. Cache Results: Store frequently accessed data
3. Batch Operations: Process multiple items together
4. Filter Early: Remove unnecessary data early in pipeline

Error Handling

1. Add Retries: Configure retries for network operations
2. Fallback Values: Provide defaults for optional data
3. Error Branches: Route errors to notification/logging
4. Validation: Check data format before processing

Security

1. Credentials: Use Data Sources for sensitive credentials
2. Input Validation: Sanitize user inputs
3. Output Filtering: Do not expose sensitive data
4. Access Control: Review workflow permissions

Node Examples

Example: Data Enrichment Pipeline

Webhook Trigger
  -> REST API (Fetch user data)
  -> AI Gateway (Analyze sentiment)
  -> MongoDB (Store results)
  -> Webhook Response (Notify completion)

Example: Document Processing

Schedule Trigger
  -> Amazon S3 (List new PDFs)
  -> Loop (For each PDF)
    -> PDF Parser (Extract text)
    -> Entity Extraction (Find entities)
    -> Neo4j (Store relationships)

Example: Batch Processing with Aggregation

Schedule Trigger
  -> SFTP Source (Download files)
  -> Loop (For each file)
    -> Conditional (Check file type)
      -> [.zip] File Extractor -> PDF Parser
      -> [.pdf] PDF Parser (direct)
    -> Table Parser (Extract data)
    -> MySQL (Lookup)
    -> PDF Redactor (Redact sensitive data)
  -> Data Aggregator (Collect results)
    -> [allPdfs] Amazon S3 (Upload batch)
    -> [allErrors] PDF Generator (Create report)
      -> Microsoft Exchange (Email report)

Example: Conditional Routing

Form Trigger
  -> Conditional (Check priority)
    -> [High Priority]
      -> AI Gateway (Urgent response)
      -> Gmail (Send immediately)
    -> [Normal Priority]
      -> MongoDB (Queue for later)

Example: Multi-Agent RAG Pipeline

Chat Trigger
  -> Embeddings (Generate query vector)
  -> Semantic Memory (Retrieve relevant documents)
  -> RAG Agent (Generate grounded response)
  -> Faithfulness Checker (Verify no hallucinations)
  -> Conditional (Check faithfulness score)
    -> [Pass] Chat Response (Return answer)
    -> [Fail] Reflection (Revise answer)
      -> Chat Response (Return revised answer)

Next Steps

• Configure workflow triggers
• Use AI agents in workflows
• Explore MCP tools
• See workflow examples