uv venv langgraph_venv --python 3.12
 source langgraph_venv/bin/activate

 uv pip install langgraph==1.0.5

 uv pip show langgraph

# 使用 LangGraph 构建一个应用，
from typing import TypedDict
from langgraph.graph import StateGraph
from langgraph.constants import START, END


# 1. 定义状态
class MyAgentState(TypedDict):
    query: str
    rag_search: str
    web_search: str
    llm_answer: str


# 2. 定义节点
def rag_node(state: MyAgentState):
    # 1. 从state中获取query
    query = state["query"]
    # 2.模拟rag检索
    rag_search = f"根据用户问题: {query}，从知识库中检索到的相关内容"
    # 3. 将rag_search添加到state中
    return {"rag_search": rag_search}


def web_search_node(state: MyAgentState):
    # 1. 从state中获取query
    query = state["query"]
    # 2.模拟web检索
    web_search = f"根据用户问题: {query}，从互联网上检索到的相关内容"
    # 3. 将web_search添加到state中
    return {"web_search": web_search}


def llm_node(state: MyAgentState):
    # 1. 从state中获取query
    rag_search = state["rag_search"]
    web_search = state["web_search"]

    # 2. 模拟llm调用，基于两路检索，生成最终答案
    llm_answer = f"根据用户问题:，根据 rag_search{rag_search} 和 web_search{web_search} 生成的答案"
    # 3. 将llm_answer添加到state中
    return {"llm_answer": llm_answer}


# 3. 构建builder，将节点和边添加到builder中
builder = StateGraph(state_schema=MyAgentState)
# 添加节点
builder.add_node(rag_node)  # add_node 底层会将节点名称设置为函数名
builder.add_node(web_search_node)
builder.add_node(llm_node)
# 添加边 开始 -> 知识库检索 -> 最终回答 -> 结束
builder.add_edge(START, "rag_node")  # 此处添加边时，需要传入节点名称，当前为函数名
builder.add_edge(START, "web_search_node")
builder.add_edge("rag_node", "llm_node")
builder.add_edge("web_search_node", "llm_node")
# 添加END节点的连接
builder.add_edge("llm_node", END)
# 4. 编译图
graph = builder.compile()
# 5. 调用图
res = graph.invoke({"query": "如何使用langgraph"})
print(res)


# 编译好之后，可以通过mermaid查看图的结构。 uv add grandalf
graph_structure = graph.get_graph()
res = graph_structure.draw_ascii()
print(res)

from typing import TypedDict
from langgraph.constants import START, END
from langgraph.graph import StateGraph
class MyStateFull(TypedDict):
    rag_result:str
    web_search_result:str
    final_answer:str
    query:str
    a_new_key:str

class InputSchema(TypedDict):
    query:str

class OutputSchema(TypedDict):
    final_answer:str

graph = StateGraph(state_schema=MyStateFull,input_schema=InputSchema,output_schema=OutputSchema)

def rag_search_node(state:MyStateFull):
    print(state)
    query = state["query"]
    rag_result = f"关于{query}的rag_result"
    return {"rag_result":rag_result,"a_new_key":"a_new_key_value"}

def web_search_node(state:MyStateFull):
    print(state)
    query = state["query"]
    web_search_result = f"关于{query}的web_search_result"
    return {"web_search_result":web_search_result}

def final_answer_node(state:MyStateFull):
    print('在final_answer_node当中的state',state)
    rag_result = state["rag_result"]
    web_search_result = state["web_search_result"]
    final_answer = f"LLM基于{rag_result}和{web_search_result}的最终回复"
    return {"final_answer":final_answer}

graph.add_node(rag_search_node)
graph.add_node(web_search_node)
graph.add_node(final_answer_node)
graph.add_edge(START, "rag_search_node")
graph.add_edge(START,"web_search_node")
graph.add_edge("rag_search_node", "final_answer_node")
graph.add_edge("web_search_node","final_answer_node")
graph.add_edge("final_answer_node", END)
compiled_graph = graph.compile()
res = compiled_graph.invoke({"query":"如何使用LangGraph","a_new_key":"a_new_key_value"})
print('最终结果为',res)

from typing import TypedDict
from pydantic import BaseModel
from langgraph.constants import START, END
from langgraph.graph import StateGraph
class MyState(TypedDict):
    query:str
    final_answer:str

class SearchState(TypedDict):
    rag_result:str
    web_search_result:str

class InputSchema(TypedDict):
    query:str

class OutputSchema(TypedDict):
    final_answer:str

graph = StateGraph(state_schema=MyState)

def rag_search_node(state:MyState):
    print(state)
    query = state["query"]
    rag_result = f"关于{query}的rag_result"
    return {"rag_result":rag_result,"a_new_key":"a_new_key_value"}

