LangChain vs LangGraph vs LangSmith vs LangFlow: principais diferenças explicadas

Este artigo traz uma comparação formal, lado a lado, de LangChain vs LangGraph e também onde LangSmith e LangFlow entram. Vamos nos apoiar em conceitos já abordados em outros artigos da DataCamp e discutir quando escolher cada framework para colocar em produção sistemas agentic de IA. Se você busca um começo prático em LangChain, eu recomendo o curso Developing LLM Applications with LangChain.

Resumo

Antes de entrar nos detalhes, aqui vai uma visão rápida de como LangChain, LangGraph, LangSmith e LangFlow se complementam e quando você pode escolher cada um.

• LangChain: a base para montar workflows modulares de LLM (prompts, ferramentas, memória, retrievers) usando APIs simples como LCEL. Ideal para protótipos e apps lineares.
• LangGraph: o orquestrador para gerenciar workflows complexos, com estado, ramificações, retries, loops e persistência. Melhor para sistemas resilientes, prontos para produção, inclusive multi‑agente.
• LangSmith: o observador, com tracing, avaliação e monitoramento agnósticos de framework para apps de LLM. Ideal para depuração, testes de regressão e acompanhamento de qualidade.
• LangFlow: o construtor visual, com interface de arrastar e soltar para prototipar rapidamente e exportar para código. Ótimo para times, workshops e não programadores.

Heurística rápida: comece com LangChain, migre para LangGraph conforme os workflows crescem, adicione LangSmith para observabilidade e use LangFlow quando precisar iterar ou colaborar mais rápido.

Introdução ao LangChain e ao LangGraph

Grandes modelos de linguagem (LLMs) vão muito bem com prompts únicos. Isso já é praticamente consenso hoje em dia, já que usamos esses modelos o tempo todo. 

Mas aplicações reais precisam de workflows: buscar dados, raciocinar, chamar ferramentas, fazer perguntas de follow‑up, tentar de novo em caso de falha e, às vezes, pausar para validação humana. Por isso, dois frameworks aparecem sempre: LangChain e LangGraph. Eles vivem no mesmo ecossistema e trabalham juntos com frequência, mas resolvem partes diferentes do problema:

• LangChain nos ajuda a construir as etapas
• LangGraph nos ajuda a orquestrar essas etapas quando a coisa complica.

Falando em ecossistema, também vamos abordar o LangSmith (para observabilidade/avaliação) e o LangFlow (um construtor visual de arrastar e soltar), já que eles também fazem parte desse universo. 

Um breve histórico do ecossistema LangChain (2022–2025)

Vale começar com um pouco de história do ecossistema LangChain; ele virou o framework de referência para IA agentic, e entender como chegou aqui ajuda a ver por que LangGraph, LangSmith e LangFlow são importantes. 

• 2022 — nasce o LangChain: lançado como projeto open‑source em out/2022 por Harrison Chase e equipe. Rapidamente virou o framework preferido para compor apps de LLM, atraindo uma comunidade e integrações em ritmo acelerado.
• 2023 — da popularidade à plataforma: o LangChain formalizou abstrações centrais e adicionou a LCEL (LangChain Expression Language) para composição em estilo pipeline. Também surgiu uma nova forma de expor cadeias em produção via API, chamada LangServe. A empresa por trás do LangChain captou investimentos para acelerar o ecossistema.
• 2023–2024 — chega a observabilidade com LangSmith: no meio de 2023, e em GA no início de 2024, o LangSmith trouxe tracing, avaliação e monitoramento unificados para equipes depurarem/testarem cadeias/agentes e acompanharem a qualidade ao longo do tempo.
• 2024 — orquestração com LangGraph: para dar suporte a apps de múltiplas etapas/agentes e de longa duração, o LangGraph introduziu um runtime de grafo com estado explícito, roteadores/ramificações, loops, retries e checkpointers para persistência. Foi um passo vital por estabelecer a base para agentes duráveis e prontos para produção. Atualizações posteriores ampliaram a personalização e integrações com diferentes provedores de LLM, incluindo o Ollama (modelos open‑source). 
• 2024–2025 — construção visual com LangFlow. O editor visual do LangFlow evoluiu rapidamente (grandes releases até o fim de 2024 e uma Launch Week em 2025), permitindo arrastar e soltar componentes de LLM, iterar rápido e exportar fluxos para código. Foi importante porque abriu caminho para não programadores criarem agentes de IA robustos.
• 2025 — rumo a plataformas gerenciadas de agentes. A LangChain anunciou marcos importantes: uma API funcional para LangGraph, templates de agentes prontos e a LangGraph Platform para implantar e gerenciar agentes com estado em escala. Isso foi decisivo, pois permitiu aos desenvolvedores operar agentes confiáveis em produção.

