LangGraph: alacsony szintű futtatókör állapottartó ügynökökhöz

A LangGraph a LangChain halmaz azon része, amelyik az ügynököt végrehajtja. A csomópontokat és éleket egy közös állapotobjekten deklarálják, a futtatókör pedig superstepenként halad végig a gráfon, és mindegyik után checkpointot ír, hogy a futás megállítható, folytatható és átvizsgálható legyen. Ez az egész termék, és ebből következik az ítélet: ez a legjobb nyílt forráskódú válasz egy szűk kérdésre, és akinek ezt a szűk kérdést jóval kell megválaszolni, annak érdemes ezt választania.

Az ügönök alatt és a modell felett helyezkedik el. A LangChain ügynökabsztrakciói és az újabb deepagents csomag erre épülnek; a CrewAI, a LlamaIndex és az OpenAI Agents SDK ugyanezt a feladatot a másik oldalról közelíti, több beépített véleménnyel. Ahhoz képest, amit saját hurkkal ír az ember, a hozzájárulás a perzisztenciánál számít, nem az orchestrációnál.

Mi ez

A jelenlegi kiadási sor a langgraph 1.2.x. A 1.2.14-es verzió 2026 októberében volt a PyPI-n, és Python 3.10-es vagy újabb verzióját igényli. A repository a Pregelt és az Apache Beamet nevezi meg ihletnek, a NetworkXet pedig a nyilvános interfész mintájául, és kimondja, hogy a könyvtár LangChain nélkül is használható.

• Csomópontok-gráf egy állapotobjekten. A csomópontok részleges frissítéseket adnak vissza, a csatorna-redukerek pedig eldöntik, hogy két párhuzamos írás ugyanahhoz a kulcshoz hogyan egyesül.
• Checkpointerek, amelyek superstepenként mentik az állapot snapshotját, és szálakba rendezik a futásokat a thread_id alapján.
• Store-ok, külön, szálakon átívelő kulcs-érték réteg a hosszú távú memóriához, például felhasználói preferenciákhoz és megosztott referenciaadatokhoz.
• interrupt(), amely a gráf bármely pontján felfüggeszti a csomópontot, és visszaadja a vezérlést a hívónak, amíg a gráfot nem folytatják.
• exit, async és sync tartóssági módok, amelyek hívásonként állíthatók.
• Típusos streaming. Az 1.2-től a stream_events(..., version="v3") külön projekciókat ad az üzenetekhez, értékekhez, megszakításokhoz és a végső kimenethez.

Két API éri el ugyanazt a futtatókört. A gráf API a StateGraph-re épül, és élekben fejezi ki a vezérlési folyamatot. A funkcionális API szokásos Pythonként adja ezt meg, @entrypoint és @task dekorátorokkal. A funkcionális jobban olvas egy pull requestben; a gráfos képen rajzolódik ki, és ez fontosabb annál, mint amennyire hangzik, ha egy üzemeltető csapatnak hajnali háromkor kell eldöntenie, mit fog tenni az ügynök.

Hogyan működik

A végrehajtás a Pregel modelljét követi. A futásra kész összes csomópont egy superstepben indul el; amikor mind befejeződik, az írásaik egyetlen checkpointként rögzülnek, és a következő superstep a frissített állapotból ütemeződik. Ezért érdemes törődni a függőben maradó írásokkal: ha egy csomópont hibát dob a superstepben, a sikeres testvéreinek írásai már tartósak, és az újrafuttatás nem ismétli meg őket. A fan-outban futó drága modellhívásokat így csak egyszer fizetik meg.

A párhuzamosság a hely, ahol az élek élnek. Két csomópont, amely ugyanabba az állapotszámba ír ugyanabban a superstepben, reducert igényel. A LangGraph szállítja az add és egy last-value alapértelmezett reducert, a többit kézzel kell megírni. A hiba itt nem dob semmit: az egyik írás csendben eltűnik, és a tünet sokkal később mutatkozik meg olyan döntésként, amelyet az ügynök nem tud megmagyarázni.

Az állapot egyben a tárhelyszámla is. Minden superstep újraírja a teljes állapotobjektumot, így az a kulcs, amely lekért dokumentumokat halmoz fel, minden lépést teljes payload-írássá tesz. Vékonyítsd az állapotot a csomópont határán, és tartsd a tartós artefaktumokat a gráfon kívül.

Első lépések

A legkisebb érdemi gráf egy jóváhagyási folyamat, mert a futtatókör erre való. Ez megáll emberre, ugyanazon a szálon folytat, és a mellékhatást a megszakítás után tartja, így pontosan egyszer fut le.

from typing import Literal, TypedDict
from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import Command, interrupt

class State(TypedDict):
    request: str
    decision: str | None

