Back to App

Node Editor

The Node Editor is the visual heart of SETI AI — a drag-and-drop canvas where you wire together power hardware, AI agents, sensors, and notifications into running automations without writing a line of code. If you can draw a flowchart, you can build a SETI AI workflow.

It ships with 148 node types across 14 categories, an infinite pannable/zoomable canvas, live wire animation that shows data moving in real time, 50 levels of undo/redo, and a full debugger with breakpoints and step-through. When a flow is ready, you hand it to the Workflow Engine to run once, on a schedule, or live 24/7 on the server.

Why it matters

Industrial power sites are a tangle of inverters, batteries, meters, sensors and alarms — each with its own protocol, dashboard and login. SETI AI collapses all of that into one canvas:

  • Zero-code automation for power + AI. Read a Sol-Ark inverter over Modbus, ask an AI agent whether the battery trend looks healthy, and fire a Discord alert — all by dragging three nodes and drawing two wires.
  • One mental model. A solar inverter, a Claude model, a BME280 sensor and a webhook are all just nodes with ports. Learn the canvas once and every integration works the same way.
  • What you see is what runs. The same node logic that animates in the browser is executed server-side by the Workflow Engine, so a flow you prototype live behaves identically when deployed.
  • Honest data. Energy nodes never fabricate readings. If a driver isn't wired up they return a clear pending status — see Energy Nodes.

The infinite canvas

The canvas is a single shared implementation (canvas.js) used across the whole product, tuned for comfortable, precise editing.

Center-origin world

The canvas world origin (0,0) is centered in your viewport on load, not jammed against the top-left corner. New nodes spawn with breathing room in every direction. The view auto-recenters as the panel sizes itself, and the moment you pan or zoom it hands full control to you and stops re-centering.

Pan

Move around the canvas three ways, whichever is comfortable:

  • Middle-click + drag
  • Alt + left-drag
  • Left-drag on empty canvas (dragging a node moves the node instead)

A parallax dot-grid background drifts at 0.7× the pan speed, giving a subtle sense of depth and position as you move across a large workflow.

Zoom

  • Mouse wheel zooms with zoom-to-cursor math — the exact point under your pointer stays anchored as you scale in or out, so you zoom into the part you're actually looking at.
  • Toolbar buttons zoom in/out around the viewport center, plus Fit View and Reset.
  • Fit View frames every node on the canvas with padding so you can see an entire workflow at a glance.
  • Zoom ranges roughly 15%–300%, and the current zoom percentage is shown live in the toolbar.

Scrolling inside a node (a chat panel, a Debug Probe log, a code block) scrolls that inner content instead of zooming the canvas — the editor detects scrollable regions and yields to them automatically.

Live visual feedback

  • Wire particle flow. When a node produces an output, its outgoing wires light up: a dashed gold flow animates along the wire and a burst of white particles rides the wire's bezier curve from source to destination. You literally watch data flow through your workflow as it runs.
  • Board glow & node status. Each node carries a status dot — pending, running, done (with elapsed milliseconds), error, or breakpoint. Wires pulse as their downstream node begins executing, so the run visibly propagates left-to-right through the graph.

Nodes, ports and wiring

Every node is a small card with a header (icon + label, color-coded by category), a set of input ports on the left, output ports on the right, and configurable fields in the body (text boxes, dropdowns, number inputs, text areas).

Typed ports

Ports are typed, and each type has its own color so correct connections are visually obvious:

Port type Color Carries
data cyan structured values / objects
trigger yellow "go" pulses that fire a node
text green strings / prompts / content
tool orange tool handles for agents
model pink model handles

Wiring a workflow

  1. Drag nodes from the palette onto the canvas.
  2. Click-drag from an output port to an input port to draw a wire. A temporary wire follows your cursor; release on a compatible port to connect. Duplicate connections are rejected automatically.
  3. Configure fields on each node (host/IP, model, thresholds, brand, etc.).
  4. Data flows along the wires: at run time each node reads its inputs from the upstream nodes it's wired to, executes, and writes its outputs forward.

Right-click any node for a context menu: Delete, Duplicate, or Disconnect all wires. Deleting a node automatically cleans up every wire attached to it.

The 14 categories and their nodes

