第4周 Day 4：Agent 工作流模式——编排复杂流程

笔记地址：gitee.com/liuguiting/...

前几天学了记忆、推理、协作，但还有一个问题：复杂流程怎么编排？

比如用户说：

"帮我分析这篇文章，如果质量好就推荐，不好就给出改进建议"

这涉及多个步骤，还有条件判断和循环。这就是工作流模式要解决的问题。

---

一、三种工作流模式

模式	是什么	适用场景
路由模式	根据条件走不同分支	任务类型不确定
并行模式	多个任务同时执行	独立任务需要汇总
评估-优化循环	做→检查→改进→再做	需要迭代改进

---

二、路由模式（Router）

2.1 是什么？

根据任务特征，选择走哪个分支。

2.2 Router 如何分析任务类型？

代码的示例用的是关键词匹配，这是最简单的方式。但实际开发中，有多种更智能的方式：

方式对比

方式	优点	缺点	适用场景
关键词匹配	简单、快、不调 API	不灵活、容易误判	任务类型少且明确
LLM 分析意图	智能、理解语义	需调 API、有成本	复杂任务场景（推荐）
嵌入向量匹配	灵活、语义理解	需预计算向量	任务库较大的场景

方式一：关键词匹配（当前示例）

def route(self, task: str) -> Agent:
    """简单关键词匹配"""
    if "写" in task or "文章" in task:
        return Writer()
    elif "查" in task or "资料" in task:
        return Researcher()
    else:
        return Writer()  # 默认

问题：用户说"帮我查一下怎么写文章"会被误判为"写文章"而不是"查资料"

方式二：LLM 分析意图（推荐）

def route_with_llm(self, task: str) -> Agent:
    """用 LLM 分析任务类型"""

    prompt = f"""
分析以下用户请求，判断应该交给哪个 Agent 处理。

可选 Agent：
- Researcher：负责搜集资料、查找信息
- Writer：负责写文章、创作内容
- Editor：负责审核、检查、修改

用户请求：{task}

请只输出 Agent 名称（Researcher/Writer/Editor），不要输出其他内容。
"""

    agent_name = call_llm(prompt).strip()
    return AGENT_MAP.get(agent_name, default_agent)

优点：能理解语义，用户说"帮我查一下怎么写文章"会正确判断为 Researcher

方式三：嵌入向量匹配

def route_with_embedding(self, task: str) -> Agent:
    """用向量相似度选择最匹配的 Agent"""

    # 预定义每个 Agent 的典型任务描述
    agent_descriptions = {
        "Researcher": "搜集资料、查找信息、搜索数据、调研分析",
        "Writer": "写文章、创作内容、撰写文案、编写报告",
        "Editor": "审核检查、修改润色、质量把控、校对修正"
    }

    # 计算任务与每个 Agent 描述的相似度
    task_embedding = get_embedding(task)

    best_agent = None
    best_score = 0

    for agent_name, desc in agent_descriptions.items():
        desc_embedding = get_embedding(desc)
        score = cosine_similarity(task_embedding, desc_embedding)

        if score > best_score:
            best_score = score
            best_agent = agent_name

    return AGENT_MAP[best_agent]

实际推荐：智能路由器

class SmartRouter:
    """智能路由器 - 用 LLM 分析意图"""

    SYSTEM_PROMPT = """
你是任务分析器。分析用户请求，选择最合适的处理者。

可选处理者：
1. Researcher - 搜集资料、查找信息
2. Writer - 写文章、创作内容
3. Editor - 审核、检查、修改
4. Calculator - 计算、数学问题
5. Translator - 翻译、语言转换

只输出处理者名称，不要解释。
"""

    def route(self, task: str) -> Agent:
        agent_name = call_llm(self.SYSTEM_PROMPT, task).strip()
        return self.AGENT_MAP.get(agent_name, self.default_agent)

2.3 核心代码（简单版）

class Router:
    """路由器：根据任务类型选择分支"""

    AGENT_MAP = {
        "写文章": Writer(),
        "查资料": Researcher(),
        "审核": Editor(),
    }

    def route(self, task: str) -> Agent:
        # 判断任务类型
        if "写" in task or "文章" in task:
            return self.AGENT_MAP["写文章"]
        if "查" in task or "资料" in task:
            return self.AGENT_MAP["查资料"]
        if "审核" in task:
            return self.AGENT_MAP["审核"]

        # 默认分支
        return self.AGENT_MAP["写文章"]

2.4 运行效果

用户: "帮我写一篇关于AI的文章"
Router 分析: 含有"写" → 任务类型"写文章"
选择分支: Writer Agent
执行: Writer.process("写一篇关于AI的文章")

用户: "帮我查一下猫的资料"
Router 分析: 含有"查" → 任务类型"查资料"
选择分支: Researcher Agent
执行: Researcher.process("查猫的资料")

---

三、并行模式（Parallel）

3.1 是什么？

多个任务同时执行，最后汇总结果。

3.2 核心代码

class ParallelWorkflow:
    """并行工作流：多个任务同时执行"""

    def __init__(self, workers: list, summarizer: Agent):
        self.workers = workers      # 并行执行的 Agent
        self.summarizer = summarizer # 汇总结果的 Agent

    def run(self, task: str) -> str:
        # 并行执行（模拟）
        results = []
        for worker in self.workers:
            results.append(worker.process(task))

        # 汇总
        combined = "\n---\n".join(results)
        final = self.summarizer.process(combined)
        return final

3.3 运行效果

用户: "帮我比较 Python 和 Java 的优缺点"

并行执行:
  Agent A: 分析 Python → 返回优点、缺点
  Agent B: 分析 Java → 返回优点、缺点

汇总:
  Summarizer: 整合两个结果 → 返回对比结论

---

四、评估-优化循环（Evaluate-Optimize Loop）

4.1 是什么？

先做一件事，检查结果，不满意就改进，直到满意为止。

4.2 核心代码

class EvaluateOptimizeLoop:
    """评估-优化循环"""

    MAX_ITERATIONS = 3  # 最多循环 3 次

    def __init__(self, executor: Agent, evaluator: Agent):
        self.executor = executor    # 执行者
        self.evaluator = evaluator  # 评估者

    def run(self, task: str) -> str:
        current_work = task

        for i in range(self.MAX_ITERATIONS):
            # 1. 执行
            result = self.executor.process(current_work)

            # 2. 评估
            evaluation = self.evaluator.process(result)

            # 3. 检查是否满意
            if "通过" in evaluation or "满意" in evaluation:
                return result  # 结束循环

            # 4. 不满意，准备改进
            current_work = f"请改进以下内容：\n{result}\n问题：{evaluation}"

        return result  # 达到最大次数，返回最后一次结果

4.3 运行效果

用户: "帮我写一篇关于 AI 的介绍"

第1轮:
  Executor: 写文章 → "AI是人工智能..."
  Evaluator: 评估 → "太简单，需要补充应用场景"
  不满意 → 继续

第2轮:
  Executor: 改进 → "AI是人工智能，应用包括..."
  Evaluator: 评估 → "【通过】内容完整"
  满意 → 结束

返回: 改进后的文章

---

五、完整工作流示例

把三种模式组合起来：

class WorkflowOrchestrator:
    """完整工作流编排"""

    def solve(self, task: str) -> str:
        # 1. 路由：判断任务类型
        task_type = self._classify(task)

        if task_type == "对比分析":
            # 并行模式
            return self._parallel_workflow(task)

        if task_type == "写文章":
            # 评估-优化循环
            return self._evaluate_optimize_loop(task)

        if task_type == "查资料":
            # 简单路由
            return self._simple_route(task)

    def _parallel_workflow(self, task):
        workers = [Researcher(), Researcher()]
        summarizer = Writer()
        workflow = ParallelWorkflow(workers, summarizer)
        return workflow.run(task)

    def _evaluate_optimize_loop(self, task):
        executor = Writer()
        evaluator = Editor()
        workflow = EvaluateOptimizeLoop(executor, evaluator)
        return workflow.run(task)

---

六、工作流模式对比

模式	流程	关键代码	闭环控制
路由	if/else 分支	if "写" in task: return Writer()	无循环
并行	同时执行+汇总	for worker in workers: results.append()	无循环
评估-优化	循环改进	for i in range(MAX_ITERATIONS)	有循环，需限制次数

---

七、今日总结

• 路由模式：根据条件选择分支（if/else）
• 并行模式：多个任务同时执行，最后汇总
• 评估-优化循环：做→检查→改进，最多 N 次

核心公式：

路由 = 条件判断 + 分支选择
并行 = 多任务执行 + 结果汇总
评估-优化 = 循环 + 闭环控制（MAX_ITERATIONS）

---

写于 2026-05-25，学习 Agent 工作流模式------编排复杂流程