LangChain, LangGraph, LangSmith y Langflow: qué hace cada herramienta

Cuatro nombres del mismo ecosistema aparecen siempre juntos: LangChain, LangGraph, LangSmith y Langflow. A menudo se los clasifica como frameworks rivales, pero cada uno cubre una tarea distinta.

• LangChain aporta piezas como envoltorios de modelos, plantillas de prompts, retrievers, conexiones con herramientas y parsers de salida.
• LangGraph ejecuta aplicaciones que necesitan memoria entre pasos, bifurcaciones o bucles.
• LangSmith observa lo que ha pasado y lo evalúa, tanto en desarrollo como en producción.
• Langflow pone un lienzo de arrastrar y soltar sobre esas mismas ideas.

LangChain para pipelines en línea recta

LangChain conecta un modelo con prompts, retrievers, herramientas, bases de datos y salidas estructuradas. Cuando el trabajo avanza en un solo sentido, de la entrada a un resultado pasando por unos cuantos pasos, suele ser el camino más rápido. Instálelo junto con la integración de OpenAI, importe una plantilla de prompt y un modelo de chat, defina la plantilla con una línea de sistema y otra de usuario con un marcador para el tema, y fije un modelo pequeño con temperatura cero para obtener respuestas reproducibles.

pip install langchain langchain-openai

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a concise technical writer."),
        ("user", "Explain {topic} in three bullet points."),
    ]
)

model = ChatOpenAI(
    model="gpt-4.1-mini",
    temperature=0,
)

Un operador pipe une plantilla y modelo en una cadena. Al invocar la cadena con un diccionario que contiene el tema, devuelve una respuesta cuyo texto está en el atributo content.

chain = prompt | model
response = chain.invoke(
    {"topic": "retrieval-augmented generation"}
)

print(response.content)

La plantilla y el modelo siguen siendo objetos separados, así que cualquiera de los dos puede cambiarse, mientras que la cadena ofrece una única forma de entrada limpia. Encaja con integraciones, recuperación, llamadas a herramientas, montaje de prompts y análisis de salidas.

LangGraph cuando el flujo tiene que decidir

LangGraph describe una aplicación como un grafo. Los nodos hacen el trabajo, las aristas indican qué se ejecuta después y un objeto de estado con tipos viaja con ellos. Compensa en cuanto la ejecución puede bifurcarse, hacer bucles, reintentar, pausarse o reanudarse. La demo de abajo enruta una pregunta de soporte. Tras instalar el paquete, importa utilidades de tipado y las primitivas del grafo.

pip install langgraph

from typing import Literal, TypedDict

from langgraph.graph import END, START, StateGraph

El estado compartido guarda una pregunta, una categoría y una respuesta. Un nodo asigna una categoría a partir del texto de la pregunta, y otros dos generan la respuesta, uno para facturación y otro para todo lo demás.

class SupportState(TypedDict):
    question: str
    category: str
    answer: str

def classify(state: SupportState) -> dict:
    question = state["question"].lower()
    category = (
        "billing"
        if "invoice" in question
        else "general"
    )
    return {"category": category}

def answer_billing(state: SupportState) -> dict:
    return {
        "answer": "I will help you review the invoice."
    }

def answer_general(state: SupportState) -> dict:
    return {
        "answer": "I will help you with your request."
    }

Un pequeño router devuelve la etiqueta que guardó el clasificador. Al montar el grafo se registran los cuatro nodos y luego se añaden las aristas: el inicio lleva al clasificador, una arista condicional se abre hacia el nodo de respuesta que corresponda, y ambas respuestas llevan al final.

def route(
    state: SupportState,
) -> Literal["billing", "general"]:
    return state["category"]

builder = StateGraph(SupportState)
builder.add_node("classify", classify)
builder.add_node("billing", answer_billing)
builder.add_node("general", answer_general)

builder.add_edge(START, "classify")
builder.add_conditional_edges("classify", route)
builder.add_edge("billing", END)
builder.add_edge("general", END)

Al compilar el builder se obtiene un grafo ejecutable. Si se le pasa una pregunta sobre una factura con la categoría vacía, la petición baja por la rama de facturación, y al imprimir el campo de respuesta se confirma qué camino se ejecutó.