The palette is organized into 14 color-coded categories. Representative nodes from each (148 total):

  1. Input (green) — feed data into a flow: Text Input, File Reader, Timer (interval/loop trigger), HTTP Request.
  2. AI Models (purple) — local & hosted models: Ollama Chat (live model-list discovery, green "connected" glow), Embeddings, Gemini Chat.
  3. Agents (magenta) — autonomous reasoning: SETI Agent (plan-act / ReAct / chain-of-thought / autonomous, with tool discovery and approval gates), Supervisor (delegates across agents), Critic / Evaluator (LLM scoring against a rubric with a pass gate), SETI Chat.
  4. Tools (orange) — real capabilities: Code Sandbox (isolated iframe JS execution), Web Scraper, Ping, Traceroute, DNS Lookup, Whois, Port Scanner, HTTP Headers, Vector Store, Debug Probe, plus Admin Dashboard. (The Shell Command node exists but is disabled in production for security.)
  5. Transform (teal) — reshape data: JSON Parser (with JSONPath), Template, Text Splitter.
  6. Output (amber) — surface results: Display, Cluster Output, Webhook Out, Monitor.
  7. Control (red) — flow logic: If / Condition, Loop / Iterator, Delay, Error Handler.
  8. Hardware (green) — industrial buses & devices: Victron Solar, SCADA Gateway, PLC Connector, Schneider Electric, ESPHome Device, Modbus RTU/TCP, CAN Bus Reader, MQTT Client, MQTT Server / Broker, CoAP, AMQP, Zigbee, Z-Wave, BLE Scanner, LoRaWAN, DDS, Thread / Matter, BACnet, KNX, OPC-UA.
  9. Sensors (blue) — 41 named breakout-board drivers across Adafruit and SparkFun lines: e.g. BME280, BMP390, SHT45, SCD41 CO₂, INA219 Power Monitor, BNO055 9-DOF IMU, VL53L0X ToF, PM2.5 AQI, AS7265x 18-ch Spectral, NEO-M9N GNSS, AMG8833 Grid-EYE.
  10. Google (blue) — Gmail, Google Calendar, Google Drive, Google Sheets, YouTube Data, Google Search.
  11. Cloudflare (orange) — CF DNS, CF Workers, CF KV Store, CF R2 Storage, CF Tunnels, CF Firewall / WAF.
  12. NetBird (sky) — mesh-VPN management: Peers, Networks, Routes, Policies, Groups, Users.
  13. AI Providers (violet) — 20 hosted endpoints: OpenAI, Anthropic / Claude, Hugging Face, Google Gemini, Ollama Cloud, NVIDIA NIM, Mistral, Cohere, DeepSeek, xAI / Grok, Perplexity, Together, Groq, Fireworks, Replicate, AI21, Stability, ElevenLabs TTS, AssemblyAI STT, Voyage Embed.
  14. Energy (gold) — the 14 power-system nodes (solar inverter, battery, grid meter, SETI Power Wall, solar forecast, CO₂, UPS, energy cost, load controller, EV charger, utility rates, water heater, demand response, power quality). Full reference in Energy Nodes.

Undo / redo (50 levels)

Every structural change — adding a node, wiring a connection, moving, deleting — pushes a full canvas snapshot onto an undo stack that holds the last 50 actions.

  • Ctrl/⌘ + Z — undo
  • Ctrl/⌘ + Shift + Z or Ctrl + Y — redo

Performing a new action after an undo clears the redo stack, exactly as you'd expect from a desktop editor. Snapshots capture the whole graph, so undo reliably restores both nodes and their wiring.

Breakpoints & debug step-through

The editor includes a built-in workflow debugger so you can see exactly what each node produced before the next one runs — invaluable when an inverter returns an unexpected field or an agent makes a surprising decision.

  • Press D to toggle Debug mode. The canvas indicates debug mode is on and invites you to set breakpoints.
  • Select a node and press B to toggle a breakpoint on it (a breakpoint dot appears on the node).
  • Run the workflow. Execution proceeds in topological order until it reaches a breakpointed node, then pauses — the node shows a Breakpoint status and an inspect panel lists the outputs of every node that has run so far, port by port.
  • F5 or Space — Continue to the next breakpoint.
  • F10 — Step to the next node and pause again.

Because the debugger walks the same topological execution order as a normal run, what you observe while stepping is exactly what the workflow does at full speed.

Tip: the Debug Probe node (Tools category) keeps a scrollable history of values passing through a wire — drop one inline anywhere you want a persistent tap on the data, separate from the breakpoint debugger.

From canvas to running: oneshot, scheduled, live

A workflow doesn't have to live in your browser tab. Building it on the canvas is step one; running it for real is handled by the server-side Workflow Engine.

  • In-browser run — press Run to execute the graph live on the canvas with full animation, status dots and wire bursts. Great for prototyping and debugging. (Closing the tab ends the run — which is exactly why the server engine exists.)
  • Oneshot (server) — deploy the workflow to run once, server-side, independent of any browser.
  • Scheduled (server) — deploy with a cron-style schedule to run recurring, 24/7, on the OVH production host. Poll an inverter every minute, evaluate loads every five, run a daily forecast — it keeps running whether or not anyone is logged in.
  • Live (planned) — long-lived source nodes (e.g. an MQTT subscription) that stream data continuously.

Deployed runs save to PostgreSQL, broadcast status over Server-Sent Events (so dashboards update in real time), and auto-write an execution summary to the Obsidian training corpus. See Workflow Engine for deployment, scheduling and the server-side executors.

Worked example: low-battery Discord alert

A simple, complete flow a customer can build in about a minute. It polls a battery, checks its state of charge, and pings the team on Discord if it drops too low.

┌──────────┐      ┌──────────────────┐      ┌──────────────┐      ┌──────────────┐
│  Timer   │─tick▶│ Battery Monitor  │─soc─▶│ If / Condition│─true▶│  Webhook Out │
│ every 60s│      │ pack-001 (VRM)   │      │  soc < 20     │      │  (Discord)   │
│  loop    │      │                  │      │              │      │              │
└──────────┘      └──────────────────┘      └──────────────┘      └──────────────┘

Build it:

  1. Drag a Timer (Input). Set Interval = 60, Repeat = loop.
  2. Drag a Battery Monitor (Energy). Wire Timer tick → Battery poll. Set Pack ID and chemistry. It reads live state of charge from the Victron VRM cache — see Energy Nodes.
  3. Drag an If / Condition (Control). Wire Battery soc → Condition input. Set the test to soc < 20.
  4. Drag a Webhook Out (Output) pointed at your Discord webhook. Wire Condition true → Webhook trigger.
  5. Press Run to test live — watch the wires burst as data flows. Set a breakpoint (D then B) on the Condition node to inspect the exact SoC value before the alert fires.
  6. When it behaves, deploy it scheduled so it runs every minute on the server, forever. See Workflow Engine.

From here the same pattern scales: swap the Battery Monitor for a Solar Inverter node, add a SETI Agent to reason about the trend before alerting, or route the alert through email and Slack as well as Discord. Every addition is another node and another wire — no code, no redeploy of the platform.