LangChain vs LangGraph vs LangSmith vs LangFlow: diferencias clave explicadas

Este artículo ofrece una comparación formal y en paralelo de LangChain y LangGraph, y también explica dónde encajan LangSmith y LangFlow. Partiremos de conceptos tratados en otros artículos de DataCamp y veremos cuándo elegir cada framework para poner en producción sistemas de IA agentic. Si buscas una introducción práctica a LangChain, te recomiendo el curso Developing LLM Applications with LangChain.

Resumen rápido (TL;DR)

Antes de entrar en detalle, aquí tienes un vistazo de cómo encajan LangChain, LangGraph, LangSmith y LangFlow y cuándo elegir cada uno.

• LangChain: La base: crea flujos modulares con LLM (prompts, herramientas, memoria, recuperadores) con APIs sencillas como LCEL. Ideal para prototipos y apps lineales.
• LangGraph: El orquestador: gestiona flujos complejos y con estado, con bifurcaciones, reintentos, bucles y persistencia. Ideal para sistemas multiagente resilientes y listos para producción.
• LangSmith: El observador: trazado, evaluación y monitorización de apps con LLM, independiente del framework. Ideal para depurar, tests de regresión y control de calidad.
• LangFlow: El constructor visual: interfaz de arrastrar y soltar para prototipar flujos rápidamente y exportarlos a código. Ideal para equipos, talleres y personas sin experiencia en código.

Heurística rápida: empieza con LangChain, pasa a LangGraph cuando el flujo crezca, añade LangSmith para observabilidad y usa LangFlow cuando necesites iterar o colaborar a toda velocidad.

Introducción a LangChain y LangGraph

Los grandes modelos de lenguaje (LLM) son muy buenos con prompts individuales. A estas alturas es algo bastante sabido, porque los usamos a menudo hoy en día. 

Sin embargo, las aplicaciones reales necesitan flujos de trabajo: obtener datos, razonar, llamar a herramientas, pedir una aclaración, reintentar si falla y, a veces, pausar para intervención humana. Por eso oirás una y otra vez dos frameworks: LangChain y LangGraph. Viven en el mismo ecosistema y a menudo se usan juntos, pero resuelven partes distintas del problema:

• LangChain nos ayuda a construir los pasos
• LangGraph nos ayuda a orquestar esos pasos cuando se complican.

Hablando del ecosistema, también veremos LangSmith (para observabilidad y evaluación) y LangFlow (constructor visual por arrastrar y soltar), ya que también forman parte de él. 

Breve historia del ecosistema LangChain (2022–2025)

Tiene sentido empezar con algo de historia del ecosistema LangChain; se ha convertido en el framework de referencia para la IA agentic, y entender cómo ha llegado hasta aquí ayuda a ver por qué importan LangGraph, LangSmith y LangFlow. 

• 2022 — nace LangChain: LangChain se lanzó como proyecto open‑source en octubre de 2022 de la mano de Harrison Chase y su equipo. Pronto se convirtió en el framework preferido para componer apps con LLM, atrayendo una comunidad e integraciones en rápido crecimiento.
• 2023 — de la popularidad a la plataforma: LangChain formalizó las abstracciones clave y añadió LCEL (LangChain Expression Language) para componer en estilo pipes. También se creó una nueva forma de desplegar cadenas en producción vía API, llamada LangServe. La empresa detrás de LangChain levantó financiación para acelerar el trabajo del ecosistema.
• 2023–2024 — llega la observabilidad con LangSmith: A mediados de 2023, y con disponibilidad general a principios de 2024, LangSmith introdujo trazado, evaluación y monitorización unificados para que los equipos pudieran depurar y probar cadenas/agentes y seguir su calidad en el tiempo.
• 2024 — orquestación con LangGraph: Para dar soporte a apps de larga duración y con múltiples pasos/agentes, LangGraph introdujo un runtime de grafos con estado explícito, routers/ramas, bucles, reintentos y checkpointers para persistencia. Fue clave porque puso las bases para agentes duraderos y de nivel producción. Las actualizaciones posteriores ampliaron la personalización y las integraciones con distintos proveedores de LLM, incluido Ollama (modelos open‑source). 
• 2024–2025 — construcción visual con LangFlow. El editor visual de LangFlow evolucionó rápido (grandes lanzamientos a finales de 2024 y una Launch Week en 2025), permitiendo arrastrar y soltar componentes de LLM, iterar rápido y exportar flujos a código. Fue un paso importante porque acercó la creación de agentes de IA robustos a perfiles no técnicos.
• 2025 — hacia plataformas gestionadas de agentes. LangChain anunció hitos importantes: una API funcional para LangGraph, plantillas de agentes prediseñadas y una LangGraph Platform para desplegar y gestionar agentes con estado a escala. También fue decisivo porque permitió a los desarrolladores operar agentes fiables en producción.

