Alojar LangFlow en un VPS: guía completa con Docker y HTTPS

LangFlow responde a un caso de uso preciso: diseñar pipelines de IA arrastrando y soltando componentes — modelos LLM, retrievers, prompts, memoria, agentes — y probarlos después sin escribir una sola línea de código. Es la alternativa visual a LangChain en modo solo código, pensada para los equipos que quieren iterar rápido antes de fijar una lógica en Python.

En un VPS obtiene una instancia estable y persistente, accesible para todo el equipo, a diferencia de una instalación local que desaparece al reiniciar. Sus flujos codifican a menudo una lógica de negocio sensible — cadenas de prompts, claves API, conectores hacia sus bases de datos. Estos datos no deben transitar por un SaaS cuya política de retención usted no controla.

LangFlow se apoya en FastAPI en el lado del servidor y expone cada flujo como un endpoint REST: sus aplicaciones pueden llamar directamente a sus pipelines de IA, sin código intermedio. Es esta combinación — interfaz visual para el diseño, API para la integración — la que lo convierte en una herramienta de prototipado seria para casos como el RAG documental, los chatbots de asistencia, los agentes multi-etapa o los pipelines de clasificación.

LangFlow consume más memoria que una herramienta web clásica: su motor de ejecución carga modelos y embeddings en RAM. Prevea como mínimo 2 vCPU y 4 GB de RAM para un uso cómodo. Si conecta un modelo Ollama local para la inferencia en el mismo VPS, suba a 8 GB como mínimo.

En el plano del software, necesita Docker (versión 24 o superior) y Docker Compose v2, instalados y en funcionamiento. El puerto 7860 debe ser accesible en local (LangFlow escucha en ese puerto por defecto). No exponga este puerto directamente a Internet: el reverse proxy nginx se encarga de ello.

Prepare un subdominio que apunte a la IP de su VPS — por ejemplo langflow.su-dominio.com — con los registros DNS ya propagados antes de lanzar certbot. Por último, la base de datos PostgreSQL es muy recomendable en producción: el SQLite predeterminado se corrompe bajo carga concurrente y no soporta el acceso simultáneo de varios usuarios.

Cada flujo LangFlow es accesible mediante el endpoint /api/v1/run/<flow-id>. Encuentre el identificador del flujo en la URL del editor o en el menú API del flujo. Dos ejemplos concretos.

Con curl:

curl -s -X POST \
  https://langflow.su-dominio.com/api/v1/run/SU-FLOW-ID \
  -H "Content-Type: application/json" \
  -H "x-api-key: SU-CLAVE-API" \
  -d '{
    "input_value": "¿Cuál es la capital de Francia?",
    "input_type": "chat",
    "output_type": "chat"
  }'

Con Python (biblioteca requests):

import requests

FLOW_ID = "SU-FLOW-ID"
BASE_URL = "https://langflow.su-dominio.com"
API_KEY = "SU-CLAVE-API"

response = requests.post(
    f"{BASE_URL}/api/v1/run/{FLOW_ID}",
    headers={
        "Content-Type": "application/json",
        "x-api-key": API_KEY,
    },
    json={
        "input_value": "¿Cuál es la capital de Francia?",
        "input_type": "chat",
        "output_type": "chat",
    },
    timeout=60,
)

result = response.json()
print(result["outputs"][0]["outputs"][0]["results"]["message"]["text"])

La clave API se genera en Settings → API Keys de la interfaz LangFlow. Autentifica cada llamada y puede revocarse en cualquier momento sin tocar el flujo. Para llamadas desde un servicio Node.js, la estructura es idéntica con fetch o axios — el endpoint REST es agnóstico al lenguaje.

El RAG (Retrieval-Augmented Generation) es el caso de uso central de LangFlow: carga documentos (PDF, texto, Markdown), los divide en fragmentos, los embebe en una base vectorial y un LLM responde preguntas usando ese contexto.

¿Qué VectorStore en un VPS? En un servidor con recursos limitados, Chroma (ChromaDB) es la opción más liviana: se ejecuta en el mismo contenedor LangFlow sin servicio adicional y persiste sus datos en un directorio local. Qdrant es adecuado si dispone de más RAM y quiere un servicio dedicado en un contenedor vecino.