def web_search_node(state:MyState):
    query = state["query"]
    web_search_result = f"关于{query}的web_search_result"
    return {"web_search_result":web_search_result}

def final_answer_node(state:SearchState):
    print('在final_answer_node当中的state',state)
    rag_result = state["rag_result"]
    web_search_result = state["web_search_result"]
    final_answer = f"LLM基于{rag_result}，和{web_search_result}的最终回复"
    return {"final_answer":final_answer}

graph.add_node(rag_search_node)
graph.add_node(web_search_node)
graph.add_node(final_answer_node)
graph.add_edge(START, "rag_search_node")
graph.add_edge(START,"web_search_node")
graph.add_edge("rag_search_node", "final_answer_node")
graph.add_edge("web_search_node","final_answer_node")
graph.add_edge("final_answer_node", END)
compiled_graph = graph.compile()
res = compiled_graph.invoke({"query":"如何使用LangGraph"})
print('最终结果为',res)

"""
LangGraph Reducer函数演示 - 默认Reducer（覆盖更新）
"""

from typing import List
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END

# 1. 默认Reducer（覆盖更新）
class DefaultReducerState(TypedDict):
    foo: int
    bar: List[str]
def node_default_1(state: DefaultReducerState) -> dict:
    return {"foo": 2}
def node_default_2(state: DefaultReducerState) -> dict:
    return {"bar": ["bye"]}
def run_demo():
    print("1. 默认Reducer（覆盖更新）演示:")
    builder = StateGraph(DefaultReducerState)
    builder.add_node("node1", node_default_1)
    builder.add_node("node2", node_default_2)
    builder.add_edge(START, "node1")
    builder.add_edge("node1", "node2")
    builder.add_edge("node2", END)
    graph = builder.compile()
    result = graph.invoke({"foo": 1, "bar": ["hi"]})
    print(f"初始状态: {{'foo': 1, 'bar': ['hi']}}")
    print(f"执行结果: {result}\n")

if __name__ == "__main__":
run_demo()

from langgraph.graph import StateGraph
from langchain_core.messages import ToolMessage,HumanMessage,AIMessage,BaseMessage
from typing import Annotated, TypedDict,List
from langgraph.constants import START

# 自定义Reducer
def add_message(message_list_left:list,message_list_right:list):
    print("="*20)
    print("正在执行add_message")
    print('左边的',message_list_left)
    print('右边的',message_list_right)
    print("="*20)

    return message_list_left + message_list_right

class MyAgent(TypedDict):

    # 在初始使用自定义的reducer
    messages:Annotated[List[BaseMessage],add_message]

def tool_node(state:MyAgent):
    return {"messages":[ToolMessage(content="来自tool_node的内容",tool_call_id="xxx")]}

def llm_node(state:MyAgent):
    return {"messages":[AIMessage(content="来自llm_node的内容")]}

builder = StateGraph(state_schema=MyAgent)

builder.add_node(tool_node)
builder.add_node(llm_node)
builder.add_edge(START,"tool_node")
builder.add_edge("tool_node","llm_node")

graph = builder.compile()
graph.invoke({"messages":[HumanMessage(content="你好")]})

def scenario_1_demo():
    # 1、create_agent底层就是通过LangGraph构建的图结构，此处直接通过create_agent来举一个例子
    from langchain.agents import create_agent
    from langchain.tools import tool
    from langchain_openai import ChatOpenAI

    # 1、引入checkpointer
    from langgraph.checkpoint.memory import InMemorySaver

    llm = ChatOpenAI(model="gpt-4o-mini")

    # 2、定义checkpointer实例
    checkpointer = InMemorySaver()
    @tool
    def weather_tool(city:str,date:str)->str:
        """查天气的工具"""
        return f'{city}在{date}的天气是晴朗的'
    
    # 3、构建Agent时引入checkpointer
    agent = create_agent(
        model=llm,
        tools=[weather_tool],
        checkpointer=checkpointer,
    )

    # 4、用户第一次调用
    user1_res = agent.invoke({"messages":"北京2026-01-14天气怎么样"},config={"configurable":{"thread_id":"user_1_session_1"}})
    print('第一次调用',user1_res['messages'][-1],end="\n\n==============\n\n")
    
    # 5、用户在同一个会话当中，第二次调用
    user1_res_2 = agent.invoke({"messages":"适合出去玩吗"},config={"configurable":{"thread_id":"user_1_session_1"}})
    print('第二次调用',user1_res_2['messages'][-1],end="\n\n==============\n\n")

