LangGraph生产环境部署与监控-优快云博客

LangGraph生产环境部署与监控

【免费下载链接】langgraph 项目地址: https://gitcode.com/GitHub_Trending/la/langgraph

本文详细介绍了LangGraph在生产环境中的关键部署与监控策略，包括检查点存储后端配置（PostgreSQL/SQLite/Redis）、LangSmith集成与性能监控、流式输出与实时调试以及错误处理与重试策略。通过合理的存储选择、全面的监控体系和健壮的错误处理机制，确保LangGraph应用在生产环境中稳定可靠运行。

检查点存储后端配置(PostgreSQL/SQLite/Redis)

在LangGraph的生产环境部署中，检查点存储后端的选择至关重要，它直接影响到系统的可靠性、性能和可扩展性。LangGraph提供了多种存储后端选项，包括PostgreSQL、SQLite和Redis，每种都有其特定的适用场景和配置方式。

PostgreSQL存储后端配置

PostgreSQL是生产环境中的首选存储后端，提供了强大的事务支持、高并发性能和丰富的功能特性。

基本配置

from langgraph.checkpoint.postgres import PostgresSaver

# 使用连接字符串配置PostgreSQL检查点存储
DB_URI = "postgres://username:password@localhost:5432/langgraph_db"

# 创建PostgresSaver实例
with PostgresSaver.from_conn_string(DB_URI) as checkpointer:
    # 初始化数据库表结构
    checkpointer.setup()
    
    # 配置图使用PostgreSQL检查点
    graph = builder.compile(checkpointer=checkpointer)

连接池配置

对于高并发场景，建议使用连接池来提高性能：

from psycopg_pool import ConnectionPool

# 创建连接池
pool = ConnectionPool(
    DB_URI, 
    max_size=20,  # 最大连接数
    kwargs={"autocommit": True}
)

# 使用连接池创建检查点存储
checkpointer = PostgresSaver(pool)
checkpointer.setup()

高级配置选项

# 使用管道模式提高批量操作性能
with PostgresSaver.from_conn_string(DB_URI, pipeline=True) as checkpointer:
    checkpointer.setup()
    
# 配置自定义序列化器
from langgraph.checkpoint.serde.encrypted import EncryptedSerializer

checkpointer.serde = EncryptedSerializer.from_pycryptodome_aes(
    key=b"your-32-byte-encryption-key"
)

SQLite存储后端配置

SQLite适用于开发环境、小型项目或资源受限的场景，提供轻量级的本地存储解决方案。

基本配置

from langgraph.checkpoint.sqlite import SqliteSaver

# 内存数据库（开发测试）
with SqliteSaver.from_conn_string(":memory:") as checkpointer:
    graph = builder.compile(checkpointer=checkpointer)

# 文件数据库（生产环境）
with SqliteSaver.from_conn_string("checkpoints.db") as checkpointer:
    graph = builder.compile(checkpointer=checkpointer)

异步版本配置

from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
import asyncio

async def main():
    async with AsyncSqliteSaver.from_conn_string("checkpoints.db") as checkpointer:
        graph = builder.compile(checkpointer=checkpointer)
        # 异步调用图
        result = await graph.ainvoke(input_data)

asyncio.run(main())

性能优化配置

# 启用WAL模式提高并发性能
checkpointer.conn.execute("PRAGMA journal_mode=WAL;")
checkpointer.conn.execute("PRAGMA synchronous=NORMAL;")
checkpointer.conn.execute("PRAGMA cache_size=-2000;")  # 2MB缓存

Redis存储后端配置

Redis适用于需要高速缓存和临时存储的场景，特别适合会话管理和临时状态存储。

基本配置

import redis
from langgraph.cache.redis import RedisCache

# 创建Redis客户端
redis_client = redis.Redis(
    host='localhost',
    port=6379,
    db=0,
    decode_responses=False
)

# 创建Redis缓存实例
redis_cache = RedisCache(
    redis_client,
    prefix="langgraph:cache:",  # 键前缀
    serde=None  # 使用默认序列化器
)

