Agentes LangChain em 2026: ReAct, LangGraph e Production Patterns — EasyClaw

AgentExecutor vs. LangGraph: O que mudou e por que é importante

Compreender o caminho de migração requer compreender por que AgentExecutor foi descontinuado. Não foi arbitrário — atingiu limites arquitetônicos fundamentais quando os desenvolvedores tentaram construir sistemas de produção.

A limitação mais dolorosa do AgentExecutor foi a incapacidade de pausar no meio da corrida e retomar mais tarde. Qualquer fluxo de trabalho real – pense “esboçar um relatório, aguardar a aprovação humana e depois publicar” – requer um estado persistente através dos limites de tempo. O checkpointer do LangGraph resolve isso nativamente.

O padrão ReAct: raciocínio + ação em loop

ReAct (Reason + Act) é o padrão de solicitação fundamental por trás da maioria dos agentes LangChain. Ele instrui o LLM a alternar entre dois modos: Thought (raciocínio interno sobre o que fazer a seguir) e Ação (chamando uma ferramenta específica com argumentos específicos).

O loop fica assim na prática:

1. Thought: O LLM raciocina sobre a solicitação do usuário e as ferramentas disponíveis.
2. Action: O LLM gera uma chamada de ferramenta estruturada (nome + argumentos).
3. Observation: A ferramenta é executada e retorna um resultado anexado ao contexto.
4. Thought again: O LLM raciocina sobre a observação.
5. Resposta final: Quando o LLM determina que possui informações suficientes, ele emite a resposta final.

No LangGraph, cada uma dessas etapas é um nó em um gráfico. A aresta condicional após a verificação do nó LLM: "o modelo chamou uma ferramenta ou gerou uma resposta final?" – e rotas em conformidade. Isso torna o loop ReAct explícito e inspecionável, em vez de implícito dentro de um executor de caixa preta.

LLMs modernos (GPT-4o, Claude 3.7, Gemini 2.5) lidam com ReAct nativamente por meio de suas APIs de chamada de função/uso de ferramentas. Você não precisa mais formatar manualmente as strings "Thought/Action/Observation" — o recurso de uso de ferramentas do modelo lida com isso no nível da API. LangGraph envolve isso de forma limpa para que seus nós permaneçam focados na lógica de negócios.

Building a LangGraph Agent Step by Step

Aqui está o padrão mínimo do agente LangGraph em Python. Todo agente de produção é uma variação desse esqueleto.

1. Define State

O estado é a única fonte de verdade que flui através de cada nó. Use TypedDict ou um modelo Pydantic:

from typing import Annotated, Sequence
from langchain_core.messages import BaseMessage
from langgraph.graph.message import add_messages
from typing_extensions import TypedDict

class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]
    # add any custom fields your agent needs
    context: str
    iteration_count: int

2. Define Tools

Ferramentas são funções simples do Python decoradas com @tool. A docstring se torna a descrição da ferramenta que o LLM vê:

from langchain_core.tools import tool

@tool
def search_web(query: str) -> str:
    """Search the web for current information about a topic."""
    # your search implementation here
    return results

@tool
def write_file(filename: str, content: str) -> str:
    """Write content to a file on disk."""
    with open(filename, 'w') as f:
        f.write(content)
    return f"Written {len(content)} chars to {filename}"

tools = [search_web, write_file]

3. Build the Graph

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)

def agent_node(state: AgentState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: AgentState):
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END

graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", ToolNode(tools))
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tools", "agent")

app = graph.compile()

4. Add a Checkpointer para persistência

from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string("./agent_memory.db")
app = graph.compile(checkpointer=checkpointer)

# Now every run is persisted and resumable
config = {"configurable": {"thread_id": "user-session-123"}}
result = app.invoke({"messages": [("human", "Research LangGraph and write a summary")]}, config)

LangGraph in JavaScript / TypeScript: paridade completa de recursos

A partir de 2026, @langchain/langgraph tem paridade total de recursos com o Python SDK. Se você estiver criando back-ends Node.js, ações de servidor Next.js ou rotas de API Nuxt, terá suporte total.

import { StateGraph, END } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Define a tool with Zod schema
const searchWeb = tool(
  async ({ query }) => {
    const results = await yourSearchFunction(query);
    return results;
  },
  {
    name: "search_web",
    description: "Search the web for current information",
    schema: z.object({ query: z.string() }),
  }
);

// State type
interface AgentState {
  messages: BaseMessage[];
}

const llm = new ChatOpenAI({ model: "gpt-4o" }).bindTools([searchWeb]);

// Build graph — identical pattern to Python
const graph = new StateGraph<AgentState>({ channels: messagesStateReducer })
  .addNode("agent", async (state) => ({
    messages: [await llm.invoke(state.messages)],
  }))
  .addNode("tools", new ToolNode([searchWeb]))
  .addEdge("__start__", "agent")
  .addConditionalEdges("agent", shouldContinue)
  .addEdge("tools", "agent");

const app = graph.compile();

