LangGraph-tutorial: wat is LangGraph en hoe gebruik je het?

Wat is LangGraph?

LangGraph stelt ons in staat om moeiteloos stateful applicaties met meerdere actoren te bouwen die gebruikmaken van LLMs. Het breidt de mogelijkheden van LangChain uit en introduceert de mogelijkheid om cyclische grafen te creëren en beheren, wat cruciaal is voor het ontwikkelen van geavanceerde agent-runtimes. De kernconcepten van LangGraph zijn: grafstructuur, statebeheer en coördinatie.

Grafstructuur

Stel je applicatie voor als een gerichte graaf. In LangGraph vertegenwoordigt elke node een LLM-agent en zijn de edges de communicatiekanalen tussen deze agents. Deze structuur maakt duidelijke en beheersbare workflows mogelijk, waarbij elke agent specifieke taken uitvoert en informatie doorgeeft aan andere agents wanneer dat nodig is.

Statebeheer

Een van de opvallende features van LangGraph is het automatische statebeheer. Hiermee kun je informatie over meerdere interacties heen volgen en bewaren. Terwijl agents hun taken uitvoeren, wordt de state dynamisch bijgewerkt, zodat het systeem context behoudt en passend reageert op nieuwe input.

Coördinatie

LangGraph zorgt ervoor dat agents in de juiste volgorde worden uitgevoerd en dat noodzakelijke informatie naadloos wordt uitgewisseld. Deze coördinatie is cruciaal voor complexe applicaties waarin meerdere agents moeten samenwerken om een gemeenschappelijk doel te bereiken. Door de gegevensstroom en volgorde van operaties te beheren, kunnen ontwikkelaars zich richten op de hoog-niveau logica van hun applicaties in plaats van op de finesses van agentcoördinatie.

Waarom LangGraph?

Zoals ik hierboven al noemde, biedt LangGraph verschillende belangrijke voordelen voor ontwikkelaars die met complexe LLM-applicaties werken. Dit zijn enkele praktijkvoordelen die LangGraph biedt.

Vereenvoudigde ontwikkeling

LangGraph abstraheert de complexiteit van statebeheer en agentcoördinatie. Daardoor kunnen ontwikkelaars hun workflows en logica definiëren zonder zich zorgen te maken over de onderliggende mechanismen die gegevensconsistentie en de juiste uitvoeringsvolgorde waarborgen. Deze vereenvoudiging versnelt het ontwikkelproces en verkleint de kans op fouten. Het is een gamechanger!

Flexibiliteit

Met LangGraph hebben ontwikkelaars de flexibiliteit om hun eigen agentlogica en communicatieprotocollen te definiëren. Zo kun je zeer maatwerkapplicaties bouwen voor specifieke use-cases. Of je nu een chatbot nodig hebt die verschillende soorten gebruikersverzoeken aankan of een multi-agent-systeem dat complexe taken uitvoert, LangGraph biedt de tools om precies te bouwen wat je nodig hebt. Het gaat erom jou de kracht te geven om te creëren.

Schaalbaarheid

LangGraph is gebouwd om grootschalige multi-agent-applicaties te ondersteunen. De robuuste architectuur kan een hoge hoeveelheid interacties en complexe workflows aan, waardoor je schaalbare systemen kunt ontwikkelen die met je behoeften meegroeien. Dat maakt het geschikt voor enterprise-toepassingen en scenario’s waarin prestaties en betrouwbaarheid cruciaal zijn.

Fault-tolerance

Betrouwbaarheid is een kernprincipe in het ontwerp van LangGraph. De bibliotheek bevat mechanismen om fouten netjes af te handelen, zodat je applicatie kan blijven draaien zelfs als individuele agents problemen ondervinden. Deze fault-tolerance is essentieel om de stabiliteit en robuustheid van complexe multi-agent-systemen te waarborgen. Gemoedsrust is slechts één feature verwijderd.

Aan de slag met LangGraph

Laten we bekijken hoe je LangGraph instelt en wat de basisconcepten zijn.

Installatie

Installeer LangGraph met pip:

pip install -U langgraph

Basisconcepten

Nodes: Nodes vertegenwoordigen werkonderdelen binnen je LangGraph. Het zijn doorgaans Python-functies die een specifieke taak uitvoeren, zoals:

• Interactie met een LLM
• Een tool of API aanroepen
• Datamanipulatie uitvoeren
• Gebruikersinput ontvangen
• Businesslogica uitvoeren

