CORE CONCEPTS

Node Types

Floww ships with 22 built-in node types across five categories.

Every node in Floww represents a single operation: reading a file, calling an API, running a script, or making a decision. Nodes receive data through input ports, process it, and emit results through output ports. You compose complex behavior by wiring nodes together into workflows.

Node Anatomy

All nodes share the same structural elements, regardless of type:

• Header — Displays the node name and a category-colored accent bar. Click to select; double-click to rename.
• Input Ports — Small circles on the left edge. Each port is typed (text, number, JSON, file, any). Hover over a port to see its name and expected type.
• Output Ports — Small circles on the right edge. Most nodes have a single output port, but some (like Conditional) have multiple named outputs.
• Config Panel — Click a node to open its configuration panel on the right side of the screen. This is where you set parameters like prompts, file paths, or code.
• Status Indicator — A small dot in the top-right corner of the node header:
  • Gray — Idle, has not been run.
  • Blue pulse — Currently executing.
  • Green — Completed successfully.
  • Red — Completed with an error.
• Result Preview — After execution, the node body shows a truncated preview of the output. Click Expand to view the full result.

AI Nodes

AI nodes integrate language models into your workflows for text generation, classification, routing, and embeddings.

Claude Prompt

Sends a prompt to Anthropic's Claude API and returns the response.

• Inputs: input (text) — the data to include in the prompt context.
• Outputs: output (text) — the model's response.
• Config: System prompt, user prompt (supports {{input}} template), model selection (Haiku, Sonnet, Opus), temperature, max tokens.
• Use case: Summarize documents, generate code, answer questions about data.

Ollama Prompt

Sends a prompt to a locally running Ollama instance. No API key required—everything stays on your machine.

• Inputs: input (text)
• Outputs: output (text)
• Config: Model name (e.g., llama3, mistral, codellama), system prompt, user prompt, temperature, Ollama server URL.
• Use case: Run AI tasks entirely offline for privacy-sensitive workflows.

AI Router

Uses an LLM to analyze the input and route it to one of several named output ports based on content classification.

• Inputs: input (text)
• Outputs: Multiple named ports (user-defined, e.g., bug-report, feature-request, question).
• Config: Route descriptions, model selection, confidence threshold.
• Use case: Triage incoming support tickets or categorize form submissions.

AI Classifier

Classifies input text into one or more predefined labels and outputs the classification result as JSON.

• Inputs: input (text)
• Outputs: output (JSON) — {"label": "...", "confidence": 0.95}
• Config: Labels list, model selection, multi-label toggle.
• Use case: Sentiment analysis, content moderation, language detection.

Embeddings

Generates vector embeddings for input text using a local Ollama embedding model.

• Inputs: input (text)
• Outputs: output (JSON) — array of floating-point numbers.
• Config: Model name (e.g., nomic-embed-text), dimensions.
• Use case: Semantic search, document similarity, clustering.

Scripting Nodes

Scripting nodes let you write and run custom code within a workflow.

JavaScript

Executes a JavaScript function in a sandboxed V8 isolate. The input data is available as the input variable.

• Inputs: input (any)
• Outputs: output (any) — the return value of your function.
• Config: Code editor with syntax highlighting.
• Use case: Transform JSON, compute values, format strings.

// Example: extract email addresses from text
const emails = input.match(/[\w.-]+@[\w.-]+\.\w+/g) || [];
return emails;

Python

Executes a Python script using the system Python interpreter. The input is available via floww.input.

• Inputs: input (any)
• Outputs: output (any)
• Config: Code editor, Python path, virtual environment path (optional).
• Use case: Data analysis with pandas, image processing, scientific computing.

import json
data = json.loads(floww.input)
result = [item for item in data if item["score"] > 0.8]
floww.output(json.dumps(result))

Shell Command

Runs a shell command and captures stdout as the output. The input is piped to stdin.

• Inputs: input (text) — piped to stdin.
• Outputs: output (text) — stdout; error (text) — stderr.
• Config: Command string, working directory, environment variables, timeout.
• Use case: Run CLI tools, invoke build commands, interact with system utilities.

Template

Renders a text template using Handlebars-style syntax. Variables from upstream nodes and workflow variables are available.

• Inputs: input (any) — available as {{input}} in the template.
• Outputs: output (text) — rendered template string.
• Config: Template editor with variable autocomplete.
• Use case: Format API payloads, compose email bodies, generate reports.

Data Nodes

Data nodes handle file I/O, parsing, and external data fetching.

File Read

Reads the contents of a file from the local filesystem.

