Flowise

Flowise is an open-source, low-code platform for visually building and deploying AI agents and agentic workflows. Teams use its node-based canvas to wire together LLMs, retrieval pipelines, tools, memory, and human-review steps without writing boilerplate integration code—yet every node is backed by real TypeScript logic you can inspect and extend.

The platform ships as a TypeScript monorepo with a Node.js/Express backend, a React frontend, and a standalone components package that houses over 200 integrations: 20+ chat model providers (OpenAI, Anthropic, Gemini, Mistral, Ollama, Bedrock, and more), 20+ vector stores (Pinecone, Chroma, Qdrant, Postgres, Milvus, FAISS), and dozens of document loaders, memory adapters, and tool nodes. AgentFlow, Flowise’s second-generation agent runtime, replaces the older LangChain chain abstraction with purpose-built visual node types—LLM, Agent, Tool, Condition, Loop, HumanInput, ExecuteFlow, HTTP—each rendered and executed uniformly on the canvas.

Flows are serialised as JSON and exposed as REST API endpoints the moment you hit deploy, with auto-generated Swagger docs and official Python and TypeScript SDKs. The server supports SQLite out of the box and switches to MySQL, MariaDB, or PostgreSQL via environment variables. For production scale, an optional Redis + BullMQ queue layer decouples predictions and upsert jobs from the HTTP request cycle. OpenTelemetry and Prometheus metrics endpoints ship standard, and the enterprise tier adds RBAC, SSO (OAuth2/SAML), workspaces, audit logs, and a managed Flowise Cloud offering.

Deployment is documented for AWS, Azure, GCP, Digital Ocean, Railway, Render, Northflank, Hugging Face Spaces, Elestio, and Sealos, and a production-ready Docker Compose file is included in the repository. With 53,000+ GitHub stars and over 80 releases since its 2023 launch, Flowise has become one of the most-adopted open-source tools in the LLM application stack.

What You Get

• AgentFlow Visual Editor - A canvas-based workflow builder with purpose-built node types (LLM, Agent, Tool, Condition, Loop, HumanInput, HTTP, ExecuteFlow) that execute in a unified runtime, giving you full visibility into each step’s inputs and outputs.
• 200+ Pre-built Integrations - Ready-to-drop nodes for 20+ LLM providers, 20+ vector stores, 15+ document loaders, and dozens of memory, retrieval, and tool integrations—all configurable from the UI without writing connector code.
• RAG Pipeline Builder - Connect PDF, CSV, HTML, and database loaders to a document store, chunk and embed on demand, and link the resulting vector index to any LLM node for retrieval-augmented generation with source citation.
• Multi-Agent Orchestration - Compose supervisor/worker agent topologies in the visual editor: one agent routes tasks, sub-agents specialise, and a shared flow state carries context across the graph.
• Human-in-the-Loop (HITL) Steps - Insert HumanInput nodes anywhere in a flow to pause execution, surface the intermediate output for manual review, and resume only after approval—enabling compliance-aware AI pipelines.
• REST API + SDK Exposure - Every deployed flow becomes a REST endpoint with auto-generated Swagger docs; official Python and TypeScript SDKs wrap these endpoints, and an embeddable web widget lets you drop a chatbot into any page.
• Production Queue with Redis + BullMQ - An optional worker mode decouples prediction and vector-upsert jobs from the HTTP layer using BullMQ queues backed by Redis, with a built-in Bull Board dashboard for job monitoring.
• Observability and Metrics - Native Prometheus and OpenTelemetry integrations export execution counters and latency histograms; PostHog telemetry and a structured audit logger provide usage and security trails.

Common Use Cases

• Internal knowledge-base copilot - An engineering team ingests internal Confluence pages and runbooks into a Pinecone vector store via Flowise’s document store UI, then wires a RAG flow that answers Slack-triggered queries through the REST API.
• Customer-facing support chatbot - A SaaS company builds a multilingual support bot connected to their CRM via HTTP tool nodes and deploys it on AWS behind their existing auth layer using the embeddable Flowise widget.
• Automated research and synthesis pipeline - A data team orchestrates a multi-agent flow in which one agent fetches URLs via HTTP nodes, a second extracts key claims with an LLM node, and a third writes a structured summary to a database—all scheduled via Flowise’s cron trigger.
• LLM evaluation harness - A machine learning team uses Flowise’s evaluation dataset and evaluator node types to run A/B comparisons between prompt variants and models, logging scores to Prometheus for dashboard visualisation.
• Rapid AI feature prototyping - A product manager with no backend experience wires a document summariser—PDF upload, text splitter, OpenAI LLM, structured output parser—in under 30 minutes and hands a live API URL to the frontend team.
• MCP-powered tool integration - A developer registers a custom MCP server in Flowise, making its tools auto-discoverable as drag-and-drop nodes, then composes an agent that calls GitHub, Jira, and Slack in a single visual flow.

Under The Hood

