Persistance de LangGraph : points de contrôle qui permettent la reprise et le HITL

Ce guide permet de reconstruire un chemin opérationnel pour : la persistance LangGraph : la fonctionnalité qui rend tout le reste possible. Mettez l’accent sur les contrats, les vérifications et le code que vous pouvez intégrer dans un dépôt sans devoir deviner l’intention derrière lui. Pour une vue d’ensemble, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans avoir à deviner l’état caché. Préférez des unités petites et testables aux scripts volumineux. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité.

Un bref résumé de ce que nous savons jusqu’à présent

Pour un bref résumé de ce que nous savons pour l’instant, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez les terminations partielles silencieuses. Créez des points de contrôle après les étapes coûteuses afin que les tentatives de relance ne fassent pas payer à nouveau la même appel du modèle.

Qu’est-ce que la persistance, en réalité ?

Pour comprendre ce qu’est réellement la persistance, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce permet d’éviter des factures inattendues dans les environnements partagés. Créez un point de contrôle après les étapes coûteuses afin que les tentatives de relance ne facturent pas à nouveau la même appel de modèle.

Comment cela fonctionne réellement : les pointeurs de contrôle

Pour comprendre le fonctionnement réel : les points de contrôle permettent de définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer. Créez des points de contrôle après les étapes coûteuses afin que les tentatives de relance ne fassent pas appel à nouveau au même appel de modèle. Pour comprendre le fonctionnement réel : les points de contrôle permettent de définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité.

Threading : Séparer les multiples exécutions

Pour les threads : afin de maintenir des exécutions multiples séparées, il faut définir les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses. La persistance transforme les démos en systèmes : les threads, l’intervention humaine et le débogage par voyage dans le temps en dépendent.

Le code (il est plus simple que vous ne l’imaginez)

Pour le code (il est plus simple que vous ne l’imaginez), définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues dans les environnements partagés. La persistance transforme les démos en systèmes : les threads, l’intervention humaine et le débogage temporel en dépendent.

from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph
from langgraph.checkpoint.memory import InMemorySaver
from typing import TypedDict

llm = ChatOpenAI()

class JokeState(TypedDict):
    topic: str
    joke: str
    explanation: str

def generate_joke(state: JokeState):
    response = llm.invoke(f"Generate a joke on the topic: {state['topic']}")
    return {"joke": response.content}

def generate_explanation(state: JokeState):
    response = llm.invoke(f"Explain this joke: {state['joke']}")
    return {"explanation": response.content}

# Build graph
graph = StateGraph(JokeState)
graph.add_node("generate_joke", generate_joke)
graph.add_node("generate_explanation", generate_explanation)
graph.add_edge("__start__", "generate_joke")
graph.add_edge("generate_joke", "generate_explanation")
graph.add_edge("generate_explanation", "__end__")

# Add persistence - this is the key line
checkpointer = InMemorySaver()
workflow = graph.compile(checkpointer=checkpointer)

config = {"configurable": {"thread_id": "1"}}

result = workflow.invoke(
    {"topic": "pizza"},
    config=config
)

# Get the final state
workflow.get_state(config)

# Get ALL intermediate states
workflow.get_state_history(config)

config_2 = {"configurable": {"thread_id": "2"}}
result_2 = workflow.invoke({"topic": "pasta"}, config=config_2)

Ce que vous pouvez créer avec cela

Pour déterminer ce que vous pouvez construire avec cela, définez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs puissent auditer. La persistance transforme les démos en systèmes : les threads, l’intervention humaine et le débogage temporel en dépendent. Pour déterminer ce que vous pouvez construire avec cela, définez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts volumineux. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité.

1. La mémoire à court terme dans les chatbots

1. Pour la mémoire à court terme dans les chatbots, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse. Maintenez l’état du graphe plat et typé. Les blocs imbriqués cachent le fait que tel nœud a écrit telle champ et empêchent la reprise après interruption.

2. Tolérance aux pannes

Pour 2. Tolérance aux pannes, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues dans les environnements partagés. Maintenez l’état du graphe plat et typé. Les blocs imbriqués cachent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.

import time

def step_two(state):
    print("Step 2 running...")
    time.sleep(30)  # simulating a slow operation
    return {"step_two": "done"}

workflow.invoke(None, config=config)

3. Intervention humaine

Pour 3. Human-in-the-Loop, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer. Gardez l’état du graphe plat et typé. Les blocs imbriqués cachent le fait que tel nœud a écrit tel champ et empêchent la reprise après interruption. Pour 3. Human-in-the-Loop, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit correspondre à une seule responsabilité.

4. Voyage dans le temps

Pour le voyage dans le temps, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses. Créez un point de contrôle après les étapes coûteuses afin que les tentatives de relance ne fassent pas payer à nouveau la même appel du modèle.

# Go back to a specific checkpoint and change the topic
workflow.update_state(
    {"configurable": {"thread_id": "1", "checkpoint_id": "<checkpoint_id>"}},
    {"topic": "samosa"}
)

# Re-run from that point
workflow.invoke(None, config={"configurable": {"thread_id": "1", "checkpoint_id": "<new_checkpoint_id>"}})

Le contexte global

Pour le contexte global, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues dans les environnements partagés. Créez un point de contrôle après les étapes coûteuses afin que les tentatives de relance ne fassent pas payer à nouveau la même appel du modèle.

Apprentissage structuré au-delà des blogs

Pour l’apprentissage structuré au-delà des blogs, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs puissent auditer. Créez des points de contrôle après les étapes coûteuses afin que les tentatives de relance ne fassent pas payer à nouveau la même appel de modèle.

Cours

Pour les cours, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réexécution et la gestion des messages non traités font partie du produit. Créez des points de contrôle après les étapes coûteuses afin que les tentatives de réexécution ne facturent pas à nouveau la même appel de modèle.

Liste de contrôle opérationnelle

Pour la liste de contrôle opérationnelle, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.

Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réexécution et la gestion des messages non traités font partie du produit.

La persistance transforme les démos en systèmes : les threads, l’intervention humaine et le débogage temporel en dépendent.

Ajoutez un test de fumée pour le chemin critique dans CI avec des fixtures lorsque les budgets le permettent.

Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité.

La persistance transforme les démos en systèmes : les threads, l’intervention humaine et le débogage par voyage dans le temps en dépendent.

Au préalable de promouvoir l’ensemble technologique, figez les versions, capturez un enregistrement idéal pour le chemin critique et confirmez les étapes de rollback. Les environnements partagés nécessitent des limites de vitesse, des vérifications de location et un responsable clair pour la rotation des secrets.