Flowise: self-hosted low-code agents

Updated: 2026-09-02

Flowise is an open-source tool for building AI agents by dragging and connecting nodes on a visual canvas, with barely any programming. It is built on LangChain.js and, most importantly, you can self-host the whole thing on your own machine with a single Docker container, so neither your API keys nor your users’ data ever leave your network. In this guide you will see what Flowise is, how to deploy it, the difference between a chatflow and an AgentFlow v2, how to add tools, memory and RAG, and how it compares to Langflow and Dify. The same explanation is available in Spanish.

Key takeaways

• Flowise is an open-source visual agent builder (Apache 2.0 licence, except the enterprise/ folder); it has over 55,000 stars on GitHub; its final version is 3.1.4, released on 29 July 2026, and the repository was archived read-only on 13 August 2026.
• It is self-hostable: a single docker run brings up the web UI on port 3000, and it starts with a SQLite database that you can swap for PostgreSQL or MySQL in production.
• It distinguishes two flow types: the classic chatflows (a LangChain conversational chain) and AgentFlow v2, an orchestration engine with 14 native node types for loops, conditional branches and human approval.
• Everything connects by dragging: models (including local ones with Ollama), tools, conversational memory and vector stores to build RAG without writing code.
• Against Langflow (Python, from DataStax and IBM) and Dify (focused on production RAG), Flowise wins on simplicity: it is the lightest to spin up and runs even on a 1 GB RAM VPS.

What has changed since 3.1.3

This guide was written against Flowise 3.1.3 (25 June 2026) and presented the project as active. It no longer is. Checked on 2 September 2026 against the repository and the maintainers’ announcement:

• 3.1.4, 29 July 2026, is the final release. It was a security-fix release^[2]: session-ID validation, an operator-controlled allowlist for custom MCP stdio commands, cross-workspace authorisation in the OpenAI realtime node, tenant and allowed-execution-path validation, and exports no longer include variable values. If you are still running Flowise, this is the image to be on: flowiseai/flowise:3.1.4 has been on Docker Hub since that day.
• Repository archived on 13 August 2026. GitHub marks it read-only; the last commit is the README update linking the announcement. The code stays visible “indefinitely” under Apache 2.0.
• The “Future of Flowise” announcement: “we’ve decided to wind down our operations for Flowise”. Feature development ceased on 29 July, official team support ended on 31 August 2026, and the npm packages and Docker images “will be marked deprecated”. The maintainers encourage forking “to maintain their own internal updates or community-led forks” and name no official successor. The reason they give is the shift of AI development towards coding agents, against which “the typical rigid workflow low-code approach quickly hits the limit when it comes to complexity”. The announcement says nothing about Flowise Cloud.
• What to use instead. If what drew you in was the node canvas with built-in RAG, Dify (1.17.0, August 2026) is the most complete platform and also self-hosts with Docker Compose. If you want to stay on a visual builder over LangChain with Python nodes, Langflow remains active (commits on 2 September 2026). If your case is more automation than agent, n8n is also active. A community fork of Flowise is viable licence-wise, but as of today there is none with enough track record for us to recommend.
• What in this guide still holds: the Docker and Compose install, the environment variables, the chatflow versus AgentFlow v2 distinction and the wiring of tools, memory and RAG describe 3.1.x as it was left. None of it will receive new security patches.

What is Flowise?

Flowise is a low-code platform for building applications and agents based on language models without starting from a blank code file. Instead of writing Python or JavaScript, you assemble the logic in a node editor: each block is a piece (a model, a tool, a memory, a document retriever) and the connections between blocks define how data flows. It is the same idea as a workflow editor like n8n, but specialised in building things with LLMs.

Under the hood, Flowise is a TypeScript and Node.js application built on LangChain.js, the JavaScript version of the well-known agent-orchestration library. That means every node on the canvas corresponds to a real LangChain component, so you are not trapped in a closed abstraction: when your flow works, you can expose it as an API or embed it as a chat widget on any website.

The project is one of the most popular in its category: it holds more than 55,000 stars on GitHub and its code is free under the Apache 2.0 licence, with the sole exception of the enterprise/ folder, which groups enterprise features (such as advanced identity management) gated behind a separate commercial licence. You do not need that part to build and deploy agents: everything essential is open and free.

How do you deploy Flowise with Docker?

Flowise’s big advantage over a cloud service is that it runs entirely on your own machine. The fastest way to try it is a single container with the official flowiseai/flowise image:

# Brings up Flowise on http://localhost:3000
docker run -d --name flowise -p 3000:3000 flowiseai/flowise:3.1.4

With that you already have the UI on http://localhost:3000. By default it starts with an embedded SQLite database, perfect for testing but volatile unless you mount a volume. For a serious deployment use the docker compose that ships with the repository, which persists data and lets you configure everything through environment variables:

git clone https://github.com/FlowiseAI/Flowise.git
cd Flowise/docker
cp .env.example .env

    # Edit .env: set FLOWISE_USERNAME, FLOWISE_PASSWORD and
    # change DATABASE_TYPE to postgres for production.
docker compose up -d

Two settings are mandatory before exposing it. First, security: set the FLOWISE_USERNAME and FLOWISE_PASSWORD variables so the UI asks for a username and password, because by default it is open to anyone with the URL. Second, the database: SQLite does not handle real concurrent use, so change DATABASE_TYPE to postgres (or mysql) and point it at an external database with DATABASE_HOST, DATABASE_PORT, DATABASE_USER, DATABASE_PASSWORD and DATABASE_NAME. Flowise needs Node.js v18.15.0 or v20 and above, but with Docker that comes already solved inside the image.

