Skip to main content

Deploy Langflow on Docker

tip

Podman can be used instead of Docker for all commands shown here. For more information, see the Podman documentation.

Running applications in Docker containers ensures consistent behavior across different systems and eliminates dependency conflicts.

You can use the Langflow Docker image to start a Langflow container.

This guide demonstrates several ways to deploy Langflow with Docker and Docker Compose:

  • Quickstart: Start a Langflow container with default values.
  • Use Docker Compose: Clone the Langflow repo, and then use Docker Compose to build the Langflow Docker container. This option provides more control over the configuration, including a persistent PostgreSQL database service, while still using the base Langflow Docker image.
  • Create a custom flow image: Use a Dockerfile to package a flow as a Docker image.
  • Create a custom Langflow image: Use a Dockerfile to package a custom Langflow Docker image that includes your own code, custom dependencies, or other modifications.
  • Upgrade the Langflow Docker image: Upgrade to a newer image without losing your database or flows by using persistent volumes and replacing only the container.

Quickstart: Start a Langflow container with default values​

With Docker installed and running on your system, run the following command:


_10
docker run -p 7860:7860 langflowai/langflow:latest

Then, access Langflow at http://localhost:7860/.

This container runs a pre-built Docker image with default settings. For more control over the configuration, see Clone the repo and run the Langflow Docker container.

Clone the repo and run the Langflow Docker container​

Cloning the Langflow repository and using Docker Compose gives you more control over your configuration, allowing you to customize environment variables, use a persistent PostgreSQL database service (instead of the default SQLite database), and include custom dependencies.

The default deployment with Docker Compose includes the following:

  • Langflow service: Runs the latest Langflow image with PostgreSQL as the database.
  • PostgreSQL service: Provides persistent data storage for flows, users, and settings.
  • Persistent volumes: Ensures your data survives container restarts.

The complete Docker Compose configuration is available in docker_example/docker-compose.yml.

  1. Clone the Langflow repository:


    _10
    git clone https://github.com/langflow-ai/langflow.git

  2. Navigate to the docker_example directory:


    _10
    cd langflow/docker_example

  3. Run the Docker Compose file:


    _10
    docker compose up

  4. Access Langflow at http://localhost:7860/.

Customize your deployment​

You can customize the Docker Compose configuration to fit your specific deployment.

For example, to configure the container's database credentials using a .env file, do the following:

  1. Create a .env file with your database credentials in the same directory as docker-compose.yml:


    _10
    # Database credentials
    _10
    POSTGRES_USER=myuser
    _10
    POSTGRES_PASSWORD=mypassword
    _10
    POSTGRES_DB=langflow
    _10
    _10
    # Langflow configuration
    _10
    LANGFLOW_DATABASE_URL=postgresql://myuser:mypassword@postgres:5432/langflow
    _10
    LANGFLOW_CONFIG_DIR=/app/langflow

  2. Modify the docker-compose.yml file to reference the .env file for both the langflow and postgres services:


    _10
    services:
    _10
    langflow:
    _10
    environment:
    _10
    - LANGFLOW_DATABASE_URL=${LANGFLOW_DATABASE_URL}
    _10
    - LANGFLOW_CONFIG_DIR=${LANGFLOW_CONFIG_DIR}
    _10
    postgres:
    _10
    environment:
    _10
    - POSTGRES_USER=${POSTGRES_USER}
    _10
    - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    _10
    - POSTGRES_DB=${POSTGRES_DB}

For a complete list of available environment variables, see Langflow environment variables.

For more customization options, see Customize the Langflow Docker image with your own code.

Package your flow as a Docker image​

This section shows you how to create a Dockerfile that builds a Docker image containing your Langflow flow. This approach is useful when you want to distribute a specific flow as a standalone container or deploy it to environments like Kubernetes.

Unlike the previous sections that use pre-built images, this method builds a custom image with your flow embedded inside it.

  1. Create a project directory, and change directory into it.


    _10
    mkdir langflow-custom && cd langflow-custom

  2. Add your flow's JSON file to the directory. You can download an example, or use your own:


    _10
    # Download an example flow
    _10
    wget https://raw.githubusercontent.com/langflow-ai/langflow-helm-charts/refs/heads/main/examples/flows/basic-prompting-hello-world.json
    _10
    _10
    # Or copy your own flow file
    _10
    cp /path/to/your/flow.json .

  3. Create a Dockerfile to build your custom image:


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

This Dockerfile uses the official Langflow image as the base, creates a directory for your flows, copies your JSON flow files into the directory, and sets the environment variable to tell Langflow where to find the flows.

  1. Build and test your custom image:


    _10
    docker build -t myuser/langflow-custom:1.0.0 .
    _10
    docker run -p 7860:7860 myuser/langflow-custom:1.0.0

  2. Push your image to Docker Hub (optional):


    _10
    docker push myuser/langflow-custom:1.0.0

