Agentic Workflow 心智模型：四种设计模式与选型指南

Prompt → LLM 生成 → LLM 评估自己的输出 → LLM 修正 → 输出

def generate_and_review(prompt: str, model: str = "gpt-4o") -> str:
    # 第一步：生成
    code = llm.generate(prompt, model=model)

    # 第二步：反思
    review_prompt = f"""
    检查以下代码，找出：
    1. 潜在的 bug
    2. 未处理的边界条件
    3. 性能问题

    代码：
    ```python
    {code}
    ```
    """
    review = llm.generate(review_prompt, model=model)

    # 第三步：如果有问题，修正
    if "问题" in review or "bug" in review.lower():
        fix_prompt = f"""
        根据以下审查意见修改代码：

        审查意见：
        {review}

        原代码：
        ```python
        {code}
        ```
        """
        code = llm.generate(fix_prompt, model=model)

    return code

Prompt → LLM 决定用什么工具 → 执行工具 → 拿到结果 → 决定下一步 → ...

# 好的工具设计：小而精
tools = [
    search_web,       # 搜索
    read_database,    # 读数据库
    send_email,       # 发邮件
]

# 差的工具设计：大而全
tools = [
    search_web, search_images, search_videos, search_news,
    read_mysql, read_postgres, read_mongodb,
    send_email, send_sms, send_slack, send_wechat,
    # ... 20 个工具，LLM 看晕了
]

任务 → LLM 生成执行计划 → 逐步执行计划 → 根据中间结果调整 → 完成

from langgraph.graph import StateGraph, END

class AgentState(TypedDict):
    task: str
    plan: list[str]
    current_step: int
    results: list[str]
    final_output: str

def planner(state: AgentState) -> AgentState:
    """生成执行计划"""
    plan = llm.generate(f"为以下任务生成执行步骤：{state['task']}")
    state['plan'] = parse_plan(plan)
    state['current_step'] = 0
    return state

def executor(state: AgentState) -> AgentState:
    """执行当前步骤"""
    step = state['plan'][state['current_step']]
    result = llm.generate(f"执行：{step}")
    state['results'].append(result)
    state['current_step'] += 1
    return state

def should_continue(state: AgentState) -> str:
    """决定是否继续"""
    if state['current_step'] >= len(state['plan']):
        return "end"
    return "continue"

# 构建图
graph = StateGraph(AgentState)
graph.add_node("planner", planner)
graph.add_node("executor", executor)
graph.add_node("synthesizer", synthesizer)

graph.set_entry_point("planner")
graph.add_edge("planner", "executor")
graph.add_conditional_edges("executor", should_continue, {
    "continue": "executor",
    "end": "synthesizer"
})
graph.add_edge("synthesizer", END)

app = graph.compile()

任务分发 → Agent A 做 A 部分 → Agent B 做 B 部分 → 协调者整合 → 输出

# Agent A：生成者
def generator(task: str) -> str:
    return llm.generate(f"完成以下任务：{task}")

# Agent B：审查者
def reviewer(work: str, task: str) -> tuple[bool, str]:
    feedback = llm.generate(f"""
    审查以下工作是否满足任务要求：

    任务：{task}
    工作：{work}

    返回 JSON：{{"pass": true/false, "feedback": "..."}}
    """)
    result = parse_json(feedback)
    return result["pass"], result["feedback"]

# 循环
def multi_agent_loop(task: str, max_rounds: int = 3) -> str:
    work = generator(task)
    for i in range(max_rounds):
        passed, feedback = reviewer(work, task)
        if passed:
            return work
        work = generator(f"根据反馈修改：\n反馈：{feedback}\n原稿：{work}")
    return work

你的任务是什么？
│
├─ 一步就能完成？
│  └─ 是 → 不需要 agent，直接调用 LLM
│  └─ 否 ↓
│
├─ 需要跟外部系统交互？（搜索、数据库、API）
│  └─ 是 → Tool Use
│  └─ 否 ↓
│
├─ 输出质量要求高？（代码、法律文件、医疗建议）
│  └─ 是 → Reflection（生成 + 自审）
│  └─ 否 ↓
│
├─ 任务超过 3 个步骤？
│  └─ 是 → Planning
│  └─ 否 ↓
│
├─ 任务可以拆分为独立子任务？
│  └─ 是 → Multi-Agent（2 个起步）
│  └─ 否 ↓
│
└─ 组合使用
   例：Planning + Tool Use + Reflection
   这是大多数实际应用的最终形态

选题 → Planning 模式
  │
  ├─ 调研 → Tool Use（搜索 + 读文档）
  │
  ├─ 写大纲 → Reflection（自己检查大纲逻辑）
  │
  ├─ 写初稿 → 直接 LLM
  │
  ├─ 代码验证 → Tool Use（exec 运行代码）
  │
  └─ 润色 → Reflection（AI 味检测 + 改写）