Constructor Visual de IA Langflow

Despliega Langflow en Clore.ai — crea y ejecuta canalizaciones visuales de IA, sistemas RAG y flujos de trabajo multiagente en infraestructura de nube con GPU asequible con una interfaz sin código de arrastrar y soltar.

Resumen

Langflow es una plataforma de código abierto y bajo código para construir aplicaciones de IA usando una interfaz visual de arrastrar y soltar. Con más de 55K estrellas en GitHub y una comunidad en rápido crecimiento, se ha convertido en una de las herramientas preferidas para prototipar y desplegar flujos de trabajo impulsados por LLM sin escribir código complejo repetitivo.

Langflow está construido sobre LangChain y proporciona un editor gráfico donde puedes conectar componentes — LLMs, almacenes vectoriales, cargadores de documentos, recuperadores, agentes, herramientas — dibujando líneas entre nodos. La canalización resultante puede exportarse como un endpoint API, compartirse como plantilla o integrarse en tu aplicación.

Capacidades clave:

• Constructor RAG visual — Conecta cargadores de documentos → embeddings → almacenes vectoriales → recuperadores en minutos

• Flujos de trabajo multi-agente — Encadena varios agentes de IA con memoria, herramientas y lógica de decisión

• Integración con LangChain — Accede al ecosistema completo de LangChain mediante nodos en la interfaz

• Mercado de componentes — Componentes contribuidos por la comunidad para docenas de servicios

• API primero — Cada flujo genera automáticamente un endpoint REST API

• Memoria y estado — Memoria de conversación integrada, gestión de sesiones

¿Por qué Clore.ai para Langflow?

Los requisitos de cómputo de Langflow son mínimos — es un servidor web Python que maneja la orquestación de flujos de trabajo. Sin embargo, Clore.ai habilita casos de uso potentes:

• Embeddings autoalojados — Ejecuta modelos de embeddings locales (nomic-embed, BGE) en GPU para generación de vectores rápida y gratuita

• Backends LLM locales — Conecta Langflow a Ollama o vLLM ejecutándose en el mismo servidor

• Canalizaciones de datos privadas — Procesa documentos sensibles sin enviar datos a APIs externas

• Optimización de costos — Reemplaza llamadas costosas a embeddings de OpenAI con inferencia local gratuita

• Flujos persistentes — Flujos de larga duración en servidores dedicados (vs. funciones efímeras en la nube)

---

Requisitos

Langflow en sí es ligero y basado en CPU. La GPU es opcional pero permite inferencia local gratuita de LLMs/embeddings.

Configuración	GPU	VRAM	RAM	Almacenamiento	Precio estimado
Solo Langflow (backends API)	No se necesita	—	4 GB	10 GB	~$0.03–0.08/h
+ Embeddings locales (nomic-embed)	RTX 3090	24 GB	8 GB	20 GB	~$0.20/h
+ Ollama (Llama 3.1 8B)	RTX 3090	24 GB	16 GB	40 GB	~$0.20/h
+ Ollama (Qwen2.5 32B)	RTX 4090	24 GB	32 GB	60 GB	~$0.35/h
+ vLLM (RAG en producción)	A100 80GB	80 GB	64 GB	100 GB	~$1.10/h

Para una comparación de opciones de GPU en Clore.ai, consulta la Guía de comparación de GPU.

Requisitos de software en el servidor Clore.ai:

• Docker Engine (preinstalado en todas las imágenes de Clore.ai)

• NVIDIA Container Toolkit (preinstalado en imágenes con GPU, requerido solo para LLM local)

• Más de 10 GB de espacio libre en disco para la imagen de Langflow y los datos de los flujos

• Acceso a internet saliente (para descargar imágenes Docker y alcanzar APIs externas)

---

Inicio rápido

Paso 1: Conéctate a tu servidor Clore.ai

