Flowise: self-hosted low-code agents

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 54,700 stars on GitHub and its stable version is 3.1.3, released on 25 June 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 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 54,700 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.3

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. 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) 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

Flowise is 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. The next step is to bring up the container with docker run -d -p 3000:3000 flowiseai/flowise:3.1.3, open http://localhost:3000, create your first chatflow with a model and a memory, and try wiring a tool to it.

Sources: [1] Official Flowise documentation^[1], [2] Flowise on GitHub^[2], [3] AgentFlow v2 documentation^[3], [4] Official Flowise website^[4].

Sources

1. Official Flowise documentation
2. Flowise on GitHub
3. AgentFlow v2 documentation
4. Official Flowise website

Route: Agent Ecosystem: MCP, Gateways and Platforms