Node types¶

Every type the canvas can place. Each is configured by filling in a form the editor generates from its parameter schema, so they all behave the same way.

Anything here could be written as a Function node — that is what the function node is for. These exist because the same handful of shapes account for most of a real installation, and a rule you fill in is easier to read on a canvas, and to change, than five lines of code repeated eighty times.

GET /flows/node-types returns this list with each type's full parameter schema, including any connectors installed on your instance.

Function¶

python — your own code, run on every incoming message.

The one type with a source file. Its arguments are its input ports and its own settings; its return value is a dict keyed by output ports. See Writing node code.

Settings on a Function node are free-form: you add them by name, and they arrive as keyword arguments.

Integrations¶

MQTT¶

mqtt — subscribe to topics, or publish what arrives on its inputs.

A node with outputs only subscribes; a node with inputs publishes.

Nodes sharing a broker share one connection.

HTTP¶

http — receive data on a webhook, or send it to a URL.

Outputs only makes it a webhook: the engine mounts a route at /hooks/{flow}/{url}/{secret} while the flow runs. Inputs make it a sender.

InfluxDB¶

influxdb — write measurements to a bucket, or read them back.

{
  "writes": {
    "living_temperature": {
      "measurement": "environment",
      "field": "temp_c",
      "tags": {"room": "living"}
    }
  }
}

Query passthrough. An incoming message holding a flux key is run as written, and the rows come back on the first output port as {"rows": [{ts, value, field, measurement, tags}], ...}.

That is what keeps a database node a database node: it holds the credentials and the connection and nothing else. Building a query and shaping its rows are ordinary Function nodes on either side, so a dashboard widget never learns which database answered it.

Notification¶

ntfy — push an incoming value to a phone through ntfy.

This is a flow deciding something is worth saying. The engine reporting that it broke is Alerts, which is a different thing configured elsewhere.

Timing¶

Inject¶

inject — emit a value on request, on a timer, or when the flow starts.

The most-placed trigger in a real installation — mostly as a button someone presses.

Delay & schedule¶

delay — hold messages back, limit their rate, or emit on a schedule.

Order of operations: rate check → delay → forward. With a cron and no inputs it emits the current time on each tick; with inputs it emits the last value it received.

Trigger¶

trigger — send one value now and another once things go quiet.

The shape this exists for: the door opened — turn the light on, and off again in two minutes unless it opens again.

Logic¶

Switch¶

switch — send a value down one branch or another, by rule.

Each rule names an output port; a matching value leaves through that port. Comparisons: eq, ne, gt, gte, lt, lte, contains, between.

Comparing a string to a number is a mistake in the rule, not a reason to take the flow down: the rule simply does not match.

Change¶

change — scale, offset, round or map a value on its way past.

Filter unchanged¶

rbe — pass a value on only when it has actually changed.

The cheapest fix for a sensor that reports every second and changes every hour.

Join¶

join — gather several inputs into one object or list.

System¶

Command¶

exec — run a command in the engine's container and read its output.

Outputs the command's stdout, stderr and exit code.

File¶

file — read a file into the flow, or write one out of it.

Confined to a directory the engine owns. A flow that could name any path would be a way to read the secrets store or overwrite a node's source.

Numeric¶

Perceptron¶

mlp — a small neural layer over its numeric inputs.

output = weights @ inputs + biases, with weights drawn from seed so a node reloads identically.

Kept as a worked example of numeric logic rather than as a modelling tool. If you are training something, that is a batch flow and a Function node.

Connectors¶

Anything else in the palette came from an installed connector package — a node type written against a published contract and discovered through the fluksio.node_types entry point group. The editor shows which package supplied it.

A connector declares its contract version, and one written for a version this engine does not speak is ignored rather than half-loaded. Installing or upgrading one takes effect on the next engine restart, because Python does not re-import a changed module and a rescan would promise more than it delivers.

See also¶

• Payload types — what a port may carry
• Writing node code — the Function node
• The flow editor — placing and configuring them