How to Self-Host Langflow with Docker and Build AI Workflows

The quickest way to run Langflow yourself is Docker: start the official image on port 7860, create an administrator password, and open http://localhost:7860/. For anything you need to keep, move to Docker Compose with PostgreSQL, persistent volumes, and an environment file. Once Langflow is running, you can assemble visual AI workflows from typed components, save versioned flows, package them into a custom image, and expose the installation through a reverse proxy with HTTPS.

Antihost offers Linux VPS plans with full root access, unlimited traffic on a 1 Gbps port and a 14-day free trial.

What self-hosting Langflow actually involves

Langflow is a visual way to represent an AI application as a flow. A flow receives input, passes it through components such as prompts, language models, retrievers, and output handlers, then returns a result. Components are the individual steps; connections carry typed data between their ports. When you run a flow, Langflow constructs a directed acyclic graph (DAG) from the nodes and edges, validates and prepares the components, sorts them by dependency, and executes them in that order.

#	Preview	Product	Price
1		Docker Deep Dive: Zero to Docker in a single book	$9.99	Buy on Amazon
2		Docker Deep Dive	$21.61	Buy on Amazon
3		Docker Deep Dive: Zero to Docked in a Single Book (Guide): A Complete Beginner to Advanced Guide to...	$0.99	Buy on Amazon
4		Natmisz:Dive Log Book Scuba Diving, Scuba Log Book, Scuba Diving Equipment Accessories, Gifts For...	$59.90	Buy on Amazon

As an Amazon Associate I earn from qualifying purchases.

Self-hosting means the Langflow server, its configuration, its flow definitions, and its database run on infrastructure you control rather than on a hosted Langflow service. That gives you control over network access, provider credentials, upgrades, backups, and where uploaded files and flow history are stored. It also makes you responsible for authentication, TLS, patching, storage, and recovery.

Choose the right Docker deployment

Use the single container first. It confirms that Docker works, the host can expose port 7860, and your credentials are accepted. Move to Compose when losing flows after container replacement would be unacceptable or when you need PostgreSQL, a .env file, or companion services.

#1 Best Overall

Docker Deep Dive: Zero to Docker in a single book

$9.99

Buy on Amazon

Run Langflow locally in one container

1. Install and start Docker

Install Docker for your operating system, start its engine, and confirm that the Docker CLI can launch containers. The exact installation screens differ by platform, so the important prerequisite is a running Docker daemon with permission to publish a host port.

2. Start the official image

Run the official image with automatic login disabled and a strong administrator password:

docker run -p 7860:7860 -e LANGFLOW_AUTO_LOGIN=false -e LANGFLOW_SUPERUSER_PASSWORD=SUPERUSER_PASSWORD langflowai/langflow:latest

Replace SUPERUSER_PASSWORD with a unique secret. The image publishes the container’s port 7860 on the same port of your host. Open http://localhost:7860/ in a browser and sign in. If another process already occupies port 7860, publish a different host port while leaving the container port unchanged, for example -p 8080:7860, then browse to http://localhost:8080/.

3. Treat this run as disposable

A container can be replaced without warning when you use a mutable latest tag or remove it manually. Without mounted application data and a persistent database, files and saved state inside the container should not be considered a backup. Use this mode to learn the interface, test provider credentials, or check that a flow works before creating a durable deployment.

Create a durable Docker Compose installation

The repository’s Compose example separates the Langflow service from PostgreSQL and accepts configuration through a .env file. The exact file can evolve with Langflow releases, so treat the following as a clear starting layout and compare it with the example that ships with the release you select.

1. Create an environment file

Store secrets outside the Compose YAML. A typical environment file defines the PostgreSQL connection and Langflow settings listed by the official example:

POSTGRES_USER=langflow
POSTGRES_PASSWORD=replace-with-a-long-random-secret
POSTGRES_DB=langflow
LANGFLOW_DATABASE_URL=postgresql://langflow:replace-with-a-long-random-secret@postgres:5432/langflow
LANGFLOW_CONFIG_DIR=/app/langflow
LANGFLOW_SUPERUSER_PASSWORD=replace-with-a-different-admin-secret

