Node Types - Noxus Documentation

Overview

Noxus workflows are built using various node types, each designed for specific tasks. This reference covers all available node types, their configurations, and usage examples.

You can get the most up-to-date list of available node types by calling client.get_nodes() in your code.

Input/Output Nodes

InputNode

The basic input node for accepting data into your workflow.

input_node = workflow_def.node("InputNode").config(
    label="User Input",           # Display name for the input
    type="str",                   # Data type: "str", "int", "float", "bool"
    fixed_value=False,            # Whether value is set at design time
    value="default value",        # Default/fixed value (if fixed_value=True)
    required=True,                # Whether input is required
    description="Enter your text" # Help text for users
)

label

string

required

Display name for the input field

type

string

default:"str"

Data type: str, int, float, bool, list, dict

fixed_value

boolean

default:"false"

If true, uses the value parameter instead of runtime input

value

any

Default value or fixed value (when fixed_value=true)

required

boolean

default:"true"

Whether this input is required for workflow execution

FileInputNode

Accepts file uploads as workflow input.

file_input = workflow_def.node("FileInputNode").config(
    label="Document Upload",
    accepted_types=["pdf", "txt", "docx", "xlsx"],
    max_size_mb=10,
    multiple=False,
    extract_text=True
)

accepted_types

array

List of allowed file extensions

max_size_mb

number

default:"10"

Maximum file size in megabytes

multiple

boolean

default:"false"

Whether to accept multiple files

extract_text

boolean

default:"true"

Automatically extract text content from supported file types

OutputNode

Defines the final output of your workflow.

output_node = workflow_def.node("OutputNode").config(
    label="Final Result",
    format="text",                # "text", "json", "file"
    include_metadata=False        # Include execution metadata
)

AI & Language Model Nodes

TextGenerationNode

Generate text using various AI models.

text_gen = workflow_def.node("TextGenerationNode").config(
    template="Answer this question: ((Question))\n\nContext: ((Context))",
    model=["gpt-4o-mini"],
    temperature=0.7,
    max_tokens=500,
    top_p=0.9,
    frequency_penalty=0.0,
    presence_penalty=0.0,
    stop_sequences=["END", "STOP"],
    system_prompt="You are a helpful assistant."
)

template

string

required

Text template with variable placeholders in format ((Variable Name))

model

array

required

List of model names to use (first available will be selected)

temperature

number

default:"0.7"

Creativity level (0.0 = deterministic, 1.0 = very creative)

max_tokens

number

default:"500"

Maximum number of tokens to generate

top_p

number

default:"1.0"

Nucleus sampling parameter

system_prompt

string

System-level instructions for the model

SummaryNode

Create summaries of text content.

summarizer = workflow_def.node("SummaryNode").config(
    summary_format="Bullet Points",    # "Paragraph", "Bullet Points", "Key Points"
    summary_topic="Main insights",     # Focus area for summarization
    max_length=300,                    # Maximum summary length in words
    language="English",                # Output language
    include_quotes=False,              # Include relevant quotes
    extraction_mode="comprehensive"    # "comprehensive", "key_points", "abstract"
)

summary_format

string

default:"Paragraph"

Format of the summary: Paragraph, Bullet Points, Key Points

summary_topic

string

Specific focus area or topic for the summary

max_length

number

default:"300"

Maximum length in words

language

string

default:"English"

Output language for the summary

TranslationNode

Translate text between languages.

translator = workflow_def.node("TranslationNode").config(
    target_language="Spanish",
    source_language="auto",        # "auto" for auto-detection
    preserve_formatting=True,
    translation_style="formal",    # "formal", "casual", "technical"
    include_original=False
)

target_language

string

required

Target language for translation

source_language

string

default:"auto"

Source language or “auto” for automatic detection

preserve_formatting

boolean

default:"true"

Maintain original text formatting

translation_style

string

default:"formal"

Translation style: formal, casual, technical

EmbeddingNode

Generate vector embeddings for text.

embedding = workflow_def.node("EmbeddingNode").config(
    model="text-embedding-ada-002",
    chunk_size=1000,
    chunk_overlap=200,
    normalize=True
)

Data Processing Nodes

ComposeTextNode

Combine multiple text inputs using templates.

composer = workflow_def.node("ComposeTextNode").config(
    template="""# Report: ((Title))

## Summary
((Summary))

## Analysis
((Analysis))

## Recommendations
((Recommendations))

---
Generated on: {{current_date}}
Report ID: {{uuid}}
""",
    output_format="markdown",      # "text", "markdown", "html"
    include_metadata=True
)

template

string

required

Template with variable placeholders ((Variable)) and system variables {{ system_var }}

output_format

string

default:"text"

Output format: text, markdown, html

Available System Variables:

{{current_date}} - Current date
{{current_time}} - Current time
{{uuid}} - Unique identifier
{{workflow_id}} - Current workflow ID

