✅ 只用 langchain_core \+ 集成包，就能做：
   · 对话：model.invoke() / stream()
   · 记忆：手写 history.append \+ InMemoryChatMessageHistory（按 session 隔离）
   · 工具：@tool \+ bind_tools（手动循环执行 tool_calls）
   · 模板：ChatPromptTemplate \+ MessagesPlaceholder
   · 解析：StrOutputParser / with_structured_output
   · RAG：Document \+ TextSplitter \+ Embedding \+ Chroma \+ retriever \+ | 链
   · 结构化流程：LCEL 的 `a | b | c`（固定流水线）
   → 以上全是 langchain_core 范畴，不需要 LangGraph！

❌ 这些做不了 / 做起来很痛苦，才需要 LangGraph：
   · 流程会"转弯"（根据状态走不同分支）——LCEL 只有直线 `|`
   · 流程会"循环"（模型↔工具多轮，手动写 while 又丑又容易错）
   · 中途"暂停"（人审确认后再继续）——interrupt
   · 记忆"持久化、重启不丢"（手写 SQLite 要自己造轮子）——checkpointer
   · 状态"回滚/分支"（图的状态可保存可回退）
   · 可视化成图（节点/边/条件边，create_agent 内部就是一张图）

你的流程是"直线"（A→B→C 固定不变）？  → 用 langchain_core 的 `|` 链（第 09 篇 RAG 那种）
你的流程会"转弯/循环/暂停/记状态"？     → 用 LangGraph（本章）

print(type(agent))
# → <class 'langgraph.graph.state.CompiledStateGraph'>

=== 节点 ===
  __start__ → model → tools → __end__

=== 无条件边 ===
  __start__ → model
  tools     → model

=== 条件边 ===
  model 节点：有 tool_calls → 去 tools；没有 → 去 __end__

                 ┌──────────────────────────┐
                 │                          │
                 ▼                          │
  __start__ → model ──(还有 tool_calls?)──→ tools
                 │                           │
                 │ 没有 tool_calls            └──(执行完工具，绕回 model)
                 ▼
              __end__

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

# 零件一：状态（State）——节点间共享的数据结构
class CountState(TypedDict):
    count: int

# 零件二：节点（Node）——处理函数。每个节点只返回"自己改的部分"
def node_a(state):
    return {"count": state["count"] \+ 1}   # count \+1

def node_b(state):
    return {"count": state["count"] * 2}   # count *2

# 零件三：把节点和边装进图
g = StateGraph(CountState)          # 建图，声明状态结构
g.add_node("a", node_a)             # 加节点
g.add_node("b", node_b)
g.add_edge(START, "a")              # 加边：起点 → a → b → 终点
g.add_edge("a", "b")
g.add_edge("b", END)

# 零件四：编译成可调用对象
app = g.compile()

result = app.invoke({"count": 3})
print(result["count"])   # 8   （3 --a(\+1)--> 4 --b(*2)--> 8）

def decide(state):
    return "big" if state["count"] > 10 else "small"   # 判断：>10 走 big，否则走 small

g2 = StateGraph(CountState)
g2.add_node("check", lambda s: s)                          # 检查节点（原样过）
g2.add_node("big", lambda s: {"count": s["count"] \+ 100})
g2.add_node("small", lambda s: {"count": s["count"] - 1})
g2.add_edge(START, "check")
g2.add_conditional_edges("check", decide, {"big": "big", "small": "small"})   # ← 条件边
g2.add_edge("big", END)
g2.add_edge("small", END)
app2 = g2.compile()

print(app2.invoke({"count": 5})["count"])    # 4   （走 small：5-1）
print(app2.invoke({"count": 50})["count"])   # 150 （走 big：50\+100）

from langgraph.graph import StateGraph, START, END

StateGraph(
    state_schema: type[StateT],   # 状态结构（TypedDict 或 MessagesState）
    input_schema=None,            # 输入结构（默认用 state_schema）
    output_schema=None,           # 输出结构
)
g.add_node(node_name: str, action: Callable)   # 加节点
g.add_edge(start_key: str, end_key: str)       # 加边（无条件）
g.add_conditional_edges(                        # 加条件边（会转弯）
    source: str,                 # 从哪个节点出发
    path: Callable,              # 判断函数：返回 "big"/"small"/END 等
    path_map: dict,              # {"big": "big_node", "small": "small_node"}
)
g.compile(checkpointer=None, interrupt_before=None, ...) -> CompiledStateGraph

def node_a(state: dict) -> dict:
    # 读：state["count"] / state["messages"]
    # 写：只返回自己改的键
    return {"count": state["count"] \+ 1}
# LangGraph 自动合并返回值进状态