def scenario_2_demo():
    """
    场景二：如何从checkpointer中恢复状态
    """
    from langgraph.graph import StateGraph
    from typing import TypedDict
    from langgraph.graph import START
    # 1、引入sqlite3包和SqliteSaver类
    import sqlite3
    from langgraph.checkpoint.sqlite import SqliteSaver
    # 2、构建Connection对象
    conn = sqlite3.connect(database="./sqlite_data/langgraph_sqlite", check_same_thread=False)
    # 3、通过connection对象构建checkpointer实例
    memory = SqliteSaver(conn)
    class MyState(TypedDict):
        key_1: str
        key_2: str
        key_3: str

    def node_1(state: MyState) -> MyState:
        # 4、打印node_1初始状态
        print('node_1初始状态为',state)
        return {"key_1":"value_1"}
    
    def node_2(state: MyState) -> MyState:
        # 5、此处模拟生产环境下代码的bug或者其他不可预见情况，导致的报错
        raise Exception("node_2节点执行报错")
        return {"key_2":"value_2"}
    
    def node_3(state: MyState) -> MyState:
        return {"key_3":"value_3"}

    # 添加节点，添加边
    builder = StateGraph(MyState)
    builder.add_node(node_1)
    builder.add_node(node_2)
    builder.add_node(node_3)
    builder.add_edge(START, "node_1")
    builder.add_edge("node_1", "node_2")
    builder.add_edge("node_1", "node_3")
    config = {
        "configurable":{
            "thread_id":"123"
        }
    }
    # 6、compile时传入checkpointer实例
    graph = graph.compile(checkpointer=memory)
    # 7、调用时传入config
    graph.invoke({},config=config)

def scenario_2_demo():
    """
    场景一：如何从checkpointer中恢复状态
    """
    from langgraph.graph import StateGraph
    from typing import TypedDict
    from langgraph.graph import START
    
    import sqlite3
    from langgraph.checkpoint.sqlite import SqliteSaver
    
    conn = sqlite3.connect(database="./sqlite_data/langgraph_sqlite", check_same_thread=False)
    
    memory = SqliteSaver(conn)
    class MyState(TypedDict):
        key_1: str
        key_2: str
        key_3: str

    def node_1(state: MyState) -> MyState:
        
        print('node_1初始状态为',state)
        return {"key_1":"value_1"}
    
    def node_2(state: MyState) -> MyState:
        # 1、修复错误，注释掉报错代码
        # raise Exception("node_2节点执行报错")
        return {"key_2":"value_2"}
    
    def node_3(state: MyState) -> MyState:
        return {"key_3":"value_3"}

    # 添加节点，添加边
    builder = StateGraph(MyState)
    builder.add_node(node_1)
    builder.add_node(node_2)
    builder.add_node(node_3)
    builder.add_edge(START, "node_1")
    builder.add_edge("node_1", "node_2")
    builder.add_edge("node_1", "node_3")
    config = {
        "configurable":{
            "thread_id":"123"
        }
    }
    
    graph = builder.compile(checkpointer=memory)
    # 2、调用时传入相同的config，注意，从故障中恢复，此处传递None即可
    graph.invoke(None,config=config)

import operator
from typing import Annotated, Any
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END

class State(TypedDict):
    """
    状态类型定义
    """
    aggregate: Annotated[list, operator.add]

def a(state: State,config):
    print(f'Adding "A" to {state["aggregate"]}')
    return {"aggregate": ["A"]}

def b(state: State,config):
    print(f'Adding "B" to {state["aggregate"]}')
    return {"aggregate": ["B"]}

def b_2(state: State,config):
    print(f'Adding "B_2" to {state["aggregate"]}')
    return {"aggregate": ["B_2"]}

def c(state: State,config):
    print(f'Adding "C" to {state["aggregate"]}')
    return {"aggregate": ["C"]}

def d(state: State,config):
    print(f'Adding "D" to {state["aggregate"]}')
    return {"aggregate": ["D"]}

builder = StateGraph(State)

builder.add_node("a", a)
builder.add_node("b", b)
builder.add_node("b_2", b_2)
builder.add_node("c", c)
builder.add_node("d", d)

builder.add_edge(START, "a")
builder.add_edge("a", "b")
builder.add_edge("a", "c")
builder.add_edge("b", "b_2")
builder.add_edge("b_2", "d")
builder.add_edge("c", "d")
builder.add_edge("d", END)

graph = builder.compile()
# 1、查看当前图的channels
print('当前图的channels为',graph.channels,end="\n\n")
# 2、查看当前图的节点
print('当前图的节点为',graph.nodes,end="\n\n")

# 3、查看a节点的trigger（当前节点的订阅）和writers
print('当前图的节点a的triggers为',graph.nodes['a'].triggers,end="\n\n")
print('当前图的节点a的writers为',graph.nodes['a'].writers,end="\n\n")

