LangGraph: uma estrutura para construção e execução de agentes de IA com base na topologia de gráficos acíclicos direcionados

A Inteligência Artificial (IA) é um campo em rápido crescimento. Os modelos de linguagem evoluíram para permitir que os agentes de IA executem tarefas complexas e tomem decisões complexas. No entanto, à medida que as habilidades desses agentes continuam a crescer, a infraestrutura para dar suporte a eles tem dificuldades para acompanhar esse ritmo.

LangGraph, uma biblioteca revolucionária projetada para revolucionar a tecnologia de agente de IA Compilação e tempo de execução Implementação.

LangGraph apresenta um novo agenteCompilação e tempo de execuçãoParadigma construtivo, que vê os fluxos de trabalho do agente como estruturas baseadas em uma topologia de gráfico cíclico.

O que é o LangGraph?

Uma importante proposta de valor da LangChain é a capacidade de criar facilmente cadeias personalizadas. No entanto, a LangChain não tem uma maneira fácil de introduzir loops nessas cadeias. De fato, essas cadeias são gráficos acíclicos direcionados (DAG) - Como a maioria das estruturas de orquestração de dados.

Um padrão comum quando as pessoas criam aplicativos LLM complexos é introduzir loops no tempo de execução. Esses loops geralmente utilizam o LLM para raciocinar sobre a próxima ação no loop. Isso é essencialmente o equivalente a executar o LLM em um loop for. Esses sistemas são geralmente chamados de agentes.

A forma mais simples é um loop com duas etapas:

1. Chame o LLM para determinar qual ação deve ser tomada ou qual resposta deve ser dada ao usuário
2. Execute a operação fornecida e retorne à etapa 1.

Essas etapas são repetidas até que a resposta final seja gerada. Esse é o loop que aciona o AgentExecutor no coração do LangChain. É um loop muito simples, mas também é o mais importante, pois coloca quase todo o poder de decisão e raciocínio nas mãos do LLM.

É importante observar que esse processo geralmente requer mais controle. Por exemplo, forçar o agente a invocar uma ferramenta específica primeiro, mais controle sobre como a ferramenta é invocada, prompts diferentes dependendo do estado em que o agente se encontra etc.

Esses são processos controlados, que a LangChain chama de "máquinas de estado".

Essas máquinas de estado têm a capacidade de fazer um loop; no entanto, é necessária alguma intervenção humana na construção desse loop.

O LangGraph cria essas máquinas de estado especificando-as como gráficos.

O LangGraph foi desenvolvido com base no LangChain e é totalmente compatível com o ecossistema do LangChain.interoperabilidade. Ele agrega novo valor principalmente ao introduzir uma maneira fácil de criar diagramas de loop. Isso é muito útil na criação de tempos de execução de agentes.

Essa abordagem permite que os agentes apresentem comportamentos mais variáveis e diferenciados do que os modelos de execução linear de seus antecessores. Usando a teoria dos gráficos, o LangGraph oferece novas maneiras de desenvolver sistemas complexos de agentes em rede.

Figura: um LangGraph para geração de código

Um exemplo: sistema dinâmico de perguntas e respostas

tomar O usuário pode estar fornecendo informações ao modelo passo a passo, em vez de enviar todas as informações de uma só vez.

prescrição Use um diagrama cíclico:

1. Permitir que o LLM gere respostas iniciais.
2. Se a resposta estiver incompleta ou se forem necessárias mais informações, gere uma nova pergunta e continue a perguntar ao usuário.
3. até que o usuário confirme que o problema foi resolvido.

Estrutura do diagrama de ciclo

• NósCada nó representa uma tarefa ou operação específica, como geração de texto, resposta a perguntas, processamento de dados etc.
• BordasConexões entre nós indicam a ordem de execução da tarefa, possivelmente com julgamentos condicionais.
• Caminho de loopingLoops: Os loops são formados quando a saída de um nó precisa ser realimentada para o nó anterior ou quando precisa ser executada repetidamente.
• Condição de paradaOs diagramas de loop estão sujeitos a algum tipo de condição de término, por exemplo, quando a qualidade do resultado atende aos requisitos, quando o limite do número de vezes definido é atingido ou quando um sinal de parada acionado externamente é ativado.

Por que usar o LangGraph?

• destreza : À medida que os agentes de IA evoluem, os desenvolvedores precisam de mais controle sobre o tempo de execução do agente para permitir planos de ação personalizados e procedimentos de tomada de decisão.
• A natureza circular do raciocínio de IA LangGraph: Muitos aplicativos LLM complexos dependem da execução cíclica ao usar estratégias como raciocínio encadeado. O LangGraph oferece uma estrutura natural para modelar esses processos cíclicos.
• sistema de inteligência múltipla Inteligência múltipla: à medida que os fluxos de trabalho com várias inteligências se tornam mais comuns, aumenta a necessidade de sistemas que possam gerenciar e coordenar com eficiência várias inteligências autônomas.

Use o código para ver como o LangGraph funciona

