Tutorial de LangGraph: ¿Qué es LangGraph y cómo se utiliza?

Imagina que estás construyendo una aplicación compleja y multiagente de modelos lingüísticos extensos (LLM). Es emocionante, pero conlleva retos: gestionar el estado de varios agentes, coordinar sus interacciones y manejar los errores con eficacia. Aquí es donde LangGraph puede ayudarte.

LangGraph es una biblioteca del ecosistema LangChain diseñada para hacer frente a estos retos. LangGraph proporciona un marco para definir, coordinar y ejecutar múltiples agentes LLM (o cadenas) de forma estructurada.

Simplifica el proceso de desarrollo al permitir la creación de gráficos cíclicos, que son esenciales para desarrollar tiempos de ejecución de agentes. Con LangGraph, podemos construir fácilmente sistemas multiagente robustos, escalables y flexibles.

Si quieres saber más sobre el ecosistema LangChain, te recomiendo esta introducción a LangChain.

¿Qué es LangGraph?

LangGraph nos permite crear aplicaciones con estado y multiactores utilizando LLMs de la forma más sencilla posible. Amplía las capacidades de LangChain, introduciendo la posibilidad de crear y gestionar grafos cíclicos, que son fundamentales para desarrollar tiempos de ejecución de agentes sofisticados. Los conceptos básicos de LangGraph son: estructura de grafos, gestión de estados y coordinación.

Estructura gráfica

Imagina tu aplicación como un grafo dirigido. En LangGraph, cada nodo representa un agente LLM, y las aristas son los canales de comunicación entre estos agentes. Esta estructura permite flujos de trabajo claros y manejables, en los que cada agente realiza tareas específicas y pasa información a otros agentes según sea necesario.

Gestión estatal

Una de las características más destacadas de LangGraph es su gestión automática de estados. Esta función nos permite rastrear y persistir en la información a través de múltiples interacciones. A medida que los agentes realizan sus tareas, el estado se actualiza dinámicamente, asegurando que el sistema mantiene el contexto y responde adecuadamente a las nuevas entradas.

Coordinación

LangGraph garantiza que los agentes se ejecuten en el orden correcto y que la información necesaria se intercambie sin problemas. Esta coordinación es vital para aplicaciones complejas en las que varios agentes deben trabajar juntos para lograr un objetivo común. Al gestionar el flujo de datos y la secuencia de operaciones, LangGraph permite a los desarrolladores centrarse en la lógica de alto nivel de sus aplicaciones, en lugar de en las complejidades de la coordinación de agentes.

¿Por qué LangGraph?

Como he mencionado antes, LangGraph ofrece varias ventajas significativas para los desarrolladores que trabajan con aplicaciones LLM complejas. Éstas son algunas de las ventajas que ofrece LangGraph en el mundo real.

Desarrollo simplificado

LangGraph abstrae las complejidades asociadas a la gestión de estados y la coordinación de agentes. Esto significa que los desarrolladores pueden definir sus flujos de trabajo y su lógica sin preocuparse de los mecanismos subyacentes que garantizan la coherencia de los datos y el orden de ejecución adecuado. Esta simplificación acelera el proceso de desarrollo y reduce la probabilidad de errores. ¡Es un cambio de juego!

Flexibilidad

Con LangGraph, los desarrolladores tienen flexibilidad para definir su propia lógica de agente y sus protocolos de comunicación. Esto permite aplicaciones muy personalizadas, adaptadas a casos de uso específicos. Tanto si necesitas un chatbot que pueda gestionar varios tipos de peticiones de los usuarios como un sistema multiagente que realice tareas complejas, LangGraph te proporciona las herramientas para construir exactamente lo que necesitas. Se trata de darte el poder de crear.

Escalabilidad

LangGraph está construido para soportar la ejecución de aplicaciones multiagente a gran escala. Su robusta arquitectura puede gestionar un gran volumen de interacciones y flujos de trabajo complejos, permitiendo el desarrollo de sistemas escalables que pueden crecer con tus necesidades. Esto lo hace adecuado para aplicaciones de nivel empresarial y escenarios en los que el rendimiento y la fiabilidad son fundamentales.

Tolerancia a fallos

La fiabilidad es una consideración esencial en el diseño de LangGraph. La biblioteca incluye mecanismos para gestionar los errores con elegancia, garantizando que tu aplicación pueda seguir funcionando incluso cuando los agentes individuales tengan problemas. Esta tolerancia a los fallos es esencial para mantener la estabilidad y robustez de los sistemas multiagente complejos. La tranquilidad está a sólo una función de distancia.