def ask(state: State) -> Command[Literal["send", "cancel"]]:
    if interrupt({"question": "Send this?", "details": state["request"]}):
        return Command(goto="send")
    return Command(goto="cancel")

builder = StateGraph(State)
builder.add_node("ask", ask)
builder.add_node("send", lambda s: {"decision": "sent"})
builder.add_node("cancel", lambda s: {"decision": "cancelled"})
builder.add_edge(START, "ask")
builder.add_edge("send", END)
builder.add_edge("cancel", END)

with PostgresSaver.from_conn_string("postgresql://…") as saver:
    saver.setup()
    graph = builder.compile(checkpointer=saver)
    config = {"configurable": {"thread_id": "req-42"}}
    print(graph.invoke({"request": "refund 8891"}, config, durability="sync")["__interrupt__"])
    print(graph.invoke(Command(resume=True), config, durability="sync")["decision"])

Ebben a részletben két dolog fontosabb a többinél. A PostgresSaver.setup() egyszer hozza létre a checkpoint-táblákat, telepítéskor, nem folyamatonként. És a durability="sync" jóváhagyási folyamathoz a helyes választás: az írás befejeződik a következő lépés előtt, így a döntést követő két másodpercben bekövetkező összeomlás nem veszítheti el az éppen hozott döntést.

Perzisztencia és tartósság

A perzisztencia a framework bevezetésének oka, és egyben az a hely, ahol a marketingnyelv elkenődik. A checkpointer snapshotot ír. A tartós végrehajtás azt jelenti, hogy a futás folytatódik. A LangGraph az elsőt megcsinálja; a második annál marad, aki a folyamatot üzemelteti.

• exit — semmi nem íródik, amíg a futás be nem fejeződik, meg nem hibázik vagy meg nem szakad. A leggyorsabb, és folyamat-összeomlásnál a futás elveszik.
• async — az írások a következő lépés végrehajtása közben futnak. Az alap kompromisszum: jó késleltetés, és egy kis ablak, amelyben összeomlás állapotot veszít.
• sync — minden checkpoint rögzül, mielőtt a következő lépés elkezdődik. Legmagasabb tartósság, az írás a kritikus úton van.

A checkpointok korlátlanul nőnek. A perzisztenciadokumentáció ezt kimondja, és ütemezett feladatot javasol, amely törli a megőrzési ablaknál régebbi checkpointokat. Aki ezt kihagyja, egy olyan adatbázison ébred, amely csendben a legnagyobb komponenssé vált, és ez rossz délután.

Megszakítások és a visszajátszási szabályok

Az interrupt() a legtöbbet használt funkció és egyben a leggyakrabban félreértett. Nem sornál áll meg. Kivételt dob, visszatekeredik a futtatókörig, checkpointot ír, és korlátlanul vár. Amikor a gráf folytatódik, a futtatókör a teljes csomópontot elölről újraindítja, és a folytatási értékeket szigorúan index szerint rendeli az interrupt-hívásokhoz. E terület minden éles hibája abból fakad, hogy valaki figyelmen kívül hagyta e kettő valamelyik mondatát.

• Az interrupt()-hívást soha ne tedd egy nyers try/except-be. A megállás egy dobott kivétel, és a széles handler elnyeli, így a gráf egyáltalán nem áll meg.
• Ne ugráld át feltételesen a megszakításokat egy csomóponton belül, és ne rendezd át őket. A hozzárendelés index alapú, így a megváltozott sorrend hibaüzenet nélkül fogyasztja el a rossz folytatási értéket.
• Minden megszakítás előtti mellékhatást tedd idempotensé, vagy mozdítsd a megállás után, vagy külön csomópontba. A dokumentáció kifejezetten kimondja, hogy a megszakítás előtt létrehozott rekord minden folytatáskor újra létrejön.
• Kerüld a while True-ciklust egy megszakítás körül egyetlen csomópontban. Minden folytatás újrajátszza a korábbi iterációkat, így a ciklusban lévő munka exponenciálisan nő.

Hol gyengébb

A gyengeségek jönnek először, mert ők döntik el, hogy illik-e a framework. Egy futás egy folyamatban él. A nyílt forráskódú könyvtárban nincs felügyelő, nincs feladatsor és nincs worker-készlet, így ha a folyamat meghal, a futás halott, amíg egy, a LangGraphen kívüli rendszer észre nem veszi és újra nem belép. Az emberi ellenőrzés ugyanez a forma: az interrupt() megállítja a futást, és az a dolog, hogy a jóváhagyás megérkezését észrevehessük és a megfelelő szálat felébresszük, mostantól a te problémád.