Reserva un servidor en mercado de Clore.ai. Para uso solo con Langflow, cualquier servidor con ≥4 GB de RAM funciona. Conéctate vía SSH:

ssh root@<ip-del-servidor> -p <puerto-ssh>

Paso 2: Ejecuta Langflow con Docker

El despliegue más simple — un solo comando:

docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  langflowai/langflow:latest

Espera ~30–60 segundos para el arranque, luego accede en http://<ip-del-servidor>:7860

Paso 3: Exponer el puerto 7860 en Clore.ai

En el panel de Clore.ai, ve a tu servidor → sección Puertos → asegúrate de que 7860 esté mapeado. Si usas una plantilla personalizada, añade 7860:7860 a tu configuración de puertos antes de iniciar el servidor.

Paso 4: Primer inicio

En la primera visita, Langflow hará:

1. Mostrar una pantalla de bienvenida y pedir crear una cuenta (o saltarla)

2. Ofrecer un conjunto de plantillas de inicio (RAG, chatbot, agente)

3. Abrir el editor de lienzo visual

¡Estás listo para construir tu primer flujo!

---

Configuración

Almacenamiento de datos persistente

Por defecto, Langflow almacena flujos y datos dentro del contenedor. Monta un volumen para persistir tras reinicios:

mkdir -p /opt/langflow/data

docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  langflowai/langflow:latest

Referencia de variables de entorno

docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_HOST=0.0.0.0 \
  -e LANGFLOW_PORT=7860 \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  -e LANGFLOW_SECRET_KEY=tu-clave-secreta-aqui \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=tu-contraseña \
  -e LANGFLOW_WORKERS=2 \
  -e LANGFLOW_LOG_LEVEL=info \
  langflowai/langflow:latest

Variable	Descripción	Valor por defecto
LANGFLOW_HOST	Dirección de enlace	0.0.0.0
LANGFLOW_PORT	Puerto del servidor web	7860
LANGFLOW_DATABASE_URL	Cadena de conexión a la base de datos	SQLite en memoria
LANGFLOW_SECRET_KEY	Secreto de sesión (configurar para producción)	Aleatorio
LANGFLOW_AUTO_LOGIN	Omitir pantalla de inicio de sesión	true
LANGFLOW_SUPERUSER	Nombre de usuario administrador	admin
LANGFLOW_SUPERUSER_PASSWORD	Contraseña del administrador	—
LANGFLOW_WORKERS	Número de workers de la API	1
LANGFLOW_LOG_LEVEL	Nivel de verbosidad del registro	critical
OPENAI_API_KEY	Pre-cargar clave de OpenAI	—

Uso de PostgreSQL (Producción)

Para despliegues multiusuario o en producción, utiliza PostgreSQL en lugar de SQLite:

# Iniciar PostgreSQL
docker run -d \
  --name langflow-db \
  --restart unless-stopped \
  -e POSTGRES_USER=langflow \
  -e POSTGRES_PASSWORD=langflow-secret \
  -e POSTGRES_DB=langflow \
  -v langflow-pgdata:/var/lib/postgresql/data \
  postgres:16-alpine

# Iniciar Langflow con backend PostgreSQL
docker run -d \
  --name langflow \
  --restart unless-stopped \
  --link langflow-db:db \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=postgresql://langflow:langflow-secret@db:5432/langflow \
  -e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32) \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=changeme \
  langflowai/langflow:latest

Docker Compose (Full Stack)

Para una configuración completa con PostgreSQL y proxy inverso Nginx:

# /opt/langflow/docker-compose.yml
version: "3.9"

services:
  langflow:
    image: langflowai/langflow:latest
    restart: unless-stopped
    ports:
      - "7860:7860"
    environment:
      - LANGFLOW_DATABASE_URL=postgresql://langflow:secret@db:5432/langflow
      - LANGFLOW_SECRET_KEY=${SECRET_KEY:-changeme}
      - LANGFLOW_AUTO_LOGIN=false
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=${ADMIN_PASSWORD:-changeme}
      - LANGFLOW_WORKERS=2
    volumes:
      - langflow-data:/app/langflow
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_USER=langflow
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=langflow
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U langflow"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  langflow-data:
  pgdata:

cd /opt/langflow
SECRET_KEY=$(openssl rand -hex 32) ADMIN_PASSWORD=tucontraseña docker compose up -d

Bloqueo a versión específica

Para despliegues reproducibles, fija una versión específica:

# Lista versiones disponibles: https://hub.docker.com/r/langflowai/langflow/tags
docker run -d \
  --name langflow \
  -p 7860:7860 \
  langflowai/langflow:1.1.4

---

Aceleración GPU (Integración de modelos locales)

Langflow en sí se ejecuta en CPU, pero conectarlo a servicios locales impulsados por GPU en el mismo servidor Clore.ai desbloquea inferencia privada y gratuita.

Conectar Langflow a Ollama

# Paso 1: Iniciar Ollama con GPU
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# Paso 2: Descargar modelos para diferentes casos de uso
docker exec ollama ollama pull llama3.1:8b          # Chat general
docker exec ollama ollama pull nomic-embed-text     # Embeddings para RAG
docker exec ollama ollama pull qwen2.5-coder:7b    # Generación de código

# Paso 3: Iniciar Langflow con acceso a la red de Ollama
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  --add-host host.docker.internal:host-gateway \
  langflowai/langflow:latest

En la UI de Langflow, usa el Ollama componente con:

• URL base: http://host.docker.internal:11434

• Modelo: llama3.1:8b

Para embeddings, usa el OllamaEmbeddings componente con:

• URL base: http://host.docker.internal:11434

• Modelo: nomic-embed-text

Configuración completa de Ollama: consulta la guía de Ollama

Conectar Langflow a vLLM (compatible con OpenAI)

# Iniciar vLLM con API compatible con OpenAI
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --gpu-memory-utilization 0.85

# En Langflow, usa el componente OpenAI con URL base personalizada:
# URL base: http://host.docker.internal:8000/v1
# Clave API: (cualquier valor, p. ej. "none")
# Modelo: mistralai/Mistral-7B-Instruct-v0.3

Configuración completa de vLLM: consulta la guía de vLLM

Construyendo una canalización RAG local

Ejemplo de flujo RAG usando solo modelos locales (costo 0 en APIs):

1. Cargador de archivos nodo → Cargar documentos PDF/texto

2. Divisor de texto nodo → Fragmentar documentos (tamaño: 512, solapamiento: 50)

3. OllamaEmbeddings nodo → Generar embeddings (modelo: nomic-embed-text)

4. Chroma o FAISS nodo → Almacenar vectores localmente

5. OllamaEmbeddings nodo → Embedir la consulta del usuario

6. Recuperador nodo → Encontrar los top-k fragmentos similares

7. Ollama nodo → Generar respuesta (modelo: llama3.1:8b)

8. Salida de chat nodo → Devolver respuesta

Toda esta canalización se ejecuta en tu servidor Clore.ai sin llamadas a APIs externas.

---

Consejos y mejores prácticas

1. Exporta flujos como copias de seguridad

Antes de detener tu servidor Clore.ai, exporta tus flujos:

• En la UI: Flows → Seleccionar todo → Exportar → Descargar JSON

• O vía API: curl http://localhost:7860/api/v1/flows/

Almacénalos en un volumen persistente o descárgalos a tu máquina local.

2. Usa la API para automatización

Cada flujo de Langflow genera un endpoint API. Dispara flujos programáticamente:

# Obtén el ID de tu flujo desde la UI (mostrado en la URL)
FLOW_ID="tu-id-de-flujo-aqui"

curl -X POST \
  "http://<ip-del-servidor>:7860/api/v1/run/$FLOW_ID" \
  -H "Content-Type: application/json" \
  -d '{
    "input_value": "Resume los últimos artículos de investigación en IA",
    "input_type": "chat",
    "output_type": "chat"
  }'

