Cómo Instalar Langflow con Docker Compose (Guía 2026)

Langflow es un constructor visual open-source para agentes y flujos de trabajo IA. Está en la versión 1.12.5 (publicada el 06-10-2026), con 1.13.x en desarrollo, unas 155k estrellas en GitHub, y licencia MIT. Cada flujo que construyes puede correr como API o como servidor MCP, y la librería de componentes cubre todos los LLM principales, bases de datos vectoriales y un conjunto creciente de herramientas IA.

Esta guía cubre cómo instalar Langflow con Docker Compose y PostgreSQL, exponerlo sobre un Cloudflare Tunnel con SSL delante, y endurecer el despliegue contra los CVE de 2026. Esa última parte importa. Langflow ejecuta código por diseño, y una instancia pública corriendo una imagen latest vieja es un objetivo de ejecución remota de código. Fija la versión, pon una capa de acceso delante, y mantén la imagen al día.

¿Qué es Langflow?

Langflow es un IDE de arrastrar y soltar para pipelines de IA. Cableas componentes en un lienzo, y cada componente es una clase Python que puedes abrir y editar en el navegador. Más allá del constructor, el proyecto trae un playground para probar flujos, orquestación multi-agente, y una historia de despliegue: cualquier flujo puede correr como API REST o como servidor MCP (mira qué es MCP (Model Context Protocol) si el término es nuevo). Para observabilidad, Langflow exporta trazas a LangSmith o LangFuse vía OTLP; puedes self-hostear Langfuse como alternativa a LangSmith y mantener los datos en tu propia máquina. También existe Langflow Desktop para Windows y macOS, y las instalaciones pip soportan Python 3.10 a 3.14.

La línea 1.12.x ha sido de endurecimiento y estructura: fundamentos de RBAC, Knowledge Bases unificadas sobre backends de bases de datos vectoriales comunes, exportación de telemetría OTLP, y (a partir de 1.12.5) ejecución de código integrada restringida a administradores.

Langflow vs Flowise en 2026

Ambos proyectos intentan hacer visual la construcción de flujos IA, y ambos han madurado. Al 10-10-2026, Langflow 1.12.5 tiene 155.451 estrellas en GitHub; Flowise 3.1.4 (publicado el 29-07-2026) tiene 55.495. Las estrellas no lo son todo, pero la brecha sigue dónde invierte cada proyecto.

Cuál encaja depende del proyecto. Ambos merecen una tarde de clics. Notas de montaje completas del otro lado: How to Install FlowiseAI with Docker Compose. Si quieres el panorama más amplio de automatización, también puedes self-hostear n8n para automatización de flujos; n8n maneja la automatización de flujos general mientras Langflow se mantiene centrado en flujos IA.

Si te interesa ver algunas apps self-hosted open source gratuitas y chulas puedes mirar la sección self-hosted de toolhunt.net.

Instala Langflow con Docker Compose

Los pasos de abajo te dan un Langflow 1.12.5 fijado con PostgreSQL, volúmenes nombrados persistentes y un runtime sin root. El vídeo recorre el mismo flujo:

Nota: el vídeo se grabó sobre la UI 1.x. Los pasos son los mismos, la interfaz ha cambiado.

1. Prerequisitos

Antes de empezar, asegúrate de que lo siguiente ya existe:

Para el propio VPS, uso máquinas de Hetzner para este tipo de carga (Hetzner Cloud) y Hostinger cuando quiero un proveedor o región distinta. Si prefieres no alquilar, un Mini PC como Home Server como el ASUS mini PC basta para una instancia Langflow de un solo usuario.

Los precios de VPS saltaron en bloque en 2026. Si estás replanteándote una máquina alquilada, mira qué cambió y cuándo gana un mini PC.

También puedes usar Traefik como reverse proxy para tus apps. He creado un tutorial completo con instalación de Dockge también para gestionar tus contenedores: How to Use Traefik as A Reverse Proxy in Docker

2. El archivo Docker Compose

