Node Catalog

Comprehensive reference of all workflow node types available in M3 Forge.

Overview

Nodes are the building blocks of workflows. Each node performs a specific operation and can be connected to other nodes to create complex pipelines. Nodes are organized into categories based on their primary function.

Node Categories

AI/LLM Nodes

Nodes that interact with Large Language Models for generation, analysis, and transformation.

Code Execution Nodes

Nodes that execute custom code for data transformation and integration.

Quality & Validation Nodes

Nodes that evaluate outputs and ensure quality standards.

Human-in-the-Loop Nodes

Nodes that pause workflows for human review, correction, or routing.

Flow Control Nodes

Nodes that manage execution paths and data flow.

Data Nodes

Nodes for data retrieval, storage, and transformation.

Common Properties

All nodes share these core properties:

Identification

• node_id - Unique identifier within workflow (immutable after creation)
• node_type - Node category (PROMPT, CODE, GUARDRAIL, etc.)
• display_name - Human-readable label shown in canvas

Configuration

• definition - Node-specific parameters and settings
• input_source - JSONPath to input data (e.g., $.nodes.previous_node.output)
• timeout - Maximum execution time in seconds (default: 300)

Outputs

• output - Results produced by the node, accessible at $.nodes.<node_id>.output
• metadata - Execution details (duration, cost, token usage, etc.)

Node Selection Guide

Choose the right node for your use case:

When to use Prompt Node

• Generate text from templates with dynamic variables
• Classify or categorize content
• Extract structured data from unstructured text
• Summarize long documents
• Answer questions using provided context

When to use Code Node

• Transform data formats (JSON to CSV, etc.)
• Perform calculations or aggregations
• Call external APIs with custom logic
• Implement business rules not covered by other nodes
• Parse or validate complex data structures

When to use Guardrail Node

• Validate LLM outputs before returning to users
• Check data quality against thresholds
• Enforce schema compliance
• Detect PII or sensitive information
• Implement retry loops for failed validations

When to use HITL Nodes

• Approval Node: High-stakes decisions requiring human judgment
• Correction Node: Fix errors in extracted or generated data
• Router Node: Assign tasks to reviewers based on expertise

When to use Flow Control

• Branch: Simple if/else logic based on field values
• Switch: Multi-way routing (like switch/case in programming)
• Merger: Combine outputs from parallel processing branches

Node Configuration Patterns

Input Sources

Access data from previous nodes or workflow input:

// From workflow input
"input_source": "$.data.document"
 
// From specific node output
"input_source": "$.nodes.extract_text.output.text"
 
// From nested output field
"input_source": "$.nodes.llm_analysis.output.result.classification"
 
// Combine multiple sources (in Code Node)
"input_source": {
  "text": "$.nodes.extract_text.output",
  "metadata": "$.data.metadata"
}

Conditional Routing

Guardrail and HITL nodes support multiple output paths:

{
  "paths": [
    {
      "path_id": "pass",
      "target_node_ids": ["success_node", "notify_node"]
    },
    {
      "path_id": "fail",
      "target_node_ids": ["retry_node"]
    }
  ]
}

Execution continues along the selected path based on evaluation results.

Error Handling

Configure error behavior per node:

Set in node definition under error_handling field.

Performance Considerations

Parallelization

Nodes with no dependencies run in parallel automatically:

Classify, Detect PII, and Quality Score run concurrently to minimize total execution time.

Caching

Some node types support output caching:

• Prompt Node: Cache responses for identical inputs (dedupe LLM calls)
• Retrieval Node: Cache search results for same queries
• HTTP Request Node: Cache GET responses with TTL

Enable in node definition: "cache_enabled": true, "cache_ttl": 3600

Resource Limits

Configure resource constraints per node:

• timeout: Maximum execution time (default: 300s)
• max_retries: Retry limit for transient failures (default: 3)
• max_tokens: Token limit for LLM nodes (default: 4096)
• memory_limit_mb: Memory cap for Code nodes (default: 512)

Best Practices

1. Name nodes descriptively - Use action verbs: “Extract Invoice Fields”, “Validate Schema”, “Route to Reviewer”
2. Minimize node count - Combine simple operations in Code nodes rather than chaining many small nodes
3. Add guardrails early - Validate expensive operations (LLM calls) before downstream processing
4. Use timeouts appropriately - Set aggressive timeouts for fast operations, generous for slow ones
5. Test nodes individually - Use test scenarios to verify each node before connecting to workflow
6. Document complex configurations - Add descriptions explaining non-obvious parameter choices

Custom Nodes

M3 Forge supports custom node development (enterprise feature). Custom nodes:

• Implement the NodeSpec interface
• Register with nodeRegistry.register(spec)
• Appear in node palette automatically
• Support all standard node features (caching, error handling, etc.)

See the Custom Nodes guide for implementation details.

Related Resources

• Building Workflows - Compose nodes into DAGs
• Runs - Monitor node execution
• Query Plans - Agent-based workflow patterns