Blog

"LangChain e LangGraph não são concorrentes. Eles operam em camadas diferentes da mesma arquitetura de agentes."

Se você pesquisa por LangChain, LangGraph ou LangChain vs LangGraph, a dúvida real quase nunca é só conceitual. Ela é arquitetural: qual tecnologia acelera a entrega hoje sem comprometer a confiabilidade quando o agente sair da prova de conceito e entrar em produção?

A resposta curta é esta: LangChain é a camada de framework e ergonomia; LangGraph é a camada de orquestração e runtime. Em times maduros, os dois frequentemente coexistem. Você começa com abstrações prontas em LangChain e recorre ao LangGraph quando precisa de estado explícito, checkpoints, memória, loops, branching, human-in-the-loop e workflows long-running.

Este guia foi escrito para responder com clareza às buscas mais comuns sobre essas tecnologias: o que é LangChain, o que é LangGraph, qual a diferença entre LangChain e LangGraph e quando usar cada um em produção.

O que você vai aprender

• O que é LangChain e o que é LangGraph.
• Como as duas tecnologias se relacionam na prática.
• Quando usar LangChain, quando usar LangGraph e quando usar ambos.
• Como pensar arquitetura, estado e observabilidade em agentes de IA.
• Quais erros evitar ao desenhar workflows agentic em produção.

Resposta curta: LangChain vs LangGraph

Se você precisa de uma resposta objetiva para tomar uma decisão rápida de stack, use esta regra:

A melhor forma de pensar no ecossistema atual é em camadas:

Aplicação / API / UI
        ↓
LangChain (agentes, tools, models, middleware)
        ↓
LangGraph (estado, nós, arestas, checkpoints, durable execution)
        ↓
Persistência, observabilidade e deployment

O que é LangChain

LangChain é um framework open source de alto nível para construir aplicações e agentes com LLMs. O valor dele está menos em “inventar um runtime” e mais em padronizar a experiência de desenvolvimento: integração com modelos, tools, structured output, middleware, memory, retrieval e agent loops.

Na prática, LangChain é forte quando você quer:

• subir um agente funcional rápido;
• conectar modelos e ferramentas sem criar muita infraestrutura;
• trocar provider com menos acoplamento;
• manter uma API de desenvolvimento relativamente estável;
• evoluir de um fluxo simples para um agente mais sofisticado sem reescrever tudo do zero.

No ecossistema atual, a abstração create_agent é a porta de entrada mais importante. Ela entrega um agente pronto para produção, com loop de tools e suporte a extensões. O ponto técnico que muita gente perde é este: o agente criado com LangChain já roda sobre LangGraph. Em outras palavras, LangChain te dá ergonomia; o runtime embaixo continua sendo orientado a grafo.

O que é LangGraph

LangGraph é o runtime e framework de orquestração de baixo nível do ecossistema LangChain para agentes stateful e workflows long-running. Ele foi desenhado para quem precisa controlar explicitamente o fluxo de execução.

Em vez de pensar apenas em um “agent loop”, você passa a modelar o sistema como um grafo:

• nós representam etapas de processamento;
• arestas representam transições;
• estado carrega contexto entre etapas;
• checkpoints permitem pausar, retomar e inspecionar execuções.

Esse modelo fica especialmente valioso quando o fluxo deixa de ser linear e começa a exigir:

• ramificações condicionais;
• retries controlados;
• validações determinísticas;
• revisão humana;
• memória de curto e longo prazo;
• execução durável entre múltiplas interações.

Outro diferencial importante é que o LangGraph trata memória como parte da arquitetura do runtime. A memória de curto prazo vive no estado da thread e pode ser persistida via checkpointer; a memória de longo prazo pode ser armazenada e recuperada entre sessões. Para aplicações corporativas, isso faz diferença real em confiabilidade, auditoria e experiência do usuário.

LangChain vs LangGraph: qual é a diferença técnica de verdade?

A comparação mais útil não é “qual é melhor?”, e sim em qual camada do problema cada tecnologia atua.

A forma mais precisa de resumir é esta:

• LangChain responde à pergunta: “Como eu desenvolvo um agente rápido e com boa ergonomia?”
• LangGraph responde à pergunta: “Como eu opero um agente complexo com estado, controle e previsibilidade?”

LangChain vs LangGraph para RAG e multiagentes

Muita busca sobre essas tecnologias acontece no contexto de RAG e multiagentes, então vale separar os cenários.

LangChain vs LangGraph para RAG

Se o seu caso é um RAG clássico — recuperar documentos, montar contexto e gerar resposta — LangChain normalmente já resolve muito bem. Você ganha velocidade de implementação e integrações suficientes para publicar um primeiro produto com baixo atrito.

Mas quando o problema evolui para agentic RAG, LangGraph passa a fazer mais sentido. Exemplos:

• o agente decide se deve recuperar contexto ou responder direto;
• o fluxo tenta um retriever, valida a resposta e faz fallback;
• existe etapa de revisão antes da resposta final;
• o sistema precisa guardar estado entre interações longas;
• há necessidade de retries, roteamento e auditoria.

LangChain vs LangGraph para multiagentes

Para experiências com múltiplos agentes especialistas, LangGraph tende a ser a melhor base. Isso acontece porque multiagentes raramente é só “um agente chamando outro”. Normalmente existe:

• transferência de contexto;
• isolamento de responsabilidades;
• regras de roteamento;
• sincronização de estado;
• pontos de aprovação ou de parada.

Nesse tipo de desenho, modelar o fluxo como grafo costuma ser mais claro e mais seguro do que esconder a complexidade dentro de prompts.

Quando usar LangChain

Use LangChain quando o objetivo principal for velocidade com flexibilidade suficiente.

Ele é uma escolha forte para:

• MVPs e provas de conceito;
• agentes com poucas tools;
• copilotos internos;
• automações assistidas por LLM;
• aplicações que ainda não exigem state machine explícita;
• times que querem começar rápido e aprender o domínio antes de investir em orquestração mais pesada.

Também é a escolha certa quando o time ainda está respondendo perguntas básicas como:

• quais tools o agente realmente precisa;
• onde estão os gargalos de contexto;
• qual provider/modelo entrega melhor custo-benefício;
• quais etapas precisam ser determinísticas de verdade.

Em resumo: não comece complexo sem necessidade. Se o problema ainda é simples, LangChain normalmente é a melhor porta de entrada.

Quando usar LangGraph

Use LangGraph quando a sua preocupação principal for controle operacional e confiabilidade em produção.

Ele se destaca quando você precisa de:

• workflow com múltiplas etapas e regras explícitas;
• execução durável em tarefas longas;
• pause/resume entre chamadas;
• memória persistente;
• validação humana antes de executar ações sensíveis;
• orquestração híbrida entre lógica determinística e raciocínio do modelo;
• supervisão de agentes especializados;
• rastreabilidade mais clara do estado do sistema.

Na prática, LangGraph é o caminho natural para casos como:

• atendimento com políticas rígidas e aprovação;
• agentes que operam tickets, documentos ou processos internos;
• pipelines de pesquisa e síntese com múltiplas fases;
• agentes que precisam retomar trabalho depois de interrupções;
• fluxos com auditoria, governança e observabilidade mais exigentes.

Onde entra o Deep Agents

Hoje, o ecossistema da LangChain tem uma terceira camada relevante: Deep Agents.

Ele não substitui o entendimento de LangChain e LangGraph, mas adiciona uma experiência mais batteries-included para tarefas complexas. É útil quando você quer capacidades como:

• planejamento;
• lista de tarefas;
• subagentes;
• file system virtual;
• gerenciamento de contexto;
• memória mais robusta.

Se LangChain acelera o início e LangGraph te dá o runtime, o Deep Agents atua como um harness opinionado para cenários mais pesados.

Arquitetura recomendada para produção

Uma arquitetura pragmática para times que querem evoluir sem retrabalho costuma seguir este desenho:

1. Interface e camada de aplicação

Sua API, dashboard, chat ou integração com Slack, WhatsApp ou e-mail fica separada da lógica agentic. Isso facilita testes e desacopla canais de entrada.

2. Camada de agente em LangChain

Use LangChain para compor modelo, tools, middleware, output estruturado e regras de contexto. Aqui você ganha produtividade.

3. Camada de orquestração em LangGraph

Quando um fluxo ficar crítico, extraia essa parte para um grafo explícito com estado. Isso é especialmente útil para processos com validação, retries, revisão humana e múltiplos passos.

4. Persistência e memória

Defina desde cedo o que é:

• estado da execução;
• memória de curto prazo;
• memória de longo prazo;
• dado de negócio;
• log de auditoria.

Misturar essas camadas é um dos erros mais comuns em projetos com agentes.

5. Observabilidade e avaliação

Agentes sem tracing e avaliação contínua viram uma caixa-preta cara. Use observabilidade desde o começo para entender:

• quais tools são chamadas;
• em que ponto o fluxo falha;
• onde o custo explode;
• quando o agente entra em loop;
• quais prompts e políticas precisam ser ajustados.

Exemplo 1: agente simples com LangChain

Abaixo, um exemplo conceitual de um agente simples com tool calling. Ele mostra o tipo de problema em que LangChain brilha.

from langchain.agents import create_agent

def buscar_status_pedido(numero: str) -> str:
    """Retorna o status de um pedido."""
    return f"Pedido {numero}: em separação"