# 4、查看d节点的trigger和writers
print('当前图的节点d的triggers为',graph.nodes['d'].triggers,end="\n\n")
print('当前图的节点d的writers为',graph.nodes['d'].writers,end="\n\n")
# 5、执行图，查看执行结果
output_state = graph.invoke({"aggregate": []}) 
print('执行图后的状态为',output_state,end="\n\n")

import operator
from typing import Annotated, Any
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.sqlite import SqliteSaver
import sqlite3
connection = sqlite3.connect('checkpointer.db',check_same_thread=False)
checkpointer = SqliteSaver(connection)
class State(TypedDict):
    """
    状态类型定义
    """
    aggregate: Annotated[list, operator.add]

def a(state: State,config):
    print(f'Adding "A" to {state["aggregate"]}')
    return {"aggregate": ["A"]}

def b(state: State,config):
    print(f'Adding "B" to {state["aggregate"]}')
    return {"aggregate": ["B"]}

def b_2(state: State,config):
    print(f'Adding "B_2" to {state["aggregate"]}')
    return {"aggregate": ["B_2"]}

def c(state: State,config):
    print(f'Adding "C" to {state["aggregate"]}')
    return {"aggregate": ["C"]}

def d(state: State,config):
    print(f'Adding "D" to {state["aggregate"]}')
    return {"aggregate": ["D"]}

builder = StateGraph(State)

builder.add_node("a", a)
builder.add_node("b", b)
builder.add_node("b_2", b_2)
builder.add_node("c", c)
builder.add_node("d", d) 

builder.add_edge(START, "a")
builder.add_edge("a", "b")
builder.add_edge("a", "c")
builder.add_edge("b", "b_2")
builder.add_edge("b_2", "d")
builder.add_edge("c", "d")
builder.add_edge("d", END)

graph = builder.compile(checkpointer=checkpointer)
res = graph.invoke({},config={'configurable':{'thread_id':'1'}})

# 1、最终状态
print(res)

# 2、查看历史所有状态
all_states = graph.get_state_history(config={'configurable':{'thread_id':'1'}})
all_states_list = list(all_states)
print("历史所有状态如下：\n")
for state in all_states_list:
    print(state,end="\n"+"="*30+"\n")

print("\n\n最近一次状态如下：\n")
last_state = graph.get_state(config={'configurable':{'thread_id':'1'}})
print(last_state)

import time
from typing import TypedDict, Any, List
from langchain_core.runnables import RunnableConfig
from langgraph.graph import StateGraph, START, END
from langgraph.runtime import Runtime

class MockLLM:
    def invoke(self, prompt: str):
        return f"AI Generated: Answer for '{prompt}'"

class MockDatabase:
    def get_user_info(self, user_id: str):
        return {"id": user_id, "role": "vip" if "vip" in user_id else "standard"}

class CustomerSupportState(TypedDict):
    query: str          # 用户问题
    response: str       # 客服回复
    log: List[str]      # 处理日志

def node_customer_service(state: CustomerSupportState, config: RunnableConfig, runtime: Runtime) -> dict:
    """
    客服节点：展示如何从 config 中获取注入的依赖 (LLM, DB) 并使用 runtime 推送进度。
    """

    user_query = state["query"]
    
    # 1、从runtime当中获取context对象
    llm = runtime.context['llm']
    db = runtime.context['db']
    

    configurable = config.get("configurable", {})
    user_id = configurable.get("user_id", "guest")
    
    print(f"\n[Node] 开始处理，User ID: {user_id}")
    
    # 2、验证依赖是否存在
    if not llm or not db:
        return {"response": "System Error: Dependencies not injected!", "log": ["Error"]}

    # 3、使用db对象查看用户角色
    user_info = db.get_user_info(user_id)
    user_tier = user_info.get("role")
    print(f"[Node] 从 DB 获取用户角色: {user_tier}")

    # 4、使用 runtime.writer 向图外输出自定义数据 ---
    writer = runtime.stream_writer
    writer({"status": "thinking", "message": f"正在调用 LLM 为 {user_tier} 用户生成回复..."})
    time.sleep(0.5)

    # 5、根据用户角色构建不同的 Prompt，并模拟 LLM 调用
    prompt = f"User({user_tier}) asks: {user_query}"
    llm_response = llm.invoke(prompt)
    
    return {
        "response": llm_response,
        "log": [f"Processed by {llm.__class__.__name__}"]
    }


    return None
