LangChain v1 em 2026: o novo stack para construir agentes (o que dizem o Reddit e o X)

LangChain v1Hover to explore

Durante a maior parte de 2023 e 2024, as opiniões mais ruidosas sobre o LangChain no r/LangChain, no r/LocalLLaMA e no X/Twitter soavam todas iguais: «ótimo para demos, penoso em produção». Wrappers em cima de wrappers, abstrações que falhavam no momento em que era preciso um ciclo a sério, e um roadmap que parecia lançar uma nova chain todas as terças-feiras. Com o LangChain v1 (estável desde o final de 2025), essa história mudou. O framework assume agora abertamente a forma de agente: um único ponto de entrada de alto nível, create_agent, um sistema de middleware e o LangGraph como runtime por defeito por baixo.

Entre as fontes deste artigo estão o anúncio oficial do LangChain v1, a documentação de agentes do LangChain, as discussões recorrentes no r/LangChain e no r/LocalLLaMA, e tópicos de @LangChainAI e @hwchase17 no X. Os padrões valem mais do que citações escolhidas a dedo.

1. O que mudou realmente no LangChain v1

A grande mudança é que o LangChain deixou de ser um saco de chains. O pacote principal centra-se agora em três coisas:

• create_agent: uma única função para construir um agente que usa ferramentas, com modelo, ferramentas, prompt de sistema, saída estruturada e middleware.
• Middleware: hooks antes e depois das chamadas ao modelo e às ferramentas (limitação de taxa, ocultação de dados pessoais, aprovação humana, novas tentativas, resumo, guardrails).
• Runtime LangGraph: estado durável e com checkpoints por baixo de cada agente, para que pausar e retomar, a aprovação humana e a depuração com viagem no tempo sejam nativos em vez de acrescentados depois.

As peças antigas (LLMChain, AgentExecutor, initialize_agent, create_react_agent na forma antiga) continuam a poder ser importadas, mas estão marcadas como legado. O código novo deve viver em langchain.agents e langchain.messages, com as integrações dos fornecedores em langchain-openai, langchain-anthropic e afins.

2. Um agente v1 mínimo (o novo «hello world»)

from langchain.agents import create_agent
from langchain.tools import tool

@tool
def get_weather(city: str) -> str:
    """Return the current weather for a given city."""
    return f"It's 24C and sunny in {city}."

agent = create_agent(
    model="anthropic:claude-sonnet-4-5",   # or "openai:gpt-5", "google:gemini-2.5-pro"
    tools=[get_weather],
    system_prompt="You are a concise travel assistant.",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Weather in Lisbon?"}]}
)
print(result["messages"][-1].content)

Três coisas a notar: o modelo é uma string (o LangChain trata da resolução do fornecedor), as ferramentas são simples funções Python decoradas com @tool, e não há prompt ReAct explícito nem parser. O ciclo do agente, o protocolo de chamada de ferramentas e os redutores de mensagens vivem todos dentro do runtime.

3. Saída estruturada sem uma segunda chamada ao LLM

Uma das funcionalidades da v1 mais votadas no r/LangChain é o response_format. Passe um modelo Pydantic e o agente devolve um objeto validado dentro do mesmo ciclo: sem parser extra, sem uma chamada de seguimento do tipo «agora extrai isto em JSON».

from pydantic import BaseModel
from langchain.agents import create_agent

class TripPlan(BaseModel):
    city: str
    days: int
    must_do: list[str]

agent = create_agent(
    model="openai:gpt-5",
    tools=[get_weather],
    response_format=TripPlan,
)

out = agent.invoke({"messages": [
    {"role": "user", "content": "Plan 3 days in Lisbon."}
]})

plan: TripPlan = out["structured_response"]
print(plan.must_do)

4. Middleware: a parte que entusiasma discretamente as pessoas no X

É com o middleware que a v1 deixa de parecer um wrapper e passa a parecer um verdadeiro framework de agentes. Pode ligar-se a before_model, after_model, before_tool e after_tool, e distribuir comportamentos reutilizáveis como:

• SummarizationMiddleware: compacta automaticamente históricos longos quando o contexto cresce.
• HumanInTheLoopMiddleware: faz uma pausa antes de chamadas de ferramentas destrutivas e espera por aprovar, editar ou rejeitar.
• PIIMiddleware: oculta e-mails, nomes ou números de cartão antes de chegarem ao fornecedor.
• ModelFallbackMiddleware: volta a tentar automaticamente num modelo mais barato ou de reserva quando o principal falha.

from langchain.agents import create_agent
from langchain.agents.middleware import (
    HumanInTheLoopMiddleware,
    SummarizationMiddleware,
    PIIMiddleware,
)