• Inputs: path (text) — optional, overrides the configured path.
• Outputs: output (text) — file contents.
• Config: File path (with file picker), encoding (UTF-8, ASCII, binary).
• Use case: Load configuration files, read log files, ingest raw data.

File Write

Writes data to a file on the local filesystem. Creates the file if it does not exist.

• Inputs: input (text) — the content to write.
• Outputs: output (text) — the absolute path of the written file.
• Config: File path, write mode (overwrite, append), encoding.
• Use case: Save generated reports, write processed data, create configuration files.

JSON Parse

Parses a JSON string into a structured object. Optionally extracts a specific field using a JSONPath expression.

• Inputs: input (text) — JSON string.
• Outputs: output (JSON) — parsed object or extracted value.
• Config: JSONPath expression (optional, e.g., $.data.items[0].name).
• Use case: Extract fields from API responses, restructure data.

CSV Parse

Parses a CSV string into a JSON array of objects, using the first row as headers.

• Inputs: input (text) — CSV string.
• Outputs: output (JSON) — array of row objects.
• Config: Delimiter (comma, tab, pipe), quote character, skip rows.
• Use case: Import spreadsheet exports, process tabular data, convert CSV to JSON.

HTTP Request

Makes an HTTP request to a URL and returns the response body.

• Inputs: input (any) — used as the request body for POST/PUT requests.
• Outputs: output (text) — response body; status (number) — HTTP status code.
• Config: URL, method (GET, POST, PUT, DELETE, PATCH), headers, authentication (Bearer, Basic), timeout.
• Use case: Call REST APIs, fetch web data, send webhooks.

Logic Nodes

Logic nodes control the flow of execution within your workflow.

Conditional

Evaluates a condition and routes data to one of two output ports: true or false.

• Inputs: input (any)
• Outputs: true (any), false (any) — only one fires per execution.
• Config: Condition expression (JavaScript), e.g., input.length > 100.
• Use case: Branch workflows based on data content, implement if/else logic.

Loop

Iterates over an array input, executing the connected downstream nodes once per item.

• Inputs: input (JSON) — an array.
• Outputs: item (any) — the current iteration item; done (JSON) — fires after all iterations with the collected results.
• Config: Concurrency limit (1 = sequential, N = parallel batches).
• Use case: Process each row of a CSV, batch API calls, transform collections.

Merge

Waits for all connected input ports to receive data, then combines them into a single output.

• Inputs: Multiple named inputs (input_1, input_2, etc.).
• Outputs: output (JSON) — an object keyed by input port names.
• Config: Merge strategy (object, array, concatenate).
• Use case: Combine results from parallel branches, aggregate data from multiple sources.

Delay

Pauses execution for a specified duration before passing data through.

• Inputs: input (any)
• Outputs: output (any) — passes through unchanged after the delay.
• Config: Duration in milliseconds or seconds.
• Use case: Rate-limit API calls, introduce timing between operations, debounce triggers.

Variable Set

Stores a value in the workflow's variable scope under a given name.

• Inputs: input (any) — the value to store.
• Outputs: output (any) — passes through the input unchanged.
• Config: Variable name (string).
• Use case: Save intermediate results for use later in the workflow.

Variable Get

Retrieves a value from the workflow's variable scope by name.

• Inputs: None (triggered by upstream connection).
• Outputs: output (any) — the stored variable value.
• Config: Variable name (string), default value (optional).
• Use case: Access a value set earlier in the workflow without re-computing it.

Integration Nodes

Integration nodes connect your workflow to external services and systems.

Webhook

Creates a temporary HTTP endpoint that triggers the workflow when it receives a request.

• Inputs: None (this is a trigger node).
• Outputs: body (JSON) — request body; headers (JSON) — request headers; params (JSON) — query parameters.
• Config: HTTP method filter, authentication token (optional), auto-respond toggle.
• Use case: Receive GitHub webhook events, accept form submissions, create API endpoints for testing.

Email Send

Sends an email via SMTP.

• Inputs: input (text) — used as the email body if not set in config.
• Outputs: output (JSON) — delivery status and message ID.
• Config: SMTP server, port, username, password, from address, to address(es), subject, body (HTML or plain text), attachments.
• Use case: Send notification emails, deliver generated reports, alert on workflow completion.

Database Query

Executes a SQL query against a database and returns the result rows as JSON.

• Inputs: input (any) — available as $input parameter in the query.
• Outputs: output (JSON) — array of row objects.
• Config: Connection string (SQLite, PostgreSQL, MySQL), query editor, parameterized queries.
• Use case: Query application databases, generate reports from stored data, seed workflows with database content.