Use a different value for the database password and the Langflow administrator password. Keep the file readable only by the account that runs the deployment, and do not commit it to source control.

Rank #2

Sale

Docker Deep Dive

$21.61

Buy on Amazon

2. Define the services

This Compose pattern gives Langflow a persistent application-data mount and PostgreSQL a named volume. The PostgreSQL hostname in the connection string is the Compose service name, not localhost.

services:
  langflow:
    image: langflowai/langflow:1.12.0
    ports:
      - 7860:7860
    env_file:
      - .env
    environment:
      LANGFLOW_DATABASE_URL: ${LANGFLOW_DATABASE_URL}
      LANGFLOW_CONFIG_DIR: ${LANGFLOW_CONFIG_DIR}
      LANGFLOW_AUTO_LOGIN: false
      LANGFLOW_SUPERUSER_PASSWORD: ${LANGFLOW_SUPERUSER_PASSWORD}
    volumes:
      - ./langflow-data:/app/langflow
    depends_on:
      - postgres
  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - langflow-postgres:/var/lib/postgresql/data
volumes:
  langflow-postgres:

The service names, image tags, and environment keys should match the Langflow Compose example for the release you deploy. The important design is separation: application files are mounted outside the container, while database files live in a named PostgreSQL volume. Replacing the Langflow container therefore does not erase the database or flow files.

3. Start and verify the stack

1. Create a directory for the deployment, save the Compose file and .env there, and review every secret before starting.
2. Run docker compose up -d.
3. Check service status with docker compose ps and inspect startup messages with docker compose logs -f langflow.
4. Open http://localhost:7860/, sign in, create a test flow, run it, and confirm that it remains after docker compose down followed by docker compose up -d.

Do not use docker compose down -v on a deployment you intend to keep: removing volumes deletes the persistent database volume. Use it only when you deliberately want a clean reset.

Persist data, flows, and version history correctly

Langflow flows are serializable and can be saved and loaded from the installation’s filesystem. Saved versions are also stored in the deployment database, which is why a persistent PostgreSQL volume matters for version history. Mount the Langflow data directory outside the container and keep the database in a named volume or an equivalent managed persistent disk.

• Application data: mount the directory configured by LANGFLOW_CONFIG_DIR so container replacement does not remove local files.
• Flow history and metadata: keep PostgreSQL on persistent storage; an ephemeral database defeats version retention.
• Uploaded documents: identify where your flows write files and include that path in your backup plan.
• Secrets: store administrator and provider credentials in protected environment or secret-management systems, not in exported flow JSON.

Back up PostgreSQL before upgrades and before changing image profiles. Also copy the mounted Langflow data and any directories used by file-based components. Test restoring those copies on a separate instance instead of assuming that a successful database dump is a complete application backup.

Pin the image and select the correct profile

The latest tag is convenient for a first run but mutable. Production deployments should use a release tag such as langflowai/langflow:1.12.0; when reproducibility matters, pin the registry digest as well. Keep the previous image reference until the new one passes verification so you have a known rollback target.

Langflow publishes base, default, and extended image profiles. They differ in the provider and component inventory they include. Choose the smallest profile that contains every provider extension used by your flows. A smaller image reduces unnecessary packages, but omitting a required extension prevents a saved flow from running until that extension is added.

Rank #3

Docker Deep Dive: Zero to Docked in a Single Book (Guide): A Complete Beginner to Advanced Guide to Docker, Containers, DevOps, and Real-World Projects

$0.99

Buy on Amazon

Upgrade without trapping yourself

1. Export or dump the PostgreSQL database and copy mounted application data.
2. Pull the candidate image and record its tag and digest.
3. Start a temporary instance against a copy of production data, never the only live database.
4. Run smoke tests for login, flow loading, flow execution, file access, and provider credentials.
5. Keep the previous image and backup until the candidate passes all checks.
6. After a database migration, do not run an older application against that migrated database unless the downgrade path is explicitly documented.

Build your first AI workflow in Langflow

Start from a blank flow or template