Breve introducción a LangChain y LangGraph

Vamos a profundizar en el núcleo del ecosistema, empezando por LangChain y LangGraph. 

LangChain es un framework modular para crear aplicaciones impulsadas por LLM. Nos da bloques de construcción — prompts, modelos, memoria, herramientas, recuperadores — y una forma sencilla de encadenarlos en una tubería con sus APIs Runnable/LCEL (lo veremos enseguida). Me gusta pensar en él como un kit de piezas de Lego para patrones comunes con LLM como RAG, preguntas‑respuestas, chatbots y agentes que usan herramientas. 

LangGraph es una capa de orquestación basada en grafos más reciente, construida sobre componentes de LangChain. En lugar de una línea recta de pasos, la app se modela como nodos (acciones) y aristas (transiciones), con un objeto de estado explícito que fluye por el grafo. Lo veremos en detalle, pero de momento recuerda que este diseño facilita ramificar (tomar caminos distintos), iterar (hacer preguntas aclaratorias hasta tener confianza), reintentar (ante errores de herramienta/modelo) y pausar para revisión humana; justo lo que necesitamos para agentes de larga ejecución y grado de producción.

Quizá te preguntes:

“¿Para qué compararlas?”

El caso es que, aunque comparten componentes, apuntan a niveles de complejidad distintos:

• LangChain brilla en flujos lineales rápidos. Ejemplo: Cargar PDF → trocear → generar embeddings → recuperar → responder. Puedes prototiparlo en minutos.
• LangGraph destaca cuando la lógica debe adaptarse. Ejemplo: Si la confianza < 0,7 → pedir aclaración (bucle); si falla el pago → reintentar con backoff; si la petición parece arriesgada → pausar para revisión humana. Estos comportamientos son nativos en un grafo.

En la práctica, muchos desarrolladores empiezan con LangChain para validar una idea y luego pasan a LangGraph al añadir bifurcaciones, gestión de errores, coordinación multiagente o durabilidad.

¿Qué es LangChain?

Ahora vamos a profundizar en LangChain, entender su uso y programar aplicaciones con él. Recuerda: LangChain es una librería que nos permite construir la base para flujos secuenciales con LLM. 

LCEL

Para empezar, quiero explicar qué es LCEL. LCEL, o LangChain Expression Language, es una forma de conectar bloques con pipes (|). Cada bloque puede ser un prompt, un modelo, un recuperador o un parser. Al unirlos, obtenemos una cadena que podemos ejecutar una y otra vez, lo que hace el código mucho más eficiente. 

Veamos algunos ejemplos.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm    = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are concise."),
    ("human", "{question}")
])
chain = prompt | llm | StrOutputParser() # This is our chain

print(chain.invoke({"question": "Give me 3 focus tips."}))     # making a single call

qs = [{"question": q} for q in ["One tactic for RAG?", "Explain LCEL in 1 line."]]
print(chain.batch(qs))                                         # many calls at onceCon la tecnología de

En mi opinión, el bloque anterior muestra la forma más simple de usar LCEL. Primero creamos una plantilla de prompt que siempre incluye un mensaje de sistema (“you are concise”) y deja espacio para una pregunta humana. El mensaje de sistema es como una instrucción al LLM para que responda/actúe de cierta manera. Luego conectamos esta plantilla a un modelo de OpenAI: GPT‑4o‑mini. 

Por último, añadí un parser de salida, que básicamente convierte la respuesta en texto plano.

Aquí viene lo más importante: el operador | es lo que pega estos bloques en una sola tubería.