ExtractTextNode

Extract text content from various file formats.

extractor = workflow_def.node("ExtractTextNode").config(
    preserve_formatting=True,
    extract_tables=True,
    extract_images=False,
    extract_metadata=True,
    output_format="plain_text",    # "plain_text", "markdown", "structured"
    language="auto"                # Language hint for OCR
)

preserve_formatting

boolean

default:"true"

Maintain original document formatting

extract_tables

boolean

default:"true"

Extract and format table data

extract_images

boolean

default:"false"

Extract image descriptions (requires vision models)

FilterNode

Filter data based on conditions.

filter_node = workflow_def.node("FilterNode").config(
    condition="length > 100",          # Filter condition
    filter_type="text_length",         # "text_length", "contains", "regex", "custom"
    case_sensitive=False,              # For text-based filters
    regex_pattern=r"\b\w+@\w+\.\w+\b", # For regex filters
    custom_function="def filter_func(text): return len(text.split()) > 50"
)

condition

string

required

Filter condition expression

filter_type

string

required

Type of filter: text_length, contains, regex, custom

DataTransformNode

Transform and manipulate data.

transformer = workflow_def.node("DataTransformNode").config(
    transformation_type="json_to_text",  # "json_to_text", "csv_to_json", "custom"
    custom_transform="""
def transform(data):
    # Custom transformation logic
    return processed_data
""",
    output_schema={                      # Expected output schema
        "type": "object",
        "properties": {
            "result": {"type": "string"}
        }
    }
)

Logic & Control Flow Nodes

ConditionalNode

Branch workflow execution based on conditions.

conditional = workflow_def.node("ConditionalNode").config(
    condition="length > 1000",
    condition_type="text_length",      # "text_length", "contains", "equals", "custom"
    comparison_value="1000",
    case_sensitive=False,
    custom_condition="def check(data): return len(data.split()) > 100"
)

The conditional node has two outputs:

true - Data that meets the condition
false - Data that doesn’t meet the condition

# Connect both paths
workflow_def.link(conditional.output("true"), long_text_processor.input())
workflow_def.link(conditional.output("false"), short_text_processor.input())

LoopNode

Iterate over collections of data.

loop_node = workflow_def.node("LoopNode").config(
    iteration_type="list",             # "list", "range", "while"
    max_iterations=100,                # Safety limit
    parallel_execution=False,          # Process items in parallel
    batch_size=10,                     # Items per batch (if parallel)
    break_condition="error_count > 5"  # Early termination condition
)

SwitchNode

Route data based on values.

switch = workflow_def.node("SwitchNode").config(
    switch_field="category",           # Field to switch on
    cases={
        "urgent": "urgent_processor",
        "normal": "normal_processor",
        "low": "low_priority_processor"
    },
    default_case="normal_processor"    # Default route
)

MergeNode

Combine multiple data streams.

merger = workflow_def.node("MergeNode").config(
    merge_strategy="concatenate",      # "concatenate", "combine", "latest"
    separator="\n\n---\n\n",          # For concatenation
    wait_for_all=True,                # Wait for all inputs
    timeout_seconds=300               # Timeout for waiting
)

External Integration Nodes

APICallNode

Make HTTP requests to external services.

api_call = workflow_def.node("APICallNode").config(
    url="https://api.example.com/endpoint",
    method="POST",                     # "GET", "POST", "PUT", "DELETE"
    headers={
        "Authorization": "Bearer {{api_key}}",
        "Content-Type": "application/json"
    },
    body_template='{"query": "((Query))", "options": {"format": "json"}}',
    timeout_seconds=30,
    retry_attempts=3,
    retry_delay=1
)

url

string

required

API endpoint URL (can include variables)

method

string

default:"GET"

HTTP method

headers

object

HTTP headers (can include variables)

body_template

string

Request body template with variables

DatabaseQueryNode

Query databases with SQL.

db_query = workflow_def.node("DatabaseQueryNode").config(
    connection_string="postgresql://user:pass@localhost/db",
    query_template="SELECT * FROM users WHERE name LIKE '%((Name))%'",
    query_type="SELECT",               # "SELECT", "INSERT", "UPDATE", "DELETE"
    max_rows=1000,
    timeout_seconds=30
)

WebScraperNode

Extract data from web pages.

scraper = workflow_def.node("WebScraperNode").config(
    url_template="https://example.com/search?q=((Query))",
    selectors={
        "title": "h1.title",
        "content": ".content p",
        "links": "a[href]"
    },
    wait_for_element=".content",       # Wait for element to load
    timeout_seconds=30,
    user_agent="Mozilla/5.0 (compatible; NoxusBot/1.0)"
)

EmailNode

Send emails and notifications.