集群配置

from redis.cluster import RedisCluster

# Redis集群配置
redis_cluster = RedisCluster(
    startup_nodes=[
        {"host": "redis-node1", "port": 6379},
        {"host": "redis-node2", "port": 6379},
        {"host": "redis-node3", "port": 6379}
    ],
    decode_responses=False
)

redis_cache = RedisCache(redis_cluster)

TTL配置

# 配置自动过期时间
redis_cache = RedisCache(
    redis_client,
    prefix="langgraph:session:",
    # 值将自动设置1小时过期时间
)

# 或者在设置值时指定TTL
values_with_ttl = {
    ("session", "user123"): (session_data, 3600)  # 1小时过期
}
redis_cache.set(values_with_ttl)

存储后端选择指南

根据不同的应用场景，可以参考以下选择指南：

存储后端	适用场景	优点	缺点
PostgreSQL	生产环境、高并发、需要事务支持	ACID兼容、高可靠性、丰富功能	配置复杂、资源消耗较高
SQLite	开发测试、小型项目、嵌入式系统	零配置、轻量级、文件存储	并发性能有限、不适合大规模部署
Redis	会话管理、临时状态、高速缓存	极高性能、支持过期时间	数据持久性较弱、内存消耗大

配置最佳实践

连接管理：始终使用连接池或上下文管理器来管理数据库连接
错误处理：实现重试机制和故障转移策略
监控指标：监控连接数、查询延迟、存储使用量等关键指标
备份策略：定期备份检查点数据，特别是使用SQLite时
性能调优：根据负载调整连接池大小和数据库参数

mermaid

故障排除与优化

常见问题解决方案：

连接超时：调整连接池的超时参数和最大连接数
性能瓶颈：启用数据库查询日志，分析慢查询
内存不足：优化Redis的最大内存配置和淘汰策略
数据一致性问题：确保使用正确的事务隔离级别

性能优化建议：

PostgreSQL：使用连接池、调整shared_buffers、优化查询索引
SQLite：启用WAL模式、调整cache_size、定期VACUUM
Redis：使用管道操作、配置合理的内存淘汰策略、启用持久化

通过合理配置和持续监控，可以确保检查点存储后端在生产环境中稳定可靠地运行，为LangGraph应用提供强大的状态管理能力。

LangSmith集成与性能监控

LangGraph与LangSmith的深度集成为生产环境中的智能体系统提供了强大的可观测性和监控能力。通过无缝的追踪集成、丰富的元数据标注和实时性能监控，开发者可以获得对复杂工作流执行的全面可见性。

LangSmith集成配置

LangGraph通过RunnableConfig接口与LangSmith进行深度集成，支持在图形执行过程中传递丰富的追踪信息：

import uuid
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

# 配置LangSmith环境变量
import os
os.environ["LANGSMITH_API_KEY"] = "your-langsmith-api-key"
os.environ["LANGCHAIN_PROJECT"] = "production-agent"

@tool
def get_weather(city: str):
    """获取指定城市的天气信息"""
    return f"{city}的天气晴朗，温度25°C"

# 创建React智能体
model = ChatOpenAI(model="gpt-4o", temperature=0)
graph = create_react_agent(model, tools=[get_weather])

# 配置LangSmith追踪参数
config = {
    "run_name": "customer_support_agent",
    "run_id": uuid.uuid4(),  # 自定义运行ID便于追踪
    "tags": ["production", "support", "v2.1"],
    "metadata": {
        "user_id": "user_12345",
        "session_id": "session_67890",
        "environment": "production",
        "version": "2.1.0"
    }
}

# 执行图形并启用LangSmith追踪
result = graph.invoke(
    {"messages": [("user", "请问北京的天气怎么样？")]},
    config=config
)

性能监控指标体系

LangSmith提供了全面的性能监控指标，帮助开发者识别瓶颈和优化机会：

