┌─────────────────────────────────────────────────────────────┐
│                   传统 Chain vs Agent 编排                    │
│                                                             │
│   Chain:  Input → LLM → Output（单次、线性、无状态）            │
│                                                             │
│   Agent:  Input → Think → Act → Observe → Think → ...      │
│           ↑                    │                             │
│           └────────────────────┘（循环、有状态、容错）           │
└─────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────┐
│                     Agent 编排三大范式                                 │
├──────────────────┬──────────────────────┬────────────────────────────┤
│   Code-first     │   Config-first       │   Workflow-first           │
│   代码优先        │   配置优先            │   工作流优先                │
├──────────────────┼──────────────────────┼────────────────────────────┤
│  LangGraph       │  CrewAI              │  n8n                       │
│  OpenAI Agents   │  AutoGen/AG2         │  Dify                      │
│  SDK             │  MetaGPT             │  Temporal                  │
│                  │                      │  Camunda                   │
├──────────────────┼──────────────────────┼────────────────────────────┤
│  工程师写 Python  │  描述角色和目标        │  拖拽连线或 DSL 定义        │
│  /TS 控制图结构    │  框架生成执行逻辑      │  工作流自动编排              │
├──────────────────┼──────────────────────┼────────────────────────────┤
│  精确控制、可观测  │  快速原型、低门槛      │  集成广泛、业务友好          │
└──────────────────┴──────────────────────┴────────────────────────────┘

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

class AgentState(TypedDict):
    messages: List[str]
    tool_results: List[dict]
    iteration: int
    done: bool

def think(state: AgentState) -> AgentState:
    # Agent 推理：分析当前状态，决定下一步
    response = llm.invoke(state["messages"])
    state["messages"].append(response)
    return state

def act(state: AgentState) -> AgentState:
    # Agent 执行：调用工具获取外部信息
    results = tool_executor.invoke(state["messages"][-1])
    state["tool_results"].append(results)
    state["iteration"] += 1
    return state

def should_continue(state: AgentState) -> str:
    # 条件路由：判断是否需要继续推理
    if state["done"] or state["iteration"] > 5:
        return "end"
    return "continue"

graph = StateGraph(AgentState)
graph.add_node("think", think)
graph.add_node("act", act)
graph.set_entry_point("think")
graph.add_edge("think", "act")
graph.add_conditional_edges("act", should_continue, {
    "continue": "think",
    "end": END
})
agent = graph.compile()

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Senior Research Analyst",
    goal="Uncover cutting-edge developments in AI",
    backstory="You are an expert analyst at a leading tech think tank.",
    tools=[search_tool, web_scraper]
)

writer = Agent(
    role="Tech Content Writer",
    goal="Write engaging blog posts about AI discoveries",
    backstory="You are a renowned content strategist.",
    tools=[writing_tool]
)

research_task = Task(
    description="Research the latest AI agent frameworks",
    expected_output="A detailed report with comparisons",
    agent=researcher
)

writing_task = Task(
    description="Write a blog post based on the research",
    expected_output="A 1000-word blog post",
    agent=writer
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process="sequential"
)

result = crew.kickoff()

┌────────────────────────────────────────────────────────────┐
│              n8n Agent 工作流示例                            │
│                                                            │
│  [Slack 触发] → [AI Agent 节点] → [条件分支]                 │
│                       │              │                      │
│                  [知识库检索]    [发送邮件]                   │
│                       │              │                      │
│                  [LLM 推理]    [创建任务]                   │
│                       │                                    │
│                  [结果回写 Slack]                           │
└────────────────────────────────────────────────────────────┘

┌────────────────────────────────────────────────────────────┐
│              Temporal Durable Execution                    │
│                                                            │
│  Worker 进程 ──→ 执行 Workflow 代码                         │
│       │                                                    │
│       ▼                                                    │
│  Event History（事件历史）                                   │
│  ┌─────────────────────────────────────────────┐          │
│  │ WorkflowStarted → ActivityScheduled →        │          │
│  │ ActivityCompleted → TimerFired → ...         │          │
│  └─────────────────────────────────────────────┘          │
│       │                                                    │
│       ▼                                                    │
│  进程崩溃 → 重启 → 从 Event History 重放 → 恢复执行           │
└────────────────────────────────────────────────────────────┘

你的团队写代码吗？
├── 是（工程师团队）
│   ├── 需要精确控制 Agent 行为？
│   │   ├── 是 → LangGraph
│   │   └── 否，快速原型 → CrewAI
│   └── 用 OpenAI 模型为主？
│       └── 是 → OpenAI Agents SDK
│
└── 否（业务团队 + 低代码）
    ├── Agent 是独立应用？
    │   └── 是 → Dify
    └── Agent 嵌入现有业务流程？
        └── 是 → n8n

所有方案都需要生产级可靠性？
└── 加一层 Temporal 作为执行引擎

┌──────────────────────────────────────────────────────────┐
│                 Agent Eval Pipeline                       │
│                                                          │
│  [测试用例集] → [Agent 执行] → [自动评测] → [回归检测]     │
│       │              │              │            │       │
│   真实场景        多次运行        LLM-as-Judge    对比基线  │
│   期望输出        取平均/最佳     + 规则检查       检测退化  │
└──────────────────────────────────────────────────────────┘

应用层：LangGraph / CrewAI / OpenAI Agents SDK（定义 Agent 逻辑）
    ↓
引擎层：Temporal / n8n（确保执行可靠性）
    ↓
基础设施层：LangSmith / Langfuse（可观测性和评测）