def run_demo():
    builder = StateGraph(CustomerSupportState)
    builder.add_node("customer_service", node_customer_service)
    builder.add_edge(START, "customer_service")
    builder.add_edge("customer_service", END)
    graph = builder.compile()
    
    # 初始化外部依赖
    my_llm = MockLLM()
    my_db = MockDatabase()
    
    print("==================================================")
    print("场景: 依赖注入演示")
    print("演示目标: 将 LLM 和 DB 对象通过 runtime.context 注入到节点中")
    print("==================================================")
    
    # 准备状态
    initial_state = {"query": "如何升级会员？"}
    
    # user_id为一个配置信息，将其放入到config当中
    config = {
        "configurable": {
            "user_id": "vip_user_999",
        }
    }
    
    print("[System] 开始运行图，并注入依赖对象...")
    
    context = {
        "llm": my_llm,
        "db": my_db
    }
    result = graph.invoke(initial_state,config=config,context=context)
    print(result)
    

if __name__ == "__main__":
    run_demo()

from typing import TypedDict
from langgraph.constants import START,END
from langgraph.graph import StateGraph

class MyState(TypedDict):
    query:str
    file_result:str
    web_result:str
    final_answer:str

def query_web(state:MyState)->dict:
    """
    做网络搜索，返回搜索结果
    :return:
    """
    # 1、错误演示：直接return整个state，而非当前节点增量修改的状态
    query = state['query']
    state['web_result'] = f'{query}的网络搜索结果'
    return state

def query_file(state:MyState)->dict:
    """
    做文件搜索，返回搜索结果
    :return:
    """
    query = state['query']
    state['file_result'] = f'{query}的文件搜索结果'
    return state

def answer(state:MyState)->dict:
    """
    返回最终的答案
    :return:
    """
    web_result = state['web_result']
    file_result = state['file_result']
    final_answer = f'LLM基于{web_result}，{file_result} 的最终结果'
    state['final_answer'] = final_answer
    return state

graph = StateGraph(state_schema=MyState)
graph.add_node(answer)
graph.add_node(query_web)
graph.add_node(query_file)
graph.add_edge(START,'query_web')
graph.add_edge(START,'query_file')
graph.add_edge('query_web','answer')
graph.add_edge('query_file','answer')
compiled_graph = graph.compile()
res = compiled_graph.invoke({"query":"什么是Langgraph"})
print(res['final_answer'])

END = sys.intern("__end__")
"""The last (maybe virtual) node in graph-style Pregel."""
START = sys.intern("__start__")
"""The first (maybe virtual) node in graph-style Pregel."""

import time
from typing_extensions import TypedDict
from langgraph.graph import StateGraph
from langgraph.cache.memory import InMemoryCache

from langgraph.types import CachePolicy
from langgraph.constants import START
from langgraph.checkpoint.memory import InMemorySaver

class State(TypedDict):
    x: int
    result: int

builder = StateGraph(State)
checkpointer = InMemorySaver()

# 1、定义节点：模拟一些有耗时计算的节点
def expensive_node(state: State) -> dict[str, int]:
    # expensive computation
    print(f"expensive_node 被调用")
    time.sleep(5)
    print(f"expensive_node 计算完成")
    return {"result": state["x"] * 2}

# 2、添加节点时，为节点配置缓存策略，这里设置为10秒缓存，缓存键的配置同样使用默认的方式，可以在CachePolicy当中传入key_func配置不同的缓存键生成策略
builder.add_node("expensive_node", expensive_node, cache_policy=CachePolicy(ttl=10))
builder.add_edge(START, "expensive_node")

# 3、图编译时，传入缓存器，此处使用InMemoryCache，也可以使用RedisCache等
graph = builder.compile(cache=InMemoryCache(),checkpointer=checkpointer)

# 4、第一次调用，传入的状态为5
print(graph.invoke({"x": 5},config={"configurable":{"thread_id":"1"}}))

# 5、第二次调用，传入相同的状态，由于缓存策略，会直接从缓存中返回结果，而不会重新调用节点
print(graph.invoke({"x": 5},config={"configurable":{"thread_id":"2"}}))

import random
from typing import Dict, Any
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.types import RetryPolicy

# 定义状态
class State(TypedDict):
    result: str

# 模拟不稳定的API调用，使用全局变量跟踪尝试次数
attempt_counter = 0

def unstable_api_call(state: State) -> Dict[str, Any]:
    """
    模拟一个不稳定的API调用，有一定概率失败
    """
    global attempt_counter
    attempt_counter += 1
    print(f"尝试调用API，这是第 {attempt_counter} 次尝试")
    
    # 模拟前几次尝试失败，最后一次成功
    if attempt_counter < 3:
        raise Exception(f"模拟API调用失败 (尝试 {attempt_counter})")
    else:
        # 第三次尝试成功
        return {
            "result": f"API调用成功，经过 {attempt_counter} 次尝试"
        }
# 模拟抛出 ValueError 的节点
def value_error_call(state: State) -> Dict[str, Any]:
    """
    模拟抛出 ValueError 的节点（不会被默认重试策略重试）
    """
    print("调用会抛出 ValueError 的节点")
    raise ValueError("模拟 ValueError 异常")

