LangGraph Tutorial: O que é o LangGraph e como usá-lo?

Imagine que você está criando um aplicativo de modelo de linguagem grande (LLM) complexo e com vários agentes. É empolgante, mas vem com desafios: gerenciar o estado de vários agentes, coordenar suas interações e lidar com erros de forma eficaz. É nesse ponto queo LangGraph pode ajudar.

O LangGraph é uma biblioteca do ecossistema LangChain projetada para enfrentar esses desafios de frente. O LangGraph oferece uma estrutura para definir, coordenar e executar vários agentes (ou cadeias) LLM de forma estruturada.

Ele simplifica o processo de desenvolvimento, permitindo a criação de gráficos cíclicos, que são essenciais para o desenvolvimento de tempos de execução de agentes. Com o LangGraph, podemos criar facilmente sistemas multiagentes robustos, dimensionáveis e flexíveis.

Se você quiser saber mais sobre o ecossistema LangChain, recomendo esta introdução à LangChain.

O que é o LangGraph?

O LangGraph permite que você crie aplicativos com vários atores e com estado utilizando LLMs da forma mais fácil possível. Ele amplia os recursos do LangChain, introduzindo a capacidade de criar e gerenciar gráficos cíclicos, que são essenciais para o desenvolvimento de tempos de execução de agentes sofisticados. Os principais conceitos do LangGraph incluem: estrutura de gráfico, gerenciamento de estado e coordenação.

Estrutura do gráfico

Imagine seu aplicativo como um gráfico direcionado. No LangGraph, cada nó representa um agente LLM, e as bordas são os canais de comunicação entre esses agentes. Essa estrutura permite fluxos de trabalho claros e gerenciáveis, em que cada agente executa tarefas específicas e passa informações para outros agentes, conforme necessário.

Gerenciamento do estado

Um dos recursos de destaque do LangGraph é o gerenciamento automático de estado. Esse recurso nos permite rastrear e manter informações em várias interações. À medida que os agentes executam suas tarefas, o estado é atualizado dinamicamente, garantindo que o sistema mantenha o contexto e responda adequadamente a novas entradas.

Coordenação

O LangGraph garante que os agentes sejam executados na ordem correta e que as informações necessárias sejam trocadas sem problemas. Essa coordenação é vital para aplicativos complexos em que vários agentes precisam trabalhar juntos para atingir um objetivo comum. Ao gerenciar o fluxo de dados e a sequência de operações, o LangGraph permite que os desenvolvedores se concentrem na lógica de alto nível de seus aplicativos, em vez de se preocuparem com as complexidades da coordenação de agentes.

Por que o LangGraph?

Como mencionei acima, o LangGraph oferece várias vantagens significativas para os desenvolvedores que trabalham com aplicativos LLM complexos. Aqui estão alguns dos benefícios que o LangGraph oferece para o mundo real.

Desenvolvimento simplificado

O LangGraph abstrai as complexidades associadas ao gerenciamento de estados e à coordenação de agentes. Isso significa que os desenvolvedores podem definir seus fluxos de trabalho e lógica sem se preocupar com os mecanismos subjacentes que garantem a consistência dos dados e a ordem de execução adequada. Essa simplificação acelera o processo de desenvolvimento e reduz a probabilidade de erros. É um divisor de águas!

Flexibilidade

Com o LangGraph, os desenvolvedores têm a flexibilidade de definir sua própria lógica de agente e protocolos de comunicação. Isso permite a criação de aplicativos altamente personalizados, adaptados a casos de uso específicos. Se você precisa de um chatbot que possa lidar com vários tipos de solicitações de usuários ou de um sistema multiagente que execute tarefas complexas, o LangGraph fornece as ferramentas para criar exatamente o que você precisa. O objetivo é dar a você o poder de criar.

Escalabilidade