services:
  langflow-db:
    image: postgres:16-trixie   # pinned base; don't swap in -alpine under an existing volume
    container_name: Langflow-DB
    hostname: langflow-db
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
    volumes:
      - langflow-db:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    restart: on-failure:5

  langflow:
    image: langflowai/langflow:1.12.5   # pin; bump deliberately. (:latest + pull_policy: always = auto)
    container_name: Langflow
    # no user: root; image runs as uid 1000 and /app/langflow is pre-chowned
    ports:
      # bind to loopback only; cloudflared on this host dials 127.0.0.1:5060.
      # "5060:7860" without the prefix publishes 0.0.0.0 and bypasses Cloudflare Access.
      - "127.0.0.1:5060:7860"
    healthcheck:
      test: timeout 10s bash -c ':> /dev/tcp/127.0.0.1/7860' || exit 1
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 90s
    restart: on-failure:5
    depends_on:
      langflow-db:
        condition: service_healthy
    environment:
      LANGFLOW_DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@langflow-db:5432/${POSTGRES_DB}
      LANGFLOW_CONFIG_DIR: /app/langflow
      LANGFLOW_AUTO_LOGIN: "False"
      LANGFLOW_SUPERUSER_PASSWORD: ${LANGFLOW_SUPERUSER_PASSWORD:?set it in .env}
    volumes:
      - langflow-data:/app/langflow

volumes:
  langflow-db:
  langflow-data:

Dos servicios, mismo layout que antes: langflow-db corre PostgreSQL, langflow corre la app. Qué cambió frente a la versión 2024 de este archivo, y por qué:

1. postgres:16-trixie reemplaza a postgres:16-alpine. El ejemplo oficial fija trixie a propósito: evita avisos de desajuste de versión de collation de glibc en volúmenes existentes (issue #9608 de langflow). Alpine usa musl, así que apuntar una imagen Postgres basada en Debian a un volumen creado por la imagen alpine no es una operación segura en sitio.

2. Los volúmenes nombrados (langflow-db, langflow-data) reemplazan los bind mounts. Las actualizaciones entonces solo reemplazan la imagen del contenedor y los volúmenes se reconectan. Si migras desde bind mounts, haz chown -R 1000:0 al directorio de datos primero (mira los modos de fallo de abajo).

3. LANGFLOW_CONFIG_DIR es ahora /app/langflow. Este directorio contiene logs, almacenamiento de archivos, datos de monitorización y claves secretas. La imagen lo pre-crea y le hace chown a uid 1000. La vieja ruta /var/lib/langflow sigue funcionando pero ya no es la ubicación documentada.

4. La imagen está fijada en langflowai/langflow:1.12.5. Fijar te da actualizaciones controladas en tu calendario. Si prefieres auto-actualizaciones, usa langflowai/langflow:latest con pull_policy: always, a costa de cambios sorpresa.

5. No hay user: root. Las imágenes actuales corren como uid 1000 (gid 0). /app/langflow está pre-chowned, así que el volumen nombrado funciona sin juegos de permisos extra.

6. depends_on: condition: service_healthy está puesto. El contenedor Langflow espera al healthcheck de Postgres en vez de hacerle carrera y hacer crash-loop por una base de datos ausente.

7. La contraseña usa sintaxis de variable requerida. ${LANGFLOW_SUPERUSER_PASSWORD:?set it in .env} hace que docker compose up falle rápido si falta la variable, en vez de arrancar con una contraseña vacía. La variable de nombre de usuario LANGFLOW_SUPERUSER sigue existiendo, pero los ejemplos oficiales solo ponen la contraseña; deja el default a menos que necesites un usuario específico.

El archivo de referencia oficial vive en el docker_example de langflow.

Modos de fallo comunes en este paso:

• Puerto 5060 ya asignado. Cambia el lado del host del mapeo a algo libre (por ejemplo 127.0.0.1:5061:7860) o encuentra al ocupante con docker ps y ss -lntp | grep 5060.
• Colisiones de nombre de proyecto compose. Dos stacks desplegados desde el mismo nombre de proyecto reutilizarán redes y volúmenes. Fija uno con docker compose -p langflow up -d.
• Permission denied en el directorio de datos. Viejos bind mounts (./langflow) propiedad de root frente al uid 1000 de la imagen. Ejecuta chown -R 1000:0 ./langflow o cambia al volumen nombrado langflow-data.

3. El archivo .env de Langflow

Crea un archivo .env en el mismo directorio que el archivo compose:

POSTGRES_USER='user'
POSTGRES_PASSWORD='use-a-long-random-password'
POSTGRES_DB='langflow'
LANGFLOW_SUPERUSER_PASSWORD='use-a-long-random-password'

Genera las contraseñas en vez de inventarlas:

openssl rand -base64 24

LANGFLOW_SUPERUSER_PASSWORD es la única variable Langflow requerida aquí: compose se niega a arrancar sin ella gracias a la sintaxis :?. Esa contraseña es lo que escribirás en el login de la UI.

Un .env a pelo está bien para un VPS de operador único con permisos de filesystem bloqueados. Si varias personas necesitan acceso a la config de despliegue, mira secretos de Docker Compose y alternativas más seguras a archivos .env planos para un manejo de secretos en condiciones.

4. Despliega el stack

Con el archivo compose y el .env en su sitio, desde el mismo directorio:

docker compose up -d

Sigue el primer arranque mientras corre las migraciones de base de datos:

docker compose logs -f langflow

El primer arranque puede tardar un minuto o dos. El healthcheck permite un periodo de arranque de 90 segundos exactamente por eso. Cuando el log se asiente y docker compose ps muestre ambos servicios arriba sin contador de reinicios subiendo, verifica en condiciones.

5. Verifica el despliegue

No asumas que los contenedores están felices porque up -d devolvió. Comprueba:

Sobre la huella: la imagen de Langflow pesa unos 800 MB comprimida (amd64), más Postgres y lo que los flujos carguen en memoria. Cómodo en un VPS de 2 GB, justo en 1 GB. Eso es guía de prácticante, no un benchmark.

Si la sintaxis del healthcheck te molesta, la imagen trae curl, así que curl -f http://localhost:7860/health || exit 1 es una alternativa válida al check bash /dev/tcp de arriba. La base UBI10 también incluye bash.

Elegir una imagen Docker de Langflow

Desde 1.12.x, Langflow publica tres perfiles de imagen (mira los docs oficiales de perfiles de imagen):

Los tres perfiles corren como uid 1000 sin root, tienen LANGFLOW_AUTO_LOGIN=false horneado, no traen PyTorch, y están espejados en GHCR (ghcr.io/langflow-ai/langflow[:all]). Los viejos tags core-* se han ido; no hay imagen langflow-core en 1.12.x.

Sobre fijar frente a latest: fija 1.12.5 si el despliegue tiene datos que te importan (mi default), y usa latest más pull_policy: always solo para experimentos desechables. Cada imagen pesa unos 801 MB amd64 / 725 MB arm64, así que ejecuta docker image prune -f tras cada subida para recuperar las capas viejas.

Añade SSL sobre un Cloudflare Tunnel

Cloudflare Tunnels conectan la app a internet sin direcciones IP públicas ni puertos entrantes abiertos. La mecánica es simple: cloudflared corre en tu servidor y marca hacia el edge de Cloudflare. Esa conexión saliente es el tunnel entre tu origen y el edge. Las peticiones a tu dominio bajan por el tunnel al origen, y las respuestas vuelven por el mismo camino.

Sin port forwarding, sin agujeros de firewall para tráfico entrante. TLS termina en Cloudflare.

Browser --HTTPS--> Cloudflare Edge  (TLS terminates here)
                        |
                        |  outbound only: cloudflared dials out
                        v
                  cloudflared daemon
                        |
                        |  http://127.0.0.1:5060
                        v
              Langflow container :7860  (uid 1000)
                        |
                        |  postgresql://langflow-db:5432
                        v
                 Postgres  (named volume langflow-db)

Sin puertos entrantes: cloudflared marca hacia fuera; TLS termina en Cloudflare.

Si no quieres Cloudflare en el camino, hay una alternativa self-hosted a Cloudflare Tunnels (Pangolin). La ruta del reverse proxy también funciona: Setup CloudPanel As Reverse Proxy with Docker and Dockge o How to Use Traefik as A Reverse Proxy in Docker. Para otra app expuesta con el mismo patrón de tunnel, mira Cloudreve with Docker and Cloudflare Tunnels.

Apunta un hostname a Langflow

En el panel de Cloudflare Zero Trust, abre Access -> Tunnels, elige el tunnel que creaste para el servidor, y añade un hostname público:

1. Pon el subdominio y dominio, por ejemplo langflow.yourdomain.com.
2. Pon el servicio en http://127.0.0.1:5060, o http://langflow:5060 si cloudflared comparte una red Docker con el contenedor.
3. Guarda. Cloudflare crea el registro DNS por ti.

Verifica desde fuera: curl -I https://langflow.yourdomain.com debería devolver una respuesta con server: cloudflare, y un navegador en esa URL debería mostrar un certificado válido más la página de login de Langflow:

Modos de fallo en una línea cada uno: un 502 o 503 del tunnel significa que la URL del servicio o el puerto están mal; un hostname que no resuelve significa que el registro DNS no se creó; “Bad Gateway” significa que el contenedor no está escuchando en el 7860. Y si la app responde en http://your-server-ip:5060 desde tu portátil, el puerto está publicado en 0.0.0.0, lo que pone Langflow en internet sin Access en el camino. Mantén el prefijo 127.0.0.1: del archivo compose y confirma con ss -lntp | grep 5060 que el listener está en 127.0.0.1.

Pon Cloudflare Access delante de Langflow

Un tunnel oculta tu IP de origen pero sigue publicando la aplicación en internet. Añade Cloudflare Access delante:

1. En Zero Trust, abre Access -> Applications y añade una aplicación self-hosted para langflow.yourdomain.com.
2. Pon una política. Email OTP es lo más simple; un IdP (Google, GitHub, Okta) funciona si ya tienes uno.
3. Pruébalo: al cargar el hostname ahora debería pedir el PIN de un solo uso (o login de IdP) antes de que aparezca la propia página de login de Langflow.

Capas Access y el login de Langflow una encima de otra, no una en vez de la otra. Las etiquetas del panel de Cloudflare cambian con el tiempo, así que si un nombre de botón de arriba no coincide con lo que ves, sigue los docs actuales de Cloudflare Access para aplicaciones self-hosted.

Asegura tu Langflow self-hosted

Los propios docs de Langflow son directos sobre el modelo: la UI es un IDE y una plataforma de ejecución de código. El editor de código corre Python arbitrario con acceso al proceso host, filesystem y red. El aislamiento multi-tenant no es una función de la aplicación; es trabajo de la infraestructura.

2026 concretó el riesgo. Los advisories de seguridad de GitHub del proyecto incluyen:

• CVE-2026-33017 (crítico, 16-03-2026): RCE sin autenticación vía el endpoint público de build de flujos.
• CVE-2026-33873 (crítico, 24-03-2026): ejecución de código autenticada en la validación del asistente agéntico.
• CVE-2026-55255 (crítico, 19-06-2026): IDOR en /api/v1/responses dando acceso a flujos entre usuarios.
• GHSA-jxw3-mjmx-3pqm (crítico, 12-08-2026): clave Fernet débil generada vía random.seed().
• CVE-2026-105740 (crítico, 10-09-2026): RCE autenticada a través del transporte stdio de MCP.
• Altos y medios encima: CVE-2026-33760 (IDOR en Monitor API), CVE-2026-105699 (filtrado de archivos entre proyectos), CVE-2026-42867 (path traversal en la KB API), GHSA-j8f7-x8jm-wmm4 (SSRF en componentes de URL).

El proyecto parchea rápido (de 1.12.1 a 1.12.5 en cinco semanas), lo que es buena noticia solo si haces pull de las actualizaciones.

Checklist de endurecimiento:

# optional: block custom components / code editor (beta, not a complete safeguard)
LANGFLOW_ALLOW_CUSTOM_COMPONENTS=false
# optional: custom components become superuser-only
LANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY=true

Actualizar Langflow sin perder datos

Los datos viven en los volúmenes; la imagen es reemplazable. El flujo de actualización oficial es deliberadamente aburrido:

# edit the image tag in docker-compose.yml, e.g. 1.12.5 -> 1.12.6
docker compose pull
docker compose up -d
docker compose ps          # both healthy
docker image prune -f      # optional, reclaim ~800 MB per old image

Los volúmenes se reconectan. La base de datos y tus flujos sobreviven.

El rollback es lo mismo al revés: vuelve a fijar el tag de imagen anterior y corre docker compose up -d. Los volúmenes no los toca un cambio de imagen, así que una actualización de la que te arrepientas está a una edición de tag de deshacerse.

Tres avisos de los que las notas de versión no te salvarán:

1. Postgres de alpine a trixie. Si seguiste la versión 2024 de esta guía, tu volumen fue creado por postgres:16-alpine. No le apuntes postgres:16-trixie. Vuelca y restaura en su lugar:

docker compose exec langflow-db pg_dump -U user langflow > langflow-backup.sql
# switch image to postgres:16-trixie + a fresh named volume, then:
docker compose up -d langflow-db
cat langflow-backup.sql | docker compose exec -T langflow-db psql -U user -d langflow

El salto de musl a glibc encima de los problemas de collation por los que el repo oficial fijó trixie (issue #9608) no es algo con lo que apostar una base de datos.

2. Cambio de ruta de LANGFLOW_CONFIG_DIR (/var/lib/langflow a /app/langflow). Este directorio contiene logs, subidas, datos de monitorización y claves secretas. Copia el contenido antes de cambiar de ruta. Si las claves se regeneran, el peor caso es re-autenticarse y volver a introducir credenciales almacenadas; los flujos viven en Postgres y sobreviven de todos modos.

3. Precedencia de Compose v2. Los valores literales en environment: ganan a .env. Si los valores están hardcodeados en el archivo compose, editar .env no los sobrescribirá.

Verificación del día de actualización:

docker compose ps
docker compose logs langflow | head
docker compose exec langflow-db psql -U user -d langflow -c 'SELECT count(*) FROM flow;'

Más una comprobación de versión en la UI y una ejecución de prueba de un flujo real antes de darlo por terminado.

Backups y monitorización

Dos cosas importan aquí: la base de datos (flujos, usuarios, historial de chat) y el directorio de config (subidas, logs, claves secretas). Programa el volcado:

docker compose exec langflow-db pg_dump -U user langflow > backup-$(date +%F).sql

Para monitorización, vigila CPU, memoria, disco y los propios contenedores (How to Monitor Server & Docker Resources). Langflow 1.12.x también puede exportar telemetría OTLP a cualquier backend si quieres trazas junto a métricas.

Sobre escalado: el default es un solo worker con una cola de build en memoria, que es el tamaño correcto para una persona o un equipo pequeño. Si necesitas más, los docs oficiales de multi-worker cubren LANGFLOW_WORKERS más una cola Redis (LANGFLOW_JOB_QUEUE_TYPE=redis, LANGQUEUE_REDIS_QUEUE_URL, cola en Redis DB 1). Fuera de alcance de este montaje; no empieces por ahí.

Presupuesta una subida de imagen mensual como parte de la rutina. Langflow cortó de 1.12.0 a 1.12.5 en cinco semanas, y algunas de esas releases fueron correcciones de seguridad.

Conclusiones

Ya tienes Langflow 1.12.5 corriendo en Docker Compose con PostgreSQL, SSL sobre un Cloudflare Tunnel con una capa de Access delante, y una base de endurecimiento apropiada para una plataforma de ejecución de código accesible desde internet. Próximos pasos: construye un flujo real, prueba a desplegarlo como API o servidor MCP, y pon la subida de imagen en un calendario para que las divulgaciones de CVE se conviertan en una tarea de cinco minutos en vez de un incidente.

Si quieres explorar más contenedores Docker para tu home server, mira nuestra guía de los mejores 100+ contenedores Docker para home server. Langflow también se sienta junto a n8n, Dify y el resto del stack de agentes en top AI GitHub repos.