email_node = workflow_def.node("EmailNode").config(
    smtp_server="smtp.gmail.com",
    smtp_port=587,
    username="[email protected]",
    password="{{email_password}}",     # Use secure variable
    to_addresses=["[email protected]"],
    subject_template="Workflow Result: ((Subject))",
    body_template="""
Hello,

Your workflow has completed with the following result:

((Result))

Best regards,
Noxus Automation
""",
    html_format=False
)

Specialized Nodes

KnowledgeBaseQueryNode

Query Noxus knowledge bases.

kb_query = workflow_def.node("KnowledgeBaseQueryNode").config(
    knowledge_base_id="kb_12345",
    query_template="((User Question))",
    max_results=5,
    similarity_threshold=0.7,
    include_metadata=True,
    rerank_results=True
)

WorkflowCallNode

Call other workflows from within a workflow.

workflow_call = workflow_def.node("WorkflowCallNode").config(
    target_workflow_id="workflow_67890",
    input_mapping={
        "target_input": "((source_output))"
    },
    wait_for_completion=True,
    timeout_seconds=300
)

ValidationNode

Validate data against schemas or rules.

validator = workflow_def.node("ValidationNode").config(
    validation_type="json_schema",     # "json_schema", "regex", "custom"
    schema={
        "type": "object",
        "required": ["name", "email"],
        "properties": {
            "name": {"type": "string", "minLength": 1},
            "email": {"type": "string", "format": "email"}
        }
    },
    on_validation_error="stop",        # "stop", "continue", "default_value"
    default_value="Invalid input"
)

Node Configuration Best Practices

Template Variables

Use consistent variable naming:

# ✅ Good - descriptive names
template = "Analyze ((User Input)) for ((Analysis Type))"

# ❌ Bad - unclear names
template = "Analyze ((Input1)) for ((Input2))"

Error Handling

Configure appropriate timeouts and retries:

python api_call =       workflow_def.node("APICallNode").config( url="https://api.example.com/data",       timeout_seconds=30, # Reasonable timeout retry_attempts=3, # Retry on failure       retry_delay=2 # Wait between retries )

Resource Limits

Set appropriate limits to prevent resource exhaustion:

text_gen = workflow_def.node("TextGenerationNode").config(
    max_tokens=500,        # Limit output length
    temperature=0.7,       # Control randomness
    stop_sequences=["END"] # Define stop conditions
)

Security

Use secure practices for sensitive data:

# Use environment variables for secrets
api_call = workflow_def.node("APICallNode").config(
    headers={
        "Authorization": "Bearer {{API_KEY}}"  # Secure variable
    }
)

Getting Node Information

List Available Nodes

# Get all available node types
nodes = client.get_nodes()

for node in nodes:
    print(f"Type: {node['type']}")
    print(f"Description: {node['description']}")
    print(f"Category: {node['category']}")
    print("---")

Get Node Configuration Schema

# Find specific node type
text_gen_node = next(
    node for node in nodes
    if node['type'] == 'TextGenerationNode'
)

# View configuration options
config_schema = text_gen_node['config_schema']
print(f"Required fields: {config_schema.get('required', [])}")
print(f"Properties: {list(config_schema.get('properties', {}).keys())}")

Next Steps

Workflow Examples

See complete examples using different node types

Building Workflows

Learn how to connect nodes into workflows

Running Workflows

Execute workflows and handle results

API Reference

Detailed API reference for workflow nodes

Overview

Getting Started

Concepts

Conversations

Workflows

Guides

API Reference

​Overview

​Input/Output Nodes

​InputNode

​FileInputNode

​OutputNode

​AI & Language Model Nodes

​TextGenerationNode

​SummaryNode

​TranslationNode

​EmbeddingNode

​Data Processing Nodes

​ComposeTextNode

​ExtractTextNode

​FilterNode

​DataTransformNode

​Logic & Control Flow Nodes

​ConditionalNode

​LoopNode

​SwitchNode

​MergeNode

​External Integration Nodes

​APICallNode

​DatabaseQueryNode

​WebScraperNode

​EmailNode

​Specialized Nodes

​KnowledgeBaseQueryNode

​WorkflowCallNode

​ValidationNode

​Node Configuration Best Practices

​Getting Node Information

​List Available Nodes

​Get Node Configuration Schema

​Next Steps

Workflow Examples

Building Workflows

Running Workflows

API Reference

Overview

Input/Output Nodes

InputNode

FileInputNode

OutputNode

AI & Language Model Nodes

TextGenerationNode

SummaryNode

TranslationNode

EmbeddingNode

Data Processing Nodes

ComposeTextNode

ExtractTextNode

FilterNode

DataTransformNode

Logic & Control Flow Nodes

ConditionalNode

LoopNode

SwitchNode

MergeNode

External Integration Nodes

APICallNode

DatabaseQueryNode

WebScraperNode

EmailNode

Specialized Nodes

KnowledgeBaseQueryNode

WorkflowCallNode

ValidationNode

Node Configuration Best Practices

Getting Node Information

List Available Nodes

Get Node Configuration Schema

Next Steps