Direkt zum Inhalt

LangGraph Tutorial: Was ist LangGraph und wie benutzt man es?

LangGraph ist eine Bibliothek innerhalb des LangChain-Ökosystems, die einen Rahmen für die Definition, Koordination und Ausführung mehrerer LLM-Agenten (oder Ketten) auf strukturierte und effiziente Weise bietet.
Aktualisierte 16. Jan. 2025  · 12 Min. Lesezeit

Stell dir vor, du baust eine komplexe Multi-Agenten-Anwendung für ein großes Sprachmodell (LLM). Das ist aufregend, bringt aber auch Herausforderungen mit sich: den Status verschiedener Agenten zu verwalten, ihre Interaktionen zu koordinieren und Fehler effektiv zu behandeln. Genau hier kann LangGraph helfen.

LangGraph ist eine Bibliothek innerhalb des LangChain-Ökosystems, die entwickelt wurde, um diese Herausforderungen frontal anzugehen. LangGraph bietet einen Rahmen, um mehrere LLM-Agenten (oder Ketten) auf strukturierte Weise zu definieren, zu koordinieren und auszuführen.

Es vereinfacht den Entwicklungsprozess, indem es die Erstellung von zyklischen Graphen ermöglicht, die für die Entwicklung von Agentenlaufzeiten unerlässlich sind. Mit LangGraph können wir ganz einfach robuste, skalierbare und flexible Multiagentensysteme aufbauen.

Wenn du mehr über das LangChain-Ökosystem erfahren möchtest, empfehle ich dir diese Einführung in LangChain.

Was ist LangGraph?

LangGraph ermöglicht es uns, zustandsbehaftete Multi-Actor-Anwendungen zu erstellen, die LLMs so einfach wie möglich nutzen. Es erweitert die Möglichkeiten von LangChain, indem es die Fähigkeit einführt, zyklische Graphen zu erstellen und zu verwalten, die für die Entwicklung anspruchsvoller Agenten-Laufzeiten entscheidend sind. Zu den Kernkonzepten von LangGraph gehören: Graphenstruktur, Zustandsverwaltung und Koordination.

Graph Struktur

Stell dir deine Bewerbung als einen gerichteten Graphen vor. In LangGraph steht jeder Knoten für einen LLM-Agenten, und die Kanten sind die Kommunikationskanäle zwischen diesen Agenten. Diese Struktur ermöglicht klare und überschaubare Arbeitsabläufe, bei denen jeder Agent bestimmte Aufgaben ausführt und bei Bedarf Informationen an andere Agenten weitergibt.

Staatliches Management

Eine der herausragenden Eigenschaften von LangGraph ist die automatische Zustandsverwaltung. Diese Funktion ermöglicht es uns, Informationen über mehrere Interaktionen hinweg zu verfolgen und aufzubewahren. Während die Agenten ihre Aufgaben erfüllen, wird der Status dynamisch aktualisiert, um sicherzustellen, dass das System den Kontext beibehält und angemessen auf neue Eingaben reagiert.

Koordinierung

LangGraph stellt sicher, dass die Agenten in der richtigen Reihenfolge arbeiten und dass die notwendigen Informationen nahtlos ausgetauscht werden. Diese Koordination ist entscheidend für komplexe Anwendungen, bei denen mehrere Agenten zusammenarbeiten müssen, um ein gemeinsames Ziel zu erreichen. Da LangGraph den Datenfluss und die Abfolge der Operationen verwaltet, können sich die Entwickler auf die High-Level-Logik ihrer Anwendungen konzentrieren und müssen sich nicht mit den Feinheiten der Agenten-Koordination auseinandersetzen.

Warum LangGraph?

Wie ich bereits erwähnt habe, bietet LangGraph mehrere wichtige Vorteile für Entwickler, die mit komplexen LLM-Anwendungen arbeiten. Hier sind einige der Vorteile, die LangGraph in der Praxis bietet.

Vereinfachte Entwicklung

LangGraph abstrahiert die Komplexität, die mit der Zustandsverwaltung und der Koordination der Agenten verbunden ist. Das bedeutet, dass Entwickler ihre Arbeitsabläufe und Logik definieren können, ohne sich um die zugrunde liegenden Mechanismen zu kümmern, die die Datenkonsistenz und die richtige Ausführungsreihenfolge sicherstellen. Diese Vereinfachung beschleunigt den Entwicklungsprozess und verringert die Fehlerwahrscheinlichkeit. Es ist ein Wendepunkt!

Flexibilität

