# Self-host Langflow, and the open-source alternative that owns the whole system

> Self-hosting Langflow means running its own Docker image or Python package on hardware you control. Kortix, the open-source AI Operating System, adds the layer around the work: your agents, their memory, and every connector in one git repo you self-host.

URL: https://langflowalternative.com/self-host-langflow

_Commands_

## Self-hosting commands, quoted from each project's docs

Langflow publishes Docker, Compose, and Python installs; Kortix installs one stack with the `kortix self-host` command line.

### Langflow · Docker

`terminal`

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

### Langflow · Compose

`terminal`

```sh
git clone https://github.com/langflow-ai/langflow.git
cd langflow/docker_example
docker compose up
```

### Langflow · Python

`terminal`

```sh
uv venv langflow-env
source langflow-env/bin/activate
uv pip install langflow
uv run langflow run
```

### Kortix · self-host

`terminal`

```sh
curl -fsSL https://kortix.com/install | bash
kortix self-host init --domain kortix.example.com --admin-email you@example.com
kortix self-host start
```

## Self-hosting Langflow: what you run and what you still assemble

Langflow is an open-source visual builder for AI agents and workflows. Self-hosting it means running the Langflow application on a machine you control instead of a hosted service. Langflow publishes four install paths: a desktop app for macOS and Windows, a Docker image, a Python package, and a build from source. The Docker path is the common starting point. One command pulls the official image and serves the editor at http://localhost:7860, and the image ships with automatic login turned off, so it asks for a superuser password before it will run ([Langflow Docker guide](https://docs.langflow.org/deployment-docker)).

The Python path is smaller. Langflow needs Python 3.10 to 3.14 and the `uv` tool. The published minimum is a dual-core machine with 2 GB of RAM, and Langflow recommends a multi-core machine with 4 GB or more. You create a virtual environment, install the package, and start it, and the app listens on http://127.0.0.1:7860 ([Langflow install guide](https://docs.langflow.org/get-started-installation)). Teams that want the editor on a shared server usually move to the Compose path, which runs Langflow beside a PostgreSQL database with persistent volumes.

### What a self-hosted Langflow runs on

Every path lands on the same shape: a machine you own running the Langflow process, with its data in SQLite by default or in a PostgreSQL database when you use the Compose file at `docker_example/docker-compose.yml`. Upgrades keep the data and replace the image, so `docker compose pull` followed by `docker compose up -d` moves the app forward without touching the stored flows ([Langflow Docker guide](https://docs.langflow.org/deployment-docker)).

The application is the easy part to stand up. The layer around it stays yours to assemble: a reverse proxy and TLS certificate, the database, access control, secret storage, backups, and a place for agents to run once a flow leaves the editor. A Langflow flow is a saved graph of steps that the editor draws. What it does not hold is the company around the work: the agents, the memory they share, and the connectors they reach.

### What changes when the company lives in one git repo

That surrounding layer is the part Kortix takes on. Kortix is the open-source AI Operating System: your agents, their skills, your company memory, and every connector in one git repo you own, with the agents working on real cloud computers.

Self-hosting Kortix is one Docker Compose stack that the `kortix self-host` command line installs, configures, and updates. You point DNS at a Linux server, then run the bootstrap script or run `kortix self-host init` and `kortix self-host start` by hand, and sign up as the admin (see the [Kortix docs](https://kortix.com/docs/host)). The stack holds the web app, the API, the database, and the model gateway in one project. Sessions do not run on that server. Each session runs on a cloud sandbox provider you supply a key for, such as Daytona, Platinum, or E2B, and the instance stays reachable so those sandboxes can call back.

The difference is what lives in files. In Kortix, an agent is a markdown file plus a block in `kortix.yaml`, and the memory and connector definitions are files beside it. One isolated sandbox per session. Each session has its own isolated machine and branch. Session work reaches `main` through a change request. Merge is default-deny for agents, so a person reviews what an agent proposes before it lands. Run it on Kortix Cloud, in your VPC, or on your own on-prem network. Self-host is free.

That is the ownership decision. Self-hosting Langflow gives a team the flow builder on its own hardware. Self-hosting Kortix gives a team the place the agents run and the state they keep, versioned and diffable in a repository it owns.

_FAQ_

## Self-hosting Langflow and Kortix: common questions

### Do I need Docker to self-host Langflow?

No. Docker is one of four install paths. Langflow also publishes a desktop app, a Python package you run under `uv`, and a build from source. The Docker path reaches a shared server fastest because the image bundles the dependencies.

### Does a self-hosted Langflow give a team the whole company system?

It gives the flow builder on your hardware. The company layer is the part around it: the agents, the memory they share, and the connectors they reach. Kortix keeps those in one git repo you self-host.

### What does self-hosting Kortix require?

A Linux server with a public IP, DNS records for the domain and its API subdomain, ports 80 and 443 open, a key for a cloud sandbox provider, and a model key you add after the first sign-in. A wildcard record for previews is recommended on any public instance.

### Can a self-hosted Kortix use the model keys I already pay for?

Yes. Any model provider with your own keys. Or the ChatGPT plan you already pay for. Or sign in with your OpenCode Console account for OpenCode Zen and Go.

### Is Kortix open source and free to self-host?

Kortix is open source, and self-host is free. You pay only for the infrastructure you run it on and the model usage you connect.

## Run the whole company from one repo you own.

Self-host Kortix for free, or start on the managed cloud.

[Try Kortix](https://kortix.com)

Open source · Any model, your keys · Self-host, VPC, or on-prem