Persistencia de LangGraph: Puntos de control que permiten reanudar y HITL

Esta guía reconstruye un camino funcional para: Persistencia de LangGraph: La característica que hace posible todo lo demás. Enfócate en contratos, verificaciones y código que puedes incluir en un repositorio sin tener que adivinar su propósito. Para obtener una visión general, define las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido sin tener que adivinar el estado oculto. Prefiere unidades pequeñas y verificables en lugar de scripts extensos. Cuando una tarea falla, el error debe indicar una única responsabilidad.

Un breve resumen de lo que sabemos hasta ahora

Para un resumen rápido de lo que sabemos hasta ahora, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Considere esta etapa como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Coloque puntos de control después de las tareas costosas para que las reintentos no vuelvan a facturar la misma llamada al modelo.

Qué es realmente la persistencia

Para entender qué es realmente la persistencia, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Registre los tiempos y costos junto con los resultados funcionales. La visibilidad temprana evita facturas inesperadas en entornos compartidos. Coloque puntos de control después de las tareas costosas para que las reintentos no generen nuevos costos por la misma llamada al modelo.

Cómo funciona en realidad: Puntos de control

Para saber cómo funciona en la práctica: los puntos de control permiten definir las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar un paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Mantenga la configuración fuera del código de la aplicación; los archivos de entorno, los almacenes de datos confidenciales y las banderas de funcionalidad deben estar en un lugar que los operadores puedan auditar. Cree puntos de control después de pasos costosos para que las reintentos no vuelvan a facturar por la misma llamada al modelo. Para saber cómo funciona en la práctica: los puntos de control permiten definir las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar un paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos; cuando un paso falla, el error debe indicar una única responsabilidad.

Hilo de ejecución: mantener separadas las múltiples ejecuciones

Para el uso de hilos: mantener separadas las múltiples ejecuciones, se deben definir las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Considere esta fase como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. La persistencia convierte las demostraciones en sistemas: los hilos, la intervención humana y la depuración mediante retroceso en el tiempo dependen de ella.

El código (es más simple de lo que imagina)

Para el código (es más simple de lo que uno podría esperar), defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificarlo. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos y costos junto con los resultados funcionales. La visibilidad temprana evita facturas inesperadas en entornos compartidos. La persistencia convierte las demostraciones en sistemas: los hilos, la intervención humana y la depuración mediante retroceso en el tiempo dependen de ella.

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)

Qué puede crear con esto

Para determinar qué se puede construir con esto, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben encontrarse en un lugar que los operadores puedan auditar. La persistencia convierte las demostraciones en sistemas: los hilos de ejecución, la intervención humana y la depuración mediante retroceso en el tiempo dependen de ella. Para determinar qué se puede construir con esto, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando una tarea falla, el error debe indicar una única responsabilidad.

1. Memoria a corto plazo en chatbots

1. Para la Memoria a Corto Plazo en los chatbots, defina las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Considere esta etapa como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Mantenga el estado del grafo plano y tipado; los bloques anidados ocultan qué nodo escribió qué campo y dificultan la reanudación después de interrupciones.

2. Tolerancia a fallos

Para 2. Tolerancia a fallos, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Registre los tiempos y costos junto con los resultados funcionales. La visibilidad temprana evita facturas inesperadas en entornos compartidos. Mantenga el estado del grafo simple y tipado; los bloques anidados ocultan qué nodo escribió qué campo y dificultan la reanudación después de interrupciones.

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. Humano en el proceso

Para 3. Human-in-the-Loop, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa desde un punto de control conocido sin tener que adivinar el estado oculto. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben encontrarse en un lugar que los operadores puedan auditar. Mantenga el estado del grafo simple y tipado. Los bloques anidados ocultan qué nodo escribió qué campo e impiden continuar después de las interrupciones. Para 3. Human-in-the-Loop, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa desde un punto de control conocido sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando una etapa falla, el error debe indicar una única responsabilidad.

4. Viaje en el tiempo

En cuanto al viaje en el tiempo, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido sin tener que adivinar el estado oculto. Considere esta etapa como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Haga un punto de control después de las tareas costosas para que los intentos de repetición no generen nuevos cargos por la misma llamada al modelo.

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

La visión general

Para la visión general, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos y costos junto con los resultados funcionales. La visibilidad temprana evita facturas inesperadas en entornos compartidos. Haga un punto de control después de las tareas costosas para que los intentos de repetición no generen nuevos cargos por la misma llamada al modelo.

Aprendizaje Estructurado Más Allá de los Blogs

En el caso del Aprendizaje Estructurado Más Allá de los Blogs, se deben definir las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Se debe mantener la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos confidenciales y las banderas de funcionalidad deben estar en un lugar que los operadores puedan auditar. Se debe establecer un punto de control después de los pasos costosos para que las reintentos no generen nuevos costos por la misma llamada al modelo.

Cursos

Para los cursos, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Documente junto con ello la ruta normal y la ruta de recuperación. Las reintentos y el manejo de mensajes no entregados forman parte del producto. Coloque puntos de control después de las etapas costosas para que los reintentos no vuelvan a facturar la misma llamada al modelo.

Lista de verificación operativa

Para la lista de verificación operativa, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto.

Documente junto con ello la ruta normal y la ruta de recuperación. Las reintentos y el manejo de mensajes no entregados forman parte del producto.

La persistencia convierte las demostraciones en sistemas: los hilos, la intervención humana y la depuración con viajes en el tiempo dependen de ella.

Añada una prueba de humo para la ruta crítica en CI con fixtures cuando lo permitan los presupuestos.

Preferir unidades pequeñas y probables sobre scripts extensos. Cuando falla un paso, el error debe apuntar a una única responsabilidad.

La persistencia convierte las demostraciones en sistemas: los hilos, la intervención humana y la depuración mediante viajes en el tiempo dependen de ella.

Antes de promocionar la tecnología, congele las versiones, capture una transcripción de referencia para la ruta crítica y confirme los pasos de reversión. Los entornos compartidos necesitan límites de velocidad, verificaciones de tenencia y un responsable claro para la rotación de credenciales secretas.