> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/langflow.md).

# 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](https://github.com/langflow-ai/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](https://clore.ai/bare-metal) |

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

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

### Paso 2: Ejecuta Langflow con Docker

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

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

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

```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 (pila completa)

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

### Fijación de versión específica

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

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

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

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

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

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

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

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

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

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

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

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

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

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

```bash
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](https://github.com/langflow-ai/langflow) — Código fuente, incidencias, registro de cambios
* [Documentación de Langflow](https://docs.langflow.org) — Documentación oficial, referencia de componentes, documentación de la API
* [Discord de Langflow](https://discord.com/invite/EqksyE2EX9) — Soporte de la comunidad y compartición de flujos
* [Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Configure un backend LLM local para Langflow
* [vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — Servicio de 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) — Elija la GPU adecuada de Clore.ai para su 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) — Etiquetas y versiones de imagen disponibles


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.