指标类别	具体指标	描述	优化建议
延迟指标	总执行时间	图形从开始到结束的总耗时	优化节点执行效率
延迟指标	节点执行时间	单个节点的平均执行时间	检查工具调用性能
延迟指标	LLM调用延迟	语言模型调用的响应时间	调整模型参数或升级模型
吞吐量指标	QPS	每秒处理的查询数量	水平扩展或优化并发
吞吐量指标	并发执行数	同时处理的请求数量	调整资源分配
质量指标	成功率	任务执行成功的比例	改进错误处理和重试机制
质量指标	工具调用准确率	工具被正确调用的比例	优化提示词和工具描述

实时监控与告警

通过LangSmith的监控仪表板，可以设置实时告警规则：

# 监控配置示例 - 设置性能阈值告警
monitoring_config = {
    "latency_threshold": {
        "total_execution": 30.0,  # 总执行时间超过30秒告警
        "llm_calls": 5.0,        # LLM调用超过5秒告警
        "tool_calls": 2.0        # 工具调用超过2秒告警
    },
    "error_rates": {
        "overall": 0.05,         # 总体错误率超过5%告警
        "tool_errors": 0.1       # 工具错误率超过10%告警
    },
    "throughput": {
        "min_qps": 10,           # QPS低于10时告警
        "max_concurrent": 100    # 并发数超过100时告警
    }
}

分布式追踪与调用链分析

LangGraph支持完整的分布式追踪，可以可视化整个执行流程：

mermaid

自定义指标与业务监控

除了系统级指标，还可以添加业务特定的监控指标：

from langsmith import Client
from datetime import datetime

class BusinessMetricsMonitor:
    def __init__(self):
        self.client = Client()
        self.metrics = {}
    
    def track_custom_metric(self, run_id, metric_name, value, tags=None):
        """记录自定义业务指标"""
        metric_data = {
            "run_id": run_id,
            "metric": metric_name,
            "value": value,
            "timestamp": datetime.now().isoformat(),
            "tags": tags or {}
        }
        # 发送到LangSmith或自定义监控系统
        self.client.create_example(metric_data)
    
    def monitor_conversion_rate(self, run_id, success):
        """监控转化率指标"""
        self.track_custom_metric(
            run_id, 
            "conversion_success", 
            int(success),
            {"metric_type": "conversion"}
        )
    
    def monitor_user_satisfaction(self, run_id, rating):
        """监控用户满意度"""
        self.track_custom_metric(
            run_id,
            "user_satisfaction",
            rating,
            {"metric_type": "feedback"}
        )

# 在图形执行过程中使用
monitor = BusinessMetricsMonitor()

def agent_node_with_monitoring(state, config):
    try:
        result = call_agent(state, config)
        monitor.monitor_conversion_rate(config["run_id"], True)
        return result
    except Exception as e:
        monitor.monitor_conversion_rate(config["run_id"], False)
        raise

性能优化与瓶颈识别

利用LangSmith的追踪数据进行分析和优化：

import pandas as pd
from langsmith import Client

def analyze_performance(project_name, days=7):
    """分析指定项目的性能数据"""
    client = Client()
    
    # 获取最近7天的运行数据
    runs = client.list_runs(
        project_name=project_name,
        start_time=pd.Timestamp.now() - pd.Timedelta(days=days)
    )
    
    performance_data = []
    for run in runs:
        performance_data.append({
            "run_id": run.id,
            "total_time": run.total_time,
            "llm_time": run.extra.get("llm_latency", 0),
            "tool_time": run.extra.get("tool_latency", 0),
            "success": run.status == "success",
            "timestamp": run.start_time
        })
    
    df = pd.DataFrame(performance_data)
    
    # 性能分析报告
    report = {
        "avg_total_time": df["total_time"].mean(),
        "p95_total_time": df["total_time"].quantile(0.95),
        "avg_llm_time": df["llm_time"].mean(),
        "avg_tool_time": df["tool_time"].mean(),
        "success_rate": df["success"].mean(),
        "bottleneck": identify_bottleneck(df)
    }
    
    return report

