O que é o LangGraph?
LangGraph é um framework desenvolvido pela LangChain para gerenciar o fluxo de controle de aplicações que integram um modelo de linguagem (LLM).
LangGraph é diferente do LangChain?
LangChain fornece uma interface padrão para interagir com modelos e outros componentes, sendo útil para recuperação de informações, chamadas a LLMs e uso de ferramentas. As classes do LangChain podem ser utilizadas no LangGraph, mas não é obrigatório.
Os pacotes são distintos e podem ser usados separadamente, mas, na prática, a maioria dos recursos disponíveis online utiliza ambos em conjunto.
Quando devo usar o LangGraph?
Ao projetar aplicações com IA, você se depara com um dilema fundamental entre controle e liberdade:
- Liberdade dá ao seu LLM mais espaço para ser criativo e lidar com problemas inesperados.
- Controle permite garantir um comportamento previsível e manter limites de segurança.
Agentes baseados em código, como os que você encontra no smolagents, são bastante livres. Eles podem chamar várias ferramentas em uma única etapa, criar suas próprias ferramentas, etc. No entanto, esse comportamento pode torná-los menos previsíveis e mais difíceis de controlar do que um agente tradicional que trabalha com JSON.
LangGraph está no outro extremo do espectro — ele se destaca quando você precisa de controle sobre a execução do seu agente.
LangGraph é especialmente valioso quando sua aplicação exige controle. Ele oferece as ferramentas para construir uma aplicação que segue um processo previsível, ao mesmo tempo em que aproveita o poder dos LLMs.
De forma simples: se sua aplicação envolve uma sequência de etapas que precisam ser orquestradas de maneira específica, com decisões sendo tomadas em cada ponto de junção, o LangGraph oferece a estrutura necessária.
Exemplo: Suponha que queremos construir um assistente com LLM que possa responder a perguntas sobre determinados documentos.
Como os LLMs compreendem melhor textos, antes de poder responder à pergunta, será necessário converter outras modalidades mais complexas (como gráficos e tabelas) em texto. No entanto, essa escolha depende do tipo de documento que você possui!
Os principais cenários em que o LangGraph se destaca incluem:
- Processos de raciocínio com múltiplas etapas que exigem controle explícito do fluxo
- Aplicações que requerem persistência de estado entre as etapas
- Sistemas que combinam lógica determinística com capacidades de IA
- Fluxos de trabalho que exigem intervenções humanas ao longo do processo (human-in-the-loop)
- Arquiteturas de agentes complexas, com múltiplos componentes trabalhando em conjunto
Em essência, sempre que for possível — como humano — desenhar um fluxo de ações baseado na saída de cada etapa e decidir o que executar em seguida, o LangGraph é o framework certo para você!
Por que eu precisaria do LangGraph?
Você pode se perguntar: “Eu poderia simplesmente escrever um código Python com instruções if-else para lidar com todos esses fluxos, certo?”
Embora tecnicamente isso seja verdade, o LangGraph oferece algumas vantagens em relação ao Python puro (vanilla Python) na construção de sistemas complexos. Você até poderia construir a mesma aplicação sem o LangGraph, mas ele fornece ferramentas e abstrações que facilitam esse processo. Ele inclui recursos como:
- Gerenciamento de estado
- Visualização do fluxo
- Registro de execução (logging, traces)
- Suporte nativo a intervenções humanas no processo (human-in-the-loop)
- E muito mais.
Como o LangGraph funciona?
Para construir aplicações com o LangGraph, você precisa entender seus componentes principais. Vamos explorar os blocos fundamentais que compõem uma aplicação com LangGraph.
Uma aplicação no LangGraph começa a partir de um ponto de entrada (entrypoint) e, dependendo da execução, o fluxo pode seguir para uma função ou outra, até chegar ao FIM (END).
No seu núcleo, o LangGraph utiliza uma estrutura de grafo direcionado para definir o fluxo da sua aplicação:
- Estado (state) é definido pelo usuário, mantido e passado entre os nós durante a execução. Ao decidir qual nó deve ser executado em seguida, é esse estado atual que será analisado.
from typing_extensions import TypedDict class State(TypedDict): graph_state: str - Nós (nodes) representam etapas individuais de processamento (como chamar um LLM, usar uma ferramenta ou tomar uma decisão). Nós são funções de Python. Cada nó:
- Recebe o estado como entrada
- Realiza alguma operação
- Retorna atualizações para o estado
def node_1(state): print("---Node 1---") return {"graph_state": state['graph_state'] +" Eu estou"} def node_2(state): print("---Node 2---") return {"graph_state": state['graph_state'] +" feliz!"} def node_3(state): print("---Node 3---") return {"graph_state": state['graph_state'] +" triste!"} - Arestas (edges) definem as transições possíveis entre essas etapas. As arestas podem ser:
- Diretas: sempre vão do nó A para o nó B
- Condicionais: escolhem o próximo nó com base no estado atual
import random from typing import Literal def decidir_humor(state) -> Literal["node_2", "node_3"]: # Geralmente, usamos o estado para decidir qual próximo nó a ser visitado user_input = state['graph_state'] # Aqui decidimos o qual nó "jogando uma moeda para cima" if random.random() < 0.5: return "node_2" return "node_3" - StateGraph é o contêiner que contém todo o fluxo de trabalho do seu agente:
from IPython.display import Image, display from langgraph.graph import StateGraph, START, END # Criar o StateGraph e adicionar os nós builder = StateGraph(State) builder.add_node("node_1", node_1) builder.add_node("node_2", node_2) builder.add_node("node_3", node_3) # Definir a lógica entre os nós builder.add_edge(START, "node_1") builder.add_conditional_edges("node_1", decide_mood) builder.add_edge("node_2", END) builder.add_edge("node_3", END) # Compilar o fluxo graph = builder.compile()
Que pode então ser visualizado!
display(Image(graph.get_graph().draw_mermaid_png()))Mas, mais importante, pode ser chamado:
graph.invoke({"graph_state" : "Oi, eu sou o Fernando."})
