CubeLabs

1. Que es Langflow? Arquitectura y ecosistema

Langflow es una plataforma open-source (MIT) que permite construir flujos de IA de forma visual. En lugar de escribir cientos de lineas de codigo para conectar un LLM con una base de datos vectorial y un agente, arrastras componentes en un canvas y los conectas como piezas de Lego.

Por que Langflow?

• Visual builder Disena flujos complejos sin tocar codigo (aunque puedes personalizarlos con Python).
• Batteries included Compatible con OpenAI, Anthropic, Hugging Face, Ollama y decenas de modelos locales.
• Multi-agente Orquestacion de agentes autonomos con memoria y herramientas.
• API y MCP Cada flujo se convierte en un endpoint REST o en un servidor MCP.
• Observabilidad Integracion nativa con LangSmith, LangFuse y otros.

Arquitectura general

Langflow se compone de tres capas principales:

2. Instalacion y primeros pasos

Langflow se instala como paquete Python. El metodo recomendado usa uv, el gestor de paquetes ultra rapido de Astral.

Opcion A: Instalacion local con uv

# Instala uv si no lo tienes
curl -LsSf https://astral.sh/uv/install.sh | sh

# Crea un directorio para Langflow y entras
mkdir langflow-project && cd langflow-project

# Instala Langflow
uv pip install langflow -U

Opcion B: Docker

docker run -p 7860:7860 langflowai/langflow:latest

Arrancar Langflow

$ uv run langflow run
 Starting Langflow...
 Server running at: http://127.0.0.1:7860

Abre http://127.0.0.1:7860 en tu navegador. Veras el canvas vacio con la biblioteca de componentes a la izquierda.

3. El constructor visual de flujos

El corazon de Langflow es su editor visual basado en React Flow. Cada componente es un nodo con entradas y salidas que se conectan mediante enlaces.

Tipos de componentes basicos

Flujo minimal: Chat con un LLM

Conecta estos 4 componentes en orden:

Chat Input > Prompt Template > OpenAI > Chat Output

En el Prompt Template, escribe algo como:

Eres un asistente experto en tecnologia.
Responde a esta pregunta: {question}

Conecta la salida question del Chat Input al input question del Prompt Template. Pulsa Play y empieza a chatear.

4. Modelos de lenguaje (LLMs) y proveedores

Langflow soporta todos los principales proveedores de LLMs. Puedes mezclar modelos de distintos proveedores en un mismo flujo.

Configurar OpenAI

# En el nodo OpenAI, configura:
API Key: sk-...tu-clave...
Model: gpt-4o    (o gpt-4o-mini, gpt-4-turbo)
Temperature: 0.7
Max Tokens: 1000

Usar modelos locales con Ollama

# Requiere Ollama instalado localmente
# En el nodo Ollama:
Base URL: http://localhost:11434
Model: llama3.2
Temperature: 0.7

Modelos disponibles

5. Agentes autonomos y herramientas

Un agente en Langflow es un LLM que puede usar herramientas para completar tareas. En lugar de solo generar texto, el agente decide que herramienta llamar, procesa el resultado y da una respuesta final.

Agente basico con calculadora

Componentes necesarios:

Chat Input > Tool Calling Agent > Chat Output
                |
          Calculator (tool)

Conecta la herramienta Calculator al agente. Pregunta: "Cuanto es 234 x 567?". El agente llamara a la calculadora, obtendra el resultado y te dara la respuesta.

Herramientas disponibles

Crear una Custom Tool

from typing import Any

def get_weather(city: str) -> dict:
    """Obtener el clima actual de una ciudad."""
    # Tu logica aqui (ej: llamada a API de clima)
    return {"city": city, "temp": 22, "condition": "soleado"}

6. Bases de datos vectoriales y RAG

El patron RAG (Retrieval Augmented Generation) permite que tu agente responda preguntas sobre documentos que tu le proporcionas. Langflow lo hace trivial conectando 4 componentes.

Flujo RAG minimo

File Input > Split Text > OpenAI Embeddings > Chroma Vector Store
                                                          |
Chat Input > Prompt Template < Chroma (retriever) < OpenAI Embeddings
                |
           Chat Output

Paso a paso

7. Orquestacion multi-agente

Langflow permite crear flujos donde varios agentes colaboran para resolver tareas complejas. Cada agente tiene su propio rol, herramientas y memoria.

Arquitectura tipica: Supervisor + Workers

                 Chat Input
                     |
            Supervisor Agent
              /        |        \
             |         |         |
        Worker_1   Worker_2   Worker_3
        (investiga) (calcula)  (escribe)
             \         |         /
              |        |        |
            Output Aggregator
                     |
               Chat Output

Configurar un agente supervisor

Cada agente en Langflow necesita:

1. System Prompt Define su rol y reglas
2. LLM El modelo que usara
3. Tools Las herramientas a las que tiene acceso
4. Memory Para recordar conversaciones anteriores

8. Desplegar flujos como API REST

Una de las funciones mas potentes de Langflow: cada flujo que construyes puede exponerse como una API REST en un solo clic. Esto permite integrar tus agentes en aplicaciones web, bots de Telegram, Slack, etc.

Exportar un flujo como API

# Ejemplo de llamada curl generado por Langflow
curl -X POST http://localhost:7860/api/v1/run/abc-123 \
  -H "Content-Type: application/json" \
  -d '{
    "input_value": "Que es Langflow?",
    "output_type": "chat",
    "input_type": "chat"
  }'

{
  "session_id": "abc-123",
  "outputs": [{
    "outputs": [{
      "results": {
        "message": {
          "text": "Langflow es un visual builder..."
        }
      }
    }]
  }]
}

Desplegar en produccion

Para produccion, Langflow se despliega con Docker y un proxy reverso (Nginx). El contenedor oficial expone el puerto 7860 con FastAPI.

# docker-compose.yml
version: "3.8"
services:
  langflow:
    image: langflowai/langflow:latest
    ports:
      - "7860:7860"
    environment:
      - LANGFLOW_AUTO_LOGIN=true
      - LANGFLOW_DATABASE_URL=postgresql://user:pass@db/langflow
    volumes:
      - langflow_data:/app/langflow
    restart: unless-stopped

9. MCP Server desde Langflow

El Model Context Protocol (MCP) es un estandar abierto para que los asistentes de IA (Claude Code, Cursor, etc.) se conecten a herramientas externas. Langflow puede convertir cualquier flujo en un servidor MCP.

Por que MCP en Langflow?

• Conviertes flujos visuales complejos en herramientas MCP sin escribir codigo de servidor
• Los flujos MCP heredan toda la logica del canvas (RAG, agentes, herramientas)
• Claude Code, Codex y otros clientes MCP pueden usar tus flujos como herramientas

Configurar un flujo como MCP

# Exporta el flujo como JSON desde el boton "Download"
# Luego arranca el servidor MCP apuntando a ese archivo
$ uv run langflow run --mcp --flow /path/to/flow.json

MCP Server running at http://localhost:7860/mcp/v1/

// En tu claude_code_config.json:
{
  "mcpServers": {
    "langflow-search": {
      "url": "http://localhost:7860/mcp/v1/"
    }
  }
}

10. Produccion, observabilidad y buenas practicas

Llevar un flujo de Langflow a produccion requiere atencion a la seguridad, el rendimiento y la monitorizacion.

Observabilidad

Langflow se integra con plataformas de observabilidad para rastrear cada llamada a tu flujo:

Buenas practicas