Primeros pasos con LangGraph

Veamos cómo podemos configurar LangGraph y cuáles son sus conceptos básicos.

Instalación

Para instalar LangGraph, puedes utilizar pip:

pip install -U langgraph

Conceptos básicos

Nodos: Los nodos representan unidades de trabajo dentro de tu LangGraph. Suelen ser funciones de Python que realizan una tarea específica, como por ejemplo

• Interactuar con un LLM
• Llamar a una herramienta o API
• Realizar alguna manipulación de datos
• Recibir la información del usuario
• Ejecutar la lógica empresarial

En LangGraph, puedes añadir nodos utilizando la sintaxis graph.add_node(name, value).

Bordes: Las aristas son canales de comunicación entre nodos. Definen el flujo de información y el orden de ejecución. Puedes añadir aristas utilizando la sintaxis graph.add_edge(node1, node2).

Estado: El estado es un objeto central actualizado en el tiempo por los nodos del grafo. Gestiona el estado interno de tu aplicación y puede anularse o añadirse, según los requisitos de la aplicación. Este estado puede contener cosas como

• Historia de la conversación: Una lista de mensajes entre el agente y el usuario.
• Datos contextuales: Información relevante para la tarea o interacción actual.
• Variables internas: Indicadores, contadores u otras variables para seguir el progreso y el comportamiento del agente.

Construir una aplicación LangGraph sencilla

Aquí tienes un ejemplo paso a paso de cómo crear una aplicación básica de chatbot utilizando LangGraph.

Paso 1: Definir el StateGraph

Define un objeto StateGraph para estructurar el chatbot como una máquina de estados. El State es un objeto de clase definido con una sola clave messages de tipo List y utiliza la función add_messages() para añadir nuevos mensajes en lugar de sobrescribirlos.

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)

Paso 2: Inicializa un LLM y añádelo como nodo Chatbot

Aquí, inicializamos el modelo AzureChatOpenAI y creamos una sencilla función de chatbot que toma los mensajes de estado como entrada y genera un mensaje de respuesta (que posteriormente se añade al estado).

Esta función de chatbot se añade como un nodo llamado "chatbot" al gráfico.

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)

Paso 3: Fijar bordes

Como estamos construyendo un chatbot sencillo, establecemos el nodo chatbot como puntos de entrada y final del gráfico para indicar dónde empezar y terminar el proceso.

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

Paso 4: Compilar y visualizar el gráfico

Compila el grafo para crear un grafo compilado y, opcionalmente, podemos visualizar la estructura del grafo utilizando el código siguiente:

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

Paso 5: Ejecuta el chatbot

Por último, implementamos un bucle para pedir continuamente la entrada al usuario, procesarla a través del gráfico e imprimir la respuesta del asistente. El bucle sale cuando el usuario escribe "quit", "exit", o "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)

Funciones avanzadas de LangGraph

Ahora que hemos cubierto lo básico, echemos un vistazo a algunas funciones avanzadas.

Tipos de nodos personalizados

LangGraph te permite crear tipos de nodos personalizados para implementar una lógica de agente compleja. Esto proporciona flexibilidad y control sobre el comportamiento de tu aplicación.

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)

Aquí definimos una clase MyCustomNode que encapsula la lógica personalizada e interactúa con el LLM. Esto proporciona una forma más estructurada y fácil de mantener de implementar comportamientos de nodos complejos.

Tipos de aristas

LangGraph admite distintos tipos de aristas para manejar diversos patrones de comunicación entre nodos. Un tipo útil es la arista condicional, que permite tomar decisiones en función de la salida de un nodo.

Para crear un borde condicional, necesitas tres componentes:

1. El nodo ascendente: La salida del nodo decide el siguiente paso.
2. Una función: Esta función evalúa la salida del nodo anterior y determina el siguiente nodo a ejecutar, devolviendo una cadena que representa la decisión.
3. Una cartografía: Este mapeo vincula los posibles resultados de la función a los nodos correspondientes que deben ejecutarse.

Aquí tienes un ejemplo en pseudocódigo:

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

Aquí, después de llamar al nodo "modelo", podemos salir del gráfico ("fin") y volver al usuario, o podemos continuar ("continuar") y llamar a una herramienta, ¡dependiendo de lo que decida el usuario!

Gestión estatal

LangGraph ofrece potentes técnicas de gestión de estados, que incluyen el uso de bases de datos externas como SQLite, PostgreSQL y MongoDB, o soluciones de almacenamiento en la nube como Amazon S3, Google Cloud Storage y Azure Blob Storage para almacenar y recuperar el estado de tu agente, lo que permite fiabilidad y escalabilidad.

He aquí un ejemplo de utilización de una base de datos SQLite para la gestión de estados:

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)

Tratamiento de errores

LangGraph también proporciona mecanismos para el tratamiento de errores:

• Excepciones: Las funciones de nodo pueden lanzar excepciones para señalar errores durante la ejecución. Puedes atrapar y manejar estas excepciones para evitar que tu gráfico se bloquee.
• Mecanismos de reintento: Puedes implementar una lógica de reintento en tus nodos para gestionar errores transitorios, como problemas de red o tiempos de espera de la API.
• Registro: Utiliza el registro para anotar los errores y seguir la ejecución de tu gráfico.

Aplicaciones reales de LangGraph

LangGraph puede utilizarse para crear una amplia gama de aplicaciones.

Chatbots

LangGraph es ideal para desarrollar chatbots sofisticados que puedan gestionar una amplia gama de peticiones de los usuarios. Al aprovechar múltiples agentes LLM, estos chatbots pueden procesar consultas en lenguaje natural, dar respuestas precisas y cambiar sin problemas entre distintos temas de conversación. La capacidad de gestionar el estado y coordinar las interacciones garantiza que el chatbot mantenga el contexto y ofrezca una experiencia de usuario coherente.

Agentes autónomos

Para las aplicaciones que requieren una toma de decisiones autónoma, LangGraph permite crear agentes que pueden realizar tareas de forma independiente basándose en las entradas del usuario y en una lógica predefinida.

Estos agentes pueden ejecutar flujos de trabajo complejos, interactuar con otros sistemas y adaptarse a la nueva información de forma dinámica. El marco estructurado de LangGraph garantiza que cada agente funcione con eficiencia y eficacia, lo que lo hace adecuado para tareas como la atención al cliente automatizada, el procesamiento de datos y la supervisión de sistemas.

Sistemas multiagente

LangGraph destaca en la construcción de aplicaciones en las que varios agentes colaboran para lograr un objetivo común. Por ejemplo, distintos agentes pueden gestionar el inventario, procesar pedidos y coordinar las entregas en un sistema de gestión de la cadena de suministro. Las capacidades de coordinación de LangGraph garantizan que cada agente se comunique eficazmente, compartiendo información y tomando decisiones de forma sincronizada. Esto conduce a operaciones más eficientes y a un mejor rendimiento general del sistema.

Herramientas de automatización del flujo de trabajo

Con LangGraph, automatizar los procesos empresariales y los flujos de trabajo se convierte en algo sencillo. Los agentes inteligentes pueden diseñarse para gestionar tareas como el procesamiento de documentos, los flujos de trabajo de aprobación y el análisis de datos. Al definir flujos de trabajo claros y aprovechar la gestión de estados de LangGraph, estas herramientas pueden ejecutar secuencias complejas de acciones sin intervención humana, reduciendo los errores y aumentando la productividad.

Sistemas de recomendación

Los sistemas de recomendación personalizados pueden beneficiarse enormemente de las capacidades de LangGraph. Empleando múltiples agentes para analizar el comportamiento, las preferencias y los datos contextuales del usuario, estos sistemas pueden ofrecer sugerencias personalizadas de productos, contenidos o servicios. La flexibilidad de LangGraph permite integrar diversas fuentes de datos y algoritmos, mejorando la precisión y relevancia de las recomendaciones.

Entornos de aprendizaje personalizados

En las plataformas educativas, LangGraph puede utilizarse para crear entornos de aprendizaje adaptativos que se adapten a los estilos y necesidades individuales de aprendizaje. Varios agentes pueden evaluar el progreso de un alumno, proporcionarle ejercicios personalizados y ofrecerle información en tiempo real. La naturaleza de estado de LangGraph garantiza que el sistema conserve información sobre el rendimiento y las preferencias de cada alumno, lo que permite una experiencia educativa más personalizada y eficaz.

Conclusión

LangGraph simplifica significativamente el desarrollo de aplicaciones LLM complejas al proporcionar un marco estructurado para gestionar el estado y coordinar las interacciones de los agentes.

Los posibles desarrollos de LangGraph incluyen la integración con otros componentes de LangChain, la compatibilidad con nuevos modelos LLM y la introducción de tiempos de ejecución de agentes más avanzados procedentes del mundo académico.

Si quieres aprender más sobre el desarrollo de aplicaciones dentro del ecosistema LangChain, te recomiendo este curso sobre desarrollo de aplicaciones LLM con LangChain.