graph = builder.compile()

result = graph.invoke(
    {
        "question": "Why is my invoice higher?",
        "category": "",
        "answer": "",
    }
)

print(result["answer"])

La misma estructura se amplía a bucles con herramientas, checkpoints, agentes que colaboran y pasos de aprobación humana, que es donde el estado duradero, el enrutamiento, los ciclos y los reintentos demuestran su valor.

LangSmith para ver qué hizo el sistema

LangSmith no compite con los dos anteriores. Hace visible su comportamiento: prompts, llamadas al modelo, elección de herramientas, latencia, fallos, recuento de tokens y gasto pueden inspeccionarse después. La configuración son dos variables de entorno, una que activa el trazado y otra que guarda la clave de API.

import os

os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = (
    "your-langsmith-api-key"
)
os.environ["LANGSMITH_PROJECT"] = (
    "agent-comparison-demo"
)

La clave de arriba es un marcador. Las credenciales reales van en el entorno o en un gestor de secretos, nunca en los archivos de código. Con el trazado activado, las llamadas compatibles de LangChain y LangGraph aparecen en el proyecto elegido.

Para evaluar, construya un dataset que se parezca al tráfico real y compare versiones por corrección, fundamentación, acierto al elegir herramientas, velocidad y coste. LangSmith sirve para depurar, suites de regresión, trazas de producción, monitorización y análisis de feedback.

Langflow para construir sobre un lienzo

Langflow es un entorno visual de low-code. Entradas, prompts, modelos, retrievers, vector stores, herramientas y salidas se arrastran a un lienzo y se conectan. Brilla en experimentos, demos, formación y equipos mixtos.

Un flujo desplegado puede llamarse por HTTP. El cliente de abajo importa os y requests, lee la dirección del servidor de una variable de entorno con el puerto local por defecto como respaldo y envuelve la llamada en una función auxiliar que construye la URL del endpoint.

import os

import requests

LANGFLOW_URL = os.getenv(
    "LANGFLOW_URL",
    "http://localhost:7860",
)
FLOW_ID = os.environ["LANGFLOW_FLOW_ID"]
API_KEY = os.environ["LANGFLOW_API_KEY"]

def run_flow(message: str) -> dict:
    url = (
        f"{LANGFLOW_URL}/api/v1/run/{FLOW_ID}"
    )
    headers = {"x-api-key": API_KEY}
    payload = {
        "input_value": message,
        "input_type": "chat",
        "output_type": "chat",
    }

La función auxiliar envía los datos por POST con cabeceras y un timeout, comprueba los errores HTTP y devuelve el cuerpo JSON. Al llamarla con una pregunta comparativa, imprime el resultado estructurado.

response = requests.post(
        url,
        headers=headers,
        json=payload,
        timeout=60,
    )
    response.raise_for_status()
    return response.json()

result = run_flow(
    "Compare LangChain and LangGraph."
)
print(result)

La configuración queda fuera del código, las peticiones no pueden quedarse colgadas para siempre y los fallos lanzan excepciones. Elija Langflow para prototipos visuales, flujos reutilizables, demos y un trabajo en equipo más ágil. La lógica de producción muy personalizada puede ser más fácil de mantener como Python bajo control de versiones.

Las cuatro trabajando en un mismo producto

En un agente de atención al cliente, LangChain conecta el modelo, el prompt, la base de conocimiento y las herramientas. LangGraph gobierna la clasificación, la recuperación, la aprobación y los reintentos. LangSmith registra cada paso y califica la calidad, la velocidad y el coste. Langflow ofrece un borrador visual que las partes interesadas pueden recorrer haciendo clic.

Reglas prácticas:

• Pipeline lineal: empiece con LangChain.
• Estado, bifurcaciones, bucles o ejecuciones reanudables: añada LangGraph.
• Demostrar la calidad: incorpore LangSmith.
• Experimentos visuales rápidos: pruebe Langflow.

Ninguna sustituye a otra. Una aporta componentes, otra estado y enrutamiento, otra observabilidad y evaluación, y otra una forma visual de construir y publicar flujos. Use la combinación más pequeña que el equipo todavía pueda entender, probar y en la que pueda confiar.