A funcionalidade do LangGraph se baseia em alguns elementos básicos:

• Nós. Essas são ferramentas para funções ou agentes.
• Bordas. Definir caminhos para execução e fluxo de dados no sistema do agente, conectando os nós.
• StateGraph. O LangGraph permite que os dados persistentes sejam mantidos entre os ciclos de execução por meio do gerenciamento e da atualização de objetos de estado, com o fluxo de dados entre os nós.

Figura: Fluxo de trabalho básico do LangGraph

StateGraph

StateGraph é uma classe que representa um gráfico. Você cria um gráfico passando a classe state para inicializar essa classe. A definição de estado representa um objeto de estado central que é atualizado ao longo do tempo. Esse estado é atualizado por nós no gráfico, que retornam operações sobre os atributos desse estado na forma de armazenamentos de valores-chave.

import os  # 导入操作系统模块
os.environ['OpenAI_API_KEY'] = 'hk-iwtbi1e427'
from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
class State(TypedDict):
    # messages 的类型为“list”。Annotated中的“add_messages” 定义了如何更新messages
    # 在本例中，messages是追加到list中的，而不是覆盖
    messages: Annotated[list, add_messages]
# 创建StateGraph的实例，传入State类
graph_builder = StateGraph(State)

Nós

Criar um StateGraph Depois disso, você pode usar o graph.add_node(name, value) Sintaxe para adicionar nós. name O argumento é uma cadeia de caracteres que é o nome do nó. value O argumento é uma função ou um LCEL executável que será chamado.

Essa função /LCEL aceita uma função que é igual a State tem um dicionário com o mesmo formato da entrada e gera um dicionário que usa o parâmetro State para atualizar o dicionário.

from langchain_openai import ChatOpenAI  # 从langchain_openai模块导入ChatOpenAI
llm = ChatOpenAI(  # 创建ChatOpenAI的实例
    model="gpt-4o-mini",  # 指定模型
    temperature=0,  # 设置温度
    base_url="https://api.openai-hk.com/v1"# 设置基础URL
)
def chatbot(state: State):# 定义chatbot函数，接受State类型的参数
    """
    处理聊天机器人请求并返回消息。
    参数:
    state (State): 包含消息的状态。
    返回:
    dict: 机器人生成的消息的字典。
    """
    return {"messages": [llm.invoke(state["messages"])]}  # 返回包含消息的字典
# 第一个参数是节点name
# 第二个参数是被调用的函数或对象
graph_builder.add_node("chatbot", chatbot)  # 向图中添加节点，节点名称为"chatbot"

Bordas

Indica que um dos nós é sempre chamado após o outro

# 添加从START到"chatbot"的边
graph_builder.add_edge(START, "chatbot")  
# 添加从"chatbot"到END的边
graph_builder.add_edge("chatbot", END)  

Compilar Compilar

Depois de definir nosso gráfico, podemos compilá-lo para que seja executável! Exponha os mesmos métodos da LangChain ( .invoke (matemática) gênero .stream (matemática) gênero .astream_log etc.), permitindo que ele seja chamado da mesma forma que uma cadeia.

graph = graph_builder.compile()  # 编译图

estar em movimento

def stream_graph_updates(user_input: str):  # 定义stream_graph_updates函数，接受用户输入
    """
    使用user_input流式更新图的消息。
    参数:
    user_input (str): 用户输入的消息。
    返回:
    None
    """
    # 遍历图的流事件，传入用户消息以获取模型的响应
    for event in graph.stream({"messages": [("user", user_input)]}):  # 遍历图的流事件
        for value in event.values():  # 遍历事件的值
            print("Assistant:", value["messages"][-1].content)  # 打印助手的最后一条消息
whileTrue:
    try:
        user_input = input("User: ")  # 获取用户输入
        if user_input.lower() in ["quit", "exit", "q"]:  # 检查用户是否想退出
            print("Goodbye!")
            break# 退出循环
        # 调用stream_graph_updates函数处理用户输入
        stream_graph_updates(user_input)
    except:  # 捕获异常
        # fallback if input() is not available
        user_input = "What do you know about LangGraph?"# 设置默认用户输入
        print("User: " + user_input)  # 打印用户输入
        stream_graph_updates(user_input)  # 调用stream_graph_updates函数处理默认输入
        break# 退出循环

"Diagrama" de visualização (opcional)

Visualização de "diagramas" no ambiente do Jupyter Notebook

efeito operacional

Estruturas como a LangGraph estão se tornando cada vez mais importantes à medida que a IA evolui.

À medida que os desenvolvedores se familiarizam com os recursos do LangGraph, podemos esperar ver agentes de IA mais avançados, capazes de executar tarefas mais complexas.

Em resumo, o LangGraph é um avanço significativo no desenvolvimento de agentes de IA. Ele permite que os desenvolvedores ultrapassem os limites do que é possível com os agentes de IA, eliminando as deficiências dos sistemas anteriores e fornecendo uma estrutura flexível e baseada em gráficos para a construção e execução de agentes.