O que é LangGraph?
Entenda LangGraph, agentes baseados em grafos vs cadeias tradicionais, execução stateful vs stateless, e como LangGraph difere de LangChain.
O que é LangGraph?
LangGraph é um framework da LangChain para construir aplicações stateful com múltiplos atores usando grafos direcionados como abstração central. Cada nó no grafo modifica um estado compartilhado, e as arestas definem o fluxo de execução.
LangGraph não é uma ferramenta de DAG de workflow. Nós podem ser revisitados, loops podem se formar, e o estado é preservado entre ciclos. Isso é o que o torna adequado para sistemas agenticos que precisam raciocinar, agir e se adaptar.
Agentes Baseados em Grafos vs Cadeias Tradicionais
Cadeias Tradicionais
Em LangChain tradicional, você constrói cadeias lineares onde cada passo passa sua saída para o próximo:
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
prompt = PromptTemplate.from_template("Tell me about {topic}")
chain = prompt | llm | output_parser
result = chain.invoke({"topic": "AI agents"})Cadeias são lineares, previsíveis e stateless entre execuções. Quando uma cadeia completa, todos os dados intermediários são perdidos. Não há conceito de loops, ramificações ou gerenciamento de estado.
Agentes Baseados em Grafos
LangGraph substitui a cadeia linear por um grafo onde:
- Nós são funções independentes que podem ler e escrever em um estado compartilhado
- Arestas definem qual nó executa em seguida
- Condições podem rotear a execução com base no estado atual
- Loops permitem que agentes iterem até que uma condição seja atendida
from langgraph.graph import StateGraph
from typing import TypedDict, List
class AgentState(TypedDict):
messages: List[str]
agent_decision: str
def analyze(state: AgentState) -> dict:
decision = decide_next_step(state["messages"])
return {"agent_decision": decision}
def execute(state: AgentState) -> dict:
result = perform_action(state["agent_decision"])
return {"messages": state["messages"] + [result]}
graph = StateGraph(AgentState)
graph.add_node("analyze", analyze)
graph.add_node("execute", execute)
graph.add_edge("analyze", "execute")
graph.set_entry_point("analyze")
graph.set_finish_point("execute")Grafos oferecem loops, ramificações, persistência e roteamento dinâmico — tudo essencial para construir agentes autônomos.
Execução Stateful vs Stateless
Execução Stateless
Em um sistema stateless, cada invocação é independente. Nenhuma informação persiste entre chamadas:
# Stateless — cada chamada começa do zero
response = llm.invoke("What is 2+2?")
response = llm.invoke("Now add 5") # O LLM esqueceu a resposta anteriorExecução Stateful
LangGraph mantém um objeto de estado compartilhado que persiste através de todos os nós do grafo. Cada nó pode ler o estado completo e retornar atualizações:
class ConversationState(TypedDict):
messages: List[str]
turn_count: int
def chatbot(state: ConversationState) -> dict:
user_msg = get_user_input()
new_messages = state["messages"] + [user_msg]
response = llm.invoke("\n".join(new_messages))
return {
"messages": new_messages + [response],
"turn_count": state["turn_count"] + 1
}O estado flui através de cada nó e é preservado entre ciclos, permitindo memória, contexto e raciocínio de múltiplas etapas.
O estado no LangGraph não é persistido em disco por padrão. Você adiciona persistência via MemorySaver ou outros checkpointers (abordado no curso Intermediário).
LangChain vs LangGraph
| Característica | LangChain | LangGraph |
|---|---|---|
| Modelo de execução | Cadeias lineares (DAG) | Grafos cíclicos |
| Gerenciamento de estado | Manual (passar entre etapas) | Automático (estado compartilhado) |
| Loops | Não suportado | Suporte de primeira classe |
| Ramificação | Apenas sequencial | Condicional, paralela |
| Persistência | Não embutida | Via checkpointers |
| Humano-no-loop | Não suportado | Via interrupt() |
| Melhor para | Pipelines LLM simples | Workflows agenticos complexos |
Quando Usar Apenas LangChain
- Você tem um pipeline simples de prompt → LLM → saída
- Nenhuma lógica de loop ou condicional é necessária
- Você não precisa persistir estado intermediário
- Exemplo: sumarização, tradução, Q&A simples
Quando Usar LangGraph
- Você precisa de agentes que possam raciocinar, agir e observar em um loop
- O fluxo depende de resultados intermediários (roteamento condicional)
- Você precisa de memória, persistência ou humano-no-loop
- Exemplo: agentes de codificação autônomos, assistentes de pesquisa, bots de atendimento
# LangChain: Simples e linear
chain = prompt | llm | parser
result = chain.invoke(input)
# LangGraph: Flexível e stateful
graph = StateGraph(State)
graph.add_node("think", think_node)
graph.add_node("act", act_node)
graph.add_node("observe", observe_node)
graph.add_conditional_edges("think", should_continue, {True: "act", False: END})
graph.add_edge("act", "observe")
graph.add_edge("observe", "think")
app = graph.compile()
result = app.invoke(initial_state)Por que Grafos para Agentes?
Agentes precisam realizar raciocínio de múltiplas etapas, usar ferramentas, interpretar resultados e decidir a próxima ação. Isso naturalmente mapeia para uma estrutura de grafo:
- Pensar: O agente analisa o estado atual e decide o que fazer
- Agir: O agente executa uma chamada de ferramenta ou gera uma resposta
- Observar: O agente processa a saída da ferramenta
- Loop: O agente repete até que a tarefa esteja completa
Input → [Pensar] → decidir → [Agir] → [Observar] → decidir → [Pensar] → ...
↑ |
└── continuar ──────────┘
[Parar] → Output
Este loop é a fundação de todo agente ReAct. LangGraph torna trivial implementá-lo.
O padrão ReAct (Raciocinar + Agir) é a arquitetura de agente mais comum. A estrutura de grafo do LangGraph é a maneira ideal de implementá-lo — cada turno do loop é uma execução de nó.
Primitivas Principais
LangGraph tem cinco primitivas principais:
| Primitiva | Descrição | Exemplo |
|---|---|---|
StateGraph | A classe construtora de grafos | StateGraph(AgentState) |
State | Um dicionário tipado compartilhado entre nós | class AgentState(TypedDict) |
Node | Uma função Python que altera o estado | def my_node(state) -> dict |
Edge | Uma conexão entre nós | graph.add_edge("a", "b") |
Condition | Uma função de roteamento para arestas condicionais | lambda s: "b" if s["done"] else "c" |
Instalação
pip install langgraph langchain-openaiLangGraph requer Python 3.9+. É compatível com todas as integrações LangChain (LLMs, vector stores, ferramentas, etc.).
Configuração mínima para um primeiro grafo:
from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict
class MyState(TypedDict):
value: str
def echo(state: MyState) -> dict:
return {"value": f"Echo: {state['value']}"}
builder = StateGraph(MyState)
builder.add_node("echo", echo)
builder.add_edge(START, "echo")
builder.add_edge("echo", END)
app = builder.compile()
result = app.invoke({"value": "hello"})
print(result["value"]) # Echo: helloCasos de Uso do Mundo Real
Agente de Atendimento ao Cliente
Um grafo roteia consultas de clientes através de classificação de intenção, busca na base de conhecimento, criação de ticket e escalonamento para humanos.
Agente de Geração de Código
Um agente que escreve código, executa testes, lê saídas de erro e corrige bugs iterativamente — tudo dentro de um único grafo com um loop.
Assistente de Pesquisa
Um agente de múltiplas etapas que pesquisa na web, sumariza descobertas, gera relatórios e faz perguntas esclarecedoras quando necessário.
Orquestrador de Pipeline de Dados
Um grafo que ingere dados, valida, transforma, carrega em um banco de dados e envia notificações — com tratamento de erro em cada etapa.
LangGraph transforma lógica agentica complexa de código espaguete em uma estrutura de grafo limpa, visual e debugável.
Perguntas de Prática
Qual é a principal diferença entre cadeias LangChain e grafos LangGraph?
O que uma função de nó LangGraph recebe e retorna?
Qual classe LangGraph você deve usar para construir agentes stateful?
O que é o padrão ReAct?
LangGraph é mais adequado para qual tipo de aplicação?
Qual comando instala LangGraph?
Qual das seguintes NÃO é uma funcionalidade do LangGraph?
Como o estado flui em uma aplicação LangGraph?
O que torna LangGraph adequado para construir agentes autônomos?
O que o método compile() faz em LangGraph?
Principais Conclusões
- LangGraph usa grafos direcionados com estado compartilhado para construir agentes
- Grafos suportam loops, ramificação condicional e persistência — ao contrário de cadeias lineares
- O estado flui através de todos os nós; cada nó recebe o estado completo e retorna atualizações parciais
- StateGraph é a classe principal para construir aplicações LangGraph
- O padrão ReAct (raciocinar → agir → observar → loop) é uma adaptação natural para grafos
- LangGraph é instalado via
pip install langgraphe se integra com todos os componentes LangChain