Published

Langflow

Visual builder for LLM applications: you wire models, prompts, tools, vector stores and agents into flows in a browser editor, then call each flow over a REST API or as an MCP server. Fits developers and small teams that prototype AI workflows and serve them from their own server, using hosted or self-hosted model APIs.

Resources by load level

What the app itself needs at each level, next to what we recommend for a server that runs only this app.

Level	What it means	App requirements	Recommended
LightEstimate	1–2 people building flows, up to 20 flows, ~500 flow runs/day against hosted model APIs, up to 1 GB of uploaded files and local knowledge bases; one worker.	1.8 vCPU · 2.5 GiB RAM · 10.657 GiB disk	2.28 vCPU · 4.5 GiB RAM · 21.686 GiB disk
MediumEstimate	Up to 5 people building flows, up to 50 flows, ~5,000 flow runs/day over the API, up to 5 GB of uploaded files and local knowledge bases; one worker.	3 vCPU · 6 GiB RAM · 59.657 GiB disk	3.72 vCPU · 8.7 GiB RAM · 78.036 GiB disk
HeavyEstimate	Up to 15 people building flows or calling the API, up to 150 flows, ~20,000 flow runs/day, up to 15 GB of uploaded files and local knowledge bases; still one worker.	4 vCPU · 8 GiB RAM · 69.657 GiB disk	4.92 vCPU · 11.1 GiB RAM · 89.536 GiB disk

Recommended = app requirements + system baseline + safety headroom, under sizing policy 2026.10.0. Options stay at their defaults. “Estimate” means the sources give no number for that case, so it is worked out from them by the method stated under Components. How the numbers are built

Size it in the Stack Sizer

Ready-to-run files

Support level Supported

Compose template from the official sources; not yet verified by a run.

Create docker-compose

Components

What each component needs at each load level, before baseline and headroom.

vCPU / GiB RAM / GiB disk
Component	Light	Medium	Heavy	Sources
Langflow (editor and API) (app)	0.8 / 1.5 / 4.157	1 / 2 / 8.157	2 / 4 / 18.157	[11][12][17][22][25]
PostgreSQL (database)	1 / 1 / 6.5	2 / 4 / 51.5	2 / 4 / 51.5	[28][29][30][31][32][33][34]

How the estimates are worked out

Langflow (editor and API) · Light: vCPU and RAM: the Kubernetes guide's IDE minimums, frontend 512Mi / 0.3 CPU + backend 1Gi / 0.5 CPU = 0.8 vCPU, 1.5 GiB; the image serves both from one process. Disk: image 3.157 GiB (0.746 compressed + 2.411 unpacked, both kept by the containerd image store) + 1 GiB of files and knowledge bases (1 GB taken as GiB) = 4.157.
Langflow (editor and API) · Medium: vCPU and RAM: the Kubernetes guide's runtime minimum per instance, 2Gi RAM and 1000m (1 CPU). Disk: image 3.157 GiB + 5 GiB of files and knowledge bases (5 GB taken as GiB) = 8.157.
Langflow (editor and API) · Heavy: vCPU and RAM: the install guide's recommended host, a multi-core CPU (taken as 2 vCPU) and at least 4 GB RAM (taken as 4 GiB, rounded up). Disk: image 3.157 GiB + 15 GiB of files and knowledge bases (15 GB taken as GiB) = 18.157.
PostgreSQL · Light: Embedded metadata DB with the image's default config: equals the PostgreSQL profile's light preset (≤ 5 GB data, ≤ 20 concurrent connections) at every load level. Light preset method: shared_buffers 25% of RAM, worst-case work_mem/maintenance_work_mem budget, 0.5 GiB image + 5 GiB data + 1 GiB WAL.
PostgreSQL · Medium: RAM: 4 × light; shared_buffers 1 GiB = 25% (docs guidance); the other 3 GiB covers worst-case 100 connections × work_mem 4 MB × hash_mem_multiplier 2 (800 MB) plus 4 × maintenance_work_mem 64 MB. vCPU: 2 active backend processes, or a leader plus one parallel worker. Disk: 0.5 GiB image (155 MiB compressed × 3, rounded up) + 50 GiB data + 1 GiB WAL (max_wal_size default); GB taken as GiB.
PostgreSQL · Heavy: RAM: 4 × light; shared_buffers 1 GiB = 25% (docs guidance); the other 3 GiB covers worst-case 100 connections × work_mem 4 MB × hash_mem_multiplier 2 (800 MB) plus 4 × maintenance_work_mem 64 MB. vCPU: 2 active backend processes, or a leader plus one parallel worker. Disk: 0.5 GiB image (155 MiB compressed × 3, rounded up) + 50 GiB data + 1 GiB WAL (max_wal_size default); GB taken as GiB.