También quiero hablar de invoke() y batch(). Cuando llamamos a chain.invoke(...), la tubería se ejecuta una vez: se rellena la plantilla con la pregunta, el modelo genera una respuesta y el parser devuelve texto limpio. 

En cambio, cuando llamamos a chain.batch(...), la misma cadena se ejecuta sobre muchos inputs a la vez, lo que es mucho más rápido que iterar uno por uno. En la práctica, facilita pasar de una llamada simple a procesar conjuntos de datos enteros con casi nada de código extra. 

Quiero mostrar otro ejemplo:

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

stream_chain = (ChatPromptTemplate.from_template("{topic}")  | ChatOpenAI(model="gpt-4o-mini")  | StrOutputParser())

# Simple stream
for chunk in stream_chain.stream({"topic": "Explain PID in 2 lines"}):
    print(chunk, end="")Con la tecnología de

Este código es muy parecido al primero, pero en lugar de hacer una llamada única, usamos streaming. Con .stream(...), el modelo no espera a tener toda la respuesta lista. En su lugar, envía fragmentos de texto a medida que se generan, y los imprimimos en tiempo real. 

La idea clave de esta subsección es que LCEL es el sencillo sistema de “pipes y bloques” que nos permite encajar prompts, modelos, herramientas y parsers para obtener al instante una cadena que podemos invocar, procesar en lote o transmitir sin código extra.

Salidas estructuradas con Pydantic

Las salidas estructuradas son esenciales en agentes de IA. Significa que, en lugar de una respuesta larga y desordenada, el agente devuelve la información en un formato claro como JSON, tablas o listas. Así es más fácil de leer, de usar y de conectar con otras herramientas.

Uno de los principales frameworks usados en la industria para esto es Pydantic.

from pydantic import BaseModel, Field
from typing import List
from langchain_openai import ChatOpenAI

class TaskPlan(BaseModel):
    title: str
    steps: List[str] = Field(..., min_items=3, description="actionable steps")

structured = ChatOpenAI(model="gpt-4o-mini").with_structured_output(TaskPlan)
plan = structured.invoke("Plan a 20-minute deep-work session for AI Agent notes.")
print(plan.model_dump())Con la tecnología de

En este ejemplo, el método .with_structured_output() es lo importante, porque le indica al LLM que entregue la salida con el modelo de Pydantic que creamos. Por detrás, LangChain asegura que la respuesta del agente sea JSON real que cumpla el esquema y luego la convierte en un objeto de Python listo para usar. 

Así, en lugar de texto sucio, obtenemos algo como TaskPlan(title="...", steps=["...", "...", "..."]). Esto es especialmente útil cuando usamos herramientas. 

Llamadas a herramientas en LangChain

Las herramientas son importantes porque amplían la capacidad del LLM para realizar tareas que antes no podía, como buscar en internet. 

Lo que más me gusta es que LangChain (y muchos frameworks agentic) ofrecen herramientas listas para usar llamadas Built‑In Tools muy fáciles de emplear. Además, podemos crear nuestras propias herramientas usando el decorador @tool para indicar a LangChain que esa función es especial. 

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def multiply(a: int, b: int) -> int:
    """This tool multiplies two numbers."""
    return a * b

llm = ChatOpenAI(model="gpt-4o-mini")
llm_tools = llm.bind_tools([multiply])   # exposing the tools to the model

resp = llm_tools.invoke("What is 9*5? If needed, use a tool.")
print(resp.tool_calls or resp.content)   # model may emit a tool call with argumentsCon la tecnología de

En el bloque anterior he creado una herramienta muy simple, que recibe dos números y devuelve su producto. Para dar acceso a estas herramientas al modelo interno (en este caso GPT‑4o‑mini), usamos llm.bind_tools() y pasamos la lista de herramientas, exponiéndoselas al modelo. 

Memoria conversacional

La memoria también es clave al crear agentes de IA. Los agentes con memoria pueden recordar cosas de conversaciones previas, como lo que pedimos, nuestras preferencias o qué funcionó y qué no. Sin memoria, cada vez sería como conocer a alguien nuevo: tendríamos que repetir el contexto básico una y otra vez, lo que es bastante engorroso. 