O LangGraph foi criado para dar suporte à execução de aplicativos multiagentes em grande escala. Sua arquitetura robusta pode lidar com um grande volume de interações e fluxos de trabalho complexos, permitindo o desenvolvimento de sistemas dimensionáveis que podem crescer de acordo com as suas necessidades. Isso o torna adequado para aplicativos de nível empresarial e cenários em que o desempenho e a confiabilidade são essenciais.

Tolerância a falhas

A confiabilidade é uma consideração fundamental no projeto do LangGraph. A biblioteca inclui mecanismos para o tratamento adequado de erros, garantindo que o seu aplicativo possa continuar a funcionar mesmo quando agentes individuais encontrarem problemas. Essa tolerância a falhas é essencial para manter a estabilidade e a robustez de sistemas multiagentes complexos. A paz de espírito está a apenas um recurso de distância.

Primeiros passos com o LangGraph

Vamos ver como podemos configurar o LangGraph e quais são os conceitos básicos.

Instalação

Para instalar o LangGraph, você pode usar pip:

pip install -U langgraph

Conceitos básicos

Nós: Os nós representam unidades de trabalho em seu LangGraph. Em geral, são funções Python que executam uma tarefa específica, como, por exemplo, se você quiser:

• Interagindo com um LLM
• Chamada de uma ferramenta ou API
• Realização de algumas manipulações de dados
• Receber entrada do usuário
• Execução da lógica de negócios

No LangGraph, você pode adicionar nós usando a sintaxe graph.add_node(name, value).

Bordas: As bordas são canais de comunicação entre os nós. Eles definem o fluxo de informações e a ordem de execução. Você pode adicionar bordas usando a sintaxe graph.add_edge(node1, node2).

Estado: O estado é um objeto central atualizado ao longo do tempo pelos nós do gráfico. Ele gerencia o estado interno do seu aplicativo e pode ser substituído ou adicionado, dependendo dos requisitos do aplicativo. Esse estado pode conter coisas como:

• Histórico de conversas: Uma lista de mensagens entre o agente e o usuário.
• Dados contextuais: Informações relevantes para a tarefa ou interação atual.
• Variáveis internas: Sinalizadores, contadores ou outras variáveis para que você possa acompanhar o progresso e o comportamento do agente.

Criando um aplicativo LangGraph simples

Aqui está um exemplo passo a passo da criação de um aplicativo básico de chatbot usando o LangGraph.

Etapa 1: Definir o StateGraph

Defina um objeto StateGraph para estruturar o chatbot como uma máquina de estado. O State é um objeto de classe definido com uma única chave messages do tipo List e usa a função add_messages() para anexar novas mensagens em vez de sobrescrevê-las.

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
class State(TypedDict):
    # messages have the type "list".
    # The add_messages function appends messages to the list, rather than overwriting them
    messages: Annotated[list, add_messages]
graph_builder = StateGraph(State)

Etapa 2: Inicialize um LLM e adicione-o como um nó do Chatbot

Aqui, inicializamos o modelo AzureChatOpenAI e criamos uma função simples de chatbot que recebe as mensagens de estado como entrada e gera uma resposta de mensagem (que é posteriormente anexada ao estado).

Essa função de chatbot é adicionada ao gráfico como um nó chamado "chatbot".

from langchain_openai import AzureChatOpenAI
llm = AzureChatOpenAI(
    openai_api_version=os.environ["AZURE_OPENAI_API_VERSION"],
    azure_deployment=os.environ["AZURE_OPENAI_CHAT_DEPLOYMENT_NAME"],
)
def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages"])]}
‘’’The first argument is the unique node name
# The second argument is the function or object that will be called whenever the node is used.’’’
graph_builder.add_node("chatbot", chatbot)

Etapa 3: Definir bordas

Como estamos criando um chatbot simples, definimos o nó chatbot como os pontos de entrada e de saída do gráfico para indicar onde iniciar e terminar o processo.

# Set entry and finish points
graph_builder.set_entry_point("chatbot")
graph_builder.set_finish_point("chatbot")

Etapa 4: Compilar e visualizar o gráfico