A második gyengeség az ergonomia. A LangGraph nem absztrahál semmit a promptokról vagy az architektúráról, ami előny, ha az ügynök a termék, és akadály, ha nem. A framework nem mondja meg, hogyan építsd fel a promptot, mikor hagyd abba az eszközhívásokat, vagy hány retry-t érdemel egy lépés. A legtöbb csapat a LangGraph-projekt első heteiben az eszközhúkot találja fel újra, vagyis pontosan azt, amit egy magasabb absztrakció átadott volna.

A harmadik a vendorhoz való kötődés, és enyhébb, mint általában állítják. A futtatókör MIT-licenc alatt áll, a saját folyamatodban fut, és a saját adatbázisodba ír, tehát nincs túszadott adat. A valódi függés akkor jelenik meg, amikor a gráfokat a LangSmithen keresztül telepíted: a deployment, az assistants API és a cron ütemezés LangChain felületek, és a későbbi átállás valódi munka.

Mibe kerül

A LangGraph ingyenes. A LangSmithnél van a pénz, ülévenkénti díjjal és metrikai fogyasításon felüli elszámolással: a Developer egy ülésre havi 5000 alap-traces ingyenes, a Plus havi 39 dollár ülékenként 10000 alap-traces mellett, hozzáféréssel a deploymenthez, az Engine-hez és a sandboxokhoz, az Enterprise pedig egyedi áron, hibrid vagy teljesen saját üzemeltetésű telepítéssel.

• A fogyasást LangChain Standard Unitokban számítják, 1 dollár egységenként, a szerverless deployment pedig futásidő, memória, adatbázis-számítás és adatbázis-memória, valamint az adatbázis élő ideje alapján.
• A trace-ek megőrzése 14 nap az alap trace-re, 180 nap a kiterjesztett trace-re, amely külön számítanak.
• A LangSmith kijelenti, hogy nem képez modellt az ügyféladatokon, és az Enterprise szinten saját üzemeltetésű adatréteget kínál azoknak a csapatoknak, akiknek ezt a saját kontrolljaik megkövetelik.

A trace-kvóta az a szám, amire figyelni kell. Egy ügönökfutás egy trace, és egy olyan futás, amely tíz csomóponton át öt eszközt hív, spánok gráfját hozza létre. Az összes éles kérést trace-elni meglepően gyorsan felemeli az 5000 vagy 10000 trace-et, és ekkor a számla már nem lekerekítő tétel. A környezet szerinti sampling a legolcsóbb enyhítés.

Ítélet

A LangGraph jó válasz egy kérdésre: hogyan tartsuk életben egy hosszú ügönökfutást egy összeomláson, egy telepítésen vagy egy emberi jóváhagyáson keresztül. Ezen a határon belül a munka gondos: a checkpoint-formátum dokumentált, a függőben maradó írások valóban jó ötlet, az interrupt szemantika pedig elég őszintén le van írva ahhoz, hogy tervet lehessen körülötte építeni. Ezen kívül a könyvtár vélemény nélküli futtatókör, és minden, amit nem dönt el, hajnali házkor az olvasó munkája lesz.

1. Vedd fel, ha egy futásnak túl kell élnie egy újraindítást: jóváhagyási várólista, órákig futó kutatási feladat, olyan ügynök, aki emberre vár.
2. Vedd fel, ha a futásnak auditálhatónak kell lennie. A csomópontok és élek a legolcsóbb módja annak megmutatására egy nem mérnöknek, hogy pontosan mit fog tenni az ügynök.
3. Vedd fel, ha számít a determinisztikus és a modellvezérelt lépések összekeverése, és a köztük lévő határnak pontosnak és tesztelhetőnek kell lennie.
4. Hagyd ki három lépés alatt befejeződő eszközhurokhoz. A húsz sor Python olcsóbban tulajdonolható és gyorsabban hibakereshető.
5. Ne tekintsd tartóssági rétegnek. Ha egy csendesen meghalt futás rendeléseket veszteséggel jár, vegyél felügyelőt, vagy futtasd a gráfot Temporalon, amelynek LangGraph pluginje 2026 júliusában public preview-ba került.
6. Ne vezesd be anélkül, hogy egyszer elolvastad volna az interrupt szabályokat. A visszajátszási szemantika az, ami élesben dupla mellékhatásokat termel.

A LangGraph egyszerű, hatékony módja egy ügynök kifejezésének: a gráfmodell világos, az ökoszisztéma gazdag, és a prototípusok gyorsan összeállnak. De nem teljes termelési történet. Temporal, a LangGraph pluginjéről, 2026. július

Források

1. LangGraph dokumentáció: áttekintés
2. LangGraph dokumentáció: checkpointer-ek és tartóssági módok
3. LangGraph dokumentáció: megszakítások és a szabályok
4. langchain-ai/langgraph a GitHubon
5. LangSmith árazás
6. Temporal: a Python LangGraph integráció public preview-ba került (2026. július 16.)