Documentation

How to build a bot, what each tab of the app does, and what every node can do. First visit? Start with the quickstart, then take the tutorials in order: they run from an empty canvas to a bot answering your customers.

Getting started

• What Flow is — The product model in five minutes — workflows, nodes, wires and delivery channels.
• Getting started — What you need, what happens in the first five minutes, and where the tutorial ladder begins.
• Ready-made templates — Ten ready-made workflows: what each one does, what it is built from and what you must configure after importing.
• Glossary — Short definitions of the terms used in the interface and in this documentation.

Tutorials

• Tutorial 1. Your first chatbot — An agent with a model and memory: build it, test it and put it behind a link in one sitting.
• Lesson 2. A bot on your own site — The same bot as in lesson 1 — as a button in the corner of your page or a block inside your layout. One script tag.
• Tutorial 3. A bot that answers from your documents — A knowledge base, semantic search and an agent that answers only from what was retrieved — not from general knowledge.
• Lesson 4. Logic without a model — Branching and templates: a graph that sorts incoming messages and answers differently without calling a model once.
• What to do when… — Diagnosis by symptom: an edit that changed nothing, a greyed-out deploy button, a skipped node, an empty answer, a silent bot. What you see, why it happens, where to go next.

Interface

• Interface overview — How the Flow app is laid out — the sidebar, the sections, workspaces, language and account.
• The Workflows tab — The workspace workflow list — search, status tabs, card metrics, creating from a template, and deletion.
• Editor canvas — The node palette, connecting ports, selection, auto-layout, and stepping inside composite nodes.
• Node configuration dialog — The Params, Inputs and Outputs tabs, the Advanced section, fields overridden by a connected port, and split ports.
• Validation, saving and versions — The issues bar, error versus warning, version history and rollback.
• The AI assistant in the editor — How to phrase a task, read the change preview, and apply or discard it.
• The Test tab — Running the workflow from chat, node statuses on the canvas, the execution log and the node inspector.
• The Deploy tab — How a draft differs from the deployed version, and what each of the five channels configures.
• Executions — The run list, its filters, and a single run: nodes, graph, timeline, logs, tokens and credits.
• Chat — Talking to a deployed workflow — sessions, sending and stopping a reply, attachments, clearing history.
• Clients — Browse end-user sessions of a workflow and read the full conversation of each one.
• Knowledge — Creating a knowledge base, adding documents and URLs, metadata, processing status and deletion.
• Database — The workspace's JSON document collections — inserting, editing, querying and quotas.
• Files — The workspace file tree — uploads, folders, preview, quota and what deletion does.
• Settings — Ten settings sections — from profile and workspace to the widget, white-label and billing.
• Admin — The global administrator's console — users and limit overrides, plans, audit log.

How it works

• Core concepts — What a workflow is made of: the graph, nodes, ports, wires and execution order.
• Graph model — Nodes, edges, ports, entry and exit — and why the engine activates nodes by events rather than by list order.
• Wires — The ten Flow edge types — what each carries, when it appears, and why configuration links never affect order.
• Port types — The thirteen semantic payload types of a port, the compatibility rules, and how a value is adapted to the shape a node expects.
• How a graph runs — An edge starts a node, not its position on the canvas — branching, OR-joins, barriers and pure data legs.
• Agents and tools — How ai_agent differs from a single model call: rounds, tools wired through link_extension, agent state and the call budget.
• Entry and exit — Why there is exactly one entry, when several exits are allowed, and what the race for the result is.
• Loops and iteration — Why an edge pointing back is an error, and how repetition is expressed with shell nodes: while_loop, for_each, map and filter.
• Composites and sub-workflows — Folding a piece of the graph into one node: interface ports, name isolation, nesting, and WF tool as an agent's tool.
• Run statuses and skip reasons — The exact meaning of completed, partial and failed, the node statuses, and the six skip reasons.
• Node errors — The on_error branch, what arrives in it, error codes, retries, and how an integration error differs from a validation error.
• Templates — Jinja substitutions in node fields — namespaces, render rules, and the single pass.
• Variables and memory — Where a workflow keeps state — var nodes, scopes, conversation memory and agent memory.
• Timeouts and budgets — What stops a stuck run: ceilings on time, tokens, iterations and nesting depth.
• Graph validation codes — Every code the problem panel can show: what it means and when it blocks a run.

Node reference

• How to read a node page — The card, ports, badges, the field table and the example: what to look for in the node reference.

Models

• Model catalog — Where Flow's LLMs, embeddings, rerankers and media models come from, and how a node picks one.
• Your own models and keys — Connect an OpenAI-compatible provider so its models show up in nodes — and what that does to billing.
• Web search — The OpenRouter web-search node: two modes, engines, what it returns and how it is billed.
• Speech and images — Flow's three media nodes: speech recognition, speech synthesis and image generation — models, parameters, files and money.

Channels

• Public chat — A chat page behind a link — the fastest way to hand a workflow to people.
• Telegram bot — Connecting a bot, group triggers, privacy mode and diagnostics.
• Webhook — Trigger a workflow from another system — an HTTP request with a key.
• Embeddable widget — Add the Flow chat widget to your site, identify end-users, and call browser JS.
• Scheduled runs — The cron trigger: digests, exports and checks with nobody in a chat.
• Assistant MCP — An external AI agent drives the platform over MCP: reads graphs, edits them, runs them.

Integrations

• Integrations: overview — How external-service connections work: credentials live in the workspace, nodes only reference them.
• CRM: amoCRM and Bitrix24 — Thin wrappers over these CRMs' REST APIs: you name the method and the body, the platform handles the address, the auth and the parsing.
• Calendar (CalDAV) — Eleven CalDAV nodes: read busy time, create and edit events, hand the calendar to an agent.
• Email — One connection for sending and reading: SMTP, IMAP or POP3, four nodes and an agent mail tool.
• HTTP and the web — A universal request to any API, page reading for agents, and two different searches: one free, one paid.
• Connecting an MCP server — The mcp_tool node takes tools from somebody else's MCP server: the connection, two modes, attaching to an agent, and what happens when the server is down.
• Your own JavaScript — The code_javascript node: when code is justified, what arrives as input, an isolated container instead of trust, and why an administrator may switch it off.

Data

• Knowledge bases and RAG — How document search works: chunks, embeddings, metadata, hard filters and the reranker.
• Document collections — The workspace JSON document store: when to use it, and how to read and write it with the db_* nodes.
• Workspace files — File storage: the read and write nodes, filestore:// references and chat attachments.
• Tables — Fourteen nodes for CSV and Excel: how a table travels through the graph, the read → filter → group → write pipeline, and how a table differs from a collection.

Administration

• Team and roles — The workspace as a data boundary, three roles and a permission matrix, the owner as a separate entity, archiving and the workspace credit budget.
• Data and security — Where the data sits, how secrets and channel keys work, what leaves the platform, how long history lives — and what the platform honestly does not have.
• API access — Three different keys — signing in to the interface, running a workflow over HTTP, and an external AI agent over MCP. There is no single "whole API" token.
• Self-hosting — Which containers Flow is made of, what must be configured before the first start, and how your own installation differs from the hosted one — your keys, your model catalogs, your plans.

Billing

• Credits and cost — What a run costs: the run itself, nodes, tokens, media and search — and what is not billed.
• Plan limits — The full Free and Paid limits table, with the seeded default values.