Mit LangGraph haben Entwickler die Flexibilität, ihre eigene Agentenlogik und Kommunikationsprotokolle zu definieren. Dies ermöglicht sehr individuelle Anwendungen, die auf bestimmte Anwendungsfälle zugeschnitten sind. Egal, ob du einen Chatbot brauchst, der verschiedene Arten von Benutzeranfragen bearbeiten kann, oder ein Multi-Agenten-System, das komplexe Aufgaben ausführt, LangGraph bietet die Werkzeuge, um genau das zu bauen, was du brauchst. Es geht darum, dir die Macht zu geben, etwas zu schaffen.

Skalierbarkeit

LangGraph wurde entwickelt, um die Ausführung von großen Multi-Agenten-Anwendungen zu unterstützen. Seine robuste Architektur kann ein hohes Volumen an Interaktionen und komplexen Workflows bewältigen und ermöglicht die Entwicklung skalierbarer Systeme, die mit deinen Anforderungen wachsen können. Dadurch eignet sie sich für Anwendungen auf Unternehmensebene und Szenarien, in denen Leistung und Zuverlässigkeit entscheidend sind.

Fehlertoleranz

Zuverlässigkeit ist ein wichtiger Aspekt bei der Entwicklung von LangGraph. Die Bibliothek enthält Mechanismen zur Fehlerbehandlung, die sicherstellen, dass deine Anwendung auch dann weiterläuft, wenn einzelne Agenten Probleme haben. Diese Fehlertoleranz ist wichtig, um die Stabilität und Robustheit komplexer Multiagentensysteme zu erhalten. Der Seelenfrieden ist nur eine Funktion entfernt.

Erste Schritte mit LangGraph

Schauen wir uns an, wie wir LangGraph einrichten können und was die grundlegenden Konzepte sind.

Installation

Um LangGraph zu installieren, kannst du pip verwenden:

pip install -U langgraph

Grundlegende Konzepte

Knotenpunkte: Knoten stellen Arbeitseinheiten innerhalb deines LangGraphs dar. Das sind in der Regel Python-Funktionen, die eine bestimmte Aufgabe erfüllen, z. B:

  • Mit einem LLM interagieren
  • Aufrufen eines Tools oder einer API
  • Einige Datenbearbeitungen durchführen
  • Empfangen von Benutzereingaben
  • Ausführen von Geschäftslogik

In LangGraph kannst du Knoten mit der Syntax graph.add_node(name, value) hinzufügen.

Ränder: Kanten sind Kommunikationskanäle zwischen den Knotenpunkten. Sie legen den Informationsfluss und die Reihenfolge der Ausführung fest. Du kannst Kanten mit der graph.add_edge(node1, node2) Syntax hinzufügen.

Staat: Der Zustand ist ein zentrales Objekt, das im Laufe der Zeit von den Knoten im Graphen aktualisiert wird. Sie verwaltet den internen Zustand deiner Anwendung und kann je nach den Anforderungen der Anwendung überschrieben oder ergänzt werden. In diesem Zustand können Dinge wie z.B.:

  • Konversationsgeschichte: Eine Liste von Nachrichten zwischen dem Agenten und dem Nutzer.
  • Kontextuelle Daten: Informationen, die für die aktuelle Aufgabe oder Interaktion relevant sind.
  • Interne Variablen: Flaggen, Zähler oder andere Variablen, um den Fortschritt und das Verhalten des Agenten zu verfolgen.

Aufbau einer einfachen LangGraph-Anwendung

Hier ist ein Schritt-für-Schritt-Beispiel für die Erstellung einer einfachen Chatbot-Anwendung mit LangGraph.

Schritt 1: Definiere den StateGraph

Definiere ein StateGraph Objekt, um den Chatbot als Zustandsmaschine zu strukturieren. Das State ist ein Klassenobjekt, das mit einem einzigen Schlüssel messages vom Typ List definiert ist und die Funktion add_messages() verwendet, um neue Nachrichten anzuhängen, anstatt sie zu überschreiben.

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)

Schritt 2: Initialisiere einen LLM und füge ihn als Chatbot-Knoten hinzu

Hier initialisieren wir das AzureChatOpenAI-Modell und erstellen eine einfache Chatbot-Funktion, die die Statusnachrichten als Eingabe erhält und eine Antwort auf die Nachricht erzeugt (die anschließend an den Status angehängt wird).

Diese Chatbot-Funktion wird als Knoten namens "Chatbot" zum Graphen hinzugefügt.

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)

Schritt 3: Kanten setzen

Da wir einen einfachen Chatbot bauen, setzen wir den Knoten chatbot sowohl als Einstiegs- als auch als Endpunkt des Graphen, um anzugeben, wo der Prozess beginnt und endet.

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