En LangChain, memoria significa guardar mensajes o hechos pasados en un almacén (en memoria, base de datos o vector store). Luego, cuando el agente vuelve a ejecutarse, puede recuperar esa memoria para que las respuestas sean más coherentes e inteligentes.

Hay dos tipos principales: memoria a corto plazo (mensajes recientes en el mismo chat) y memoria a largo plazo (hechos o preferencias recordados a lo largo de varias sesiones). Una sesión es una conversación o ventana de interacción, donde el agente lleva el registro de lo dicho hasta que termina.

La memoria a corto plazo mantiene el contexto dentro de una conversación; la de largo plazo hace que el agente resulte más personal y útil con el tiempo.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.chat_history import InMemoryChatMessageHistory

prompt = ChatPromptTemplate.from_messages([
    ("system", "Be brief"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
chain = prompt | ChatOpenAI(model="gpt-4o")

store = {}  # session_id -> history
def get_history(session_id: str):
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

with_history = RunnableWithMessageHistory(
    chain,
    lambda cfg: get_history(cfg["configurable"]["session_id"]),
    input_messages_key="input",
    history_messages_key="history",
)

cfg = {"configurable": {"session_id": "u1"}}
print(with_history.invoke({"input": "My name is Vaibhav."}, config=cfg))
print(with_history.invoke({"input": "What is my name?"}, config=cfg))Con la tecnología de

En este bloque, el código crea una cadena de chat que puede recordar mensajes anteriores en una sesión. El prompt tiene un placeholder de historial y RunnableWithMessageHistory lo rellena automáticamente con la conversación adecuada cada vez. El store mantiene historiales para distintas sesiones. 

Es importante usar la memoria con cabeza. Hay que decidir y programar qué merece la pena guardar, cuándo almacenarlo y cuánto volver a pasar al prompt. Demasiada memoria puede ralentizar o exceder límites, pero el equilibrio adecuado hace a los agentes mucho más útiles.

¿Qué es LangGraph?

Pasamos ahora al otro framework agentic: LangGraph. 

Para explicarlo de forma sencilla, voy a usar una analogía: el diagrama de flujo con mochila. 

Podemos pensar en LangGraph como un pequeño diagrama de flujo para nuestra app de IA. Cada caja (nodo) es una pequeña función de Python que hace una tarea. Las flechas (aristas) indican qué caja se ejecuta después. Una pequeña mochila de datos (el “estado”) avanza por el diagrama, de modo que cada nodo puede leerla y añadir información. En una app de chat, la mochila suele ser la lista de mensajes acumulada.

Grafo fundamental

Se entenderá mejor con un ejemplo: 

pip install langgraph langchain-openaiCon la tecnología de

from typing import TypedDict, Annotated, List
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

# Esta es la mochila que recorre el grafo.
class State(TypedDict):
	# Para añadir mensajes al estado
    messages: Annotated[List, add_messages]

llm = ChatOpenAI(model="gpt-4o")

# Este es un nodo que consulta el modelo y añade la réplica a la mochila.
def model_node(state: State):
    reply = llm.invoke(state["messages"])
    return {"messages": [reply]}

# Construcción del grafo
graph = StateGraph(State)
graph.add_node("model", model_node)
graph.add_edge(START, "model")
graph.add_edge("model", END)

# Compilar y ejecutar una vez
app = graph.compile()

result = app.invoke({"messages": [HumanMessage(content="Explain LangGraph in one sentence.")]} )
print(result["messages"][-1].content)Con la tecnología de

Repasemos el código. Aquí creamos la app más simple posible con LangGraph. El estado es como una mochila que lleva mensajes por el grafo. Lo definimos con State, indicando a LangGraph que mantenga siempre una lista de mensajes de chat.

Luego viene el nodo, que aquí es una única función, model_node, que mira dentro de la mochila, envía los mensajes al LLM y devuelve la respuesta. LangGraph añade automáticamente esa respuesta a la mochila.

El grafo en sí es un diagrama mínimo: START → model → END. Al compilar, LangGraph convierte ese “dibujo” en una app ejecutable.

Por último, ejecutamos la app (no el grafo, sino el grafo compilado) con una mochila que ya contiene un mensaje humano.

Para ayudarte a visualizarlo, podemos ejecutar este código para ver el grafo:

from IPython.display import Image, display
display(Image(app.get_graph().draw_mermaid_png()))Con la tecnología de

Ojo: que se genere la visualización no significa que el grafo vaya a ejecutarse. Puede haber errores lógicos que resolver antes.

Grafo con ramificaciones

Avancemos hacia las ramificaciones, un componente importante (y sencillo) de cualquier sistema agentic robusto. Dan más libertad al agente para decidir, pasando de un flujo de trabajo a un sistema agentic.

Veamos el código:

from typing import TypedDict, Annotated, List
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage

# Definir el estado
class State(TypedDict):
    messages: Annotated[List, add_messages]

llm = ChatOpenAI(model="gpt-4o-mini")

def answer_node(state: State):
    # Respuesta normal usando todo el historial del chat.
    return {"messages": [llm.invoke(state["messages")]]}

def clarify_node(state: State):
    # LLM pidiendo un breve seguimiento para precisar (aclaración)
    return {"messages": [AIMessage(content="¿Puedes darme un poco más de detalle para ser preciso?")]} 

# Función de enrutado
def route(state: State):
    # Busca el último mensaje humano y cuenta palabras.
    last_human = next((m for m in reversed(state["messages"]) if m.type == "human"), None)
    if not last_human:
        return "clarify"
    words = len(str(last_human.content).split())
    return "answer" if words >= 3 else "clarify"

graph = StateGraph(State)
graph.add_node("answer", answer_node)
chgraph.add_node("clarify", clarify_node)

# Arista condicional que conecta la función router 
graph.add_conditional_edges(START, route, {"answer": "answer", "clarify": "clarify"})
graph.add_edge("answer", END)
graph.add_edge("clarify", END)
app = graph.compile() # Compilar el grafoCon la tecnología de

Casi todo es similar al primer agente, salvo la arista condicional. Esto nos permite ofrecer al sistema rutas distintas en función del criterio del LLM. Visualmente, queda así:

Con aristas condicionales podemos construir sistemas agentic bastante robustos con lo que ya sabemos. Si quieres un tutorial más completo, te recomiendo mi vídeo tutorial de LangGraph.

Recientemente se añadió LangGraph Studio a LangGraph; te recomiendo mucho esta guía de LangGraph Studio.

¿Qué es LangFlow?

Aunque LangChain y LangGraph son las dos librerías a las que más recurren los desarrolladores en la familia Lang, creo que merece la pena hablar brevemente de LangFlow. 

Piensa en LangFlow como un lienzo de arrastrar y soltar para apps con LLM. Cada nodo = un paso (prompt, modelo, herramienta, recuperador, base vectorial, operación de ficheros, etc.). Conectamos nodos en un flujo, lo ejecutamos, lo exportamos o lo desplegamos. Es genial para iterar rápido y, sobre todo, para colaborar con perfiles no técnicos y convertir ideas en agentes funcionales en poco tiempo. 

No es tan avanzado como LangGraph y LangChain para construir agentes, pero hay buenas razones para usarlo:

• Constructor visual para esbozar flujos rápidamente
• Da a no programadores la capacidad de crear sistemas agentic
• Funciona en todas partes: web y ahora LangFlow Desktop para desarrollo local
• Exporta/importa flujos como JSON y para servirlos como APIs
• Ideal para enseñanza, talleres y prototipos rápidos sin apenas código

• Exportar a código: entrega a ingenieros cuando el diseño esté maduro.

Si no programas, usa LangFlow al explorar opciones de arquitectura (variantes de RAG, uso de herramientas, etc.) y para comparar rápido o comunicar diseños de forma visual a stakeholders.

Para aprender más sobre LangFlow y completar un proyecto (por ejemplo, crear un tutor), te recomiendo esta guía de LangFlow con proyecto demo. 

¿Qué es LangSmith?

La última librería que quiero tratar es LangSmith. LangSmith es la capa de observabilidad y evaluación para apps con LLM. Ofrece trazado (ver cada paso, llamada a herramienta, tokens, errores), evaluación (datasets, puntuación automatizada y con humanos) y monitorización/alertas (detectar drift y regresiones). Un ejemplo de trace en LangSmith se ve a continuación: 

Hay muchas razones por las que un desarrollador puede usar LangSmith:

1. Trazar cadenas/agentes complejos end‑to‑end (inputs, outputs, latencias, errores)
2. Evaluar cambios de forma segura con datasets y evaluadores automáticos/humanos
3. Monitorizar tráfico en vivo; detectar regresiones; comparar versiones
4. Plug‑and‑play con LangChain/LangGraph
5. Independiente del framework: puede usarse con LangChain, LangGraph u otros stacks. 
6. Funciona con distintos lenguajes: JavaScript, TypeScript, Python

Para más información sobre LangSmith, te recomiendo esta introducción detallada a LangSmith y el tutorial de LangSmith Agent Builder.

LangChain vs LangGraph vs LangSmith vs LangFlow 

En esta sección comparo las cuatro librerías para que tengas claro qué son y cuándo usarlas.

Qué son

• LangChain: para construir apps con LLM a partir de piezas modulares como prompts, modelos, herramientas y memoria.
• LangGraph: para orquestar flujos complejos, con estado, ramificación/bucles, sobre componentes de LangChain.
• LangSmith: para observar, evaluar y probar apps con LLM (recuerda: es independiente del framework).
• LangFlow: editor visual para diseñar y prototipar flujos mediante arrastrar y soltar.

Componentes principales

• LangChain: Chains, Runnables, LCEL.
• LangGraph: nodos, aristas, estado, routers, checkpointers, herramientas.
• LangSmith: trazas, ejecuciones, datasets, evaluadores, proyectos.
• LangFlow: lienzo con componentes (cargadores, LLM, recuperadores, herramientas) y conexiones.

Estructura del flujo

• LangChain: lineal o DAG, generalmente hacia adelante.
• LangGraph: grafo completo con ciclos, ramificaciones, bucles y pausas.
• LangSmith: no ejecuta flujos; envuelve tus runs para registrar y evaluar.
• LangFlow: grafo visual que suele exportarse a código de LangChain.

Gestión del estado

• LangChain: a menudo implícita o local al componente.
• LangGraph: estado central y explícito que atraviesa los nodos. Permite persistencia/checkpointing, es decir, almacenar chats en memoria.
• LangSmith: guarda metadatos de ejecuciones, entradas/salidas, métricas y feedback.
• LangFlow: configuraciones de componentes guardadas en el flujo JSON.

Flujo de control

• LangChain: primitivas limitadas para ramificación/reintentos.
• LangGraph: condicionales, reintentos y humano‑en‑el‑bucle como ciudadanos de primera clase.
• LangSmith: no ofrece control de flujo; solo evaluación/alertas.
• LangFlow: ramificación visual; la semántica exacta depende del backend exportado.

Facilidad de uso

• LangChain: APIs sencillas.
• LangGraph: curva de aprendizaje más pronunciada.
• LangSmith: muy fácil de habilitar (variables de entorno).
• LangFlow: lo más fácil para empezar de forma visual; ideal para equipos/talleres y perfiles no técnicos.

Ideal para

• LangChain: prototipos, lógica lineal, apps rápidas.
• LangGraph: apps resilientes, complejas y de larga duración/multiagente.
• LangSmith: observabilidad, depuración, tests de regresión, A/B.
• LangFlow: prototipado visual, revisiones con stakeholders, exportación a código.

Cuándo usar cada uno

• Empieza con LangChain si tu flujo es lineal o estás prototipando.
• Pasa a LangGraph si necesitas ramificación, reintentos y persistencia.
• Añade LangSmith cuando pruebes/depures o vayas a producción.
• Usa LangFlow para talleres, no programadores o para esbozar arquitecturas.

Tabla comparativa

En la tabla siguiente tienes la comparación entre LangChain, LangGraph, LangSmith y LangFlow:

Reflexiones finales

Ya hemos cubierto y comparado estas 4 librerías en bastante profundidad, pero queda mucho por aprender para convertirte en un/a AI Engineer avanzado/a con ellas. Por eso, te recomiendo cursos como RAG Systems with LangChain y building Agentic Systems with LangChain.