Langflow CVE-2026-110186 is the check to run this week if you self-host Langflow in Docker. With auto-login enabled, one unauthenticated request to /api/v1/auto_login returns a full superuser session, no password involved, and IBM scores the flaw 9.8 critical. We confirmed that against a stock container in the lab. The request handed us an access token, the token read all 26 flows, and Langflow logged a warning about what it had just done.
I ran the whole sequence on Ubuntu 24.04 Docker VMs in November 2026 against Langflow 1.12.8 and 1.13.1, and every response below comes from those runs. The advisories gave us the text but no tested guide, so this one covers the check, the fix, the upgrade path, and a hardened Compose stack.

The check, the patch and the hardening each stand on their own, so jump to the one your instance needs. We used the same check-first order in our Plex media server CVE walkthrough: know whether you were exposed before changing configs.
1. What CVE-2026-110186 actually does
CVE-2026-110186 sits in the auto-login feature. When LANGFLOW_AUTO_LOGIN=true, the /api/v1/auto_login endpoint issues a superuser JWT to any client that can reach the port, with no credentials checked, which is why IBM classifies it as code injection (CWE-94) at a 9.8 score. Auto-login is a convenience mode, and most Docker quick-starts written before the fix recommend it because it saves you creating a user. That recommendation is exactly what turns an internet-facing Langflow into an open instance.
IBM’s bulletin ties three sibling CVEs to the same release window, and it is worth knowing all four because they fail in different places:
| CVE | Weakness | IBM score |
|---|---|---|
| CVE-2026-110186 | CWE-94, code injection | 9.8 |
| CVE-2026-93680 | CWE-287, improper authentication | 9.8 |
| CVE-2026-110193 | CWE-94, code injection | 8.8 |
| CVE-2026-110192 | CWE-522, insufficiently protected credentials | 6.5 |
Two sourcing notes before you lean on that table. The CWE labels and the scores come from IBM’s bulletin, not from an independent registry entry we re-derived, and the bulletin’s remediation is a single instruction, upgrade to 1.13.0, not tied to any one CVE ID. Community write-ups relay the auto-login behavior differently: some attach it to CVE-2026-110186, others to CVE-2026-93680, and nothing we read settles that mapping. What is not in dispute is the behavior we reproduced and the fix for it, and both are what this guide tests.
All four affect Langflow open source from 1.0.0 through 1.12.8, and IBM’s remediation bulletin names 1.13.0 as the fixed release. The same bulletin lists three more CVEs against Hono, a bundled web framework in the same releases, covering request smuggling, resource exhaustion and path traversal at scores between 5.3 and 6.5, and the 1.13.0 upgrade clears those too. The two point releases that shipped after it in the older line do not carry the fix, so being on the newest 1.12 build is not safe either. The change that matters landed as “disable automatic login by default” in the 1.13.0 release notes, which tells you how the project reads the problem: the default itself was the vulnerability.
One honesty note on scope. The four CVEs describe more than the session leak, and we did not attempt an exploit payload in the lab. What we reproduced end to end is the exposure mechanics that let a stranger hold a superuser session and read the instance. That is the part every exposed deployment shares, and the part you can check in two minutes with curl.
A fresh pull of the old image is also not automatically exposed. We ran the stock older image with no environment overrides and it ships LANGFLOW_AUTO_LOGIN=false baked in, then refuses to start at all until you set a superuser name and password. The exposure appears when auto-login is switched on, which the older quick-start guides do, or when a custom image or compose file flips it back on. So the first place to look is not the internet, it is your own container’s environment.
2. Step 1: Check whether your Langflow container is exposed
Is your instance exposed? Two checks answer that: read the environment the container actually runs with, then send the request a stranger would send, from a host that is not the Docker host. Run it from outside because a reverse proxy or firewall can make the port behave differently on the host itself. The curl has to reach the service the way the internet would.
Find the container and its published port first:
docker ps --format '{{.Names}}\t{{.Image}}\t{{.Ports}}'
Then read the auto-login setting from inside the container, using the name you just found, because the compose file on disk and the running environment do not always agree:
docker exec langflow printenv | grep -i LANGFLOW_AUTO_LOGIN
The request itself settles it. From a second host, with your server’s address in place of the example IP:
curl -i http://10.0.1.50:7860/api/v1/auto_login
Against the vulnerable configuration we got a 200 with a full session in the body and in the cookies. We have truncated the tokens for print:
HTTP/1.1 200 OK
content-type: application/json
set-cookie: access_token_lf=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0ZDhh...
set-cookie: refresh_token_lf=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0eXBlIjoicmVmcmVzaCI...
{"access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0ZDhh...","refresh_token":"eyJhbGciOiJIUzI1NiIs...","token_type":"bearer"}
We then repeated the request from a second host in our lab, reaching the Docker host through a tunnel the way a remote reader or a VPN client would. The answer was the same session, handed to a machine that holds no account on the instance:

Read the response like this: a 200 with tokens means the instance is exposed and you should treat everything in it as read. A 401 or 403 means auto-login is off, although the signup trap in the next section still applies to you. Connection refused means nothing is listening on that port from where you sit, which is the answer you want. The browser check is even quicker, because the editor under auto-login opens straight to the welcome screen with no sign-in form at all:

While you are probing, send a POST to /api/v1/users/ as well. In our test the older release accepted the signup with a 201 even with auto-login turned off, because LANGFLOW_ENABLE_SIGNUP defaults to true, so an account you did not create is a smaller version of the same problem. The MCP endpoint refused an unauthenticated POST with a 403 in our run, but once the flows API is readable we would treat the whole port as compromised anyway.
3. Step 2: See what that session is worth
The token from auto_login is a real superuser session, so the next request a thief makes is the flows list. With the token set as a cookie, GET /api/v1/flows/ returned every flow in the container, 26 of them, every one a packaged starter project such as Basic Prompting. Flows are not just diagrams. They carry your prompt templates, the model endpoints your pipelines call, webhook URLs that can trigger runs, and references to the credentials stored in the variables table. If the flows call cloud models, the API keys usually sit one request away. That makes the exposure a billing problem, not just a privacy one.
If your Langflow drives a model you host yourself, for example when you run a local model with llama.cpp, the thief takes pipeline knowledge rather than a billing credential, which is a smaller loss but still your work.
We also read the database directly to show what sits behind the port in a stock container: the superuser row, 26 flows and an API key record. That is the inventory a thief gets in three requests:

You do not need database access to notice the problem, because Langflow tells on itself. Every auto_login hit under the vulnerable configuration logs a warning line:
docker logs langflow 2>&1 | grep LANGFLOW_AUTO_LOGIN
The line to watch for looks like this:

The warning names the problem directly. It reads: “LANGFLOW_AUTO_LOGIN is enabled: /auto_login is issuing a superuser session without credentials. Disable AUTO_LOGIN and create a real superuser for any non-local or shared deployment.” If that line appears with timestamps you do not recognize, assume the instance has been read. Rotate the credentials in it as part of the fix.
4. Step 3: Close the hole on a release you cannot replace yet
If you are pinned to the older line for now, you can still close the hole today with three environment variables, and you should treat that as containment rather than the fix. The container needs a real user to authenticate against, so auto-login off and a superuser with a password is the pair that works:
LANGFLOW_AUTO_LOGIN=falseLANGFLOW_SUPERUSER=admin, a name you chooseLANGFLOW_SUPERUSER_PASSWORD, a long unique value
Add them to the compose service environment and recreate, because an edit alone does nothing until the container is replaced:
docker compose up -d --force-recreate langflow
Skip the superuser variables and the container will not start at all. The stock image now demands credentials, which is the fix arriving as a default, and the failure is loud rather than subtle:

The relevant lines are ValueError: Username and password must be set and Worker (pid:12) exited with code 3, which means the application never came up. That is the intended behavior on the newer default, so do not “fix” it by switching auto-login back on; set the variables.
Recreate, then send these three probes, first from the Docker host and then from the second host:
curl -s -o /dev/null -w "%{http_code}\n" http://10.0.1.50:7860/api/v1/auto_login
curl -s -o /dev/null -w "%{http_code}\n" http://10.0.1.50:7860/api/v1/flows/
curl -s -o /dev/null -w "%{http_code}\n" -X POST http://10.0.1.50:7860/api/v1/mcp/
The answer is a flat 403 on every endpoint, not a redirect and not a login challenge, and it is the same from the second host. The verbose form shows what the refusal looks like on the wire:
curl -i http://10.0.1.50:7860/api/v1/auto_login
HTTP/1.1 403 Forbidden
date: Mon, 09 Nov 2026 07:50:47 GMT
server: uvicorn
content-length: 67
Our capture, with the second-host replay sitting underneath the header block:

Note the code: 403, not 401. Langflow does not offer a login challenge to an unauthenticated caller here, it refuses the call outright, which is the behavior that closes the session leak. Then close the two side doors we found. Auto-login off still allowed a POST /api/v1/users/ to return 201 in our test, so add LANGFLOW_ENABLE_SIGNUP=false, or anyone reaching the port can self-register and wait for approval. And if you build custom components, the newer release logs a SECURITY warning under multi-user mode when LANGFLOW_ALLOW_CUSTOM_COMPONENTS=true, because component code executes on the server at flow-build time. Set LANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY=true so only admins can author component code, or turn custom components off entirely if nobody uses them.
One warning before you move on. Langflow’s own documentation states that “disabling auto-login prevents new anonymous sessions; it does not revoke previously issued sessions or API keys”. The refresh token we captured was valid for a week, so rotate the API keys stored in the instance and treat sessions issued before the change as live until they expire.
5. Step 4: Upgrade without losing your login
Before you touch the image, find the database, because this is where upgrades eat data. The stock docker run line keeps the SQLite database inside the container under /app/.venv, so removing the container deletes every flow you ever built. Mount a volume for /app/data, or better, point LANGFLOW_DATABASE_URL at a Postgres container the way the hardened stack below does. Copy the database out before the first upgrade attempt:
docker cp langflow:/app/.venv/lib/python3.14/site-packages/langflow/langflow.db ./langflow-backup.db
The upgrade itself has a trap that will bite anyone who sets a new password in the environment and expects it to apply. If an earlier run seeded a superuser on the volume, the new release keeps the old password and ignores the one you just configured. We hit exactly this message on the upgrade:
LANGFLOW_SUPERUSER_PASSWORD was not applied because the configured superuser already exists with a different password. The existing password was preserved. To recover access after upgrading, see https://github.com/langflow-ai/langflow/blob/release-1.13.0/docs/docs/Develop/api-keys-and-authentication.mdx#recover-access-after-upgrading-recover-access-after-upgrading
We captured the same warning in the first boot log of the upgraded container, recovery link included:

Notice the recovery link in that message: the anchor fragment appears twice at the end. That is an upstream logging bug in the release itself, not something we introduced, and it is present in both 1.13.0 and 1.13.1. The working link is the same documentation page with the anchor stated once, #recover-access-after-upgrading, so strip the repeat when you follow it.
Follow the recovery procedure the message links to in the Langflow documentation; that is the supported way back in. The cleaner path is to avoid the trap: keep LANGFLOW_SUPERUSER and LANGFLOW_SUPERUSER_PASSWORD in your .env file and never change the password between starts, so every start agrees on the same credentials. When the values do agree, the startup logs show the good case instead, and the release even tells you it kept the user because it owns rows in the API key table.
A second message covers the opposite case. If you come up with auto-login off and no named superuser, the release deactivates the old default account and keeps it rather than deleting it, with a PATCH /api/v1/users/<id> call as the remedy. Read the startup logs on the first boot after an upgrade, because Langflow prints its authentication decisions there and each one is a different lockout path.
After the upgrade, the login page replaces the open editor, and your existing URL, flows and variables carry over with the database volume. Do not plan on downgrading if something looks wrong; the same database will refuse the older release, as the rollback failure in the last section shows. Take the backup, upgrade, and fix forward.
6. Step 5: Deploy the hardened Docker Compose stack
We tested the following stack in the lab: nginx terminating TLS with basic auth in front of Langflow, a certbot sidecar for renewals, Postgres for the database, and Langflow bound to the host loopback so nothing but the proxy can reach it. Three files, one password file and a certificate directory make it up, and all of them ran as written. The cert steps also assume Docker is installed, the certificate name has a public DNS A record pointing at the host, and port 80 is reachable from the internet. Start with the environment file, saved as .env next to your compose file, because Compose interpolates ${LANGFLOW_SUPERUSER_PASSWORD} only from that exact name:
LANGFLOW_SUPERUSER_PASSWORD=change-to-a-long-unique-value
LANGFLOW_SECRET_KEY=paste-output-of-token-urlsafe-32
POSTGRES_PASSWORD=change-to-another-long-unique-value
Generate the values rather than inventing them. For the two passwords any long random string works, so run this once for each:
openssl rand -hex 32
Do not reuse that command for the secret key, because this is where the earlier version of this guide went wrong. Langflow encrypts stored API keys and variables with Fernet, which needs the key as 32 url-safe base64-encoded bytes, so a hex string boots fine and then makes every API key creation fail with HTTP 400. Generate it the way the Langflow docs do:
python3 -c "from secrets import token_urlsafe; print(token_urlsafe(32))"
Expect a 43-character string of letters, digits, dashes and underscores. Paste that as LANGFLOW_SECRET_KEY, and keep a copy somewhere safe, because the key decrypts everything Langflow has already stored with it.
The edge password for the browser and for curl lives in an htpasswd file, generated the same way we do it for the private Docker registry:
docker run --rm httpd:2.4-alpine htpasswd -nbB langflowviewer 'type-an-edge-password' > htpasswd
The stack file is the one we deployed. Four things matter in it: the loopback bind on port 7860, the pinned image, the environment block that turns off every convenience feature the CVEs abuse, and the two edge services that publish ports 80 and 443 and nothing else:
vi docker-compose.yml
The file below is the one we deployed and tested, verbatim:
services:
langflow:
image: langflowai/langflow:1.13.1 # pin: tested release for this guide #https://github.com/langflow-ai/langflow/releases
restart: unless-stopped
depends_on:
langflow-db:
condition: service_healthy
environment:
- LANGFLOW_AUTO_LOGIN=false
- LANGFLOW_SUPERUSER=langflowadmin
- LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD}
- LANGFLOW_SECRET_KEY=${LANGFLOW_SECRET_KEY}
- LANGFLOW_ENABLE_SIGNUP=false
- LANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY=true
- LANGFLOW_DATABASE_URL=postgresql://langflow:${POSTGRES_PASSWORD}@langflow-db:5432/langflow
ports:
- "127.0.0.1:7860:7860"
volumes:
- langflow-data:/app/data
langflow-db:
image: postgres:16-alpine
restart: unless-stopped
environment:
- POSTGRES_USER=langflow
- POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
- POSTGRES_DB=langflow
volumes:
- langflow-pg:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U langflow -d langflow"]
interval: 5s
timeout: 5s
retries: 10
proxy:
image: nginx:1.29-alpine
restart: unless-stopped
depends_on:
- langflow
ports:
- "80:80"
- "443:443"
volumes:
- ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
- ./htpasswd:/etc/nginx/langflow.htpasswd:ro
- ./certs:/etc/letsencrypt:ro
- certbot-www:/var/www/certbot:ro
certbot:
image: certbot/certbot
restart: unless-stopped
volumes:
- ./certs:/etc/letsencrypt
- certbot-www:/var/www/certbot
entrypoint: /bin/sh -c 'trap exit TERM; while :; do certbot renew --webroot -w /var/www/certbot; sleep 12h & wait $${!}; done'
volumes:
langflow-data:
langflow-pg:
certbot-www:
The proxy needs a certificate before its first start, because nginx refuses to come up with a missing cert file. Issue one with the standalone certbot image while port 80 is still free, pointing -d at the name you will serve:
docker run --rm -p 80:80 -v "$PWD/certs:/etc/letsencrypt" certbot/certbot certonly --standalone -d langflow.example.com --agree-tos --register-unsafely-without-email --no-eff-email
That command wrote the fullchain and key files under ./certs/live/langflow.example.com/ in our run, which are the two paths the nginx config mounts read-only. Replace langflow.example.com with the name your certificate was issued for, in the -d flag, in both server_name lines and in the cert paths of the config below. Renewal is handled inside the stack: the certbot service loops a webroot renew every 12 hours, writing challenge files into the shared certbot-www volume that nginx serves on port 80. We let the dry run prove that loop before trusting it:
docker compose exec -T certbot certbot renew --dry-run --webroot -w /var/www/certbot
The dry run answered with Congratulations, all simulated renewals succeeded and reported the live certificate valid for another 89 days, so the renewal path is exercised against the Let’s Encrypt staging endpoint without touching the cert itself. One caveat we have not lived through: the renew loop refreshes the files but never tells nginx, so a proxy that stays up past the 90-day cert lifetime would serve the expired one. Run docker compose exec proxy nginx -s reload after a renewal, or fold the reload into the certbot loop.
The environment block is doing the security work, so it is worth reading line by line:
LANGFLOW_AUTO_LOGIN=falsekills the free-session endpointLANGFLOW_ENABLE_SIGNUP=falsestops self-registrationLANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY=truekeeps component code admin-onlyLANGFLOW_SECRET_KEYsigns session tokens and encrypts stored API keys, so a unique value invalidates anything issued under a default127.0.0.1:7860:7860binds Langflow to the host loopback, so only the proxy reaches it
One note on the loopback bind: it exists for the Docker host’s own diagnostics, so nothing off the host can reach Langflow directly, which is what the diagram’s compose-network note means. Only nginx answers other machines.
The proxy config authenticates everything, including the MCP and SSE endpoints that a location-based exception would leave open:
vi nginx.conf
Two server blocks make it up: port 80 exists to answer ACME challenges and redirect everything else to HTTPS, and port 443 carries the auth and the proxying. This is exactly what ran:
server {
listen 80;
server_name langflow.example.com;
# ACME HTTP-01 challenges only; everything else moves to HTTPS.
location /.well-known/acme-challenge/ {
root /var/www/certbot;
}
location / {
return 301 https://$host$request_uri;
}
}
server {
listen 443 ssl;
http2 on;
server_name langflow.example.com;
ssl_certificate /etc/letsencrypt/live/langflow.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/langflow.example.com/privkey.pem;
# Everything, including /api/v1/mcp and the SSE endpoints, sits behind basic auth.
auth_basic "Langflow";
auth_basic_user_file /etc/nginx/langflow.htpasswd;
location / {
proxy_pass http://langflow:7860;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# SSE and streaming responses must not be buffered.
proxy_buffering off;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_read_timeout 3600s;
}
}
Bring the stack up and check that all four services settle, with the database waiting for its health check before Langflow starts:
docker compose up -d
docker compose ps
With the edge password, the editor loads through nginx, and behind it Langflow asks for the superuser login that auto-login used to skip. That second prompt is the point of the design, not an extra step to remove:

One detail in that capture is worth calling out. The login page still shows a Sign Up link even though LANGFLOW_ENABLE_SIGNUP=false, because the frontend renders it regardless. The server enforces the flag: a signup attempt through the stack answered 403 in our run, so the link leads nowhere.
Two credentials now guard the instance: the nginx pair for the network edge, and the Langflow superuser for the application. Losing either one is not enough on its own, which is the property a single auto-login flag could never give you.
7. Step 6: Prove the lockdown from outside
Replay the Step 1 probe plus the flows and MCP calls against the hardened stack, first from the Docker host and then from a second host over the internet, and send them to the HTTPS name, because a lockdown you have not probed is a guess. Without credentials, every endpoint that handed over a session before now refuses:
curl -s -o /dev/null -w '%{http_code}' https://langflow.example.com/api/v1/auto_login
curl -s -o /dev/null -w '%{http_code}' https://langflow.example.com/api/v1/flows/
curl -s -o /dev/null -w '%{http_code}' -X POST https://langflow.example.com/api/v1/mcp/
Our lab run, with the stack status sitting above the probes, the plain-HTTP redirect and the two basic-auth checks in the middle, and the certificate lines at the bottom:

All three answered 401. Plain HTTP answered a 301 to HTTPS before any auth prompt, and the certificate chain verified against the system trust store, so the basic-auth pair does not travel in the clear. We then replayed the same three probes from a second host over the internet, the answer that actually matters to you: the same three 401s. The proxy answers before Langflow is ever consulted, so the vulnerable endpoint never sees the request at all.