def run_demo():
    print("=== LangGraph 节点重试策略演示 ===\n")
    
    # 重置全局计数器
    global attempt_counter
    attempt_counter = 0
    
    # 演示1: 使用默认重试策略
    print("1. 使用默认重试策略:")
    print("   默认策略会对除特定异常外的所有异常进行重试")
    print("   不会重试的异常包括: ValueError, TypeError, ArithmeticError, ImportError,")
    print("                     LookupError, NameError, SyntaxError, RuntimeError,")
    print("                     ReferenceError, StopIteration, StopAsyncIteration, OSError\n")
    
    builder1 = StateGraph(State)
    
# 添加节点，使用默认重试策略，
#
    builder1.add_node(
        "unstable_call", 
        unstable_api_call, 
        retry_policy=RetryPolicy(max_attempts=5)  # 允许最多5次尝试
    )
    
    builder1.add_edge(START, "unstable_call")
    builder1.add_edge("unstable_call", END)
    
    graph1 = builder1.compile()
    
    print("测试默认重试策略:")
    try:
        result = graph1.invoke({"result": ""})
        print(f"最终结果: {result}\n")
    except Exception as e:
        print(f"最终失败: {type(e).__name__}: {e}\n")
    
    # 演示2: 使用自定义重试策略
    print("2. 使用自定义重试策略:")
    print("   自定义策略只对特定错误进行重试\n")
    
    # 重置全局计数器
    attempt_counter = 0
    # 演示3: 不会重试的异常类型
    print("3. 测试不会重试的异常类型:")
    
    builder3 = StateGraph(State)
    
    # 添加节点，使用默认重试策略
    builder3.add_node(
        "value_error_call", 
        value_error_call, 
        retry_policy=RetryPolicy(max_attempts=3)
    )
    builder3.add_edge(START, "value_error_call")
    builder3.add_edge("value_error_call", END)
    
    graph3 = builder3.compile()
    
    print("测试 ValueError（默认策略不会重试）:")
    try:
        result = graph3.invoke({"result": ""})
        print(f"最终结果: {result}\n")
    except Exception as e:
        print(f"最终失败: {type(e).__name__}: {e}\n")

if __name__ == "__main__":
    run_demo()

import time
from typing import TypedDict, Annotated, List
import operator
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, START, END
from langgraph.types import StreamWriter
from langgraph.runtime import Runtime
llm = ChatOpenAI(model="gpt-4o-mini")

# --- 1. 定义状态 ---
class State(TypedDict):
    messages: Annotated[List[BaseMessage], operator.add]
    current_step: str

# --- 2. 定义节点 ---

def node_input(state: State):
    """模拟接收用户输入"""
    return {
        "messages": [HumanMessage(content="请帮我写一段Python代码")],
        "current_step": "input_received"
    }

def node_processing(state: State, runtime: Runtime):
    """
    模拟中间处理过程，并使用 writer 输出自定义流式数据
    这对应 stream_mode="custom"
    """
    steps = ["正在分析意图...", "正在检索知识库...", "正在构建Prompt..."]
    writer = runtime.stream_writer
    for i, step in enumerate(steps):
        time.sleep(0.5) # 模拟耗时操作
        
        # 使用 writer 发送自定义数据 (不影响图的状态)
        # 这些数据只能通过 stream_mode="custom" 接收到
        writer({
            "step_index": i + 1,
            "description": step,
            "timestamp": time.time()
        })
        
    return {"current_step": "processing_complete"}

def node_generation(state: State):
    """
    模拟 LLM 生成过程
    LangGraph 的 stream_mode="messages" 会自动捕获 LLM 的流式输出
    """   
    
    # 调用 LLM
    response = llm.invoke(state["messages"])
    
    return {
        "messages": [response],
        "current_step": "generation_complete"
    }

# --- 3. 构建图 ---
builder = StateGraph(State)
builder.add_node("input", node_input)
builder.add_node("process", node_processing)
builder.add_node("generate", node_generation)

builder.add_edge(START, "input")
builder.add_edge("input", "process")
builder.add_edge("process", "generate")
builder.add_edge("generate", END)

graph = builder.compile()