Ports

Public ports are meant to be reached from outside the stack, usually through a reverse proxy; internal ones stay on the stack's own network.

Component	Port	Exposure	Purpose	Sources
Langflow (editor and API)	7860/tcp	Public, through a proxy	Visual editor, REST API and MCP endpoints (HTTP; put behind a TLS reverse proxy)	[5][6][14]
PostgreSQL	5432/tcp	Internal only	PostgreSQL connections from Langflow (LANGFLOW_DATABASE_URL)	[5][10]

Every port in the catalog, with conflicts between apps

User and permissions (UID/GID)

The user each container's process runs as, and the paths it writes to. A bind mount for one of these paths must be writable by that UID:GID.

Component	UID:GID	User	Starts as root	Writes to	Sources
Langflow (editor and API)	1000:0	`user`	No	`/app/langflow/app/data/app/.npm`	[6][8]
PostgreSQL	999:999	`postgres`	Yes, prepares its directories, then drops to this user	`/var/lib/postgresql/var/run/postgresql`	[26][27][33]

Langflow (editor and API): The image creates user (uid 1000, primary group 0), makes /app/data, /app/langflow and /app/.npm owned by 1000:0 and group-writable, and runs langflow run as USER user with no root entrypoint. HOME is /app/data; the template keeps config, files and knowledge bases in /app/langflow. A bind mount must be writable by uid 1000 or gid 0.

Storage growth

How much each component's data grows per month at each load level, on top of the disk in the profile. A value marked Assumption is ANAROQ's stated assumption, not a figure from the sources; the notes say what it rests on.

GiB per month
Component	Light	Medium	Heavy	Sources
Langflow (editor and API)Assumption	0.083	0.417	1.25	[4][17]
PostgreSQLAssumption	0.057	0.572	2.289	[15][21]

What the growth figures rest on

Langflow (editor and API): Upstream gives no growth rate. Assumes the level's 1 GiB of uploaded files and local knowledge bases in /app/langflow fill over 12 months: 1 / 12 = 0.083.
Langflow (editor and API): Upstream gives no growth rate. Assumes the level's 5 GiB of uploaded files and local knowledge bases in /app/langflow fill over 12 months: 5 / 12 = 0.417.
Langflow (editor and API): Upstream gives no growth rate. Assumes the level's 15 GiB of uploaded files and local knowledge bases in /app/langflow fill over 12 months: 15 / 12 = 1.25.
PostgreSQL: Transactions and vertex builds are capped at 3,000 rows each and flow versions at 50 per flow, so what grows is chat message history. Langflow gives no size per run; ANAROQ assumes 4 KiB of messages per run: 500 runs/day × 30 × 4 KiB = 0.057 GiB.
PostgreSQL: Transactions and vertex builds are capped at 3,000 rows each and flow versions at 50 per flow, so what grows is chat message history. Langflow gives no size per run; ANAROQ assumes 4 KiB of messages per run: 5,000 runs/day × 30 × 4 KiB = 0.572 GiB.
PostgreSQL: Transactions and vertex builds are capped at 3,000 rows each and flow versions at 50 per flow, so what grows is chat message history. Langflow gives no size per run; ANAROQ assumes 4 KiB of messages per run: 20,000 runs/day × 30 × 4 KiB = 2.289 GiB.

Upgrade and rollback

How to move to a new version safely, and how to go back if it fails.

Back up first

Stop Langflow, take a pg_dump of the langflow database and a copy of the /app/langflow volume, and export your projects as JSON. Record the current image tag and digest. [8][16][18]

Upgrade steps

Read the release notes of every version you skip for breaking changes, and test the new tag against a copy of your data first (login, flow loading, flow runs, files, provider credentials). [8][18]
Set the new pinned tag langflowai/langflow:X.Y.Z in the Compose file, then run docker compose pull and docker compose up -d. The same volumes are reattached, so flows and files are kept. [7]
Start a single Langflow instance: pending Alembic migrations run at startup. If startup reports a schema mismatch, run langflow migration to inspect it and restore the backup if needed. Keep LANGFLOW_SECRET_KEY unchanged. [9][16]

Roll back

After a database migration, stop the new version, restore the pre-upgrade database backup and redeploy the previous tag or digest. Do not run an older Langflow against a database a newer version migrated. [8]

Known breaking changes

In 1.12.4: Connector hardening: PGVector or other connectors that reach localhost or a private or container host name (such as postgres) need it in LANGFLOW_SSRF_ALLOWED_HOSTS; MySQL/MariaDB URLs need local_infile turned off. Custom component input names can no longer match Component method names, and MCP stdio configs can't put Node.js options before the script. [18]
In 1.12.0: Bundle separation concluded: the default install and image include only a curated provider list, and a flow using a missing provider package won't build until it is installed. The Admin Page was removed; manage users with the Users API. [8][18]
In 1.11.0: The langflow/langflow default superuser credentials are gone and Docker images set LANGFLOW_AUTO_LOGIN=false: set LANGFLOW_SUPERUSER_PASSWORD (not langflow) or the container won't start. [7][19]

Limits

Runs one worker process. More workers (LANGFLOW_WORKERS > 1) need a Redis job queue, or Langflow refuses to start; without it the editor and Playground break. This profile doesn't cover multi-worker or multi-instance setups. [13]
The default image has a curated provider set and no PyTorch. A flow that uses an omitted provider component won't run until you switch to langflowai/langflow-all or build a derived image; never install packages into the running container. [8]
Uploaded files and local (Chroma) knowledge bases live on this server's disk in the data volume. Uploads are capped at 1024 MB per file by default, and large payloads raise memory use; models themselves run at the provider, not in these figures. [4][11][17]
Langflow's database pool can open up to 50 connections (pool_size 20 + max_overflow 30), so from medium the bundled PostgreSQL is sized as the PostgreSQL profile's medium preset (up to 50 GB). Run history is capped at 3,000 rows; chat messages keep growing. [15][20][21]

Security

Langflow is a code execution platform: anyone who can edit flows can run arbitrary Python with access to the container's files, network and database connection, and users are not isolated from each other. Give editor accounts only to people you trust with the server. [14]
Keep LANGFLOW_AUTO_LOGIN=false (the image default since 1.11): with auto-login on, every visitor is signed in as the superuser. Sign in as langflow with LANGFLOW_SUPERUSER_PASSWORD; public sign-up is off in this template and new accounts stay inactive until the superuser activates them. [7][9]
Serve port 7860 only through an HTTPS reverse proxy, and keep PostgreSQL reachable by Langflow alone. API calls need a Langflow API key once authentication is on. [9][11]

Backup

Back up the PostgreSQL database with pg_dump (flows, users, API keys, encrypted global variables, messages) and keep LANGFLOW_SECRET_KEY with it: without the key the stored credentials can't be decrypted. [9][15][16]
Back up the data volume (/app/langflow) too: it holds uploaded files, local knowledge bases (with this template's LANGFLOW_KNOWLEDGE_BASES_DIR) and the secret_key file. [4][5][17]