def identify_bottleneck(df):
    """识别性能瓶颈"""
    if df["llm_time"].mean() > df["tool_time"].mean() * 2:
        return "LLM调用是主要瓶颈"
    elif df["tool_time"].mean() > df["llm_time"].mean() * 2:
        return "工具调用是主要瓶颈"
    else:
        return "系统整体性能均衡"

安全与合规监控

在生产环境中，还需要监控安全性和合规性指标：

class SecurityMonitor:
    def __init__(self):
        self.sensitive_patterns = [
            r"\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b",  # 信用卡号
            r"\b\d{3}[- ]?\d{2}[- ]?\d{4}\b",           # 社保号
            r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"  # 邮箱
        ]
    
    def check_sensitive_data(self, text, run_id):
        """检查敏感数据泄露"""
        import re
        findings = []
        
        for pattern in self.sensitive_patterns:
            if re.search(pattern, text):
                findings.append({
                    "pattern": pattern,
                    "context": text[max(0, text.find(pattern)-50):text.find(pattern)+50]
                })
        
        if findings:
            self.log_security_event(run_id, "sensitive_data_detected", findings)
        
        return len(findings) == 0
    
    def log_security_event(self, run_id, event_type, details):
        """记录安全事件"""
        # 发送到安全监控系统
        print(f"安全告警 - RunID: {run_id}, 事件: {event_type}, 详情: {details}")

# 集成到图形执行中
security_monitor = SecurityMonitor()

def safe_llm_call(state, config):
    """安全的LLM调用包装器"""
    response = call_llm(state, config)
    
    # 检查响应中的敏感信息
    if isinstance(response, str):
        security_monitor.check_sensitive_data(response, config["run_id"])
    elif hasattr(response, "content"):
        security_monitor.check_sensitive_data(response.content, config["run_id"])
    
    return response

自动化报告与仪表板

创建自动化监控报告和实时仪表板：

def generate_daily_report(project_name):
    """生成每日监控报告"""
    performance_report = analyze_performance(project_name, 1)
    security_events = get_security_events(project_name, 1)
    error_analysis = analyze_errors(project_name, 1)
    
    report = f"""
    LangGraph生产环境监控日报
    ========================
    
    日期: {pd.Timestamp.now().date()}
    项目: {project_name}
    
    性能指标:
    - 平均执行时间: {performance_report['avg_total_time']:.2f}s
    - P95执行时间: {performance_report['p95_total_time']:.2f}s
    - 成功率: {performance_report['success_rate']:.2%}
    - 瓶颈分析: {performance_report['bottleneck']}
    
    安全监控:
    - 敏感数据检测: {len(security_events)} 次
    - 主要安全事件: {security_events[:3] if security_events else '无'}
    
    错误分析:
    - 总错误数: {error_analysis['total_errors']}
    - 主要错误类型: {list(error_analysis['error_types'].keys())[:3]}
    - 建议改进: {error_analysis['recommendations']}
    """
    
    return report

# 定时生成报告
from apscheduler.schedulers.background import BackgroundScheduler

scheduler = BackgroundScheduler()
scheduler.add_job(
    generate_daily_report,
    'cron',
    hour=23,
    minute=59,
    args=['production-agent']
)
scheduler.start()

通过上述完整的LangSmith集成与监控方案，开发者可以构建高度可观测的生产级LangGraph应用，确保系统稳定性、性能优异且符合安全合规要求。

流式输出与实时调试

LangGraph提供了强大的流式输出功能，使开发者能够在生产环境中实时监控和调试复杂的多步工作流。通过灵活的流模式配置和自定义数据输出机制，您可以深入了解Agent的执行过程，及时发现并解决问题。

流式输出模式详解

LangGraph支持多种流式输出模式，每种模式提供不同粒度的执行信息：

流模式	描述	适用场景
`values`	每个步骤后输出完整状态值	全面监控状态变化
`updates`	仅输出节点或任务的更新内容	关注增量变化
`custom`	输出自定义数据	特定业务指标监控
`messages`	输出LLM消息和元数据	对话流程调试
`checkpoints`	输出检查点事件	持久化状态跟踪
`tasks`	输出任务开始和结束事件	性能分析和错误追踪
`debug`	组合checkpoints和tasks事件	完整调试信息