Architecture Flowise is structured as a pnpm monorepo managed by Turborepo, with four clearly bounded packages: a Node.js/Express server responsible for API routing, credential management, database access, and job scheduling; a React single-page application that renders the visual canvas and configuration panels; a components package that houses all integrable node definitions; and an agentflow package that publishes the embeddable canvas as a standalone React library. The server follows a layered controller–service–repository pattern with TypeORM entities, and dynamic node loading at startup means new integrations are discovered from the components package without modifying the server core. State that must span the HTTP boundary—execution results, SSE streams, abort signals—is held in singleton pool classes rather than passed through the call stack, a pragmatic choice that keeps route handlers thin while avoiding a full dependency-injection framework.

Tech Stack The backend runs on Node.js 24 with Express and TypeScript, persisting data to SQLite by default and switching to MySQL, MariaDB, or PostgreSQL through environment variables, with TypeORM handling schema migrations. Horizontal scaling is enabled by an optional Redis + BullMQ queue layer that separates prediction and vector-upsert workloads into a worker process visible via Bull Board. The React 18 frontend is built with Vite, bundled with Rollup, and renders the flow canvas using React Flow, with MUI for layout components and CodeMirror for in-node code editing. LangChain Core provides the base abstractions for chains and tools, while LLM providers, vector stores, and loaders are loaded as independent node modules at runtime. Observability is wired through OpenTelemetry and Prometheus metric counters, with PostHog capturing anonymised product telemetry.

Code Quality The repository has meaningful test coverage spread across the components and server packages, including unit tests for utility functions, security helpers, queue scheduling, and HTTP header validation—all backed by Jest with explicit mock boundaries for external dependencies. TypeScript is used strictly throughout, with shared interface files defining the node contract (INode, INodeParams, INodeData) and runtime types that every integration must satisfy. Error handling is explicit: a custom InternalFlowiseError class carries HTTP status codes, and the Express error middleware formats and logs them consistently. Linting is enforced via ESLint with React, hooks, and unused-imports plugins, Prettier controls formatting, Husky runs lint-staged on commits, and Turborepo gates builds on lint and type-check tasks. The codebase is well-organised, though the enterprise subdirectory and the components package are notably larger than the rest and carry more coupling.

What Makes It Unique Flowise’s most distinctive engineering choice is treating both the canvas editor and the agent runtime as independently publishable artifacts: the agentflow package exports the visual flow builder as a React library that any application can embed, while the server exposes executed flows as versioned REST APIs, decoupling authoring from consumption. Its MCP (Model Context Protocol) server integration lets teams register external tool servers whose capabilities are dynamically discovered and surfaced as drop-in nodes at runtime—no code change required to add a new tool class. The AgentFlow node types (Condition, Loop, HumanInput, ExecuteFlow) implement control-flow primitives that most LLM frameworks leave to the developer, making non-trivial agent topologies expressible entirely in the visual editor. Combined with an enterprise tier that layers RBAC, SSO, workspaces, and audit logging onto the same open-source core, Flowise occupies an unusual position: genuinely useful for individual developers prototyping and for organisations deploying governed, multi-tenant AI infrastructure.

Self-Hosting

Flowise is dual-licensed. The core platform—everything outside the packages/server/src/enterprise directory—is released under the Apache License 2.0, which permits free commercial use, modification, and distribution without copyleft obligations. The enterprise subdirectory is covered by a separate FlowiseAI Commercial License that requires a paid subscription for production use; development and testing are permitted without a subscription. In practice this means a self-hosted deployment is fully open-source unless you need RBAC, SSO, workspaces, or audit logging—those features live in the commercial tier.

Running Flowise yourself is straightforward at small scale: a single npx flowise start or docker compose up gets you a working instance backed by SQLite on the local filesystem. In production you will want to swap SQLite for a managed PostgreSQL or MySQL database, configure encrypted credential storage with a secret encryption key, and decide whether to enable the Redis + BullMQ worker queue for high-throughput or long-running predictions. Backups, SSL termination, secret rotation, scaling the worker pool, and keeping the instance updated with new releases—which ship at roughly two per month—are all your responsibility. The included Dockerfiles and Compose examples for the queue-worker topology are production-quality and reduce the operational burden significantly, but there is no built-in high-availability or managed-upgrade path.

Flowise Cloud, the managed SaaS offering, handles infrastructure, automatic upgrades, and access to enterprise features (RBAC, SSO, workspaces, usage quotas) out of the box and is the path of least resistance for teams that want the full feature set without the operational overhead. Self-hosters on the open-source tier give up SSO and fine-grained permission management, have no SLA or official support channel beyond the GitHub Discussions forum and Discord community, and must manage availability themselves. Teams evaluating the hosted versus self-hosted trade-off should weigh the engineering time required to maintain a production-grade Flowise deployment—database, queue, credentials, TLS, monitoring—against the Flowise Cloud subscription cost.