Introdução rápida a LangChain e LangGraph

Agora, vamos mergulhar no coração do ecossistema, começando por LangChain e LangGraph. 

LangChain é um framework modular para criar aplicações com LLM. Ele oferece blocos — prompts, modelos, memória, ferramentas, retrievers — e uma forma simples de encadeá‑los em um pipeline usando as APIs Runnable/LCEL (já vamos falar delas). Gosto de pensar nele como um kit de peças de Lego para padrões comuns com LLM, como RAG, perguntas e respostas, chatbots e agentes que usam ferramentas. 

LangGraph é mais novo, uma camada de orquestração baseada em grafos construída sobre componentes do LangChain. Em vez de uma sequência única de passos, o app é modelado como nós (as ações) e arestas (as transições), com um objeto de estado explícito fluindo pelo grafo. Vamos detalhar isso já já, mas por enquanto lembre que esse design torna natural ramificar (seguir caminhos diferentes), iterar (fazer perguntas esclarecedoras até ter confiança), tentar novamente (em erros de ferramenta/modelo) e pausar para revisão humana — exatamente o que precisamos para agentes duráveis, em nível de produção.

Você pode estar se perguntando:

“Por que compará‑los?”

A questão é: embora compartilhem componentes, eles miram níveis de complexidade diferentes:

• LangChain brilha em fluxos rápidos e lineares. Exemplo: carregar PDF → segmentar → gerar embeddings → recuperar → responder. Dá para prototipar em minutos.
• LangGraph é melhor quando a lógica precisa se adaptar. Exemplo: se confiança < 0,7 → fazer pergunta de esclarecimento (loop); se pagamento falhar → tentar novamente com backoff; se o pedido parecer arriscado → pausar para humano. Esses comportamentos são nativos em um grafo.

Na prática, muitos desenvolvedores começam com LangChain para validar a ideia e depois evoluem para LangGraph conforme adicionam ramificações, tratamento de erros, coordenação multi‑agente ou durabilidade.

O que é LangChain?

Agora vamos nos aprofundar no LangChain, entender seu uso e codificar aplicações com ele. Reforçando: LangChain é uma biblioteca que nos permite construir a base para workflows sequenciais com LLM. 

LCEL

Para começar, quero explicar o que é LCEL. LCEL, ou LangChain Expression Language, é uma forma de conectar blocos com pipes (|). Cada bloco pode ser um prompt, um modelo, um retriever ou um parser. Ao juntá‑los, obtemos uma cadeia que podemos executar repetidamente, tornando o código muito mais eficiente. 

Vamos a alguns exemplos.

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() # Esta é a nossa cadeia

print(chain.invoke({"question": "Give me 3 focus tips."}))     # uma chamada única

qs = [{"question": q} for q in ["One tactic for RAG?", "Explain LCEL in 1 line."]]
print(chain.batch(qs))                                         # várias chamadas de uma vezTecnologia

Na minha opinião, o código acima mostra o jeito mais simples de usar LCEL. Primeiro criamos um template de prompt que sempre inclui uma mensagem do sistema (“you are concise”) e deixa espaço para a pergunta do usuário. A mensagem de sistema funciona como uma instrução para o LLM responder/agir de um jeito específico. Depois conectamos esse template a um modelo da OpenAI — GPT‑4o‑mini. 

Por fim, adicionei um parser de saída, que basicamente converte a resposta em texto puro.

Agora vem a parte mais importante: o operador | é o que cola esses blocos em um único pipeline.

Também quero falar sobre invoke() e batch(). Quando chamamos chain.invoke(...), o pipeline roda uma vez: o template preenche a pergunta, o modelo gera a resposta e o parser retorna o texto limpo. 

Já ao chamar chain.batch(...), a mesma cadeia executa vários inputs de uma vez, o que é bem mais rápido do que iterar um a um. Na prática, isso facilita passar de uma chamada simples para tratar conjuntos inteiros de dados quase sem código extra. 

Quero mostrar outro exemplo:

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())

# Streaming simples
for chunk in stream_chain.stream({"topic": "Explain PID in 2 lines"}):
    print(chunk, end="")Tecnologia

Este código é bem parecido com o primeiro, mas em vez de apenas chamar, usamos streaming. Com .stream(...), o modelo não espera a resposta inteira ficar pronta. Em vez disso, manda pedaços de texto conforme vai gerando, e a gente imprime em tempo real. 

O principal recado aqui é que a LCEL é o sistema simples de “tubos e blocos” que permite encaixar prompts, modelos, ferramentas e parsers e, na hora, ter uma cadeia que a gente pode rodar, processar em lote ou transmitir sem código extra.

Saídas estruturadas com Pydantic

Saídas estruturadas são vitais em agentes de IA. Em vez de um texto longo e bagunçado, o agente devolve a resposta em um formato claro como JSON, tabelas ou listas. Isso facilita leitura, uso e integração com outras ferramentas por máquinas e pessoas.

Um dos principais frameworks usados para isso na indústria é o 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())Tecnologia

Neste exemplo, o método .with_structured_output() é a peça‑chave, pois instrui o LLM a devolver a saída no formato do modelo Pydantic que criamos. Por baixo dos panos, o LangChain garante que a resposta do agente seja um JSON válido que bate com o schema e, em seguida, transforma isso em um objeto Python pronto para uso. 

Assim, em vez de texto solto, recebemos algo como TaskPlan(title="...", steps=["...", "...", "..."]). Isso é especialmente útil quando usamos ferramentas. 

Chamadas de ferramentas no LangChain

Ferramentas são importantes porque estendem a capacidade do LLM para executar tarefas que ele não faria sozinho, como pesquisar na internet. 

O que eu mais gosto das ferramentas é que o LangChain (e outros frameworks agentic) oferece ferramentas prontas chamadas Built-In Tools, fáceis de usar. Além disso, podemos criar nossas próprias ferramentas usando o decorator @tool, que informa ao LangChain que essa função é 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])   # expondo as ferramentas ao modelo

resp = llm_tools.invoke("What is 9*5? If needed, use a tool.")
print(resp.tool_calls or resp.content)   # o modelo pode emitir uma chamada de ferramenta com argumentosTecnologia

No código acima, criei uma ferramenta simples que recebe dois números e retorna o produto. Para dar ao modelo interno (aqui, o GPT‑4o‑mini) acesso a essas ferramentas, usamos llm.bind_tools() passando a lista de ferramentas, expondo as ferramentas ao modelo. 

Memória conversacional

Memória também é vital ao construir agentes de IA. Agentes com memória conseguem lembrar do que foi dito antes, nossas preferências, o que funcionou e o que não funcionou. Sem memória, cada conversa parece um primeiro encontro — você precisa repetir o contexto básico toda hora, o que é cansativo. 

No LangChain, memória significa salvar mensagens ou fatos passados em um storage (memória, banco de dados ou vector store). Quando o agente roda de novo, ele pode buscar essa memória para respostas mais consistentes e inteligentes.

Há dois tipos principais: memória de curto prazo (mensagens recentes no mesmo chat) e memória de longo prazo (fatos ou preferências lembrados ao longo de várias sessões). Uma sessão é uma conversa única ou janela de interação, em que o agente acompanha o que foi dito até encerrar.

A de curto prazo mantém o contexto na conversa atual; a de longo prazo faz o agente parecer mais pessoal e útil com o tempo.

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))Tecnologia

No trecho acima, o código cria uma cadeia de chat que lembra mensagens anteriores na sessão. O prompt tem um placeholder de histórico e o RunnableWithMessageHistory preenche automaticamente com a conversa certa a cada vez. O store guarda históricos para sessões diferentes. 

É importante usar memória com critério. Precisamos decidir e codificar o que vale manter, quando armazenar e quanto voltar a passar no prompt. Excesso de memória pode deixar tudo lento ou estourar limites, mas o equilíbrio certo torna os agentes muito mais úteis.

O que é LangGraph?

Agora partimos para o outro framework agentic — o LangGraph. 

Para explicar o LangGraph de forma simples, vou usar uma analogia: o fluxograma da mochila. 

Pense no LangGraph como um fluxograma do seu app de IA. Cada caixa (nó) é uma pequena função Python que faz um trabalho. As setas (arestas) dizem qual caixa roda em seguida. Uma pequena mochila de dados (o “estado”) caminha pelo fluxograma para cada nó ler e complementar. Em um app de chat, por exemplo, a mochila costuma ser a lista corrente de mensagens.

Grafo fundamental

Vai fazer mais sentido com um exemplo: 

pip install langgraph langchain-openaiTecnologia

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 é a mochila que se move pelo grafo.
class State(TypedDict):
	# Para adicionar mensagens ao estado
    messages: Annotated[List, add_messages]

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

# Este é um nó que chama o modelo e adiciona a resposta à mochila.
def model_node(state: State):
    reply = llm.invoke(state["messages"])
    return {"messages": [reply]}

# Construindo o grafo
graph = StateGraph(State)
graph.add_node("model", model_node)
graph.add_edge(START, "model")
graph.add_edge("model", END)

# Compilando e executando uma vez
app = graph.compile()

result = app.invoke({"messages": [HumanMessage(content="Explain LangGraph in one sentence.")]} )
print(result["messages"][-1].content)Tecnologia

Vamos passar pelo código. Aqui estamos construindo o app LangGraph mais simples possível. O estado é como uma mochila carregando mensagens pelo grafo. Definimos com State, dizendo ao LangGraph para manter sempre a lista de mensagens do chat.

Depois vem o nó, que aqui é só uma função, model_node, que olha a mochila, envia as mensagens ao LLM e retorna a resposta. O LangGraph adiciona essa resposta de volta à mochila automaticamente.

O grafo em si é um fluxograma mínimo: START → model → END. Ao compilar, o LangGraph transforma o desenho em um app executável.

Por fim, rodamos o app (não o grafo — e sim o grafo compilado) com uma mochila que já contém uma mensagem humana.

Para ajudar na visualização, podemos rodar este código para ver o grafo:

from IPython.display import Image, display
display(Image(app.get_graph().draw_mermaid_png()))Tecnologia

Mas atenção: o fato de haver uma visualização não garante que o grafo vai rodar! Podem existir erros lógicos a corrigir antes.

Grafo com ramificações

Vamos avançar para ramificação — um componente importante (e simples) de qualquer sistema agentic robusto. Ela dá mais liberdade de escolha aos agentes, transformando um workflow em um sistema agentic.

Veja o 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

# Definindo o estado
class State(TypedDict):
    messages: Annotated[List, add_messages]

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

def answer_node(state: State):
    # Resposta normal usando todo o histórico do chat.
    return {"messages": [llm.invoke(state["messages"])]}

def clarify_node(state: State):
    # LLM pedindo um breve complemento para ter detalhes suficientes
    return {"messages": [AIMessage(content="Could you share a bit more so I can be precise?")]}

# Função roteadora
def route(state: State):
    # Procura a última mensagem humana e conta palavras.
    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)
graph.add_node("clarify", clarify_node)

# Aresta condicional conectando a função roteadora
graph.add_conditional_edges(START, route, {"answer": "answer", "clarify": "clarify"})
graph.add_edge("answer", END)
graph.add_edge("clarify", END)
app = graph.compile() # Compilando o grafoTecnologia

Quase tudo é igual ao primeiro agente, com exceção da aresta condicional. Ela permite oferecer rotas diferentes com base no julgamento do LLM. Visualmente, fica assim:

Com arestas condicionais, já dá para montar sistemas agentic bem robustos com o que vimos. Se quiser um tutorial mais amplo, recomendo meu tutorial em vídeo de LangGraph.

Recentemente, surgiu também o LangGraph Studio, e recomendo muito este guia do LangGraph Studio.

O que é LangFlow?

Embora LangChain e LangGraph sejam as bibliotecas mais usadas da família, vale falar brevemente do LangFlow também. 

Pense no LangFlow como uma tela de arrastar e soltar para apps com LLM. Cada nó = um passo (prompt, modelo, ferramenta, retriever, banco vetorial, operação de arquivo etc.). Conectamos nós em um fluxo, depois executamos, exportamos ou publicamos. É ótimo para iterar rápido e colaborar com não programadores, além de transformar ideias em agentes funcionais em pouco tempo. 

Não é tão avançado quanto LangGraph e LangChain para construir agentes; porém, há bons motivos para usar:

• Construtor visual para rascunhar fluxos rapidamente
• Dá a não programadores a capacidade de criar sistemas agentic
• Roda em qualquer lugar: web e, agora, LangFlow Desktop para desenvolvimento local
• Exporta/importa fluxos em JSON e para servir como APIs
• Excelente para ensino, workshops e protótipos rápidos sem muito código

• Exportar para código: entregar aos engenheiros quando estabilizar.

Se você não programa, use o LangFlow para explorar opções de arquitetura (variantes de RAG, uso de ferramentas etc.) e comparar rapidamente, ou quando precisar comunicar o design de forma visual a stakeholders.

