LangChain vs LangGraph: 4 diferenças que definem como você constrói agentes de IA

Por que essa comparação importa agora

Em 2026, a conversa sobre IA generativa deixou de girar apenas em torno de qual modelo usar e passou a girar em torno de como orquestrar agentes. Ferramentas de agentes de IA — sistemas que tomam decisões, chamam APIs, corrigem o próprio código e interagem com o mundo real — viraram o centro do debate técnico. E, nesse cenário, dois nomes dominam o ecossistema Python: LangChain e LangGraph.

Muita gente ainda trata os dois como concorrentes. Não são. O LangGraph faz parte do ecossistema LangChain — ele é, na prática, uma extensão construída sobre a base do LangChain para resolver um problema específico: fluxos de controle complexos. Entender a diferença entre eles é o que separa um projeto que escala de um que desmorona na primeira exigência de agente com memória, aprovação humana ou retomada após falha.

Neste guia, explicamos as 4 diferenças-chave entre LangChain e LangGraph, com exemplos reais de código, e mostramos quando usar cada um — para que você pare de escolher por achismo e passe a escolher por arquitetura.

Antes de tudo: o que é cada um

O LangChain é o framework que popularizou o encadeamento de componentes de IA. A ideia central é simples: você liga um prompt a um modelo e a um parser, e o dado flui em uma direção.

O LangGraph, criado pela mesma equipe, modela o fluxo como um grafo — com nós (que executam tarefas) e arestas (que definem transições). Isso permite construir loops, estados persistentes e fluxos que vão e voltam, algo que o LangChain puro não faz de forma nativa.

As 4 diferenças que mudam o seu código

1. Pipeline vs. Loops

O LangChain é, por padrão, um pipeline com direção clara. O código abaixo resume essa filosofia:

chain = prompt | model | parser
output = chain.invoke(input)

Você pode até ramificar, rodar etapas em paralelo e montar DAGs, mas a abstração padrão é: o dado anda para a frente. Isso resolve muitos problemas — recuperar documentos e gerar resposta, extrair campos e salvar, resumir texto e classificar. Mas, quando você precisa voltar, é obrigado a escrever um loop em Python por fora. Ou seja, a aplicação assume a responsabilidade, não o framework.

O LangGraph, por outro lado, trata o loop como parte do próprio fluxo. Ele é um grafo com nós e arestas:

• Nó executa uma tarefa específica.
• Aresta normal define uma transição fixa entre nós.
• Aresta condicional decide para onde ir em seguida.

Graças às arestas condicionais, dá para rotear de volta a nós anteriores sem gambiarra — exatamente o que um agente de atendimento precisa para negociar preço e reserva em múltiplas idas e vindas.

2. Sem estado vs. Com estado

Um pipeline LangChain não guarda estado internamente. Cada componente recebe uma entrada e devolve uma saída; o estado viaja na forma de dicionário, mensagem ou objeto. Isso funciona quando cada etapa só precisa do resultado da anterior. Mas, em fluxos com loops e ramificações, você precisa rastrear rascunho atual, erros de validação, histórico de conversa e contagem de tentativas — tudo em código Python extra.

O LangGraph cria agentes com estado: o estado faz parte do grafo. Você declara um esquema, normalmente um TypedDict:

class AgentState(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]
    booking_details: BookingDetails
    calculated_price: NotRequired[float | None]
    selected_slot: NotRequired[TimeOption | None]
    status: BookingStatus

Um nó não precisa reconstruir o estado inteiro — ele pode fazer atualizações parciais que o LangGraph mescla automaticamente. Campos ainda podem ter reducers (como add_messages), que acumulam valores escritos por vários nós — essencial para não sobrescrever o histórico de chat.

3. Interromper o loop vs. Humano no loop

Agentes cometem erros, e em tarefas críticas — migração de banco, reembolso, deploy em produção — você quer um humano aprovando antes da execução.

No LangChain convencional, a pausa fica por conta da aplicação: rodar a cadeia até propor uma ação, salvar a proposta, devolver o controle à API, esperar o evento de aprovação, reconstruir o contexto e só então retomar. Funciona, mas dá trabalho — e soa mais como “quebrar o loop e reconstruí-lo” do que pausar de verdade.

O LangGraph oferece chamadas dinâmicas de interrupt() dentro dos nós, que pausam a execução em pontos específicos e aguardam entrada externa, salvando o estado do grafo automaticamente:

from langgraph.types import interrupt

def approval_node(state: State):
    approved = interrupt({
        "question": "Executar esta migração?",
        "sql": state["sql"],
    })
    return {"approved": approved}

4. Recomeçar do zero vs. Retomar de onde parou

