LangGraph: Zustand, Knoten und einen ersten Workflow verstehen

Was LangGraph steuert

Die Projektübersicht beschreibt LangGraph als Grundlage für länger laufende, zustandsbasierte Abläufe und Agenten. Ein Programm kann damit zwischen Verarbeitungsschritten wechseln und den dafür nötigen Zustand verwalten.

Du musst LangChain nicht verwenden, um LangGraph zu nutzen. Für einen einfachen festen Ablauf brauchst du auch keinen Modellaufruf. Ein KI-Agent kommt erst dann ins Spiel, wenn ein Modell innerhalb erlaubter Grenzen Entscheidungen über weitere Schritte trifft.

Das ist ein wichtiger Unterschied für die Planung: „Drei Regeln nacheinander ausführen“ und „ein Modell wählt wiederholt Werkzeuge“ brauchen unterschiedliche Prüfungen. Beginne mit dem kleineren Ablauf, dessen Ergebnis du selbst erklären kannst.

Zustand, Knoten und Übergang verstehen

Unser eigener Auftragscheck hat vier Zustandsfelder: den eingegebenen Auftrag, den bereinigten Text, einen Status und ein Ergebnis. Ein Knoten gibt jeweils nur die Felder zurück, die er ändern soll. Der Graph führt diese Änderungen mit seinem Zustand weiter.

1. Bereinigen: unnötige Leerzeichen im Auftrag vereinheitlichen.
2. Prüfen: feststellen, ob überhaupt ein Text übrig bleibt.
3. Weiterführen: einen vorhandenen Auftrag zur fachlichen Prüfung ausgeben.
4. Enden: bei leerer Eingabe mit einem Ergänzungshinweis stoppen.

Die Prüfung bestätigt keine fachliche Richtigkeit und gibt keine Werkzeuge frei. Sie kontrolliert nur den beschriebenen Eingabefall. Dadurch bleibt erkennbar, was der Ablauf kann und was später ergänzt werden müsste.

Eine eigene Python-Umgebung vorbereiten

Verwende einen neuen Übungsordner und für dieses Lernbeispiel Python 3.10 oder neuer. Die Installationshilfe führt LangGraph als eigenes Basispaket. Zusätzliche Modellanbieter werden getrennt eingebunden; für unseren Ablauf sind sie nicht nötig.

python -m venv .venv
.\.venv\Scripts\python.exe -m pip install langgraph
.\.venv\Scripts\python.exe -m pip show langgraph

python3 -m venv .venv
.venv/bin/python -m pip install langgraph
.venv/bin/python -m pip show langgraph

Die direkte Verwendung des Python-Programms in der Umgebung benötigt keine Änderung einer Shell-Ausführungsrichtlinie. Notiere die tatsächlich installierte Paketversion. Falls eine Installation scheitert, prüfe zunächst Fehlermeldung, Python-Version und Umgebung; installiere nicht wahllos weitere Pakete.

Einen kleinen Auftragscheck aufbauen

Speichere die folgende eigene Datei als langgraph-auftragscheck.py in deinem Übungsordner. Die drei Verarbeitungsschritte sind gewöhnliche Python-Funktionen. Erst bauen() verbindet sie über LangGraph.

from typing import TypedDict

class Auftrag(TypedDict):
    auftrag: str
    text: str
    status: str
    ergebnis: str

def bereinigen(state: Auftrag) -> dict:
    if not isinstance(state["auftrag"], str):
        raise ValueError("auftrag muss Text sein")
    return {"text": " ".join(state["auftrag"].split())}

def pruefen(state: Auftrag) -> dict:
    return {"status": "bereit" if state["text"] else "fehlt"}

def fertig(state: Auftrag) -> dict:
    return {"ergebnis": "Zur fachlichen Prüfung: " + state["text"]}