Para saber mais e construir um projeto, como um Tutor, recomendo muito este guia de LangFlow com projeto demo. 

O que é LangSmith?

A última biblioteca que quero cobrir é o LangSmith. LangSmith é a camada de observabilidade + avaliações para apps com LLM. Ele fornece tracing (permite ver cada etapa, chamada de ferramenta, token, erro), avaliação (datasets, notas automatizadas e com humanos no loop) e monitoramento/alertas (acompanhar drift, regressões). Um exemplo de trace no LangSmith pode ser visto abaixo: 

Há muitos motivos para usar LangSmith:

1. Traçar cadeias/agentes complexos de ponta a ponta (entradas, saídas, latências, erros)
2. Avaliar mudanças com segurança usando datasets + avaliadores automáticos/humanos
3. Monitorar tráfego ao vivo; capturar regressões; comparar versões
4. Plug and play com LangChain/LangGraph
5. Agnóstico de framework — pode ser usado com LangChain, LangGraph ou stacks totalmente diferentes. 
6. Funciona em qualquer stack de linguagem — JavaScript, TypeScript, Python

Para mais informações, recomendo esta introdução ao LangSmith e o tutorial LangSmith Agent Builder.

LangChain vs LangGraph vs LangSmith vs LangFlow 

Nesta seção, quero comparar as quatro bibliotecas para você entender claramente o que são e quando usar cada uma.

O que são

• LangChain: para construir apps de LLM a partir de peças modulares como prompts, modelos, ferramentas e memória.
• LangGraph: para orquestrar workflows complexos, com estado, ramificação/looping, em cima dos componentes do LangChain.
• LangSmith: para observar, avaliar e testar apps de LLM (lembre: é agnóstico de framework).
• LangFlow: editor visual para desenhar e prototipar fluxos por arrastar e soltar.

Principais componentes

• LangChain: Chains, Runnables, LCEL.
• LangGraph: nós, arestas, estado, roteadores, checkpointers, ferramentas.
• LangSmith: traces, runs, datasets, evaluators, projects.
• LangFlow: canvas com componentes (loaders, LLMs, retrievers, ferramentas) e conexões.

Estrutura do workflow

• LangChain: linear ou DAG, geralmente só para frente.
• LangGraph: grafo completo com ciclos, ramificações, loops e pausas.
• LangSmith: não é framework de execução; encapsula suas runs para logging/avaliação.
• LangFlow: grafo visual, tipicamente exportado para código LangChain.

Gestão de estado

• LangChain: muitas vezes implícito ou local ao componente.
• LangGraph: estado central e explícito percorrendo os nós. Permite persistência/checkpointing — ou seja, guardar conversas.
• LangSmith: armazena metadados de runs, entradas/saídas, métricas e feedback.
• LangFlow: configurações de componentes salvas no fluxo JSON.

Fluxo de controle

• LangChain: primitivas limitadas de ramificação/retry.
• LangGraph: condicionais, retries e humano‑no‑loop como elementos de primeira classe.
• LangSmith: não oferece fluxo de controle; foca em avaliação/alertas.
• LangFlow: ramificação visual; semântica exata depende do backend exportado.

Facilidade de uso

• LangChain: APIs simples.
• LangGraph: curva de aprendizado mais íngreme.
• LangSmith: muito fácil de habilitar via variáveis de ambiente.
• LangFlow: o mais fácil para começar visualmente; ótimo para times/workshops, especialmente não programadores.

Melhor para

• LangChain: prototipagem, lógica linear, apps rápidos.
• LangGraph: apps resilientes, complexos, de longa duração/multi‑agente.
• LangSmith: observabilidade, depuração, testes de regressão, avaliações A/B.
• LangFlow: prototipagem visual, validação com stakeholders, exportação de código.

Quando usar cada um

• Comece com LangChain se o workflow for linear/prototipagem.
• Migre para LangGraph se precisar de ramificações, retries, persistência.
• Adicione LangSmith ao testar/depurar ou ao ir para produção.
• Use LangFlow para workshops, não programadores ou esboçar arquiteturas.

Tabela comparativa

Na tabela abaixo, você encontra a comparação entre LangChain, LangGraph, LangSmith e LangFlow:

Considerações finais

Agora cobrimos e comparamos essas 4 bibliotecas em bastante profundidade, mas claro que há muito mais para aprender até se tornar um engenheiro de IA avançado com elas. Por isso, recomendo fortemente cursos como RAG Systems with LangChain e building Agentic Systems with LangChain.