A maior parte do material sobre LangChain que circula em português descreve um framework que não existe mais.
Os tutoriais ensinam a montar chains, a encadear prompts com LCEL e a rodar tudo dentro do AgentExecutor, um desenho que foi padrão até o fim de 2025 e que deixou de ser o centro da biblioteca.
Em 22 de outubro de 2025, a LangChain publicou a versão 1.0 do framework e a 1.0 do LangGraph no mesmo dia, chamando as duas de primeiras versões maiores do código aberto depois de três anos de crítica acumulada.
O que o 1.0 aposentou
A reclamação era sempre parecida: as abstrações pesavam demais, a superfície de pacotes cresceu sem controle e quem precisava de um comportamento fora do padrão acabava descendo para chamadas cruas de API.
A resposta veio em três movimentos.
O primeiro mudou o foco, e a biblioteca deixou de ser um catálogo de chains para virar um harness de agente.
A documentação resume a ideia numa equação: agente é modelo mais harness, isto é, o modelo com suas ferramentas, seu prompt e seus middleware.
O segundo movimento reduziu o namespace, e o que sobrou das chains antigas foi para um pacote separado chamado langchain-classic.
Quem mantém código escrito antes do 1.0 continua tendo onde rodar, mas a biblioteca principal ficou menor e mais fácil de percorrer.
O terceiro movimento assumiu um compromisso público de não quebrar compatibilidade antes da versão 2.0. Para um projeto que ficou conhecido justamente pela rotatividade das APIs, essa é a parte mais relevante do anúncio.
A arquitetura que sobrou
Antes do 1.0, a divisão era fácil de explicar: LangChain para chains, LangGraph para agentes, duas bibliotecas irmãs que resolviam problemas diferentes.
Hoje a relação é de camadas, com o LangGraph no papel de runtime de baixo nível, responsável por estado, nós, arestas, checkpointing e streaming, e o LangChain como a API de alto nível que roda por cima dele.
A consequência prática é direta. Quando você chama o construtor de agente do LangChain, quem executa o laço é o LangGraph, e é dessa camada de baixo que vêm persistência, execução durável e interrupção para revisão humana.
O LangGraph se descreve como framework de orquestração e runtime para agentes de longa duração e com estado, tendo a durabilidade como argumento central: um agente com execução durável retoma do ponto onde parou depois de uma falha, em vez de recomeçar do zero.
As versões publicadas hoje, consultadas no PyPI em setembro de 2026, são LangChain 1.4.0 e LangGraph 1.2.11. A linha 1.x andou rápido desde o anúncio, mas dentro da promessa de não quebrar.
Como isso aparece no código
O construtor create_agent substituiu o create_react_agent que os tutoriais antigos usavam, e essa função antiga está marcada como obsoleta. Um agente mínimo ficou assim:
from langchain.agents import create_agent
from langchain_core.tools import tool
from langgraph.checkpoint.memory import InMemorySaver
@tool
def consulta_vendas(trimestre: str) -> str:
"""Devolve o faturamento de um trimestre fiscal, como 'Q1-2026'."""
return buscar_no_banco(trimestre)
agente = create_agent(
model="anthropic:claude-sonnet-4-5",
tools=[consulta_vendas],
system_prompt="Você é um analista financeiro preciso.",
checkpointer=InMemorySaver(),
)
Três coisas chamam atenção nesse bloco.
A primeira é o prefixo anthropic: no nome do modelo. O provedor é inferido dali, e trocar para openai:gpt-5.1 não exige reescrever o laço nem o parsing das respostas, que é a portabilidade entre provedores que a biblioteca vende desde o começo.
A segunda é o checkpointer, que guarda o estado da conversa e é o que permite retomar uma execução interrompida. Nos exemplos antigos, isso exigia montar o grafo à mão.
A terceira é o tamanho do bloco. O laço do agente não aparece no código do usuário, porque ele ficou dentro da biblioteca, e é justamente esse o ponto da versão 1.0.
Middleware: onde mora a customização
Toda a flexibilidade que antes se resolvia editando o laço do agente passou para um sistema de middleware, que são funções penduradas em pontos do passo de execução.
Você monta uma lista e cada item intercepta o que precisa, sem reimplementar o laço para trocar o comportamento.
O 1.0 já vem com três prontos. Um faz revisão humana, pausando para aprovar uma chamada de ferramenta antes que ela aconteça.
Outro resume a conversa para manter conversas longas dentro da janela de contexto. O terceiro remove dados pessoais identificáveis antes que eles cheguem ao modelo ou aos logs.
Quem precisa de outra coisa escreve o próprio middleware, e como o ponto de extensão é sempre o mesmo, a lista de capacidades cresce sem inflar a biblioteca.
Quando usar LangChain e quando ir direto ao langgraph
A escolha deixou de ser entre duas ferramentas rivais e passou a ser uma escolha de nível de abstração dentro da mesma pilha.
O LangChain cobre bem o caso comum. Um agente com laço padrão de chamada de ferramentas, mais middleware para aprovação, resumo e redação de dados sensíveis, resolve a maioria dos projetos, com curva de aprendizado de horas em vez de semanas.
O LangGraph direto faz sentido quando o controle precisa ser explícito, como em esquemas de estado próprios, execução que sobrevive a reinícios, interrupções em pontos arbitrários do fluxo e topologias com vários agentes.
A documentação é franca sobre o limite. Sistemas multiagente são possíveis no LangChain, mas você cresce para fora do laço único logo, enquanto no LangGraph os subgrafos compõem essas topologias de forma natural.
Falta a terceira peça, que é a camada de observabilidade. O LangSmith registra cada entrada, saída e chamada aninhada para inspeção e depuração, e a recomendação atual da LangChain é essa divisão de trabalho: LangChain para montar, LangGraph para o que é agentivo e LangSmith para ver o que aconteceu de fato.
Conteúdo padronizado entre provedores
A versão 1.0 também mexeu em como as respostas são representadas. O que a LangChain chama de blocos de conteúdo padronizados normaliza rastros de raciocínio, citações e chamadas de ferramenta entre provedores diferentes.
Na prática, o mesmo trecho de código lê a resposta de um modelo da Anthropic e de um da OpenAI sem espalhar condicional por fornecedor pelo projeto, que era um dos pontos de atrito mais chatos de manter.
A promessa de portabilidade existe desde as primeiras versões, mas sempre foi parcial, porque cada provedor devolvia o raciocínio e as citações num formato próprio.
O que ainda pesa contra
Três pontos continuam abertos, e valem mais do que qualquer elogio.
O pacote de JavaScript e TypeScript anda atrás do de Python nas funcionalidades mais novas, e quem trabalha em Node sente a diferença de ritmo.
A migração de código pré-1.0 é trabalho real. O pacote langchain-classic dá onde rodar, mas não elimina a migração, e quem copiou tutoriais que usam create_react_agent vai encontrar a função marcada como obsoleta.
Some-se a isso o padrão que a própria LangChain admite ter criado. A empresa reconheceu que as abstrações eram às vezes pesadas demais e que a superfície tinha crescido sem controle, o que faz da promessa de estabilidade até a 2.0 uma resposta a esse histórico que ainda precisa ser testada no tempo.
Referências
- Anúncio oficial das versões 1.0: https://www.langchain.com/blog/langchain-langgraph-1dot0
- Documentação do LangChain: https://docs.langchain.com
- LangChain no PyPI: https://pypi.org/project/langchain/
- LangGraph no PyPI: https://pypi.org/project/langgraph/