agent = create_agent(
    model="SEU_MODELO",
    tools=[buscar_status_pedido],
    system_prompt=(
        "Você é um assistente de operações. "
        "Use ferramentas quando precisar de dados externos."
    ),
)

resposta = agent.invoke(
    {
        "messages": [
            {"role": "user", "content": "Qual o status do pedido 12345?"}
        ]
    }
)

print(resposta)

Esse padrão costuma ser suficiente para muitos copilotos corporativos e automações leves.

Exemplo 2: workflow stateful com LangGraph

Agora compare com um fluxo em que o agente precisa passar por geração, revisão e decisão condicional.

from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class Estado(TypedDict):
    pergunta: str
    rascunho: str
    aprovado: bool

def gerar_rascunho(state: Estado):
    return {"rascunho": f"Resposta preliminar para: {state['pergunta']}"}

def revisao_humana(state: Estado):
    # Em produção, aqui pode existir um gate real de aprovação
    return {"aprovado": True}

def proximo_passo(state: Estado):
    return END if state["aprovado"] else "gerar_rascunho"

graph = StateGraph(Estado)
graph.add_node("gerar_rascunho", gerar_rascunho)
graph.add_node("revisao_humana", revisao_humana)

graph.add_edge(START, "gerar_rascunho")
graph.add_edge("gerar_rascunho", "revisao_humana")
graph.add_conditional_edges("revisao_humana", proximo_passo)

app = graph.compile()

resultado = app.invoke(
    {
        "pergunta": "Resuma os tickets críticos da semana",
        "aprovado": False,
        "rascunho": ""
    }
)

print(resultado)

O ganho do LangGraph não é “escrever mais código”. O ganho é explicitar o fluxo, tornar o estado visível e preparar o sistema para interrupções, validações e evolução controlada.

Erros comuns ao escolher entre LangChain e LangGraph

1. Tratar LangChain e LangGraph como tecnologias rivais

Esse é o erro mais frequente. Na prática, elas se complementam. Um desenvolvedor experiente frequentemente usa LangChain para compor e LangGraph para orquestrar.

2. Começar por LangGraph sem necessidade real

Se o problema ainda é simples, começar pelo nível mais baixo pode gerar complexidade antes da hora. Nem todo agente precisa de um grafo customizado.

3. Esconder lógica crítica dentro do prompt

Quando regras de negócio, compliance ou aprovação vivem só no prompt, o sistema fica frágil. Etapas importantes devem virar estado, transição ou validação explícita.

4. Confundir histórico de conversa com memória de aplicação

Histórico não substitui memória persistente, e memória persistente não substitui dado transacional. Cada camada tem responsabilidade diferente.

5. Ignorar observabilidade

Sem tracing, métricas e avaliação, você não sabe se o agente está melhorando ou apenas variando de comportamento.

Checklist rápido de decisão

• Quero lançar um agente funcional rápido: comece com LangChain.
• Preciso de controle fino do fluxo e do estado: use LangGraph.
• Tenho múltiplas etapas, retries e aprovação humana: use LangGraph.
• Quero planejamento, subagentes e contexto mais robusto: avalie Deep Agents.
• Quero equilíbrio entre velocidade e escalabilidade: use LangChain e extraia os fluxos críticos para LangGraph.

FAQ

LangGraph substitui LangChain?

Não. LangGraph é o runtime/orquestrador de baixo nível. LangChain continua sendo a camada de framework que facilita a construção de agentes.

Posso usar LangGraph sem LangChain?

Sim. Você pode usar LangGraph diretamente quando quiser controlar modelos, tools e fluxo por conta própria.

LangChain serve para produção?

Serve, especialmente quando o fluxo ainda não exige controle fino de estado. Além disso, os agentes do LangChain já rodam sobre LangGraph.

Quando vale adotar LangGraph desde o início?

Quando os requisitos de produção já são claros desde o dia um: persistência, retomada, aprovação humana, branching, auditoria e workflows long-running.

Deep Agents é obrigatório?

Não. Ele é útil quando você quer uma camada mais opinionada para tarefas complexas com planejamento, subagentes e gerenciamento de contexto.

Conclusão

A melhor decisão entre LangChain e LangGraph depende menos de preferência pessoal e mais da natureza operacional do seu fluxo.

Se você quer velocidade de implementação, uma boa abstração de agente e liberdade para integrar modelos e tools, LangChain é a escolha natural.

Se você quer confiabilidade operacional, estado explícito, memória persistente, human-in-the-loop e workflows realmente complexos, LangGraph é a base certa.

Na maioria dos times maduros, a resposta final não é “LangChain ou LangGraph”. É LangChain para acelerar a construção, LangGraph para sustentar a complexidade em produção.

Referências oficiais

• LangChain Overview
• LangChain Agents
• LangGraph Overview
• LangGraph Memory Overview
• Frameworks, Runtimes, and Harnesses
• Deep Agents Overview