Tutorial su LangGraph: cos'è LangGraph e come usarlo

Cos'è LangGraph?

LangGraph ci permette di creare applicazioni stateful e multi-attore che utilizzano LLM nel modo più semplice possibile. Estende le capacità di LangChain, introducendo la possibilità di creare e gestire grafi ciclici, fondamentali per sviluppare runtime di agent sofisticati. I concetti chiave di LangGraph includono: struttura del grafo, gestione dello stato e coordinamento.

Struttura del grafo

Immagina la tua applicazione come un grafo diretto. In LangGraph, ogni nodo rappresenta un agent LLM e gli archi sono i canali di comunicazione tra questi agent. Questa struttura consente flussi di lavoro chiari e gestibili, in cui ogni agent svolge compiti specifici e passa le informazioni ad altri agent quando necessario.

Gestione dello stato

Una delle funzionalità di spicco di LangGraph è la gestione automatica dello stato. Questa funzione ci permette di tracciare e mantenere le informazioni attraverso più interazioni. Man mano che gli agent svolgono i loro compiti, lo stato viene aggiornato dinamicamente, garantendo che il sistema mantenga il contesto e risponda in modo appropriato ai nuovi input.

Coordinamento

LangGraph assicura che gli agent vengano eseguiti nell'ordine corretto e che le informazioni necessarie vengano scambiate senza soluzione di continuità. Questo coordinamento è vitale per applicazioni complesse in cui più agent devono lavorare insieme per raggiungere un obiettivo comune. Gestendo il flusso di dati e la sequenza delle operazioni, LangGraph consente agli sviluppatori di concentrarsi sulla logica di alto livello delle loro applicazioni invece che sulle complessità del coordinamento tra agent.

Perché LangGraph?

Come accennato sopra, LangGraph offre diversi vantaggi significativi per gli sviluppatori che lavorano con applicazioni LLM complesse. Ecco alcuni benefici reali che LangGraph offre.

Sviluppo semplificato

LangGraph astrae le complessità associate alla gestione dello stato e al coordinamento degli agent. Ciò significa che gli sviluppatori possono definire flussi di lavoro e logica senza preoccuparsi dei meccanismi sottostanti che garantiscono la coerenza dei dati e il corretto ordine di esecuzione. Questa semplificazione accelera lo sviluppo e riduce la probabilità di errori. È una svolta!

Flessibilità

Con LangGraph, gli sviluppatori hanno la flessibilità di definire la propria logica degli agent e i protocolli di comunicazione. Questo permette applicazioni altamente personalizzate, su misura per casi d'uso specifici. Che tu abbia bisogno di un chatbot in grado di gestire vari tipi di richieste utente o di un sistema multi-agent che esegue compiti complessi, LangGraph fornisce gli strumenti per costruire esattamente ciò che ti serve. Si tratta di darti il potere di creare.

Scalabilità

LangGraph è progettato per supportare l'esecuzione di applicazioni multi-agent su larga scala. La sua architettura robusta può gestire un alto volume di interazioni e flussi di lavoro complessi, consentendo lo sviluppo di sistemi scalabili che possono crescere con le tue esigenze. Questo lo rende adatto ad applicazioni di livello enterprise e a scenari in cui prestazioni e affidabilità sono fondamentali.

Tolleranza ai guasti

L'affidabilità è una considerazione centrale nel design di LangGraph. La libreria include meccanismi per gestire gli errori in modo graduale, assicurando che la tua applicazione possa continuare a funzionare anche quando singoli agent incontrano problemi. Questa tolleranza ai guasti è essenziale per mantenere stabilità e robustezza in sistemi multi-agent complessi. La tranquillità è a portata di funzionalità.

Primi passi con LangGraph

Vediamo come impostare LangGraph e quali sono i concetti di base.

Installazione

Per installare LangGraph, puoi usare pip:

pip install -U langgraph

Concetti di base

Nodi: i nodi rappresentano unità di lavoro all'interno del tuo LangGraph. In genere sono funzioni Python che svolgono un compito specifico, come:

• Interagire con un LLM
• Chiamare uno strumento o un'API
• Eseguire qualche manipolazione dei dati
• Ricevere input dell'utente
• Eseguire logica di business

In LangGraph, puoi aggiungere nodi usando la sintassi graph.add_node(name, value).

Archi: gli archi sono canali di comunicazione tra nodi. Definiscono il flusso di informazioni e l'ordine di esecuzione. Puoi aggiungere archi usando la sintassi graph.add_edge(node1, node2).

Stato: lo stato è un oggetto centrale aggiornato nel tempo dai nodi del grafo. Gestisce lo stato interno della tua applicazione e può essere sovrascritto o esteso, a seconda dei requisiti. Lo stato può contenere elementi come:

• Cronologia della conversazione: un elenco di messaggi tra l'agent e l'utente.
• Dati contestuali: informazioni rilevanti per il compito o l'interazione in corso.
• Variabili interne: flag, contatori o altre variabili per tracciare i progressi e il comportamento dell'agent.

Creare una semplice applicazione con LangGraph

Ecco un esempio passo-passo per creare un chatbot di base con LangGraph.

Passaggio 1: definisci lo StateGraph

Definisci un oggetto StateGraph per strutturare il chatbot come una macchina a stati. State è una classe definita con una singola chiave messages di tipo List e usa la funzione add_messages() per aggiungere nuovi messaggi invece di sovrascriverli.

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)

Passaggio 2: inizializza un LLM e aggiungilo come nodo Chatbot

Qui inizializziamo il modello AzureChatOpenAI e creiamo una semplice funzione di chatbot che prende come input i messaggi dello stato e genera una risposta (che viene poi aggiunta allo stato).

Questa funzione chatbot viene aggiunta come nodo chiamato “chatbot” al grafo.

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)

Passaggio 3: imposta gli archi

Dato che stiamo costruendo un semplice chatbot, impostiamo il nodo chatbot sia come punto di ingresso sia come punto di uscita del grafo per indicare dove iniziare e terminare il processo.

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

Passaggio 4: compila e visualizza il grafo

Compila il grafo per creare un oggetto CompiledGraph e, facoltativamente, puoi visualizzare la struttura del grafo usando il codice seguente:

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

Passaggio 5: esegui il chatbot

Infine, implementiamo un ciclo che richiede continuamente l'input dell'utente, lo elabora attraverso il grafo e stampa la risposta dell'assistente. Il ciclo termina quando l'utente digita "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)

Funzionalità avanzate di LangGraph

Ora che abbiamo visto le basi, diamo un'occhiata ad alcune funzionalità avanzate.

Tipi di nodo personalizzati

LangGraph ti permette di creare tipi di nodo personalizzati per implementare logiche di agent complesse. Questo offre flessibilità e controllo sul comportamento della tua applicazione.

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)

Qui definiamo una classe MyCustomNode che incapsula la logica personalizzata e interagisce con l'LLM. Questo fornisce un modo più strutturato e manutenibile per implementare comportamenti di nodo complessi.

Tipi di archi

LangGraph supporta diversi tipi di archi per gestire vari schemi di comunicazione tra nodi. Un tipo utile è l'arco condizionale, che consente di prendere decisioni in base all'output di un nodo.

Per creare un arco condizionale, servono tre componenti:

1. Il nodo a monte: l'output del nodo decide il passo successivo.
2. Una funzione: questa funzione valuta l'output del nodo a monte e determina il nodo successivo da eseguire, restituendo una stringa che rappresenta la decisione.
3. Una mappatura: questa mappatura collega i possibili esiti della funzione ai nodi corrispondenti da eseguire.

Ecco un esempio in pseudocodice:

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

Qui, dopo la chiamata al nodo “model”, possiamo uscire dal grafo (“end”) e tornare all'utente, oppure possiamo continuare (“continue”) e chiamare uno strumento, a seconda di ciò che decide l'utente!

Gestione dello stato

LangGraph offre potenti tecniche di gestione dello stato, che includono l'uso di database esterni come SQLite, PostgreSQL e MongoDB, o soluzioni di storage cloud come Amazon S3, Google Cloud Storage e Azure Blob Storage per archiviare e recuperare lo stato dei tuoi agent, abilitando affidabilità e scalabilità.

Ecco un esempio di utilizzo di un database SQLite per la gestione dello stato:

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)

Gestione degli errori

LangGraph fornisce anche meccanismi per la gestione degli errori:

• Eccezioni: le funzioni dei nodi possono sollevare eccezioni per segnalare errori durante l'esecuzione. Puoi intercettare e gestire queste eccezioni per evitare che il grafo si arresti.
• Meccanismi di retry: puoi implementare logiche di retry all'interno dei nodi per gestire errori transitori, come problemi di rete o timeout di API.
• Logging: usa il logging per registrare gli errori e tracciare l'esecuzione del tuo grafo.

Applicazioni reali di LangGraph

LangGraph può essere utilizzato per creare un'ampia gamma di applicazioni.

Chatbot

LangGraph è ideale per sviluppare chatbot sofisticati in grado di gestire un'ampia gamma di richieste degli utenti. Sfruttando più agent LLM, questi chatbot possono elaborare richieste in linguaggio naturale, fornire risposte accurate e passare senza problemi tra diversi argomenti di conversazione. La capacità di gestire lo stato e coordinare le interazioni assicura che il chatbot mantenga il contesto e offra un'esperienza coerente.

Agent autonomi

Per applicazioni che richiedono decisioni autonome, LangGraph consente di creare agent in grado di svolgere compiti in modo indipendente sulla base degli input dell'utente e di una logica predefinita.

Questi agent possono eseguire flussi di lavoro complessi, interagire con altri sistemi e adattarsi dinamicamente a nuove informazioni. Il framework strutturato di LangGraph assicura che ogni agent operi in modo efficiente ed efficace, rendendolo adatto per attività come assistenza clienti automatizzata, elaborazione dati e monitoraggio di sistemi.

Sistemi multi-agent

LangGraph eccelle nella creazione di applicazioni in cui più agent collaborano per raggiungere un obiettivo comune. Ad esempio, in un sistema di gestione della supply chain, agent diversi possono gestire l'inventario, elaborare gli ordini e coordinare le consegne. Le capacità di coordinamento di LangGraph assicurano che ogni agent comunichi in modo efficace, condividendo informazioni e prendendo decisioni in modo sincronizzato. Questo porta a operazioni più efficienti e a migliori prestazioni complessive del sistema.

Strumenti di automazione dei workflow

Con LangGraph, automatizzare processi e workflow aziendali diventa semplice. È possibile progettare agent intelligenti per gestire attività come l'elaborazione di documenti, i flussi di approvazione e l'analisi dei dati. Definendo flussi di lavoro chiari e sfruttando la gestione dello stato di LangGraph, questi strumenti possono eseguire sequenze complesse di azioni senza intervento umano, riducendo gli errori e aumentando la produttività.

Sistemi di raccomandazione

I sistemi di raccomandazione personalizzati possono trarre grande vantaggio dalle funzionalità di LangGraph. Impiegando più agent per analizzare il comportamento degli utenti, le preferenze e i dati contestuali, questi sistemi possono offrire suggerimenti su misura per prodotti, contenuti o servizi. La flessibilità di LangGraph consente di integrare diverse fonti di dati e algoritmi, migliorando l'accuratezza e la pertinenza delle raccomandazioni.

Ambienti di apprendimento personalizzati

Nelle piattaforme educative, LangGraph può essere usato per creare ambienti di apprendimento adattivi, adatti agli stili e alle esigenze individuali. Più agent possono valutare i progressi di uno studente, fornire esercizi personalizzati e offrire feedback in tempo reale. La natura stateful di LangGraph assicura che il sistema conservi informazioni sulle prestazioni e le preferenze di ciascun discente, abilitando un'esperienza educativa più personalizzata ed efficace.

Conclusione

LangGraph semplifica notevolmente lo sviluppo di applicazioni LLM complesse fornendo un framework strutturato per gestire lo stato e coordinare le interazioni tra agent.

Gli sviluppi futuri per LangGraph potrebbero includere l'integrazione con altri componenti di LangChain, il supporto a nuovi modelli LLM e l'introduzione di runtime di agent più avanzati provenienti dal mondo accademico.

Se vuoi approfondire lo sviluppo di applicazioni all'interno dell'ecosistema LangChain, ti consiglio questo corso su sviluppare applicazioni LLM con LangChain.