基础流式输出实现

使用LangGraph的流式输出非常简单，只需调用stream()方法并指定相应的流模式：

from pprint import pprint

# 配置输入参数
inputs = {"question": "What are the types of agent memory?"}

# 实时监控执行流程
for output in app.stream(inputs, stream_mode="updates"):
    for key, value in output.items():
        # 输出节点执行信息
        pprint(f"Node '{key}':")
        # 可选的详细状态输出
        # pprint.pprint(value["keys"], indent=2, width=80, depth=None)
    pprint("\n---\n")

# 获取最终生成结果
pprint(value["generation"])

自定义流式数据输出

对于需要输出特定业务指标的场景，可以使用custom模式配合StreamWriter：

from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START
from langgraph.config import get_stream_writer

class State(TypedDict):
    foo: int

def my_node(state: State):
    # 获取流式写入器
    my_stream_writer = get_stream_writer()
    # 输出自定义监控数据
    my_stream_writer({"custom_data": "Hello!", "timestamp": time.time()})
    return {"foo": state["foo"] + 1}

# 构建图
graph = (
    StateGraph(State)
    .add_node(my_node)
    .add_edge(START, "my_node")
    .compile()
)

# 使用custom模式接收自定义数据
for chunk in graph.stream({"foo": 1}, stream_mode="custom"):
    print(chunk)  # 输出: {'custom_data': 'Hello!', 'timestamp': 1698765432.1}

实时调试与性能监控

LangGraph的流式输出功能特别适合生产环境的实时调试和性能监控：

import time
from datetime import datetime

def monitoring_node(state):
    writer = get_stream_writer()
    
    # 记录性能指标
    start_time = time.time()
    # 执行业务逻辑
    result = some_expensive_operation(state)
    end_time = time.time()
    
    # 输出性能数据
    writer({
        "node": "monitoring_node",
        "execution_time": end_time - start_time,
        "timestamp": datetime.now().isoformat(),
        "input_size": len(str(state)),
        "result_size": len(str(result))
    })
    
    return result

# 监控执行流程
for update in graph.stream(input_data, stream_mode="custom"):
    if "execution_time" in update:
        print(f"性能指标: {update}")
        # 这里可以集成到监控系统如Prometheus、Datadog等

多级流式输出配置

对于复杂的生产环境，可以组合使用多种流模式：

# 同时启用多种流模式
stream_modes = ["updates", "custom", "tasks"]

for output in app.stream(
    inputs, 
    stream_mode=stream_modes,
    debug=True  # 启用调试模式
):
    # 根据输出类型进行处理
    if "updates" in output:
        handle_state_updates(output["updates"])
    elif "custom" in output:
        handle_custom_metrics(output["custom"])
    elif "tasks" in output:
        handle_task_events(output["tasks"])

错误追踪与重试监控

流式输出还可以用于实时错误追踪和重试机制监控：

def robust_node(state):
    writer = get_stream_writer()
    retry_count = 0
    max_retries = 3
    
    while retry_count < max_retries:
        try:
            result = potentially_failing_operation(state)
            writer({
                "status": "success",
                "retry_count": retry_count,
                "node": "robust_node"
            })
            return result
        except Exception as e:
            retry_count += 1
            writer({
                "status": "retry",
                "retry_count": retry_count,
                "error": str(e),
                "timestamp": time.time()
            })
            if retry_count >= max_retries:
                writer({
                    "status": "failed",
                    "error": str(e),
                    "node": "robust_node"
                })
                raise

# 监控重试过程
for event in graph.stream(inputs, stream_mode="custom"):
    if event.get("status") == "retry":
        alert_ops_team(f"重试事件: {event}")

流式输出与可视化集成

LangGraph的流式输出可以轻松集成到各种可视化工具中：

mermaid

最佳实践建议