O SDK JS/TS suporta os mesmos pontos de verificação (na memória para desenvolvimento, PostgreSQL para produção), a mesma API de streaming (streamEvents) e a mesma integração de rastreamento LangSmith. O modelo mental é transferido diretamente entre idiomas.

Arquiteturas multiagentes: orquestradores e subgráficos

Os sistemas de agente único atingem os limites rapidamente: as janelas de contexto transbordam, a especialização é prejudicada e tarefas complexas exigem coordenação. Em 2026, as implantações de produção LangGraph quase sempre usam padrões multiagentes.

Os três padrões principais

LangGraph implementa sistemas multiagentes por meio de composição de subgrafo. Cada agente especializado é um gráfico compilado que é incorporado como um nó no gráfico do orquestrador pai. O estado pode fluir entre os níveis e cada subgráfico pode ter seu próprio checkpointer e memória.

Production Patterns: O que as demonstrações de brinquedos não mostram a você

Fazer com que um agente LangGraph trabalhe em um notebook Jupyter é uma coisa. Executá-lo de forma confiável em escala é outra. Aqui estão os padrões que separam o protótipo da produção.

Error Handling and Retry Logic

As falhas de ferramentas são inevitáveis ​​— limites de taxa, tempos limite de rede, resultados malformados. LangGraph oferece duas alavancas: tentativa/captura em nível de nó que retorna uma mensagem de erro ao LLM (permitindo que ele se recupere normalmente) e políticas de repetição em nível de gráfico nas bordas.

Iteration Limits

Sempre defina recursion_limit ao compilar. Sem ele, um LLM confuso pode ficar em loop indefinidamente e queimar seu orçamento de API. Um padrão razoável é de 25 iterações para a maioria das tarefas.

app = graph.compile(checkpointer=checkpointer)
# Invoke with recursion limit
result = app.invoke(
    {"messages": [("human", query)]},
    config={"recursion_limit": 25, "configurable": {"thread_id": thread_id}}
)

Interrupções Humanas no Loop

As opções de compilação interrupt_before e interrupt_after do LangGraph permitem pausar a execução em nós específicos, exibir o estado atual para um humano, coletar entradas e retomar. Isso é indispensável para fluxos de trabalho de aprovação, portas de revisão de conteúdo e chamadas de ferramentas de alto risco.

Streaming para UX em tempo real

Para aplicativos voltados para o usuário, o streaming não é negociável. O astream_events do LangGraph fornece eventos granulares: qual nó está em execução, qual ferramenta foi chamada e saída LLM token por token. Conecte isso a eventos enviados pelo servidor (SSE) ou WebSockets para progresso ao vivo em sua UI.

Observability with LangSmith

Defina LANGCHAIN_TRACING_V2=true e cada execução do agente obtém um rastreamento completo: quais nós foram acionados, o que o LLM viu, o que cada ferramenta retornou, latência total e custos de token. É assim que você depura o "por que chamou a ferramenta errada?" classe de bugs de produção - não instruções de impressão.

Real-World LangChain Agent Use Cases in 2026

Os padrões acima abrem uma ampla gama de aplicações de produção. Aqui estão as categorias onde os agentes LangGraph estão agregando valor real hoje.

Como escolher a arquitetura de agente certa para seu caso de uso

Nem todo problema precisa de um gráfico multiagente complexo. Aqui está uma estrutura de decisão baseada no que você realmente está tentando construir.

Uma heurística prática: comece com o padrão mais simples que poderia funcionar, instrumente com LangSmith e, em seguida, identifique o gargalo. Os engenheiros que projetam antecipadamente a complexidade quase sempre projetam demais seu primeiro sistema de agente. Os padrões em LangGraph facilitam a transição para arquiteturas mais complexas à medida que os requisitos se tornam claros.

Perguntas frequentes

Considerações finais: LangGraph é o padrão do agente em 2026

Os "agentes LangChain" que você deveria construir em 2026 são máquinas de estado LangGraph. A era obsoleta do AgentExecutor acabou. O estado explícito do LangGraph, o roteamento condicional, os pontos de verificação persistentes e a composição multiagente nativa não são bons de se ter - eles são pré-requisitos para qualquer coisa em que você confie na produção.

O padrão ReAct continua sendo o ponto de partida correto para a maioria das tarefas. Adicione complexidade multiagente somente quando um único agente atingir comprovadamente seus limites. Instrumente tudo com o LangSmith desde o primeiro dia — a depuração sem rastros é a maneira mais rápida de perder uma semana em um problema que leva 10 minutos para ser diagnosticado com visibilidade.

A mudança mais importante é conceitual: os agentes LangGraph não são chatbots com ferramentas integradas. Eles são sistemas persistentes e com estado em que um LLM orienta o fluxo de controle. Projete-os como sistemas distribuídos — com modos de falha, lógica de repetição, limites de estado e observabilidade — e eles recompensarão você com uma confiabilidade que surpreende até mesmo engenheiros experientes.

Se você estiver criando automação de conteúdo, pipelines de SEO ou fluxos de trabalho de pesquisa em várias etapas, EasyClaw é a maneira mais rápida de ver esses padrões em ação — sem gastar semanas instalando a infraestrutura sozinho.