Compile o gráfico para criar um CompiledGraph e, opcionalmente, podemos visualizar a estrutura do gráfico usando o código abaixo:

graph = graph_builder.compile()
from IPython.display import Image, display
try:
    display(Image(graph.get_graph().draw_mermaid_png()))
except Exception:
    pass

Etapa 5: Execute o chatbot

Por fim, implementamos um loop para solicitar continuamente a entrada do usuário, processá-la por meio do gráfico e imprimir a resposta do assistente. O loop é encerrado quando o usuário digita "quit", "exit", ou "q".

# Run the chatbot
while True:
    user_input = input("User: ")
    if user_input.lower() in ["quit", "exit", "q"]:
        print("Goodbye!")
        break
    for event in graph.stream({"messages": [("user", user_input)]}):
        for value in event.values():
            print("Assistant:", value["messages"][-1].content)

Recursos avançados do LangGraph

Agora que já abordamos o básico, vamos dar uma olhada em alguns recursos avançados.

Tipos de nós personalizados

O LangGraph permite que você crie tipos de nós personalizados para implementar uma lógica de agente complexa. Isso proporciona flexibilidade e controle sobre o comportamento do seu aplicativo.

from typing import Annotated
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
class MyCustomNode:
    def __init__(self, llm):
        self.llm = llm
    def __call__(self, state):
        # Implement your custom logic here
        # Access the state and perform actions
        messages = state["messages"]
        response = self.llm.invoke(messages)
        return {"messages": [response]}
graph_builder = StateGraph(State)
llm = ChatAnthropic(model="claude-3-haiku-20240307")
custom_node = MyCustomNode(llm)
graph_builder.add_node("custom_node", custom_node)

Aqui, definimos uma classe MyCustomNode que encapsula a lógica personalizada e interage com o LLM. Isso proporciona uma maneira mais estruturada e de fácil manutenção para implementar comportamentos complexos de nós.

Tipos de borda

O LangGraph oferece suporte a diferentes tipos de borda para lidar com vários padrões de comunicação entre os nós. Um tipo útil é a borda condicional, que permite a tomada de decisões com base na saída de um nó.

Para criar uma borda condicional, você precisa de três componentes:

1. O nó upstream: A saída do nó decide a próxima etapa.
2. Uma função: Essa função avalia a saída do nó upstream e determina o próximo nó a ser executado, retornando uma cadeia de caracteres que representa a decisão.
3. Um mapeamento: Esse mapeamento vincula os possíveis resultados da função aos nós correspondentes a serem executados.

Aqui está um exemplo em pseudocódigo:

graph.add_conditional_edge(
    "model",
    should_continue,
    {
        "end": END,
        "continue": "tools"
    }
)

Aqui, depois que o nó "model" é chamado, podemos sair do gráfico ("end") e retornar ao usuário, ou podemos continuar ("continue") e chamar uma ferramenta - dependendo do que o usuário decidir!

Gerenciamento do estado

O LangGraph oferece técnicas avançadas de gerenciamento de estado, que incluem o uso de bancos de dados externos, como SQLite, PostgreSQL e MongoDB, ou soluções de armazenamento em nuvem, como Amazon S3, Google Cloud Storage e Azure Blob Storage, para armazenar e recuperar o estado do seu agente, permitindo confiabilidade e escalabilidade.

Aqui está um exemplo de uso de um banco de dados SQLite para gerenciamento de estado:

from langgraph.checkpoint.sqlite import SqliteSaver
# Connect to the SQLite database
memory = SqliteSaver.from_conn_string(":memory:")
# Compile the graph with the checkpointer
graph = graph_builder.compile(checkpointer=memory)

Tratamento de erros

O LangGraph também oferece mecanismos para tratamento de erros:

• Exceções: As funções de nó podem gerar exceções para sinalizar erros durante a execução. Você pode capturar e tratar essas exceções para evitar que o gráfico seja interrompido.
• Mecanismos de repetição: Você pode implementar a lógica de repetição em seus nós para lidar com erros transitórios, como problemas de rede ou tempos limite de API.
• Registro em log: Use o logging para registrar erros e acompanhar a execução do seu gráfico.

Aplicativos do LangGraph no mundo real

O LangGraph pode ser usado para criar uma ampla variedade de aplicativos.

Chatbots

O LangGraph é ideal para desenvolver chatbots sofisticados que podem lidar com uma grande variedade de solicitações de usuários. Ao aproveitar vários agentes LLM, esses chatbots podem processar consultas em linguagem natural, fornecer respostas precisas e alternar perfeitamente entre diferentes tópicos de conversa. A capacidade de gerenciar o estado e coordenar as interações garante que o chatbot mantenha o contexto e ofereça uma experiência de usuário coerente.

Agentes autônomos

Para aplicativos que exigem tomada de decisão autônoma, o LangGraph permite a criação de agentes que podem executar tarefas de forma independente com base nas entradas do usuário e na lógica predefinida.

Esses agentes podem executar fluxos de trabalho complexos, interagir com outros sistemas e adaptar-se a novas informações de forma dinâmica. A estrutura estruturada do LangGraph garante que cada agente opere de forma eficiente e eficaz, tornando-o adequado para tarefas como suporte automatizado ao cliente, processamento de dados e monitoramento do sistema.

Sistemas multiagentes

O LangGraph é excelente na criação de aplicativos em que vários agentes colaboram para atingir um objetivo comum. Por exemplo, diferentes agentes podem gerenciar o estoque, processar pedidos e coordenar entregas em um sistema de gerenciamento da cadeia de suprimentos. Os recursos de coordenação do LangGraph garantem que cada agente se comunique de forma eficaz, compartilhando informações e tomando decisões de forma sincronizada. Isso leva a operações mais eficientes e a um melhor desempenho geral do sistema.

Ferramentas de automação de fluxo de trabalho

Com o LangGraph, você pode automatizar processos de negócios e fluxos de trabalho com facilidade. Os agentes inteligentes podem ser projetados para lidar com tarefas como processamento de documentos, fluxos de trabalho de aprovação e análise de dados. Ao definir fluxos de trabalho claros e aproveitar o gerenciamento de estado do LangGraph, essas ferramentas podem executar sequências complexas de ações sem intervenção humana, reduzindo erros e aumentando a produtividade.

Sistemas de recomendação

Os sistemas de recomendação personalizados podem se beneficiar muito dos recursos do LangGraph. Ao empregar vários agentes para analisar o comportamento, as preferências e os dados contextuais do usuário, esses sistemas podem fornecer sugestões personalizadas de produtos, conteúdo ou serviços. A flexibilidade do LangGraph permite a integração de várias fontes de dados e algoritmos, aprimorando a precisão e a relevância das recomendações.

Ambientes de aprendizagem personalizados

Em plataformas educacionais, o LangGraph pode ser usado para criar ambientes de aprendizagem adaptáveis que atendam a estilos e necessidades individuais de aprendizagem. Vários agentes podem avaliar o progresso de um aluno, fornecer exercícios personalizados e oferecer feedback em tempo real. A natureza de estado do LangGraph garante que o sistema retenha informações sobre o desempenho e as preferências de cada aluno, possibilitando uma experiência educacional mais personalizada e eficaz.

Conclusão

O LangGraph simplifica significativamente o desenvolvimento de aplicativos LLM complexos, fornecendo uma estrutura estruturada para gerenciar o estado e coordenar as interações dos agentes.

Os possíveis desenvolvimentos do LangGraph incluem a integração com outros componentes do LangChain, o suporte a novos modelos de LLM e a introdução de tempos de execução de agentes mais avançados do meio acadêmico.

Se você quiser saber mais sobre o desenvolvimento de aplicativos no ecossistema LangChain, recomendo este curso sobre desenvolvimento de aplicativos LLM com LangChain.