Schritt 4: Zusammenstellen und Visualisieren des Diagramms

Kompiliere den Graphen, um einen CompiledGraph Objekt zu erstellen, und optional können wir die Graphenstruktur mit dem folgenden Code visualisieren:

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

LangGraph graph

Schritt 5: Den Chatbot ausführen

Zum Schluss implementieren wir eine Schleife, die den Benutzer kontinuierlich zur Eingabe auffordert, sie durch den Graphen verarbeitet und die Antwort des Assistenten ausgibt. Die Schleife wird beendet, wenn der Benutzer "quit", "exit" oder "q" eingibt.

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

Erweiterte LangGraph-Funktionen

Nachdem wir nun die Grundlagen behandelt haben, werfen wir einen Blick auf einige fortgeschrittene Funktionen.

Benutzerdefinierte Knotentypen

Mit LangGraph kannst du eigene Knotentypen erstellen, um komplexe Agentenlogik zu implementieren. Das bietet Flexibilität und Kontrolle über das Verhalten deiner Anwendung.

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 definieren wir eine Klasse MyCustomNode, die die eigene Logik kapselt und mit dem LLM interagiert. Dies ermöglicht eine strukturiertere und leichter zu wartende Implementierung komplexer Verhaltensweisen von Knoten.

Kantenarten

LangGraph unterstützt verschiedene Kantentypen, um verschiedene Kommunikationsmuster zwischen den Knotenpunkten zu ermöglichen. Ein nützlicher Typ ist die bedingte Kante, die eine Entscheidungsfindung auf der Grundlage der Ausgabe eines Knotens ermöglicht.

Um eine bedingte Kante zu erstellen, brauchst du drei Komponenten:

  1. Der vorgelagerte Knotenpunkt: Der Output des Knotens entscheidet über den nächsten Schritt.
  2. Eine Funktion: Diese Funktion wertet die Ausgabe des vorgelagerten Knotens aus und bestimmt den nächsten auszuführenden Knoten, indem sie einen String zurückgibt, der die Entscheidung darstellt.
  3. Eine Kartierung: Diese Zuordnung verknüpft die möglichen Ergebnisse der Funktion mit den entsprechenden Knoten, die ausgeführt werden sollen.

Hier ist ein Beispiel in Pseudocode:

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

Hier können wir nach dem Aufruf des Knotens "model" entweder den Graphen verlassen ("end") und zum Benutzer zurückkehren oder wir können fortfahren ("continue") und ein Tool aufrufen - je nachdem, wie sich der Benutzer entscheidet!

Staatliches Management

LangGraph bietet leistungsstarke Techniken für die Zustandsverwaltung, z. B. die Nutzung externer Datenbanken wie SQLite, PostgreSQL und MongoDB oder Cloud-Speicherlösungen wie Amazon S3, Google Cloud Storage und Azure Blob Storage, um den Zustand deines Agenten zu speichern und abzurufen, was Zuverlässigkeit und Skalierbarkeit ermöglicht.

Hier ist ein Beispiel für die Verwendung einer SQLite-Datenbank für die Statusverwaltung:

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)

Fehlerbehandlung

LangGraph bietet auch Mechanismen zur Fehlerbehandlung:

  • Ausnahmen: Knotenfunktionen können Ausnahmen auslösen, um Fehler während der Ausführung zu signalisieren. Du kannst diese Ausnahmen abfangen und behandeln, um zu verhindern, dass dein Graph abstürzt.
  • Wiederholungsmechanismen: Du kannst in deinen Knotenpunkten eine Wiederholungslogik implementieren, um vorübergehende Fehler wie Netzwerkprobleme oder API-Zeitüberschreitungen zu behandeln.
  • Loggen: Verwende das Logging, um Fehler aufzuzeichnen und die Ausführung deines Lernpfads zu verfolgen.

Anwendungen von LangGraph in der realen Welt

Mit LangGraph kannst du eine Vielzahl von Anwendungen erstellen.

Chatbots

LangGraph ist ideal für die Entwicklung anspruchsvoller Chatbots, die eine Vielzahl von Nutzeranfragen bearbeiten können. Durch den Einsatz mehrerer LLM-Agenten können diese Chatbots natürlichsprachliche Anfragen verarbeiten, präzise Antworten geben und nahtlos zwischen verschiedenen Gesprächsthemen wechseln. Die Fähigkeit, den Status zu verwalten und Interaktionen zu koordinieren, stellt sicher, dass der Chatbot den Kontext beibehält und ein kohärentes Nutzererlebnis bietet.

Autonome Agenten