# --- 4. 演示不同的流式输出模式 ---
def run_demo():
    initial_state = {"messages": [], "current_step": "start"}
    
    print(f"\n{'='*20} 1. Mode: values (输出完整状态) {'='*20}")
    print("描述: 每执行完一个节点，输出当前的完整 State")
    for event in graph.stream(initial_state, stream_mode="values"):
        # event 就是当前的 State 字典
        print(f"State: keys={list(event.keys())}, step={event.get('current_step')}")

    print(f"\n{'='*20} 2. Mode: updates (输出增量更新) {'='*20}")
    print("描述: 每执行完一个节点，输出该节点返回的增量数据")
    for event in graph.stream(initial_state, stream_mode="updates"):
        # event 是一个字典，key是节点名，value是该节点的输出
        handle_event(event)
        print(f"Update: {event}")

    print(f"\n{'='*20} 3. Mode: custom (输出自定义数据) {'='*20}")
    print("描述: 仅输出节点内部通过 writer() 发送的数据")
    for event in graph.stream(initial_state, stream_mode="custom"):
        # event 就是 writer() 中传入的对象
        print(f"Custom Data: {event}")

    print(f"\n{'='*20} 4. Mode: messages (输出 LLM Token) {'='*20}")
    print("描述: 输出 LLM 生成的消息片段 (Token)")
    # 注意：FakeListChatModel 默认是一次性返回，但在 messages 模式下会被包装成 chunk
    for chunk, metadata in graph.stream(initial_state, stream_mode="messages"):
        # chunk 是 BaseMessageChunk 对象
        # metadata 包含 node 信息
        node_name = metadata.get('langgraph_node', 'unknown')
        print(f"[{node_name}] Token: {chunk.content!r}")
        # print(chunk.content,end="")
        time.sleep(0.2)
        

    print(f"\n{'='*20} 5. Mode: debug (调试模式) {'='*20}")
    print("描述: 输出所有详细的执行信息，包括任务调度、输入输出等")
    # debug 模式输出量很大，这里只打印前几条示意
    count = 0
    for event in graph.stream(initial_state, stream_mode="debug"):
        if count < 3:
            print(f"Debug Event: {event['type']} - {event.get('payload', {}).get('name')}")
        count += 1
    print("... (省略后续 debug 信息)")

    print(f"\n{'='*20} 6. Mixed Mode (混合模式) {'='*20}")
    print("描述: 同时获取 updates 和 custom 数据")
    # 返回的是 (mode, data) 元组
    for mode, data in graph.stream(initial_state, stream_mode=["updates", "custom"]):
        if mode == "updates":
            print(f"[Updates] 来自节点 {list(data.keys())[0]}")
        elif mode == "custom":
            print(f"[Custom] {data['description']}")

if __name__ == "__main__":
    run_demo()

"""
LangGraph interrupt 演示：让用户参与关键决策

场景：准备执行一笔“转账”，在真正执行前让用户审核/修改转账信息。
"""

from __future__ import annotations

from typing import Any
from typing_extensions import TypedDict

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import Command, interrupt

class TransferState(TypedDict):
    recipient: str
    amount: int
    memo: str
    approved: bool
    final_status: str

def review_transfer(state: TransferState) -> dict[str, Any]:
    print("\n[Node] review_transfer：生成待执行的转账请求")
    pending_transfer = {
        "recipient": state["recipient"],
        "amount": state["amount"],
        "memo": state["memo"],
    }

    user_review = interrupt(
        {
            "title": "转账审核",
            "pending_transfer": pending_transfer,
            "instruction": "请返回 bool(是否批准) 或 dict(可改 recipient/amount/memo，并带 approved 字段)。",
        }
    )

    approved = False
    updated_transfer = dict(pending_transfer)
    if isinstance(user_review, bool):
        approved = user_review
    elif isinstance(user_review, dict):
        approved = bool(user_review.get("approved", True))
        for k in ("recipient", "amount", "memo"):
            if k in user_review:
                updated_transfer[k] = user_review[k]

    print(f"[Node] review_transfer：用户审核结果 approved={approved}，transfer={updated_transfer}")
    return {
        "approved": approved,
        "recipient": updated_transfer["recipient"],
        "amount": updated_transfer["amount"],
        "memo": updated_transfer["memo"],
    }

def execute_transfer(state: TransferState) -> dict[str, str]:
    if not state["approved"]:
        print("\n[Node] execute_transfer：用户未批准，取消转账")
        return {"final_status": "已取消：用户未批准转账"}

    print("\n[Node] execute_transfer：模拟执行转账")
    recipient = state["recipient"]
    amount = state["amount"]
    memo = state["memo"]
    return {"final_status": f"已转账：收款人={recipient}，金额={amount}，备注={memo}"}

def build_graph():
    builder = StateGraph(TransferState)
    builder.add_node("review_transfer", review_transfer)
    builder.add_node("execute_transfer", execute_transfer)

    builder.add_edge(START, "review_transfer")
    builder.add_edge("review_transfer", "execute_transfer")
    builder.add_edge("execute_transfer", END)

    return builder.compile(checkpointer=InMemorySaver())

def run_demo():
    graph = build_graph()
    config = {"configurable": {"thread_id": "interrupt-demo-1"}}

    print("==================================================")
    print("场景：转账前人工审核（interrupt）")
    print("第一次 invoke 会停在 interrupt，并把审核数据带出来")
    print("第二次 invoke 使用 Command(resume=...) 把用户决策传回去继续执行")
    print("==================================================")

    initial_state: TransferState = {
        "recipient": "Alice",
        "amount": 100,
        "memo": "午饭AA",
        "approved": False,
        "final_status": "",
    }

    first = graph.invoke(initial_state, config=config)
    interrupt_payload = first["__interrupt__"][0].value
    print("\n[System] 图已暂停，等待用户审核。可给用户展示的数据如下：")
    print(interrupt_payload)

    user_resume_value = {"approved": True, "amount": 80, "memo": "改为80元（实际应付）"}
    final = graph.invoke(Command(resume=user_resume_value), config=config)
    print("\n[System] 已恢复执行，最终结果：")
    print(final["final_status"])

if __name__ == "__main__":
    run_demo()

from typing import Literal
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END

# 定义状态
class GraphState(TypedDict):
    value: int
    step: str

# 定义节点函数
def node_a(state: GraphState) -> dict:
    """节点A"""
    print("执行节点A")
    return {"value": state["value"], "step": "A执行完毕"}

def node_b(state: GraphState) -> dict:
    """节点B"""
    print("执行节点B")
    return {"value": state["value"] * 2, "step": "B执行完毕"}

def node_c(state: GraphState) -> dict:
    """节点C"""
    print("执行节点C")
    return {"value": state["value"] - 1, "step": "C执行完毕"}

# 条件边的路由函数
def route_condition(state: GraphState) -> Literal["node_b", "node_c"]:
    """根据value值决定路由到哪个节点"""
    if state["value"] % 2 == 0:
        return "node_b_alias"  # 偶数路由到节点B
    else:
        return "node_c_alias"  # 奇数路由到节点C

def main():
    """演示条件边"""
    print("=== 条件边演示 ===")
    
    # 创建图
    builder = StateGraph(GraphState)
    
    # 添加节点
    builder.add_node("node_a", node_a)
    builder.add_node("node_b", node_b)
    builder.add_node("node_c", node_c)
    
    # 添加边
    builder.add_edge(START, "node_a")  # 入口点
    
    # 添加条件边
    builder.add_conditional_edges(
        "node_a",  # 源节点
        route_condition,  # 路由函数
        {  # 路由映射
            "node_b_alias": "node_b",
            "node_c_alias": "node_c"
        }
    )
    
    # 从B和C到结束
    builder.add_edge("node_b", END)
    builder.add_edge("node_c", END)
    
    # 编译图
    graph = builder.compile()
    
    # 执行图 - 偶数情况
    print("输入值为偶数:")
    result = graph.invoke({"value": 2})
    print(f"执行结果: {result}")
    
    # 执行图 - 奇数情况
    print("\n输入值为奇数:")
    result = graph.invoke({"value": 1})
    print(f"执行结果: {result}\n")

if __name__ == "__main__":
    main()

from typing import Annotated, Dict, Literal
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.errors import GraphRecursionError

class LoopState(TypedDict):
    count: int
    result: str
    max_count: int

def node_a(state: LoopState) -> dict:
    """节点a：处理逻辑并更新计数"""
    print(f"执行节点a，当前计数: {state['count']}")
    return {
        'count': state['count'] + 1,
        'result': f"已处理{state['count']}次"
    }

def node_b(state: LoopState) -> dict:
    """节点b：辅助处理"""
    print(f"执行节点b，当前计数: {state['count']}")
    return {
        'result': f"已处理{state['count']}次 - 辅助处理"
    }

def route(state: LoopState) -> Literal["b", END]:
    """条件路由函数：决定是继续循环还是终止"""
    # 终止条件：当计数达到最大值时终止
    if state['count'] >= state['max_count']:
        print(f"满足终止条件，计数 {state['count']} >= {state['max_count']}，返回END")
        return END
    else:
        print(f"未满足终止条件，计数 {state['count']} < {state['max_count']}，返回b")
        return "b"

# 创建图
builder = StateGraph(LoopState)

# 添加节点
builder.add_node("a", node_a)
builder.add_node("b", node_b)

# 添加边
builder.add_edge(START, "a")
builder.add_conditional_edges("a", route)
builder.add_edge("b", "a")

# 编译图
graph = builder.compile()

# 执行图
print("=== 开始执行工作流 ===")
try:
    result = graph.invoke(input={
        'count': 0,
        'result': '',
        'max_count': 300
    }, config={
        'recursion_limit': 6  # 设置递归限制
    })
    print("=== 执行结果 ===")
    print(result)
except GraphRecursionError as e:
print(f"递归错误: {e}")