In LangGraph kun je nodes toevoegen met de syntaxis graph.add_node(name, value).

Edges: Edges zijn communicatiekanalen tussen nodes. Ze definiëren de informatiestroom en de uitvoeringsvolgorde. Je kunt edges toevoegen met de syntaxis graph.add_edge(node1, node2).

State: De state is een centraal object dat in de tijd wordt bijgewerkt door de nodes in de graaf. Het beheert de interne staat van je applicatie en kan worden overschreven of uitgebreid, afhankelijk van de vereisten. Deze state kan onder andere bevatten:

• Gespreksgeschiedenis: Een lijst met berichten tussen de agent en de gebruiker.
• Contextuele data: Informatie die relevant is voor de huidige taak of interactie.
• Interne variabelen: Vlaggen, tellers of andere variabelen om de voortgang en het gedrag van de agent bij te houden.

Een eenvoudige LangGraph-applicatie bouwen

Hier is een stapsgewijs voorbeeld van het maken van een eenvoudige chatbotapplicatie met LangGraph.

Stap 1: Definieer de StateGraph

Definieer een StateGraph-object om de chatbot als een toestandsmachine te structureren. De State is een klasseobject met één sleutel messages van het type List en gebruikt de functie add_messages() om nieuwe berichten toe te voegen in plaats van ze te overschrijven.

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)

Stap 2: Initialiseer een LLM en voeg die toe als Chatbot-node

Hier initialiseren we het AzureChatOpenAI-model en maken we een eenvoudige chatbotfunctie die de state-berichten als input neemt en een berichtrespons genereert (die vervolgens aan de state wordt toegevoegd).

Deze chatbotfunctie wordt als node met de naam “chatbot” aan de graaf toegevoegd.

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)

Stap 3: Stel edges in

Omdat we een eenvoudige chatbot bouwen, stellen we de chatbot-node in als zowel het start- als eindpunt van de graaf om aan te geven waar het proces begint en eindigt.

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

Stap 4: Compileer en visualiseer de graaf

Compileer de graaf om een CompiledGraph-object te maken, en optioneel kun je de graafstructuur visualiseren met onderstaande code:

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

Stap 5: Run de chatbot

Tot slot implementeren we een lus die de gebruiker continu om input vraagt, deze via de graaf verwerkt en het antwoord van de assistant print. De lus stopt wanneer de gebruiker "quit", "exit" of "q" typt.

# 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)

Geavanceerde LangGraph-features

Nu we de basis hebben behandeld, kijken we naar enkele geavanceerde features.

Aangepaste nodetypen

Met LangGraph kun je aangepaste nodetypen maken om complexe agentlogica te implementeren. Dit geeft flexibiliteit en controle over het gedrag van je applicatie.

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)

Hier definiëren we een klasse MyCustomNode die aangepaste logica omvat en met de LLM interageert. Dit biedt een meer gestructureerde en onderhoudbare manier om complex nodegedrag te implementeren.

Edge-typen

LangGraph ondersteunt verschillende edge-typen om uiteenlopende communicatiepatronen tussen nodes af te handelen. Een nuttig type is de voorwaardelijke edge, waarmee je beslissingen kunt nemen op basis van de output van een node.

Om een voorwaardelijke edge te maken, heb je drie componenten nodig:

1. De upstream-node: De output van deze node bepaalt de volgende stap.
2. Een functie: Deze functie beoordeelt de output van de upstream-node en bepaalt de volgende node om uit te voeren, en retourneert een string die de beslissing weergeeft.
3. Een mapping: Deze mapping koppelt de mogelijke uitkomsten van de functie aan de bijbehorende nodes die uitgevoerd moeten worden.

Hier is een voorbeeld in pseudocode:

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

Hier kunnen we, nadat de “model”-node is aangeroepen, ofwel de graaf verlaten (“end”) en terugkeren naar de gebruiker, of doorgaan (“continue”) en een tool aanroepen—afhankelijk van wat de gebruiker besluit!

Statebeheer

LangGraph biedt krachtige technieken voor statebeheer, waaronder het gebruik van externe databases zoals SQLite, PostgreSQL en MongoDB, of cloudopslag zoals Amazon S3, Google Cloud Storage en Azure Blob Storage om de state van je agent op te slaan en op te halen, wat betrouwbaarheid en schaalbaarheid mogelijk maakt.

Hier is een voorbeeld van het gebruik van een SQLite-database voor statebeheer:

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)

Foutafhandeling