选择合适的流模式：根据监控需求选择适当的流模式组合
控制输出频率：避免过于频繁的输出影响性能
结构化日志输出：使用一致的JSON格式便于解析和分析
集成监控系统：将流式输出连接到现有的监控基础设施
设置告警阈值：基于流式输出数据设置性能告警

通过LangGraph强大的流式输出功能，您可以构建高度可观察的生产级AI应用，实时掌握系统运行状态，快速定位和解决问题，确保服务的稳定性和可靠性。

错误处理与重试策略

在LangGraph生产环境部署中，健壮的错误处理和智能重试策略是确保系统可靠性的关键组件。LangGraph提供了强大的内置机制来处理各种异常情况，从网络故障到业务逻辑错误，都能优雅地恢复和重试。

重试策略核心概念

LangGraph的RetryPolicy类提供了灵活的重试配置选项，允许开发者根据具体需求定制重试行为：

from langgraph.types import RetryPolicy

# 基本重试策略配置
retry_policy = RetryPolicy(
    max_attempts=3,           # 最大重试次数
    initial_interval=1.0,     # 初始重试间隔（秒）
    backoff_factor=2.0,       # 退避因子（指数增长）
    jitter=True,              # 是否启用随机抖动
    retry_on=ValueError       # 重试的异常类型
)

重试策略参数详解

参数	类型	默认值	描述
`max_attempts`	int	无	最大重试尝试次数
`initial_interval`	float	无	首次重试前的等待时间（秒）
`backoff_factor`	float	1.0	每次重试间隔的倍增因子
`jitter`	bool	False	是否在重试间隔中添加随机抖动
`retry_on`	Exception或Callable	默认策略	触发重试的异常类型或判断函数

默认重试行为

LangGraph内置了智能的默认重试策略，能够识别常见的可重试异常：

mermaid

默认重试策略会重试以下异常：

ConnectionError - 网络连接问题
HTTP 5xx状态码错误 - 服务器端错误
大多数其他异常（除编程错误外）

而以下编程错误不会触发重试：

ValueError, TypeError, ArithmeticError
ImportError, LookupError, NameError
SyntaxError, RuntimeError, ReferenceError
StopIteration, StopAsyncIteration, OSError

自定义重试条件

开发者可以创建自定义的重试判断函数，实现更精细的控制：

def custom_retry_predicate(exc: Exception) -> bool:
    """自定义重试判断逻辑"""
    if isinstance(exc, ValueError):
        # 只重试包含特定错误信息的ValueError
        return "retry" in str(exc).lower()
    elif isinstance(exc, ConnectionError):
        # 总是重试连接错误
        return True
    elif hasattr(exc, 'status_code'):
        # 重试5xx服务器错误，不重试4xx客户端错误
        return 500 <= exc.status_code < 600
    return False

custom_policy = RetryPolicy(
    max_attempts=5,
    initial_interval=0.5,
    backoff_factor=1.5,
    retry_on=custom_retry_predicate
)

节点级别的重试配置

在StateGraph中，可以为每个节点单独配置重试策略：

from langgraph.graph import StateGraph, START
from typing_extensions import TypedDict

class State(TypedDict):
    data: str
    attempts: int

def flaky_node(state: State):
    """模拟不稳定的节点操作"""
    import random
    if random.random() < 0.7:  # 70%失败率
        raise ConnectionError("临时网络故障")
    return {"data": "success", "attempts": state.get("attempts", 0) + 1}

# 创建图形并配置重试
graph = (
    StateGraph(State)
    .add_node(
        "flaky_operation", 
        flaky_node,
        retry_policy=RetryPolicy(
            max_attempts=5,
            initial_interval=1.0,
            backoff_factor=2.0,
            jitter=True,
            retry_on=ConnectionError
        )
    )
    .add_edge(START, "flaky_operation")
    .compile()
)

多重重试策略组合

对于复杂的错误处理场景，可以组合多个重试策略：

# 针对不同异常类型的多重策略
http_retry_policy = RetryPolicy(
    max_attempts=3,
    initial_interval=2.0,
    retry_on=(ConnectionError, TimeoutError)
)