One result surprised us at first: requesting the flows list with only the basic-auth pair still returns a 403. That is correct behavior, because nginx authenticates the edge and Langflow still requires its own session for the API. The editor path returns 200 with the edge credentials, and the API requires the Langflow login on top. Defense in depth is supposed to feel like this, and it means an attacker needs both credentials to do anything, where the old setup needed neither.
Confirm the bind while you are at it, because the compose bind is only as good as the file that declares it:
docker compose port langflow 7860
ss -tlnp | grep 7860
You want to see 127.0.0.1:7860 on the host side and nothing listening on all interfaces. If the ss line shows a wildcard address, the environment block from the previous section did not apply, so recreate the service.
The MCP endpoint you just locked down is the one you will want back once an agent needs your flows as tools. If that agent is Claude Code running on local models, our guide to calling the Langflow MCP server from Claude Code with Ollama covers the client side. It authenticates with a Langflow API key in the x-api-key header, which is one more reason the secret key in Step 5 has to be in the url-safe format.
8. What broke in our lab
Four things went wrong on the way to the working setup, and each one cost us a restart to diagnose, so they are here with the exact errors we saw.
AutogenerateDiffsDetected on the way back down
After the newer release had migrated the database, we tried starting the older image against the same volume to test whether a rollback was possible. The answer was no. The migration added tables and indexes the older code does not expect, and Alembic aborted with:
AutogenerateDiffsDetected: New upgrade operations detected: [('remove_index', Index('ix_flow_last_modified_by', Column('last_modified_by', CHAR(length=32), table=<flow>))), ...
The same wall of schema complaints filled the rest of the log:

There is no same-volume downgrade, so the backup you take before upgrading is not paranoia, it is the rollback plan. We restored from the copy we made in Step 4 and moved forward instead.
Fernet key must be 32 url-safe base64-encoded bytes
Our first version of this guide shipped this bug, because it told you to fill LANGFLOW_SECRET_KEY from openssl rand -hex 32. Langflow starts and the login works, so nothing looks wrong until you create an API key. We reproduced it on a fresh Langflow 1.13.1 container on Ubuntu 24.04, and you can test your own stack with the same API key request. It expects a session token from /api/v1/login in $TOKEN.
curl -s -w '\nHTTP %{http_code}\n' -X POST http://127.0.0.1:7860/api/v1/api_key/ -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' -d '{"name":"ci-runner"}'
With the hex key, the API refused it and the container log carried the same message from startup, when Langflow tried to encrypt a built-in variable:
{"detail":"Fernet key must be 32 url-safe base64-encoded bytes."}
HTTP 400
A 64-character hex string is not valid base64 of 32 bytes, so Fernet rejects it. On a fresh container started with a token_urlsafe(32) key from Step 5, the same request returned HTTP 200 with a new sk- key that read the flows list. If you deployed with the hex key, change the value in .env and run docker compose up -d so Compose recreates the Langflow container with it. Sessions signed with the old key stop working, so log in again for a fresh $TOKEN before you repeat the request.
Bind for 0.0.0.0:7860 failed: port is already allocated
Bringing the hardened stack up while the exposed test container was still running failed with a port conflict on 7860, because both stacks wanted the same host port. Stopping the old container first resolved it, and the error is worth knowing because it means one of your two Langflow containers is still holding the port.
host not found in upstream “langflow”
The proxy crash-looped on the first bring-up with host not found in upstream "langflow" in its logs, which happens when the nginx container starts before the Docker network alias exists after a messy recreate. A clean docker compose down followed by docker compose up -d re-attached the networks and the proxy came up stable, so do not chase this one inside the nginx config.
What I would change for production
The stack above is where I would stop for a homelab behind a VPN, and it is not where I would stop for something internet-facing. TLS with the webroot renewal loop is already in the stack, so the basic-auth pair does not travel in the clear, and what remains for production is secrets and operations:
- Move the
.envvalues into Docker secrets or your secrets manager - Restrict ports 80 and 443 to your VPN range instead of the internet
- Back up the Postgres volume on a schedule, and test a restore
- Pin the image and read release notes before pulling, not after
The release-reading habit matters more than it sounds, because this fix shipped quietly inside a feature release rather than as an emergency patch. We point a release feed at self-hosted ntfy so a new Langflow tag pings a phone instead of waiting for someone to notice. And if Langflow feeds other automation, for example a self-hosted n8n workflow, rotate the credentials those integrations hold as part of the response, because flows and API keys were readable in the exposed state.
The last thing worth saying is that the default change in the newer release is the real fix, and everything in this guide is what you do about the deployments that predate it. Check the port, close the flag, upgrade on purpose, and put an authenticated edge in front before the next convenience feature ships.