Langflow lets you create a blank flow, start from a template, duplicate an existing flow, or import one. The template collection includes a Basic Prompting example and a Vector Store RAG example with separate ingestion and retrieval sub-flows. Templates are useful because they show compatible components and connections before you design your own graph.

Assemble a basic chat flow

1. Create a new blank flow or open the Basic Prompting template.
2. Add a Chat Input component to receive the user’s message.
3. Add a Prompt or instruction-template component and connect the incoming message to its text or variable port.
4. Add a Language Model component, select a provider supported by your image profile, and enter its credential through the deployment’s protected configuration.
5. Add Chat Output and connect the model response to it.
6. Run the flow with a short test message, inspect each component’s output, then save the flow and give it a versioned name.

Components are available through the Core components and Bundles menus. Connections are typed: a message port carries text intended as a message, while other ports may carry documents, embeddings, or configuration objects. If a connector refuses to attach, check that the source and destination types are compatible rather than forcing a connection.

Add retrieval-augmented generation

A RAG workflow adds a document-ingestion path and a question-answering path:

1. Use a document loader to read the files your application is allowed to access.
2. Split documents into chunks sized for the selected model and retrieval strategy.
3. Create embeddings for those chunks and write them to a vector store.
4. Connect a retriever to the vector store so a user question can fetch relevant chunks.
5. Pass the retrieved context and the user’s question into a context-aware prompt.
6. Send that prompt to the language model and return the answer through Chat Output.

The ingestion and retrieval portions can be separate sub-flows. Ensure that the Docker image profile includes the loader, embedding provider, vector-store integration, and model components you selected. If an extension is absent, a flow may import successfully but fail at execution time; install an image profile containing it, or rebuild the image with the required extension before relying on the flow.

Understand what happens at run time

Langflow validates the graph, prepares component parameters, determines dependencies, and executes nodes in dependency order. A cycle or an unconnected required input prevents a valid execution. Test from the edges inward: first confirm input, then prompt rendering, then model credentials, then retrieval, and finally output formatting. Save a working version before making structural changes so you can compare or restore it.

Package a flow into a custom image

For a repeatable hand-off, put exported flow JSON files in a project directory and build a derived image. The official pattern copies JSON files into /app/flows and sets LANGFLOW_LOAD_FLOWS_PATH:

FROM langflowai/langflow:latest
RUN mkdir /app/flows
COPY ./*.json /app/flows/
ENV LANGFLOW_LOAD_FLOWS_PATH=/app/flows

For a real deployment, replace latest with the release tag and, when required, its digest. With the Dockerfile and JSON files in the same directory, build and run the image:

Rank #4

Natmisz:Dive Log Book Scuba Diving, Scuba Log Book, Scuba Diving Equipment Accessories, Gifts For Scuba Divers Men, Leather Logbook Binder, A6 Size Binders 50 Pages

• This dive logbook is made from genuine cowhide leather, and just like fingerprints, each piece is one-of-a-kind. Each logbook flaunts its own unique personality with varying colors, textures, and markings. Over time, the leather develops its own charming "battle scars," making it even more beautiful and uniquely yours. It's like your favorite pair of jeans – the more you use it, the cooler it gets
• Its compact A6 size (5.1in x 7.5in) makes it super easy to carry around, letting you jot down your dive logs anytime, anywhere. Whether you toss it in your dive bag or take it on the go, it’s a breeze to bring along. Perfectly suited for A6 dive logs and A6 binders. Think of it as your trusty sidekick – always ready for the next adventure
• This dive logbook isn't just a pretty face – it's got some serious chops too. The genuine leather cover laughs in the face of splashes, and the 120g high-quality paper ensures your notes won't dissolve into a soggy mess. Perfect for those damp and drizzly dives
• 3 Card Slots: Perfect for stashing your dive cards, transit passes, and other important cards. 1 Zipper Pocket: Keep your valuables secure and safe. 4 Receipt Pockets: Perfect for holding tickets, passports, and other essential documents We’ve included 2 removable, expandable PVC pages: Transparent PVC Page: Holds up to 3 cards, making them easy to see and use. PVC Storage Bag: Specially designed waterproof bag for those items that just hate getting wet.
• Our dive logbook includes all the essential fields for divers to record every dive, such as date, dive site, conditions, equipment, dive stats, and dive verification, among others. With 50 pages designed to capture the key details of each dive adventure, it's perfect for PADI divers and fits the A6 size dive log requirements

$59.90

Buy on Amazon

docker build -t my-langflow:1.12.0 .
docker run -p 7860:7860 -e LANGFLOW_AUTO_LOGIN=false -e LANGFLOW_SUPERUSER_PASSWORD=replace-with-a-strong-secret my-langflow:1.12.0

You can push the tagged image to your organization’s registry when another server or deployment system needs it. Keep provider credentials out of the JSON and inject them at run time. A packaged flow is not a substitute for backing up PostgreSQL: the image distributes definitions, while the database preserves deployment state and saved versions.

Publish Langflow safely with HTTPS

Localhost is private to the machine. A public deployment adds DNS, firewall exposure, TLS certificates, authentication, and ongoing patch responsibility. Langflow’s deployment guidance describes four practical directions: a remote Docker server with Caddy as a reverse proxy, Nginx with Let’s Encrypt for automatic certificates, Kubernetes, and cloud-provider-specific guides.

Remote Docker server with a reverse proxy

Run Langflow on a server that has persistent storage, bind the application to an internal network, and let Caddy or Nginx terminate HTTPS on the public interface. Point a DNS name at the server, allow only the required web ports through the firewall, and proxy requests to the internal Langflow port. Keep PostgreSQL off the public interface.

Nginx and Let’s Encrypt

An Nginx reverse proxy can request and renew certificates through Let’s Encrypt. The proxy handles TLS while Langflow remains on the private Docker network. Verify renewal before declaring the deployment complete; an expired certificate is an outage even when the container itself is healthy.

Kubernetes or a cloud deployment

Kubernetes can provide scheduling, rolling updates, secrets, and persistent-volume abstractions, but it also adds cluster operations. Cloud-specific instructions vary by provider. Follow the provider’s guidance for managed databases, load balancers, certificate management, and secret storage rather than copying a local Compose file unchanged.

Public-deployment checklist

• Set LANGFLOW_AUTO_LOGIN=false and provide a strong LANGFLOW_SUPERUSER_PASSWORD before startup.
• Use HTTPS and redirect plain HTTP after certificate issuance.
• Restrict inbound traffic with firewall or security-group rules.
• Keep PostgreSQL and Docker’s management interface off the public network.
• Store provider credentials as secrets and rotate them if logs or exports expose them.
• Back up the database and mounted data on a schedule, then test restoration.
• Pin the image version and retain the previous image until upgrade smoke tests pass.
• Monitor container health, disk capacity, certificate expiry, and database availability.

Troubleshoot common failures

A practical operating routine

1. Develop locally with the single image or Compose, keeping flows small and testable.
2. Export a known-good flow and record the Langflow release, image profile, provider components, and required secrets.
3. Build a versioned image or deploy the pinned official image in a staging environment.
4. Restore a copy of production data, then test login, flow loading, execution, file access, and provider credentials.
5. Promote the candidate behind HTTPS only after those tests pass.
6. Keep the prior image and a verified database backup through the change window.
7. Document the image tag or digest, volume names, environment keys, proxy configuration, and recovery commands.

This sequence keeps experimentation fast while making the state that matters—flows, versions, files, and credentials—portable and recoverable.

Quick Recap

Bestseller No. 1

Docker Deep Dive: Zero to Docker in a single book

$9.99

SaleBestseller No. 2

Docker Deep Dive

$21.61

Bestseller No. 3

Docker Deep Dive: Zero to Docked in a Single Book (Guide): A Complete Beginner to Advanced Guide to Docker, Containers, DevOps, and Real-World Projects

$0.99

Bestseller No. 4

Natmisz:Dive Log Book Scuba Diving, Scuba Log Book, Scuba Diving Equipment Accessories, Gifts For Scuba Divers Men, Leather Logbook Binder, A6 Size Binders 50 Pages

$59.90

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.