Construir el pipeline de indexación en LangFlow:

En el editor, ensamble la siguiente cadena arrastrando los componentes:

1. File (o Directory) → carga el PDF o la carpeta de documentos.
2. Split Text → divide en fragmentos (tamaño recomendado: 500 a 800 tokens, superposición 50).
3. OpenAI Embeddings (u Ollama Embeddings para permanecer completamente local) → transforma cada fragmento en un vector.
4. Chroma DB → almacena los vectores. Apunte el campo Persist Directory hacia un volumen montado en Docker para que el índice sobreviva a los reinicios.

Para el volumen Chroma, añada en su docker-compose.yml:

  langflow:
    volumes:
      - chromadb:/data/chroma

volumes:
  pgdata:
  chromadb:

Y defina en LangFlow la variable global CHROMA_PERSIST_DIR con el valor /data/chroma.

Pipeline de consulta:

Una vez poblado el índice, cree un segundo flujo (o una rama del mismo): Text Input → Chroma DB (en modo búsqueda, con el mismo directorio) → Prompt (inyecte los fragmentos recuperados) → LLM → Chat Output. Cada pregunta desencadena una búsqueda vectorial, recupera los pasajes más cercanos y los envía al modelo con el contexto.

LangFlow permite crear componentes Python a medida sin bifurcar el proyecto. Un componente es una clase que hereda de Component y declara sus entradas, sus salidas y su lógica.

Ejemplo mínimo — un componente que limpia y convierte el texto a mayúsculas:

from langflow.custom import Component
from langflow.io import MessageTextInput, Output
from langflow.schema import Data

class UpperCaseComponent(Component):
    display_name = "Uppercase Text"
    description = "Convierte el texto a mayúsculas."

    inputs = [
        MessageTextInput(
            name="input_text",
            display_name="Texto de entrada",
        )
    ]

    outputs = [
        Output(
            display_name="Texto procesado",
            name="output_text",
            method="process_text",
        )
    ]

    def process_text(self) -> Data:
        result = self.input_text.strip().upper()
        return Data(text=result)

Para añadir este componente a su instancia: en la interfaz LangFlow, vaya a Settings → Custom Components, pegue el código y guarde. El componente aparece de inmediato en la barra lateral, listo para arrastrarlo a cualquier flujo. Puede encapsular así cualquier lógica de negocio — llamada a una API interna, transformación de datos, acceso a una base propia — y exponerla como un bloque reutilizable en todos sus flujos.

LangFlow publica actualizaciones con regularidad (la rama 1.x es la rama estable activa en octubre de 2026). Antes de cualquier actualización, haga sistemáticamente una copia de seguridad de la base:

docker exec langflow-postgres-1 pg_dump -U langflow langflow \
  > /opt/backups/langflow-antes-actualizacion-$(date +%F).sql

Actualice la imagen y reinicie la stack:

cd /opt/langflow
docker compose pull
docker compose up -d

Siga los logs para detectar posibles migraciones automáticas del esquema:

docker compose logs -f langflow

Puntos de atención en las actualizaciones v1.x. Las versiones 1.x pueden incluir migraciones de base de datos (el contenedor las aplica al arrancar). Si un flujo deja de funcionar tras la actualización, consulte el CHANGELOG en GitHub (langflow-ai/langflow) para identificar los breaking changes: algunos componentes se renombran o refactorizan entre versiones menores. Exporte sus flujos en JSON antes de la actualización — es la forma más rápida de restaurarlos a un estado conocido si una migración causa problemas.

Si desea fijar una versión concreta (recomendado en producción), sustituya latest por el tag deseado en su docker-compose.yml:

image: langflowai/langflow:1.12.4