Quando um passo de uma cadeia falha, o caminho mais simples é invocar a cadeia de novo — mas isso repete chamadas de modelo, consultas de recuperação e ferramentas que já haviam funcionado. Caro e lento.

O LangGraph tem o checkpointer, uma camada de persistência que salva um snapshot do estado do grafo a cada passo. Para ativar, basta compilar com um checkpointer:

graph.compile(checkpointer=checkpointer)

Com isso, você retoma após a falha em vez de recomeçar, inspeciona o estado antes de um trecho problemático e reinicia de qualquer checkpoint anterior — economizando tempo e dinheiro.

Tabela comparativa

Quando usar cada um

Fique no LangChain quando o fluxo é previsível e segue em frente:

• Pipelines RAG padrão;
• Bots de perguntas e respostas simples;
• Extração e classificação de documentos;
• Resumos.

Considere o LangGraph quando o controle de fluxo é complexo e é a parte principal do sistema:

• Assistentes de código que geram, testam e corrigem o próprio código;
• Fluxos com planejamento e avaliação repetidos;
• Aplicações que precisam pausar, persistir e retomar.

Regra prática: use LangChain quando a aplicação é melhor entendida como pipeline; use LangGraph quando é melhor entendida como sistema com estado.

Prós e contras de cada abordagem

✅ LangChain — o que você ganha:

• Curva de aprendizado suave e início rápido;
• Sintaxe expressiva com o operador |;
• Encaixa perfeitamente em tarefas lineares como RAG e sumarização;
• Ecossistema maduro de integrações e documentação.

⚠️ LangChain — o que você não ganha:

• Loops e estado persistentes sem código extra;
• Pausa e retomada nativas;
• Controle fino de fluxo complexo dentro do framework.

✅ LangGraph — o que você ganha:

• Fluxos com loops, ramificações e ciclos nativos;
• Estado declarativo com atualizações parciais e reducers;
• Interrupção para aprovação humana sem reconstruir contexto;
• Retomada após falha via checkpointer.

⚠️ LangGraph — o que você não ganha:

• Simplicidade: exige pensar em termos de grafo e estado;
• É excesso de engenharia para pipelines triviais.

Casos de uso reais

• RAG corporativo: LangChain resolve com pipeline simples e barato.
• Agente de atendimento: LangGraph lida com preço, reserva e negociação em várias rodadas.
• Assistente de código: gerar → testar → corrigir em loop pede LangGraph.
• Automação com aprovação: reembolsos e deploys com human-in-the-loop pedem interrupt().
• Extrator de dados: PDF → campos estruturados é um pipeline, LangChain basta.

Troubleshooting

• ❌ “Meu agente perde o histórico entre mensagens” → você está em um pipeline sem estado; migre para o estado do LangGraph com reducer add_messages.
• ❌ “Preciso aprovar antes de executar, mas não sei onde pausar” → use interrupt() no nó de aprovação; o LangGraph salva o estado automaticamente.
• ❌ “Uma falha no meio do fluxo me obriga a recomeçar tudo” → compile o grafo com checkpointer e retome do checkpoint.
• ❌ “Meu pipeline está ficando lento porque repete chamadas” → avalie se o fluxo tem loops; se tiver, é sinal de que LangGraph é o ajuste certo.
• ❌ “A aresta condicional não volta para o nó anterior” → revise a definição de arestas; loops exigem aresta condicional apontando para um nó já visitado.

FAQ

LangChain e LangGraph são concorrentes? Não. O LangGraph faz parte do ecossistema LangChain e é construído sobre ele — é uma extensão para fluxos complexos.

Preciso abandonar o LangChain para usar LangGraph? Não. Você pode combinar os dois, usando LangChain para os componentes e LangGraph para a orquestração.

Para um RAG simples, qual escolher? LangChain. Um pipeline linear resolve o problema com menos complexidade.

Quando um agente realmente precisa de estado? Quando o fluxo tem loops, histórico de conversa, validações repetidas ou precisa pausar e retomar.

O que é o checkpointer? Uma camada de persistência que salva snapshots do estado do grafo a cada passo, permitindo retomar após falhas.

Vale a pena aprender LangGraph em 2026? Sim, se você constrói agentes com controle de fluxo complexo — é a abstração que separa protótipos de sistemas em produção.

O que esperar daqui para frente

A direção do mercado é clara: agentes estão deixando de ser pipelines lineares para virar sistemas com estado, memória e pontos de intervenção humana. Frameworks de orquestração como o LangGraph materializam essa mudança, e quem domina a diferença entre “encadear” e “orquestrar” sai na frente ao projetar a próxima geração de aplicações de IA. Se você está começando agora, aprenda LangChain primeiro — e evolua para LangGraph quando o fluxo pedir mais do que seguir em frente.