What are Nodes? Nodes are the fundamental building blocks of both chatflows and agentflows in Flowise. Each node represents a specific component, tool, or functionality that can be visually connected to create AI workflows. Think of nodes as Lego blocks that snap together to build complex AI applications.
Flowise dynamically loads nodes from the flowise-components package at runtime, making the system extensible and modular.
Node Architecture Node Structure Every node in Flowise implements the INode interface:
interface INode { // Basic Properties label : string // Display name in the UI name : string // Unique identifier version : number // Node version for compatibility type : string // Node type classification icon : string // Path to icon file (SVG, PNG, JPG) category : string // Category for organization description : string // What this node does // Advanced Properties baseClasses : string [] // Compatible connection types tags ?: string [] // Filtering and search tags badge ?: string // Visual badge (e.g., "NEW", "BETA") color ?: string // Node color in the canvas author ?: string // Creator (for community nodes) documentation ?: string // Link to docs // Configuration inputs ?: INodeParams [] // Input parameters outputs ?: INodeOutputsValue [] // Output types credential ?: INodeParams // Required credentials // Methods init ?: Function // Initialize node instance run ?: Function // Execute node logic loadMethods ?: Object // Dynamic option loading }
Node Categories Flowise organizes nodes into categories:
Chat Models LLM integrations (OpenAI, Anthropic, Google, etc.)
Agents Autonomous agents with tool-calling capabilities
Agent Flows Specialized nodes for agentflow workflows
Tools External integrations and utilities
Document Loaders Load data from various sources
Vector Stores Store and retrieve embeddings
Embeddings Convert text to vector representations
Memory Conversation history management
Chains Pre-built workflow patterns
Nodes in the “Analytic” and “SpeechToText” categories are handled differently and may not appear in the standard node palette.
Nodes accept various input types:
type NodeParamsType = | 'string' // Text input | 'number' // Numeric input | 'boolean' // Toggle/checkbox | 'password' // Masked text | 'json' // JSON editor | 'code' // Code editor | 'options' // Dropdown selection | 'multiOptions' // Multiple selections | 'asyncOptions' // Dynamically loaded options | 'file' // File upload | 'folder' // Folder selection | 'date' // Date picker | 'datagrid' // Table/grid input | 'tabs' // Tabbed interface
Advanced Input Features:
Variable Support : Accept runtime variables with acceptVariable: trueConditional Display : Show/hide based on other inputs using show and hideDynamic Loading : Load options from APIs with loadMethodArray Inputs : Repeatable input groups with array property
Output Anchors Nodes expose outputs through anchors:
interface INodeOutputsValue { label : string // Display name name : string // Identifier baseClasses ?: string [] // Compatible types description ?: string hidden ?: boolean // Hide from UI isAnchor ?: boolean // Can connect to other nodes }
Connection Validation Flowise validates connections based on baseClasses:
Nodes can only connect if output and input base classes are compatible
Example: A “ChatOpenAI” node (baseClasses: [“ChatOpenAI”, “BaseChatModel”]) can connect to inputs accepting “BaseChatModel”
Node Lifecycle Initialization When a node is loaded:
Class Instantiation
Node class is imported and instantiated from the components package
Icon Resolution
Icon paths are converted to absolute paths for the UI
Credential Mapping
If the node requires credentials, they’re linked to available credential types
Registration
Node is added to the componentNodes pool and becomes available in the palette
Execution When a workflow runs:
Dependency Resolution
Flowise builds a directed graph of node dependencies
Sequential Execution
Nodes execute in topological order (dependencies first)
Data Passing
Output from each node is passed to connected downstream nodes
State Management
Node execution data is tracked for debugging and analytics
Node Data Flow Data flows through nodes via the IReactFlowNode structure:
interface IReactFlowNode { id : string // Unique node instance ID type : string // Node type position : { x : number , y : number } // Canvas position data : INodeData // Node configuration and values } interface INodeData { id : string name : string label : string type ?: string category ?: string version ?: number description ?: string // Configuration inputAnchors ?: INodeParams [] // Available input connections inputParams ?: INodeParams [] // Parameter definitions inputValues ?: Record < string , unknown > // User-entered values outputAnchors ?: INodeParams [] // Available output connections // Execution State (Agentflows) status ?: 'INPROGRESS' | 'FINISHED' | 'ERROR' | 'STOPPED' error ?: string warning ?: string }
Special Node Types Agentflow Nodes Nodes in the “Agent Flows” category have unique capabilities:
Start Node
Entry point for agentflows
Accepts chat or form inputs
Hides input anchors (hideInput: true)
Agent Node
Dynamic tool selection
Multi-step reasoning
Memory and knowledge integration
Structured output support
Condition Node
Branching logic based on expressions
Multiple output paths
Iteration Node
Loop through arrays
Process items sequentially or in parallel
Tool nodes can be used by agents:
Must be in the “Tools” or “Tools (MCP)” category
Implement a callable interface
Return results that agents can interpret
Support human-in-the-loop approvals
Tool nodes are converted to LangChain Tool instances at runtime, with schemas automatically generated from their input parameters.
Node Configuration Load Methods Nodes can define dynamic option loaders:
loadMethods = { async listModels ( nodeData : INodeData , options : ICommonObject ) { // Fetch available models from API const models = await fetchModels () return models . map ( m => ({ label: m . name , name: m . id , description: m . description })) } }
This populates dropdowns dynamically based on:
Available credentials
API responses
Other node configurations
Workspace context
Credential Integration Nodes that require API keys or authentication:
credential : { label : 'Connect Credential' , name : 'credential' , type : 'credential' , credentialNames : [ 'anthropicApi' , 'openAIApi' ] }
Credentials are injected at runtime and never exposed in the flow data.
Visual Properties Node Appearance Customize how nodes look on the canvas:
{ label : 'ChatAnthropic' , name : 'chatAnthropic' , icon : 'anthropic.svg' , color : '#D97757' , // Background color badge : 'NEW' , // Corner badge }
Node States In agentflows, nodes display execution status:
Default : No execution yetIn Progress : Currently executing (animated indicator)Finished : Successfully completed (checkmark)Error : Failed execution (error icon)Stopped : Manually stopped
Creating Custom Nodes While this documentation focuses on using existing nodes, Flowise supports custom node development. Custom nodes are:
Created as TypeScript classes implementing INode
Placed in the components package
Automatically loaded at startup
Available in the node palette if not disabled
Community nodes are supported but can be disabled with the SHOW_COMMUNITY_NODES environment variable.
Node Pool Management Flowise manages available nodes through the NodesPool class:
class NodesPool { componentNodes : IComponentNodes = {} componentCredentials : IComponentCredentials = {} async initialize () { await this . initializeNodes () await this . initializeCredentials () } }
Nodes are:
Loaded from flowise-components/dist/nodes
Filtered based on environment variables (disabled nodes)
Filtered by category (analytic nodes excluded)
Filtered by community node settings
Best Practices When Building Workflows
Start with pre-built chain nodes for common patterns
Use the search function to find relevant nodes quickly
Check node documentation links for detailed configuration
Group related nodes visually for better organization
Name node instances descriptively (not just the default name)
Common Issues
Connection errors often mean incompatible base classes
Missing credentials prevent node execution
Deprecated nodes may be removed in future versions
Community nodes may have different support levels
Chatflows - Using nodes in sequential workflowsAgentflows - Using nodes in autonomous workflowsCredentials - Authenticating nodes with external services