LangFlow expone varias variables de entorno para adaptar la instancia a su contexto. LANGFLOW_SECRET_KEY cifra los datos sensibles almacenados en base de datos — cambie el valor por defecto antes del primer arranque, pues una rotación posterior invalida los datos cifrados existentes. LANGFLOW_AUTO_LOGIN en false obliga siempre a un inicio de sesión explícito, incluso desde localhost. LANGFLOW_WORKERS controla el número de procesos Uvicorn: el valor predeterminado (1) es adecuado para un uso moderado; auméntelo a 2 o 4 si varios usuarios ejecutan flujos simultáneamente.

Para los flujos que llaman a modelos locales mediante Ollama, defina OLLAMA_BASE_URL en las variables globales de LangFlow en lugar de en el entorno Docker: el valor se gestiona entonces desde la interfaz y puede cambiarse sin reinicio.

Si actualiza LangFlow, haga siempre un pg_dump antes de docker compose pull && docker compose up -d: algunas actualizaciones de versión modifican el esquema de la base de datos.

Error OOM (Out of Memory). Si el contenedor LangFlow se reinicia espontáneamente, consulte docker compose logs langflow y busque Killed. La causa es la falta de RAM. Reduzca LANGFLOW_WORKERS a 1 y, si el problema persiste, aumente la RAM del VPS o evite ejecutar flujos pesados simultáneamente.

RuntimeError: CUDA out of memory. Este error ocurre cuando un componente intenta usar una GPU (vía PyTorch o un modelo Hugging Face) y el VPS no dispone de una, o la memoria GPU es insuficiente. Fuerce la ejecución en CPU añadiendo la variable de entorno CUDA_VISIBLE_DEVICES="" al servicio langflow en docker-compose.yml. Si el error proviene de un modelo Hugging Face, seleccione una variante CPU (sufijo -cpu o gguf) en el componente.

Puerto 7860 ya en uso. Si docker compose up -d falla con address already in use, otro proceso escucha en ese puerto. Identifíquelo con ss -tlnp | grep 7860 y deténgalo, o cambie el puerto host en docker-compose.yml (por ejemplo "127.0.0.1:7861:7860") y actualice la configuración nginx en consecuencia.

ImportError: No module named 'torch' o dependencia faltante. Algunos componentes avanzados (embeddings Hugging Face, modelos locales) requieren bibliotecas pesadas no incluidas en la imagen base. Cree un Dockerfile derivado que instale las dependencias faltantes, o utilice la imagen langflowai/langflow-backend con los extras necesarios.

Conexión rechazada a Ollama. Si LangFlow no puede contactar con Ollama en el mismo VPS, compruebe que Ollama escucha en 0.0.0.0 y no solo en 127.0.0.1. En docker-compose.yml, añada extra_hosts: ["host-gateway:host-gateway"] al servicio LangFlow y use la dirección http://host-gateway:11434 en los componentes Ollama.

Canvas en blanco o WebSocket cortado. Compruebe que las cabeceras Upgrade y Connection se transmiten correctamente por nginx. Un proxy intermedio (Cloudflare en modo Full Strict, balanceador de carga) puede interceptar los WebSockets: asegúrese de que el protocolo WebSocket esté correctamente configurado en el proxy.

Logs de flujo ausentes o incompletos. LangFlow almacena los logs de ejecución en base de datos. Si PostgreSQL no estaba listo cuando LangFlow arrancó, las primeras solicitudes fallan en silencio. El healthcheck del ejemplo de docker-compose.yml anterior resuelve este problema.

Una vez LangFlow operativo, varias integraciones amplían su ámbito de uso.

Si desea un modelo LLM completamente local (sin llamadas a una API externa), instale Ollama en el mismo VPS y conéctelo a LangFlow mediante el componente Ollama: sus pipelines dejan de enviar datos fuera de su infraestructura. Ollama expone una API compatible con OpenAI en el puerto 11434.

Para un RAG documental más robusto, pase de Chroma a Qdrant — una base vectorial de código abierto que despliega en un contenedor vecino y que ofrece buen rendimiento con grandes corpus (varios decenas de miles de documentos).

Por último, si varios equipos utilizan la instancia, plantéese aislar los flujos por espacio de trabajo (función disponible según la versión) o desplegar una instancia LangFlow por proyecto con la plantilla ServOrbit, que configura automáticamente Docker Compose, PostgreSQL y el reverse proxy.