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 GPU asequible con una interfaz no-code de arrastrar y soltar.

Descripción general

Langflow es una plataforma de código abierto y de bajo código para crear aplicaciones de IA mediante una interfaz visual de arrastrar y soltar. Con más de 55 mil estrellas en GitHub y una comunidad en rápido crecimiento, se ha convertido en una de las herramientas de referencia para prototipar e implementar flujos de trabajo impulsados por LLM sin escribir código complejo de andamiaje.

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. El pipeline resultante puede exportarse como un endpoint de API, compartirse como plantilla o incrustarse en tu aplicación.

Capacidades clave:

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

• Flujos de trabajo multiagente — Encadena múltiples agentes de IA con memoria, herramientas y lógica de decisión

• Integración con LangChain — Accede a todo el ecosistema de LangChain mediante nodos de la interfaz

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

• API-first — Cada flujo genera automáticamente un endpoint de API REST

• 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 en Python que maneja la orquestación de flujos de trabajo. Sin embargo, Clore.ai abre casos de uso potentes:

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

• Backends LLM locales — Conecta Langflow con 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 las costosas llamadas de embeddings de OpenAI con inferencia local gratuita

• Flujos de trabajo persistentes — Flujos de larga duración en servidores dedicados (frente a 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 LLM/embeddings.

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

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 de 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 saliente a internet (para descargar imágenes de Docker y الوصول a APIs externas)

---

Inicio rápido

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

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

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

Paso 2: Ejecuta Langflow con Docker

La implementación más sencilla — un solo comando:

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

Espera ~30–60 segundos a que inicie y luego accede en http://<ip-del-servidor>:7860

Paso 3: Expón 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é asignado. Si usas una plantilla personalizada, añade 7860:7860 a la configuración de puertos antes de iniciar el servidor.

Paso 4: Primer inicio

En la primera visita, Langflow hará lo siguiente:

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

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

3. Abrir el editor visual del lienzo

¡Ya estás listo para crear tu primer flujo!

---

Configuración

Almacenamiento persistente de datos

Por defecto, Langflow almacena los flujos y los datos dentro del contenedor. Monta un volumen para que persista entre 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-aquí \
  -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	Predeterminado
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 (configúralo para producción)	Aleatorio
LANGFLOW_AUTO_LOGIN	Omitir pantalla de inicio de sesión	true
LANGFLOW_SUPERUSER	Nombre de usuario del administrador	admin
LANGFLOW_SUPERUSER_PASSWORD	Contraseña del administrador	—
LANGFLOW_WORKERS	Número de trabajadores de API	1
LANGFLOW_LOG_LEVEL	Nivel de verbosidad del registro	crítico
OPENAI_API_KEY	Precargar clave de OpenAI	—

Usando PostgreSQL (Producción)

Para implementaciones multiusuario o de producción, usa 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 (pila completa)

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

Fijación de versión específica

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

# Lista de 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 por GPU (Integración de modelos locales)

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

Conectar Langflow a Ollama

# Paso 1: Inicia 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: Descarga modelos para distintos 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: Inicia Langflow con acceso de red a 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 interfaz 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)

# Inicia 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, por ejemplo, "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 (coste de API cero):

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

2. Divisor de texto nodo → Dividir documentos en fragmentos (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 → Insertar en embeddings la consulta del usuario

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

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 de Clore.ai sin llamadas externas a APIs.

---

Consejos y buenas prácticas

1. Exporta los flujos como copias de seguridad

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

• En la interfaz: Flujos → Seleccionar todo → Exportar → Descargar JSON

• O a través de la API: curl http://localhost:7860/api/v1/flows/

Guárdalos en un volumen persistente o descárgalos a tu máquina local.

2. Usa la API para la automatización

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

# Obtén el ID de tu flujo desde la interfaz (se muestra en la URL)
FLOW_ID="tu-id-de-flujo-aquí"

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 sobre IA",
    "input_type": "chat",
    "output_type": "chat"
  }'

3. Asegura tu instancia

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

# Establece siempre 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. Supervisa el uso de memoria

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

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

5. Usa plantillas iniciales

Langflow incluye plantillas listas para producción:

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

• Chatbot con memoria — Agente conversacional con historial

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

• Acceso mediante: Nuevo flujo → Proyectos iniciales

6. Caché de componentes

Activa la caché para acelerar ejecuciones repetidas del flujo:

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

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

---

Solución de problemas

El contenedor no logra iniciarse

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

# Problema común: el puerto ya está 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

# Comprueba el estado del proceso trabajador
docker exec langflow ps aux | grep langflow

# Comprueba errores de paquetes de 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 opción --add-host, recrea el contenedor con:
--add-host host.docker.internal:host-gateway

# Verifica que Ollama esté ejecutándose
docker ps | grep ollama
curl http://localhost:11434/api/tags

Errores de base de datos al reiniciar

# Si usas SQLite y obtienes errores de bloqueo:
docker stop langflow
ls -la /opt/langflow/data/
# Comprueba 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 del flujo

# Aumenta los trabajadores para procesamiento en paralelo
-e LANGFLOW_WORKERS=4

# Para cargas de trabajo intensivas en embeddings, asegúrese de que Ollama use la GPU:
docker exec ollama nvidia-smi
# Debería mostrar el uso de la 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
# Use la CLI de Langflow en su lugar:
"
# Use el método de la CLI:
docker exec -it langflow langflow superuser --username admin --password newpassword

---

Lecturas adicionales

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

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

• Discord de Langflow — Soporte de la comunidad y compartición de flujos

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

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

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

• Documentación de LangChain — Referencia del marco subyacente

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