Für Anwendungen, die autonome Entscheidungen erfordern, ermöglicht LangGraph die Erstellung von Agenten, die auf der Grundlage von Benutzereingaben und vordefinierter Logik selbstständig Aufgaben ausführen können.

Diese Agenten können komplexe Arbeitsabläufe ausführen, mit anderen Systemen interagieren und sich dynamisch an neue Informationen anpassen. Das strukturierte Framework von LangGraph stellt sicher, dass jeder Agent effizient und effektiv arbeitet und eignet sich daher für Aufgaben wie automatisierten Kundensupport, Datenverarbeitung und Systemüberwachung.

Multi-Agenten-Systeme

LangGraph eignet sich hervorragend für die Entwicklung von Anwendungen, bei denen mehrere Agenten zusammenarbeiten, um ein gemeinsames Ziel zu erreichen. In einem Supply Chain Management System können zum Beispiel verschiedene Agenten den Bestand verwalten, Bestellungen bearbeiten und Lieferungen koordinieren. Die Koordinierungsfunktionen von LangGraph stellen sicher, dass jeder Agent effektiv kommuniziert, Informationen austauscht und Entscheidungen synchronisiert trifft. Das führt zu einem effizienteren Betrieb und einer besseren Gesamtleistung des Systems.

Tools zur Workflow-Automatisierung

Mit LangGraph wird die Automatisierung von Geschäftsprozessen und Arbeitsabläufen ganz einfach. Intelligente Agenten können Aufgaben wie die Bearbeitung von Dokumenten, Genehmigungsworkflows und Datenanalysen übernehmen. Durch die Definition klarer Arbeitsabläufe und die Nutzung der Zustandsverwaltung von LangGraph können diese Werkzeuge komplexe Abfolgen von Aktionen ohne menschliches Eingreifen ausführen, wodurch Fehler reduziert und die Produktivität erhöht werden.

Empfehlungssysteme

Personalisierte Empfehlungssysteme können von den Fähigkeiten von LangGraph stark profitieren. Durch den Einsatz mehrerer Agenten, die das Nutzerverhalten, die Vorlieben und die Kontextdaten analysieren, können diese Systeme maßgeschneiderte Vorschläge für Produkte, Inhalte oder Dienstleistungen liefern. Die Flexibilität von LangGraph ermöglicht es, verschiedene Datenquellen und Algorithmen zu integrieren und so die Genauigkeit und Relevanz der Empfehlungen zu verbessern.

Personalisierte Lernumgebungen

In Bildungsplattformen kann LangGraph verwendet werden, um adaptive Lernumgebungen zu schaffen, die auf individuelle Lernstile und Bedürfnisse eingehen. Mehrere Agenten können die Fortschritte eines Schülers/einer Schülerin bewerten, individuelle Übungen anbieten und Feedback in Echtzeit geben. Die zustandsabhängige Natur von LangGraph stellt sicher, dass das System Informationen über die Leistungen und Vorlieben jedes Lernenden speichert, was ein personalisiertes und effektives Bildungserlebnis ermöglicht.

Fazit

LangGraph vereinfacht die Entwicklung komplexer LLM-Anwendungen erheblich, indem es einen strukturierten Rahmen für die Verwaltung von Zuständen und die Koordination von Agenteninteraktionen bietet.

Mögliche Entwicklungen für LangGraph sind die Integration mit anderen LangChain-Komponenten, die Unterstützung neuer LLM-Modelle und die Einführung fortschrittlicherer Agenten-Laufzeiten aus dem akademischen Bereich.

Wenn du mehr über die Entwicklung von Anwendungen innerhalb des LangChain-Ökosystems erfahren möchtest, empfehle ich dir diesen Kurs über Entwicklung von LLM-Anwendungen mit LangChain.


Ryan Ong's photo
Author
Ryan Ong
LinkedIn
Twitter

Ryan ist ein führender Datenwissenschaftler, der sich auf die Entwicklung von KI-Anwendungen mit LLMs spezialisiert hat. Er ist Doktorand für natürliche Sprachverarbeitung und Wissensgraphen am Imperial College London, wo er auch seinen Master in Informatik gemacht hat. Außerhalb der Datenwissenschaft schreibt er einen wöchentlichen Substack-Newsletter, The Limitless Playbook, in dem er eine umsetzbare Idee von den besten Denkern der Welt teilt und gelegentlich über zentrale KI-Konzepte schreibt.

Themen

Lerne KI mit diesen Kursen!

Zertifizierung verfügbar

Kurs

Entwicklung von LLM-Anwendungen mit LangChain

3 hr
10.6K
Entdecke, wie du mit LLMs, Prompts, Ketten und Agenten in LangChain KI-gestützte Anwendungen erstellen kannst.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow