LangGraph: un marco para la construcción y ejecución de agentes de IA basado en la topología de grafos acíclicos dirigidos

La Inteligencia Artificial (IA) es un campo en rápido crecimiento. Los modelos lingüísticos han evolucionado para permitir a los agentes de IA realizar tareas complejas y tomar decisiones complejas. Sin embargo, a medida que aumentan las habilidades de estos agentes, la infraestructura que los soporta se esfuerza por seguirles el ritmo.

LangGraph, una biblioteca revolucionaria diseñada para revolucionar el agente de IA Creación y tiempo de ejecución Implantación.

LangGraph presenta un nuevo AgenteCreación y tiempo de ejecuciónParadigma constructivo, que considera los flujos de trabajo de los Agentes como estructuras basadas en una topología gráfica cíclica.

¿Qué es LangGraph?

Una importante propuesta de valor de LangChain es la posibilidad de crear fácilmente cadenas personalizadas. Sin embargo, LangChain carece de una forma sencilla de introducir bucles en estas cadenas. De hecho, estas cadenas son grafos acíclicos dirigidos (DAG) - Como la mayoría de los marcos de orquestación de datos.

Un patrón común cuando la gente construye aplicaciones LLM complejas es introducir bucles en el tiempo de ejecución. Estos bucles a menudo recurren al LLM para razonar sobre la siguiente acción en el bucle. Esto es esencialmente el equivalente a ejecutar el LLM en un bucle for. a estos sistemas se les suele llamar Agentes.

La forma más sencilla es un bucle con dos pasos:

1. Llamar a LLM para determinar qué acción tomar o qué respuesta dar al usuario.
2. Realiza la operación dada y vuelve al paso 1.

Estos pasos se repiten hasta que se genera la respuesta final. Este es el bucle que acciona el AgentExecutor en el corazón de LangChain. Es un bucle muy simple, pero también es el más crítico porque pone casi todo el poder de decisión y razonamiento en manos del LLM.

Es importante tener en cuenta que este proceso suele requerir más control. Por ejemplo, forzar al Agente a invocar primero una herramienta específica, más control sobre cómo se invoca la herramienta, diferentes avisos dependiendo del estado en el que se encuentre el Agente, etc.

Son procesos controlados, que LangChain llama "máquinas de estado".

Estas máquinas de estado tienen la capacidad de formar bucles, sin embargo, se requiere cierta intervención humana en la construcción de este bucle.

LangGraph crea estas máquinas de estado especificándolas como grafos.

LangGraph está construido sobre LangChain y es totalmente compatible con el ecosistema LangChain.interoperabilidad. Añade nuevo valor principalmente introduciendo una forma fácil de crear diagramas de bucle. Esto es muy útil para crear tiempos de ejecución de agentes.

Este enfoque permite a los Agentes mostrar comportamientos más variables y matizados que los modelos de ejecución lineal de sus predecesores. Mediante el uso de la teoría de grafos, LangGraph proporciona nuevas formas de desarrollar complejos sistemas de Agentes en red.

Figura: un LangGraph para la generación de código

Un ejemplo: sistema dinámico de preguntas y respuestas

toma El usuario puede ir proporcionando información al modelo paso a paso, en lugar de enviar toda la información a la vez.

prescripción Utiliza un diagrama cíclico:

1. Permitir que el LLM genere respuestas iniciales.
2. Si la respuesta es incompleta o se necesita más información, genere una nueva pregunta y siga preguntando al usuario.
3. hasta que el usuario confirme que el problema se ha resuelto.

Estructura del diagrama del ciclo

• NodosCada nodo representa una tarea u operación específica, como la generación de texto, la respuesta a preguntas, el procesamiento de datos, etc.
• Bordes: Las conexiones entre nodos indican el orden de ejecución de las tareas, posiblemente con juicios condicionales.
• Trayectoria en bucleBucle: Los bucles se forman cuando la salida de un nodo debe retroalimentarse al nodo anterior, o cuando debe ejecutarse repetidamente.
• Condición de paradaEl diagrama de bucle establecerá algún tipo de condición de finalización, por ejemplo, que la calidad del resultado cumpla los requisitos, que se alcance un límite de veces establecido o que se active una señal de parada externa.

¿Por qué utilizar LangGraph?

• destreza Los agentes de IA evolucionan y los desarrolladores necesitan más control sobre el tiempo de ejecución del agente para poder personalizar los planes de acción y los procedimientos de toma de decisiones.
• La naturaleza circular del razonamiento de la IA LangGraph: Muchas aplicaciones LLM complejas se basan en la ejecución cíclica cuando se utilizan estrategias como el razonamiento encadenado. LangGraph proporciona un marco natural para modelar estos procesos cíclicos.
• sistema de inteligencia múltiple La necesidad de sistemas capaces de gestionar y coordinar eficazmente múltiples inteligencias autónomas aumenta a medida que se generalizan los flujos de trabajo multiinteligencia.

Utiliza el código para ver cómo funciona LangGraph

La funcionalidad de LangGraph se basa en unos pocos elementos básicos:

• Nodos. Se trata de herramientas para funciones o Agentes.
• Bordes. Definir rutas para la ejecución y el flujo de datos en el sistema Agente, conectando nodos.
• StateGraph. LangGraph permite mantener datos persistentes entre ciclos de ejecución mediante la gestión y actualización de objetos de estado, con flujo de datos entre nodos.

Figura : Flujo de trabajo básico de LangGraph

StateGraph

StateGraph es una clase que representa un gráfico. Para crear un gráfico, se le pasa la clase state para inicializar esta clase. La definición de estado representa un objeto de estado central que se actualiza con el tiempo. Este estado es actualizado por nodos del grafo, que devuelven operaciones sobre los atributos de este estado en forma de almacenes clave-valor.

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)

Nodos

Crear un StateGraph A continuación, puede utilizar la función graph.add_node(name, value) Sintaxis para añadir nodos. name El argumento es una cadena que es el nombre del nodo. value El argumento es una función o un LCEL ejecutable que será llamado.

Esta función /LCEL acepta una función igual a State tiene un diccionario de la misma forma que el de entrada y produce un diccionario que utiliza el método State para actualizar el diccionario.

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"

Bordes

Indica que uno de los nodos se llama siempre después del otro

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

Compilar Compilar

Después de definir nuestro grafo, ¡podemos compilarlo para que sea ejecutable! Exponga los mismos métodos que LangChain ( .invoke (matemáticas) género .stream (matemáticas) género .astream_log etc.), lo que permite llamarla del mismo modo que a una cadena.

graph = graph_builder.compile()  # 编译图

estar en movimiento

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 visualización (opcional)

Visualización de "diagramas" en el entorno Jupyter Notebook

efecto operativo

Los marcos como LangGraph son cada vez más importantes a medida que evoluciona la IA.

A medida que los desarrolladores se familiaricen con las funciones de LangGraph, podremos ver agentes de IA más avanzados, capaces de realizar tareas más complejas.

En resumen, LangGraph supone un avance significativo en el desarrollo de agentes de IA. Permite a los desarrolladores ampliar los límites de lo que es posible con los Agentes de IA eliminando las deficiencias de los sistemas anteriores y proporcionando un marco flexible basado en grafos para la construcción y ejecución de Agentes.LangGraph tiene el potencial de influir significativamente en la dirección del desarrollo de la IA en el futuro.