def bauen():
    from langgraph.graph import StateGraph, START, END
    graph = StateGraph(Auftrag)
    graph.add_node("bereinigen", bereinigen)
    graph.add_node("pruefen", pruefen)
    graph.add_node("fertig", fertig)
    graph.add_edge(START, "bereinigen")
    graph.add_edge("bereinigen", "pruefen")
    def route(state):
        return "fertig" if state["status"] == "bereit" else END
    graph.add_conditional_edges("pruefen", route, ["fertig", END])
    graph.add_edge("fertig", END)
    return graph.compile()

if __name__ == "__main__":
    app = bauen()
    start = {"auftrag": "  Prüfe   den Entwurf.  ", "text": "",
             "status": "", "ergebnis": "Bitte Auftrag ergänzen."}
    print(app.invoke(start))

Den vollständigen Auftragscheck herunterladen. Starte ihn mit dem Python-Programm deiner Umgebung, beispielsweise unter Windows mit .\.venv\Scripts\python.exe langgraph-auftragscheck.py.

Die reinen Eingabe- und Ergebnisfunktionen werden im begleitenden Check getrennt geprüft. Eine ausgeführte LangGraph-Installation oder ein Modelltest wird daraus nicht abgeleitet. Halte bei deinem eigenen Versuch fest, welche Prüfung du tatsächlich ausgeführt hast. Der Lernpfad zeigt dir, wie du KI-Code mit festgelegten Testfällen prüfen kannst.

Zwischenstand und Gedächtnis getrennt planen

Unser Beispiel hält den Zustand für seinen Ablauf. Daraus folgt noch keine dauerhafte Speicherung nach dem Beenden des Programms. Die Memory-Übersicht unterscheidet zwei Reichweiten:

Wenn du einen Checkpointer verwendest, braucht die Zuordnung einen passenden thread_id. Ein In-Memory-Speicher ist für eine Übung hilfreich, ersetzt aber keine geplante Datenbank und Sicherung für dauerhaften Betrieb. Speicher macht Antworten außerdem nicht automatisch richtig: Gespeicherte falsche Angaben können später erneut in den Kontext geraten.

Vom Workflow zum begrenzten Agenten

Der offizielle Quickstart zeigt zusätzlich eine Modell-/Toolschleife. Das Modell kann eine Werkzeuganfrage erzeugen; danach entscheidet ein Übergang über einen weiteren Schritt oder das Ende. Ein solches Muster ist umfangreicher als unser fester Eingabecheck. Bei der Planung einer KI-Automatisierung klärst du zuerst, welche Entscheidung überhaupt ein Modell benötigt und welche Schritte feste Regeln bleiben können.

Plane vor einer Erweiterung das erlaubte Ergebnis, die verfügbaren Werkzeuge und ein klares Ende. Ein Modell, das keine brauchbare Antwort findet, sollte nicht unbegrenzt wiederholen. Lege Grenzen für Schritte, Zeit und gegebenenfalls Kosten fest. Behandle Werkzeugfehler und fehlende Freigaben als eigene Zustände.

Ein Eintrag im Prompt entzieht einem Werkzeug keine tatsächliche Berechtigung. Bevor dein Ablauf Dateien ändert, Nachrichten versendet oder andere Außenwirkungen auslöst, sollte die konkrete Aktion überprüfbar sein. Wie du Agenten mit begrenzten Rechten einsetzen kannst, vertieft diese Trennung.

Der sinnvolle nächste Ausbau ist eine einzelne zusätzliche Funktion mit einem Normalfall und einem Abbruchfall. So bleibt sichtbar, ob ein Fehler aus der Eingabe, dem Kontrollfluss, einem Werkzeug oder einem späteren Modellaufruf stammt.

Wenn du anschließend einen KI-Agenten mit begrenztem Werkzeug erstellen möchtest, führt der SDK-Guide einen kleinen eigenen Werkstattfall durch: genau eine lesende Funktion, künstliche Daten und getrennte Prüfungen für fehlende Informationen sowie unerlaubte Aktionen.