LangGraph biedt ook mechanismen voor foutafhandeling:

• Exceptions: Nodefuncties kunnen exceptions opwerpen om fouten tijdens de uitvoering te signaleren. Je kunt deze exceptions opvangen en afhandelen zodat je graaf niet crasht.
• Retry-mechanismen: Je kunt retry-logica in je nodes implementeren om tijdelijke fouten, zoals netwerkproblemen of API-timeouts, op te vangen.
• Logging: Gebruik logging om fouten vast te leggen en de uitvoering van je graaf te volgen.

Toepassingen van LangGraph in de praktijk

LangGraph kan worden gebruikt om een breed scala aan applicaties te bouwen.

Chatbots

LangGraph is ideaal voor het ontwikkelen van geavanceerde chatbots die een groot aantal gebruikersverzoeken aankunnen. Door meerdere LLM-agents te benutten, kunnen deze chatbots natuurlijke taal verwerken, nauwkeurige antwoorden geven en naadloos tussen verschillende gespreksonderwerpen schakelen. Het vermogen om state te beheren en interacties te coördineren zorgt ervoor dat de chatbot context behoudt en een coherente gebruikerservaring levert.

Autonome agents

Voor applicaties die autonome besluitvorming vereisen, maakt LangGraph het mogelijk om agents te creëren die zelfstandig taken uitvoeren op basis van gebruikersinput en vooraf gedefinieerde logica.

Deze agents kunnen complexe workflows uitvoeren, met andere systemen interacteren en zich dynamisch aanpassen aan nieuwe informatie. Het gestructureerde framework van LangGraph zorgt ervoor dat elke agent efficiënt en effectief opereert, wat het geschikt maakt voor taken zoals geautomatiseerde klantenservice, dataverwerking en systeemmonitoring.

Multi-agent-systemen

LangGraph blinkt uit in applicaties waarin meerdere agents samenwerken om een gemeenschappelijk doel te bereiken. In een supplychainmanagementsysteem kunnen verschillende agents bijvoorbeeld de voorraad beheren, bestellingen verwerken en leveringen coördineren. De coördinatiemogelijkheden van LangGraph zorgen ervoor dat elke agent effectief communiceert, informatie deelt en beslissingen gesynchroniseerd neemt. Dat leidt tot efficiëntere operaties en betere systeemprestaties.

Workflow-automatiseringstools

Met LangGraph wordt het automatiseren van bedrijfsprocessen en workflows eenvoudig. Je kunt intelligente agents ontwerpen voor taken zoals documentverwerking, goedkeuringsworkflows en data-analyse. Door duidelijke workflows te definiëren en het statebeheer van LangGraph te benutten, kunnen deze tools complexe actiesequenties uitvoeren zonder menselijke tussenkomst, wat fouten vermindert en de productiviteit verhoogt.

Aanbevelingssystemen

Gepersonaliseerde aanbevelingssystemen profiteren sterk van de mogelijkheden van LangGraph. Door meerdere agents in te zetten die gebruikersgedrag, voorkeuren en contextuele data analyseren, kunnen deze systemen gerichte suggesties doen voor producten, content of diensten. De flexibiliteit van LangGraph maakt het mogelijk om diverse databronnen en algoritmen te integreren, wat de nauwkeurigheid en relevantie van aanbevelingen vergroot.

Gepersonaliseerde leeromgevingen

In educatieve platforms kan LangGraph worden gebruikt om adaptieve leeromgevingen te creëren die aansluiten op individuele leerstijlen en -behoeften. Meerdere agents kunnen de voortgang van een student beoordelen, aangepaste oefeningen aanbieden en realtime feedback geven. Het stateful karakter van LangGraph zorgt ervoor dat het systeem informatie over de prestaties en voorkeuren van elke leerling behoudt, wat leidt tot een persoonlijkere en effectievere leerervaring.

Conclusie

LangGraph vereenvoudigt de ontwikkeling van complexe LLM-applicaties aanzienlijk door een gestructureerd framework te bieden voor statebeheer en het coördineren van agentinteracties.

Mogelijke toekomstige ontwikkelingen voor LangGraph zijn integratie met andere LangChain-componenten, ondersteuning voor nieuwe LLM-modellen en de introductie van meer geavanceerde agent-runtimes uit de academische wereld.

Wil je meer leren over het ontwikkelen van applicaties binnen het LangChain-ecosysteem, bekijk dan deze cursus over LLM-applicaties ontwikkelen met LangChain.