Your custom image now contains your flow and can be deployed anywhere Docker runs. For Kubernetes deployment, see Deploy the Langflow production environment on Kubernetes.

Customize the Langflow Docker image with your own code​

While the previous section showed how to package a flow with a Docker image, this section shows how to customize the Langflow application itself. This is useful when you need to add custom Python packages or dependencies, modify Langflow's configuration or settings, include custom components or tools, or add your own code to extend Langflow's functionality.

This example demonstrates how to customize the Message History component, but the same approach can be used for any code modifications.


_27
FROM langflowai/langflow:latest
_27
_27
# Set working directory
_27
WORKDIR /app
_27
_27
# Copy your modified memory component
_27
COPY src/lfx/src/lfx/components/helpers/memory.py /tmp/memory.py
_27
_27
# Find the site-packages directory where langflow is installed
_27
RUN python -c "import site; print(site.getsitepackages()[0])" > /tmp/site_packages.txt
_27
_27
# Replace the file in the site-packages location
_27
RUN SITE_PACKAGES=$(cat /tmp/site_packages.txt) && \
_27
echo "Site packages at: $SITE_PACKAGES" && \
_27
mkdir -p "$SITE_PACKAGES/langflow/components/helpers" && \
_27
cp /tmp/memory.py "$SITE_PACKAGES/langflow/components/helpers/"
_27
_27
# Clear Python cache in the site-packages directory only
_27
RUN SITE_PACKAGES=$(cat /tmp/site_packages.txt) && \
_27
find "$SITE_PACKAGES" -name "*.pyc" -delete && \
_27
find "$SITE_PACKAGES" -name "__pycache__" -type d -exec rm -rf {} +
_27
_27
# Expose the default Langflow port
_27
EXPOSE 7860
_27
_27
# Command to run Langflow
_27
CMD ["python", "-m", "langflow", "run", "--host", "0.0.0.0", "--port", "7860"]

To use this custom Dockerfile, do the following:

  1. Create a directory for your custom Langflow setup:


    _10
    mkdir langflow-custom && cd langflow-custom

  2. Create the necessary directory structure for your custom code. In this example, Langflow expects memory.py to exist in the /helpers directory, so you create a directory in that location.


    _10
    mkdir -p src/lfx/src/lfx/components/helpers

  3. Place your modified memory.py file in the /helpers directory.

  4. Create a new file named Dockerfile in your langflow-custom directory, and then copy the Dockerfile contents shown above into it.

  5. Build and run the image:


    _10
    docker build -t myuser/langflow-custom:1.0.0 .
    _10
    docker run -p 7860:7860 myuser/langflow-custom:1.0.0

This approach can be adapted for any other components or custom code you want to add to Langflow by modifying the file paths and component names.

Upgrade the Langflow Docker image​

To upgrade a Langflow Docker deployment without losing your database or flows, do the following:

  1. Keep data on persistent volumes, so when you upgrade Langflow, you will replace only the container image. Use Docker volumes or bind mounts for Langflow data and the database so they persist outside of the container. For example, this Docker Compose file uses a bind mount for Langflow data (./langflow-data on the host) and a named volume for the PostgreSQL database (langflow-postgres):


    _14
    services:
    _14
    langflow:
    _14
    image: langflowai/langflow:1.8.0
    _14
    environment:
    _14
    - LANGFLOW_CONFIG_DIR=/app/langflow
    _14
    volumes:
    _14
    - ./langflow-data:/app/langflow
    _14
    postgres:
    _14
    image: postgres:16
    _14
    volumes:
    _14
    - langflow-postgres:/var/lib/postgresql/data
    _14
    _14
    volumes:
    _14
    langflow-postgres:

    For additional examples, see the Docker Compose configuration and the docker_example compose file.

  2. Pull the new image and update the image tag in your docker-compose.yml or docker run command.

    With Docker Compose, set the image in your compose file, such as image: langflowai/langflow:1.8.0, and then pull:


    _10
    docker compose pull

    With docker run, pull the image:


    _10
    docker pull langflowai/langflow:1.8.0

  3. Restart the container. The same volumes will be reattached, so your database and flows are preserved.

    With Docker Compose:


    _10
    docker compose up -d

    With docker run, use the same volume mount and the new image tag:


    _10
    docker run -p 7860:7860 -v langflow-data:/app/langflow langflowai/langflow:1.8.0

This approach keeps the persistent volumes separate from the Langflow container, so you can upgrade the Langflow application without losing data.

If you need to upgrade to a custom image based on a Langflow release, such as to add uv in 1.8.0, first build a derived image from the official image, and then follow the same steps above. Set the custom image in your compose file or docker run, and then pull and restart.

For a minimal Dockerfile that adds uv to the 1.8.0 image, see the release notes (“Docker image no longer includes uv or uvx”).

Search