3. Asegura tu instancia

Para cualquier cosa más allá de pruebas locales:

# Siempre establece autenticación
-e LANGFLOW_AUTO_LOGIN=false \
-e LANGFLOW_SUPERUSER=admin \
-e LANGFLOW_SUPERUSER_PASSWORD=$(openssl rand -base64 16)

# Usa una clave secreta fuerte
-e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32)

4. Monitorea el uso de memoria

Langflow puede acumular memoria con el tiempo si hay muchos flujos activos:

docker stats langflow
# Si la memoria crece sin límite, reinicia periódicamente:
docker restart langflow

5. Usa plantillas de inicio

Langflow incluye plantillas listas para producción:

• RAG básico — Preguntas y respuestas de documentos con almacén vectorial

• Chatbot con memoria — Agente conversacional con historial

• Asistente de investigación — Búsqueda web + síntesis con LLM

• Accede vía: New Flow → Starter Projects

6. Caché de componentes

Habilita el caché para acelerar ejecuciones repetidas de flujos:

• En la configuración del flujo: Habilita "Cache" en nodos costosos (embeddings, llamadas a LLM)

• Particularmente útil para la recuperación RAG durante el desarrollo

---

Solución de problemas

El contenedor no arranca

# Revisa los logs en busca de errores
docker logs langflow --tail 50

# Problema común: puerto ya en uso
lsof -i :7860
# Mata el proceso en conflicto o cambia el puerto:
docker run ... -p 7861:7860 ...

La interfaz carga pero los flujos no se ejecutan

# Revisa el estado de los procesos worker
docker exec langflow ps aux | grep langflow

# Revisa errores en paquetes Python
docker logs langflow 2>&1 | grep -i error

# Reinicia el contenedor
docker restart langflow

No se puede conectar a Ollama

# Prueba la conectividad desde dentro del contenedor de Langflow
docker exec langflow curl http://host.docker.internal:11434/api/tags

# Si falta la bandera --add-host, recrea el contenedor con:
--add-host host.docker.internal:host-gateway

# Verifica que Ollama esté en funcionamiento
docker ps | grep ollama
curl http://localhost:11434/api/tags

Errores de base de datos al reiniciar

# Si usas SQLite y obtienes errores de lock:
docker stop langflow
ls -la /opt/langflow/data/
# Revisa archivos .lock obsoletos
rm -f /opt/langflow/data/langflow.db-wal
rm -f /opt/langflow/data/langflow.db-shm
docker start langflow

Ejecución lenta de flujos

# Aumenta workers para procesamiento en paralelo
-e LANGFLOW_WORKERS=4

# Para cargas de trabajo intensivas en embeddings, asegúrate de que Ollama use la GPU:
docker exec ollama nvidia-smi
# Debe mostrar utilización de GPU al generar embeddings

Restablecer contraseña de administrador

docker exec -it langflow python -c "
from langflow.services.database.utils import initialize_db
from langflow.services.deps import get_settings_service
# Usa la CLI de Langflow en su lugar:
"
# Usa el método de la CLI:
docker exec -it langflow langflow superuser --username admin --password newpassword

---

Lecturas adicionales

• Repositorio de Langflow en GitHub — Código fuente, issues, registro de cambios

• Documentación de Langflow — Documentación oficial, referencia de componentes, docs de la API

• Discord de Langflow — Soporte comunitario y compartición de flujos

• Ollama en Clore.ai — Configura un backend LLM local para Langflow

• vLLM en Clore.ai — Servicio LLM de alto rendimiento para flujos de producción

• Guía de comparación de GPU — Elige la GPU Clore.ai adecuada para tu carga de trabajo

• Documentación de LangChain — Referencia del marco subyacente

• Docker Hub: langflowai/langflow — Tags y versiones de imagen disponibles