What is the difference between chatflows and AgentFlow v2?

Inside Flowise you build two kinds of flow, and understanding the difference is the key to not getting lost. A chatflow is the original format: a LangChain conversational chain where you wire up a model, a prompt, maybe a memory and a retriever. It is linear and direct, ideal for a question-and-answer chatbot over your documents. It works very well, but it falls short when the flow needs to decide, repeat steps or coordinate several agents.

That is why AgentFlow v2 arrived, Flowise’s native orchestration engine. Instead of relying on LangChain’s agent abstractions, v2 brings a set of 14 node types of its own that you assemble as an explicit flowchart: a Start node that initialises the state, LLM and Agent nodes to reason, Tool nodes for deterministic actions, a Condition node to branch, a Loop node to repeat and a Human Input node that pauses execution until a person approves an action. The piece that ties it all together is the flow state ($flow.state), a key-value store declared in the Start node and read from any other with {{ $flow.state.key }}, so two nodes that are not connected can still share data.

With those nodes you can model patterns a chatflow cannot reach: a supervisor that hands out tasks to worker agents, a loop that retries until a condition is met, or a flow that stops halfway to ask for confirmation before sending an email. It is a conceptual leap similar to what a state graph offers in code, but drawn on the canvas.

How do you add tools, memory and RAG?

An agent’s usefulness depends on what it can do and remember, and in Flowise all three capabilities connect by dragging nodes.

• Tools. A Tool node gives the agent a specific capability: searching the web, running a calculator, calling an external API with an HTTP node or invoking MCP servers (the Model Context Protocol), the open standard for exposing tools to agents. You can also write your own tool in JavaScript with the Custom Function node.
• Memory. By default an LLM remembers nothing between messages. Memory nodes (conversation buffer, a window with the last N interactions, or memory backed by Redis (an in-memory key-value store that is fast for short-lived data such as a conversation’s history)) keep the thread, so the agent knows what you discussed three turns ago.
• RAG. For the agent to answer with your documents instead of making things up, you connect a vector store. Flowise ships nodes to load documents, split them, generate their embeddings and save them in a vector database like Chroma, Qdrant or Pinecone. At query time, a Retriever node finds the fragments most similar to the question and passes them to the model as context.

The interesting part is that all these nodes are swappable by provider. You can start with an OpenAI model and, by changing a single node, serve the agent with a model you run on your own machine with Ollama, without touching the rest of the flow. That provider independence is one of the reasons Flowise fits well in environments that demand privacy.

Flowise, Langflow or Dify?

Flowise is not alone: it shares its category with Langflow and Dify, and all three are open-source and self-hostable, but they aim at different audiences.

Langflow is the equivalent in the Python world: it is developed by DataStax (acquired by IBM in 2025 and folded into watsonx) and its big draw is that you can write custom nodes in plain Python. If your team lives in Python and needs very bespoke logic, Langflow fits better. Dify plays in a different league: it is a more complete platform, with RAG and knowledge bases as first-class citizens and management tools designed to take applications to production; in exchange, it is heavier to deploy.

Flowise’s advantage is simplicity. A single Docker container gets it running, it works fine on a modest 1 GB RAM VPS and its learning curve is the gentlest of the three. If you want to prototype an agent this afternoon and deploy it yourself, Flowise is the natural entry point.

Frequently asked questions

Is Flowise free and open source?

Yes. Almost all of Flowise is free software under the Apache 2.0 licence, and you can self-host it at no cost and with no cap on how many flows you build. The only closed part is the enterprise/ folder, which groups features for large organisations (such as advanced identity and permission control) gated behind a commercial licence. To build, deploy and expose agents with tools, memory and RAG you do not need that paid part.

Do I need to know how to program to use Flowise?

Not for the basics. The whole point of a low-code tool is precisely that you assemble working flows by dragging and connecting nodes, without writing code. That said, some programming knowledge helps when you want a bespoke tool with the Custom Function node, when you debug why a flow does not respond as expected, or when you configure the production deployment. For 80% of cases, the visual canvas is enough.

Can I use Flowise with local models instead of OpenAI?

Yes. Flowise ships nodes to connect to models you run locally with Ollama through its OpenAI-compatible API. You just swap the model node on the canvas: the rest of the flow (tools, memory, retriever) stays the same. By combining self-hosted Flowise with a model served on your own machine you get a complete agent in which no data leaves your network.

Conclusion

With the project archived, this guide stands as a reference for existing installs and for anyone starting from a fork. While it was alive, Flowise was the fastest route from the idea of an agent to something that works and that you control. With a single docker run you bring up a visual builder on top of LangChain.js where you drag models, tools, memory and RAG, and where you can choose between a linear chatflow or an AgentFlow v2 with loops, conditions and human approval, all under the Apache 2.0 licence and without your data leaving your network. If you bring it up anyway, use the final image, docker run -d -p 3000:3000 flowiseai/flowise:3.1.4, open http://localhost:3000, create your first chatflow with a model and a memory, and have your exit to Dify, Langflow or n8n planned: there will be no more patches.

Sources

1. announced the end of the project
2. security-fix release
3. Official Flowise documentation
4. Flowise on GitHub
5. AgentFlow v2 documentation
6. Official Flowise website

Route: Agent Ecosystem: MCP, Gateways and Platforms