agent = create_agent(
    model="anthropic:claude-sonnet-4-5",
    tools=[refund_order, send_email, query_db],
    middleware=[
        PIIMiddleware(strategy="redact"),
        SummarizationMiddleware(max_tokens_before_summary=12_000),
        HumanInTheLoopMiddleware(
            interrupt_on={"refund_order": True, "send_email": True}
        ),
    ],
)

É esta peça que, no nosso próprio trabalho com clientes e em tópicos recentes no X, faz finalmente o LangChain parecer pronto para produção: as questões espinhosas de produção compõem-se, em vez de serem coladas ao nível do prompt.

Com estado por defeitoHover to explore

5. Multiagente: supervisor, enxame ou simplesmente subgrafos

Para configurações multiagente, o LangChain apoia-se no LangGraph e em dois componentes prontos a usar que aparecem repetidamente no Reddit:

• langgraph-supervisor: um agente router decide que especialista (pesquisa, código, suporte) trata do passo seguinte. Ideal para uma divisão clara de papéis.
• langgraph-swarm: agentes pares passam o testemunho uns aos outros com base no contexto. Mais próximo dos chats de grupo do CrewAI / AutoGen.
• Subgrafos personalizados: componha simplesmente saídas de create_agent num StateGraph quando precisar de controlo total sobre as arestas e a forma do estado.

6. O que o Reddit e o X dizem realmente (o balanço honesto)

Ao longo dos últimos meses no r/LangChain, no r/LocalLLaMA e nos cantos do X dedicados à engenharia de IA, os temas recorrentes são estes:

• Positivo: «O create_agent é o que devia ter sido há dois anos.» O middleware e a saída estruturada são os ganhos mais citados. Os traces do LangSmith «simplesmente funcionam», sem cerimónias.
• Misto: a divisão em pacotes (langchain, langchain-core, langgraph, pacotes dos fornecedores) continua a confundir quem chega. Migrar código 0.x é «sobretudo mecânico, às vezes cirúrgico».
• Crítico: as equipas que passam totalmente para modelos de pesos abertos ou que são extremamente sensíveis à latência continuam a preferir ciclos escritos à mão, o Pydantic AI ou os SDK dos fornecedores. O argumento já não é «o LangChain é pesado», mas «não preciso de um grafo para um pipeline de 3 passos». Justo.
• Comparações: face ao CrewAI, o LangChain ganha em durabilidade, observabilidade e rigor na chamada de ferramentas; o CrewAI ganha na ergonomia de papéis e tarefas. Face ao AutoGen, o LangChain ganha nas primitivas de produção; o AutoGen na conversa multiagente livre. Face ao OpenAI Agents SDK, o LangChain ganha na portabilidade entre fornecedores e no middleware/aprovação humana; o SDK da OpenAI ganha no tempo até à primeira demo quando aposta tudo num único fornecedor.

«Em 2026, a pergunta interessante já não é "que framework". É: qual deles lhe permite lançar o mesmo agente em três fornecedores, com aprovação humana e um trace para cada falha.»

7. A checklist do fundador antes de se comprometer

1. Consegue descrever o seu agente numa única frase, com um verbo e um resultado («processa um reembolso e envia um e-mail ao cliente»)? Se não, pare e reduza primeiro o âmbito.
2. Escolha o mínimo de primitivas: create_agent + 2 a 5 ferramentas + response_format. Deixe o middleware de fora no primeiro dia.
3. Ative o LangSmith desde o primeiro commit. Qualquer otimização posterior (custo, latência, avaliação) parte dos traces que já tem.
4. Acrescente o HumanInTheLoopMiddleware no momento em que uma ferramenta possa gastar dinheiro, enviar uma mensagem ou alterar uma linha da base de dados. É a linha de código com maior alavancagem num agente em produção.
5. Só recorra ao supervisor ou ao enxame depois de ter uma versão sólida com um único agente. A maioria dos problemas «multiagente» são, na verdade, problemas de ferramentas mal delimitadas.

A conclusão

O LangChain v1 é a primeira versão em que a forma do framework corresponde à maneira como as equipas constroem realmente agentes em produção: um ciclo que usa ferramentas com um grafo por baixo, hooks para as questões pouco glamorosas (dados pessoais, aprovações, resumo, novas tentativas) e o mesmo caminho de código para qualquer fornecedor. A conversa no Reddit e no X passou de «o LangChain é um meme?» para «o seu agente é observável, recuperável e portável?». Para os fundadores que lançam um MVP em 2026, é uma discussão muito melhor.

Related Posts

Removing Expense Leakage Using Agentic Flow: The 2026 Founder's GuideApril 11, 2026

Gemma 4 by Google: What Founders Building AI MVPs Need to Know (2026)April 10, 2026

The Vibe Coding Trap: Why Thousands of AI Startups Are Paying $50K–$500K to Rebuild Their MVPsApril 2026