# Constructor visual de IA Langflow

## Resumen

[Langflow](https://github.com/langflow-ai/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](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md).

**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](https://clore.ai). Para uso solo con Langflow, cualquier servidor con ≥4 GB de RAM funciona. Conéctate vía SSH:

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

### Paso 2: Ejecuta Langflow con Docker

El despliegue más simple — un solo comando:

```bash
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:

```bash
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

```bash
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:

```bash
# 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:

```yaml
# /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:
```

```bash
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:

```bash
# 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

```bash
# 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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)

### Conectar Langflow a vLLM (compatible con OpenAI)

```bash
# 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](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)

### 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:

```bash
# 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:

```bash
# 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:

```bash
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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
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](https://github.com/langflow-ai/langflow) — Código fuente, issues, registro de cambios
* [Documentación de Langflow](https://docs.langflow.org) — Documentación oficial, referencia de componentes, docs de la API
* [Discord de Langflow](https://discord.com/invite/EqksyE2EX9) — Soporte comunitario y compartición de flujos
* [Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Configura un backend LLM local para Langflow
* [vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — Servicio LLM de alto rendimiento para flujos de producción
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — Elige la GPU Clore.ai adecuada para tu carga de trabajo
* [Documentación de LangChain](https://python.langchain.com/docs/) — Referencia del marco subyacente
* [Docker Hub: langflowai/langflow](https://hub.docker.com/r/langflowai/langflow) — Tags y versiones de imagen disponibles


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/langflow.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.