business_retry_policy = RetryPolicy(
    max_attempts=2,
    initial_interval=5.0,
    retry_on=ValueError
)

# 应用多重策略
graph.add_node(
    "complex_operation",
    complex_business_logic,
    retry_policy=[http_retry_policy, business_retry_policy]
)

重试间隔计算算法

LangGraph使用指数退避算法计算重试间隔，公式如下：

interval = initial_interval * (backoff_factor ^ (attempt_number - 1)) + random_jitter

其中随机抖动范围是[0, interval * jitter_factor]，默认jitter_factor为0.1。

生产环境最佳实践

1. 合理的重试次数配置

# 网络操作 - 较多重试次数
network_retry = RetryPolicy(
    max_attempts=5,
    initial_interval=1.0,
    backoff_factor=2.0,
    jitter=True
)

# 业务操作 - 较少重试次数
business_retry = RetryPolicy(
    max_attempts=2,
    initial_interval=3.0,
    backoff_factor=1.5
)

2. 异常分类处理

mermaid

3. 监控和日志记录

import logging
from langgraph.types import RetryPolicy

logger = logging.getLogger(__name__)

class MonitoredRetryPolicy(RetryPolicy):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.retry_count = 0
    
    def should_retry(self, exc: Exception) -> bool:
        result = super().should_retry(exc)
        if result:
            self.retry_count += 1
            logger.warning(
                f"重试尝试 {self.retry_count}/{self.max_attempts} "
                f"对于异常: {type(exc).__name__}: {exc}"
            )
        return result

4. 与持久化执行集成

LangGraph的重试机制与持久化执行完美集成，确保在系统故障时能够正确恢复：

from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.graph import StateGraph

# 配置Postgres检查点存储
checkpointer = PostgresSaver.from_conn_string("postgresql://user:pass@localhost/db")

graph = (
    StateGraph(State)
    .add_node("api_call", api_call_function, retry_policy=retry_policy)
    .compile(checkpointer=checkpointer)
)

# 执行时自动处理故障恢复
result = graph.invoke(
    {"input": "data"},
    config={"configurable": {"thread_id": "unique-id"}}
)

故障场景处理

网络分区和超时

network_retry_policy = RetryPolicy(
    max_attempts=5,
    initial_interval=1.0,
    backoff_factor=2.0,
    jitter=True,
    retry_on=(ConnectionError, TimeoutError, requests.exceptions.RequestException)
)

服务降级和熔断

def resilient_api_call(state: State):
    try:
        # 主要API调用
        return call_primary_api(state)
    except Exception as e:
        if should_retry(e):
            raise  # 触发重试
        else:
            # 降级到备用方案
            return call_fallback_api(state)

graph.add_node("resilient_api", resilient_api_call, retry_policy=retry_policy)

性能考虑

重试策略会影响系统性能，需要仔细权衡：

重试次数：过多的重试会增加延迟和资源消耗
退避策略：过长的退避间隔会影响用户体验
抖动配置：适当的抖动可以避免重试风暴

推荐配置：

关键操作：3-5次重试，适中的退避
非关键操作：1-2次重试，快速失败
批量操作：考虑整体超时而非单个重试

通过合理配置LangGraph的错误处理和重试策略，可以显著提高生产环境的系统可靠性和韧性，确保在面临各种故障场景时能够优雅地恢复和继续执行。

总结

LangGraph提供了完整的生产环境部署解决方案，从存储后端的选择配置到性能监控和错误处理，形成了一套完善的运维体系。通过PostgreSQL、SQLite和Redis等存储选项的灵活配置，结合LangSmith的深度集成监控能力，以及强大的流式输出和重试机制，开发者可以构建高可用、高性能的生产级AI应用。合理运用这些工具和策略，能够显著提升系统的可靠性和可观测性，确保在大规模生产环境中稳定运行。

【免费下载链接】langgraph 项目地址: https://gitcode.com/GitHub_Trending/la/langgraph

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考