{ "metadata": { "id": "ch04", "title": "第4章：Agent 核心概念", "volume": "vol2", "volume_title": "基础篇", "word_count": 3660, "difficulty": "beginner", "prerequisites": [ "ch01", "ch03" ], "key_concepts": [ "什么是 Agent", "从 Chatbot 到 Agent", "Agent 的直觉类比", "Agent 的能力层次", "Agent 架构模型", "ReAct：推理与行动交织", "Plan-and-Execute：先规划再执行", "Reflexion：带自我反思的 Agent", "三种架构的对比", "Agent 核心组件", "LLM：推理引擎", "工具集：Agent 的\"手\"", "记忆系统：Agent 的\"经验\"", "规划器：Agent 的\"策略家\"", "Agent 生命周期" ], "learning_objectives": [], "estimated_tokens": 2196, "source_file": "vol2/ch04_Agent核心概念.md" }, "overview": "", "sections": [ { "id": "4.1", "title": "4.1 什么是 Agent", "level": 2, "content": "", "subsections": [ { "id": "4.1.1", "title": "4.1.1 从 Chatbot 到 Agent", "content": "如果你使用过 ChatGPT，你已经在和一种最简单的\"Agent\"交互了——只不过它的能力被严格限定在对话范围内。当你问它一个问题，它基于自己的训练数据和你的输入生成回答。但当你让它\"帮我查一下今天的天气\"或者\"帮我在 GitHub 上创建一个 Issue\"时，普通 Chatbot 就无能为力了。\n\n**Agent（智能体）** 是对这种局限性的突破。它不仅仅能\"说\"，更能\"做\"。\n\n一个正式的定义：\n\n> **Agent 是一个以 LLM 为核心推理引擎，能够自主感知环境、制定计划、调用工具并执行行动，从而完成复杂目标的自治系统。**\n\n关键区别在于：\n\n| 特性 | Chatbot | Agent |\n|------|---------|-------|\n| 交互方式 | 单轮/多轮对话 | 持续的感知-推理-行动循环 |\n| 能力边界 | 限于文本生成 | 可以调用外部工具、操作 API |\n| 自主性 | 被动响应 | 主动规划和执行 |\n| 状态管理 | 无状态或简单对话历史 | 维护长期记忆和世界模型 |\n| 目标导向 | 回答问题 | 完成任务 |" }, { "id": "4.1.2", "title": "4.1.2 Agent 的直觉类比", "content": "理解 Agent 最好的方式是类比人类自身：\n\n- **你（LLM）** 是大脑，负责思考和决策\n- **你的手（工具）** 可以操作键盘、手机、各种工具\n- **你的眼睛和耳朵（感知）** 观察环境，获取信息\n- **你的记忆（记忆系统）** 帮你记住过去的经验和知识\n- **你的计划能力（规划器）** 帮你把大目标分解为小步骤\n\nAgent 就是把这个过程系统化、自动化的产物。" }, { "id": "4.1.3", "title": "4.1.3 Agent 的能力层次", "content": "并非所有 Agent 都是平等的。根据其能力的复杂度，我们可以分为几个层次：\n\n\n本卷主要聚焦于 Level 2-4 的内容，Level 5 的多 Agent 协作将在卷三中详细讨论。\n\n---" } ] }, { "id": "4.2", "title": "4.2 Agent 架构模型", "level": 2, "content": "Agent 的架构决定了它如何组织\"思考\"和\"行动\"。目前主流的架构模型有三种，各有适用场景。", "subsections": [ { "id": "4.2.1", "title": "4.2.1 ReAct：推理与行动交织", "content": "**ReAct**（Reasoning + Acting）是目前最广泛使用的 Agent 架构，由 Yao 等人在 2022 年提出。其核心思想是：**推理和行动交替进行，形成 \"Thought → Action → Observation\" 的循环**。\n\n\n**ReAct 的优势：**\n- 过程透明——每一步推理都可以被追踪\n- 灵活性高——可以根据中间结果调整策略\n- 实现相对简单" }, { "id": "4.2.2", "title": "4.2.2 Plan-and-Execute：先规划再执行", "content": "与 ReAct 的\"边想边做\"不同，**Plan-and-Execute** 架构采用分阶段策略：先制定完整计划，再逐步执行。\n\n\n\n**Plan-and-Execute 的优势：**\n- 适合复杂、多步骤任务\n- 计划可复用、可审查\n- 步骤可并行（无依赖关系的步骤）\n\n**劣势：**\n- 前期规划成本高\n- 面对意外情况需要重新规划\n- 不适合需要实时交互的场景" }, { "id": "4.2.3", "title": "4.2.3 Reflexion：带自我反思的 Agent", "content": "**Reflexion** 架构由 Shinn 等人在 2023 年提出，在 ReAct 的基础上增加了**自我反思（Self-Reflection）**机制。Agent 执行完行动后，会评估结果是否满意，如果不满意就反思失败原因并调整策略。" }, { "id": "4.2.4", "title": "4.2.4 三种架构的对比", "content": "| 维度 | ReAct | Plan-and-Execute | Reflexion |\n|------|-------|------------------|-----------|\n| **决策方式** | 边想边做 | 先想后做 | 做完再想 |\n| **适合任务** | 中等复杂度 | 高复杂度、多步骤 | 需要高质量输出的任务 |\n| **推理透明度** | 高（每步可见） | 高（计划可见） | 极高（含反思） |\n| **执行效率** | 中等 | 高（可并行） | 低（多轮尝试） |\n| **Token 消耗** | 中等 | 较高（规划阶段） | 高（反思消耗） |\n| **实现复杂度** | 低 | 中 | 中高 |\n\n**选型建议：**\n- 快速原型 / 简单工具使用场景 → **ReAct**\n- 复杂工作流 / 数据分析管线 → **Plan-and-Execute**\n- 代码生成 / 写作 / 需要质量保证 → **Reflexion**\n\n---" } ] }, { "id": "4.3", "title": "4.3 Agent 核心组件", "level": 2, "content": "无论采用哪种架构，一个完整的 Agent 都由以下核心组件构成。", "subsections": [ { "id": "4.3.1", "title": "4.3.1 LLM：推理引擎", "content": "LLM 是 Agent 的\"大脑\"，负责理解输入、进行推理、生成决策。但 Agent 对 LLM 的要求不同于普通对话：\n\n\n**Agent 场景下的 LLM 配置要点：**\n\n| 参数 | 推荐值 | 原因 |\n|------|--------|------|\n| `temperature` | 0.0 - 0.3 | 低随机性确保稳定决策 |\n| `top_p` | 0.9 - 1.0 | 与低 temperature 配合 |\n| `max_tokens` | 4096+ | 确保有足够空间生成完整响应 |\n| `response_format` | 按需 | 结构化输出时可指定 JSON |" }, { "id": "4.3.2", "title": "4.3.2 工具集：Agent 的\"手\"", "content": "工具赋予 Agent 与外部世界交互的能力。第6章将深入讨论，这里先了解基本概念。" }, { "id": "4.3.3", "title": "4.3.3 记忆系统：Agent 的\"经验\"", "content": "记忆系统让 Agent 能够在交互中积累经验，避免重复犯错，提供连贯的用户体验。第7章将深入讨论。\n\n核心类型：" }, { "id": "4.3.4", "title": "4.3.4 规划器：Agent 的\"策略家\"", "content": "规划器负责将复杂任务分解为可执行的子任务序列：\n\n\n---" } ] }, { "id": "4.4", "title": "4.4 Agent 生命周期", "level": 2, "content": "一个 Agent 从创建到完成任务，会经历以下生命周期阶段：", "subsections": [ { "id": "4.4.1", "title": "4.4.1 完整的 Agent 实现", "content": "" }, { "id": "4.4.2", "title": "4.4.2 Agent 的状态管理", "content": "在长期运行中，Agent 需要管理自己的状态：\n\n\n---" } ] }, { "id": "4.5", "title": "4.5 感知-推理-行动循环", "level": 2, "content": "", "subsections": [ { "id": "4.5.1", "title": "4.5.1 循环的本质", "content": "Agent 的核心是一个持续运转的循环，每个循环周期包含三个阶段：" }, { "id": "4.5.2", "title": "4.5.2 感知（Perception）", "content": "感知是 Agent 获取环境信息的过程：" }, { "id": "4.5.3", "title": "4.5.3 推理（Reasoning）", "content": "推理是 Agent 分析感知信息、做出决策的过程：" }, { "id": "4.5.4", "title": "4.5.4 行动（Action）", "content": "行动是 Agent 改变环境的过程：\n\n\n---" } ] }, { "id": "4.6", "title": "4.6 Agent 评估指标", "level": 2, "content": "如何评估一个 Agent 的好坏？以下是常用的评估维度。", "subsections": [ { "id": "4.6.1", "title": "4.6.1 任务完成度", "content": "" }, { "id": "4.6.2", "title": "4.6.2 效率指标", "content": "" }, { "id": "4.6.3", "title": "4.6.3 基准测试", "content": "---" } ] }, { "id": "4.7", "title": "4.7 常见陷阱与最佳实践", "level": 2, "content": "", "subsections": [ { "id": "4.7.1", "title": "4.7.1 常见陷阱", "content": "#### 陷阱1：过度依赖 LLM 的规划能力\n\nLLM 的规划能力有上限。面对超过 10 步的复杂任务，LLM 往往会遗漏细节或产生矛盾。\n\n**解决方案：**\n- 将大任务分解为多个小 Agent 协作\n- 使用外部规划算法（如状态空间搜索）辅助\n- 设置检查点，在关键步骤验证中间结果\n\n#### 陷阱2：工具描述模糊导致误用\n\n\n#### 陷阱3：无限循环\n\nAgent 可能陷入 \"调用工具→失败→重试→再失败\" 的循环。\n\n**解决方案：**\n\n#### 陷阱4：忽略成本控制\n\nAgent 的 Token 消耗可能很快失控。一个复杂任务可能消耗数十万 Token。\n\n**解决方案：**" }, { "id": "4.7.2", "title": "4.7.2 最佳实践", "content": "#### 实践1：渐进式复杂度\n\n不要一开始就构建最复杂的 Agent。从简单开始，逐步增加能力。\n\n\n#### 实践2：可观测性\n\nAgent 的决策过程应该是可观测的：\n\n\n#### 实践3：优雅降级\n\n当工具不可用时，Agent 应该有备选方案：\n\n\n---" } ] }, { "id": "4.8", "title": "4.8 本章小结", "level": 2, "content": "本章我们建立了 Agent 的核心认知框架：\n\n1. **Agent 的本质**：以 LLM 为核心，具备感知、推理、行动能力的自治系统\n2. **三种主流架构**：ReAct（边想边做）、Plan-and-Execute（先想后做）、Reflexion（做完再想）\n3. **四大核心组件**：LLM（大脑）、工具集（手）、记忆系统（经验）、规划器（策略）\n4. **生命周期管理**：从初始化到清理的完整流程\n5. **感知-推理-行动循环**：Agent 运转的核心机制\n6. **评估指标**：任务完成度、效率、成本等多维度评价\n7. **常见陷阱**：无限循环、成本失控、工具误用等\n\n掌握了这些核心概念，你已经有了一个完整的 Agent 认知地图。接下来的章节将逐一深入每个组件的实现细节——下一章我们将聚焦 Agent 的\"大脑\"：LLM 与 Prompt Engineering。\n\n---\n\n> **下一章**：[第5章：LLM 基础与 Prompt Engineering](ch05_LLM基础与Prompt_Engineering.md) —— 理解 Agent 推理引擎的工作原理，掌握高效 Prompt 设计技巧。", "subsections": [] } ], "code_blocks": [ { "id": "code-1", "language": "python", "description": "Agent 就是把这个过程系统化、自动化的产物。", "code": "# 一个最简化的 Agent 概念模型\nclass SimpleAgent:\n def __init__(self):\n self.brain = LLM() # 推理引擎\n self.tools = ToolBox() # 工具集\n self.memory = Memory() # 记忆系统\n self.planner = Planner() # 规划器\n \n def run(self, task: str):\n \"\"\"Agent 的核心循环\"\"\"\n while not self.is_done(task):\n # 1. 感知：收集当前状态\n context = self.perceive(task)\n \n # 2. 推理：思考下一步该做什么\n action = self.think(context)\n \n # 3. 行动：执行决策\n result = self.act(action)\n \n # 4. 记忆：记录结果\n self.remember(result)", "section_ref": "4.1.2", "runnable": true, "dependencies": [] }, { "id": "code-2", "language": "text", "description": "并非所有 Agent 都是平等的。根据其能力的复杂度，我们可以分为几个层次：", "code": "┌──────────────────────────────────────┐\n│ Level 5: 自主 Agent │ ← 完全自主，多 Agent 协作\n│ (Autonomous Multi-Agent) │\n├──────────────────────────────────────┤\n│ Level 4: 规划 Agent │ ← 能分解复杂任务，自我反思\n│ (Planning & Reflection Agent) │\n├──────────────────────────────────────┤\n│ Level 3: 工具使用 Agent │ ← 能调用 API、搜索、执行代码\n│ (Tool-Using Agent) │\n├──────────────────────────────────────┤\n│ Level 2: 增强型 Chatbot │ ← 有上下文记忆，RAG 增强\n│ (Augmented Chatbot) │\n├──────────────────────────────────────┤\n│ Level 1: 基础 Chatbot │ ← 单轮/多轮文本对话\n│ (Basic Chatbot) │\n└──────────────────────────────────────┘", "section_ref": "4.1.3", "runnable": false, "dependencies": [] }, { "id": "code-3", "language": "text", "description": "ReAct（Reasoning + Acting）是目前最广泛使用的 Agent 架构，由 Yao 等人在 2022 年提出。其核心思想是：推理和行动交替进行，形成 \"Thought → Action", "code": "用户提问\n │\n ▼\n┌─────────────────────────────────────────┐\n│ Thought: 我需要先搜索相关信息 │\n│ Action: search(\"Python asyncio 教程\") │\n│ Observation: 找到了3篇相关文章... │\n│ │\n│ Thought: 我需要查看第一篇文章的内容 │\n│ Action: read_page(\"article_1_url\") │\n│ Observation: 文章介绍了 event loop... │\n│ │\n│ Thought: 我已经有足够信息来回答了 │\n│ Action: answer(\"根据搜索结果...\") │\n└─────────────────────────────────────────┘", "section_ref": "4.2.1", "runnable": false, "dependencies": [] }, { "id": "code-4", "language": "python", "description": "- 实现相对简单", "code": "import json\nfrom typing import Callable\n\nclass ReActAgent:\n \"\"\"ReAct 架构的 Agent 实现\"\"\"\n \n def __init__(self, llm, tools: dict[str, Callable]):\n self.llm = llm\n self.tools = tools\n self.max_iterations = 10\n \n def run(self, task: str) -> str:\n history = [{\"role\": \"user\", \"content\": task}]\n \n for i in range(self.max_iterations):\n # LLM 进行推理\n response = self.llm.chat(\n messages=history,\n tools=self._get_tool_definitions()\n )\n \n # 如果 LLM 直接给出最终回答\n if not response.tool_calls:\n return response.content\n \n # 执行工具调用\n for tool_call in response.tool_calls:\n tool_name = tool_call.function.name\n tool_args = json.loads(tool_call.function.arguments)\n \n # 执行工具\n result = self.tools[tool_name](**tool_args)\n \n # 记录到历史\n history.append({\n \"role\": \"assistant\",\n \"content\": None,\n \"tool_calls\": [tool_call]\n })\n history.append({\n \"role\": \"tool\",\n \"tool_call_id\": tool_call.id,\n \"content\": str(result)\n })\n \n return \"达到最大迭代次数，任务未完成。\"", "section_ref": "4.2.1", "runnable": true, "dependencies": [] }, { "id": "code-5", "language": "text", "description": "与 ReAct 的\"边想边做\"不同，Plan-and-Execute 架构采用分阶段策略：先制定完整计划，再逐步执行。", "code": "用户提问\n │\n ▼\n┌─────────────┐\n│ Planner │ 制定完整计划\n│ (规划器) │ → Step 1: 搜索数据\n└──────┬──────┘ → Step 2: 分析数据\n │ → Step 3: 生成报告\n ▼ → Step 4: 格式化输出\n┌─────────────┐\n│ Executor │ 按计划逐步执行\n│ (执行器) │ 执行 Step 1 → 得到结果 1\n└──────┬──────┘ 执行 Step 2 → 得到结果 2\n │ ...\n ▼\n 最终结果", "section_ref": "4.2.2", "runnable": false, "dependencies": [] }, { "id": "code-6", "language": "python", "description": "最终结果", "code": "from pydantic import BaseModel\nfrom typing import List\n\nclass PlanStep(BaseModel):\n \"\"\"计划中的单个步骤\"\"\"\n step_id: int\n description: str\n tool: str | None = None # 需要的工具\n depends_on: List[int] = [] # 依赖的前置步骤\n expected_output: str # 预期产出\n\nclass Plan(BaseModel):\n \"\"\"完整的执行计划\"\"\"\n goal: str\n steps: List[PlanStep]\n \n def get_ready_steps(self, completed: set[int]) -> List[PlanStep]:\n \"\"\"获取可执行的步骤（依赖已满足）\"\"\"\n return [\n step for step in self.steps\n if step.step_id not in completed\n and all(dep in completed for dep in step.depends_on)\n ]\n\nclass PlanAndExecuteAgent:\n \"\"\"Plan-and-Execute 架构实现\"\"\"\n \n def __init__(self, llm, executor):\n self.llm = llm\n self.executor = executor\n \n def plan(self, task: str) -> Plan:\n \"\"\"让 LLM 制定计划\"\"\"\n prompt = f\"\"\"请为以下任务制定一个详细的执行计划。\n 每个步骤应该清晰、可执行，并注明需要的工具和依赖关系。\n\n 任务：{task}\n \n 请用 JSON 格式返回计划。\"\"\"\n \n response = self.llm.chat(prompt)\n return Plan.model_validate_json(response.content)\n \n def execute(self, plan: Plan) -> dict:\n \"\"\"按计划执行\"\"\"\n results = {}\n completed = set()\n \n while len(completed) < len(plan.steps):\n ready = plan.get_ready_steps(completed)\n \n for step in ready:\n result = self.executor.execute(step)\n results[step.step_id] = result\n completed.add(step.step_id)\n \n # 根据执行结果决定是否需要重新规划\n if not result.success:\n revised_plan = self.replan(plan, step, result.error)\n if revised_plan:\n plan = revised_plan\n break\n \n return results\n \n def rep plan(self, plan, failed_step, error):\n \"\"\"重新规划失败的步骤\"\"\"\n prompt = f\"\"\"步骤 {failed_step.description} 执行失败。\n 错误信息：{error}\n 请修改计划中剩余的步骤。\"\"\"\n # ... 重新规划的实现", "section_ref": "4.2.2", "runnable": true, "dependencies": [ "pydantic" ] }, { "id": "code-7", "language": "text", "description": "Reflexion 架构由 Shinn 等人在 2023 年提出，在 ReAct 的基础上增加了自我反思（Self-Reflection）机制。Agent 执行完行动后，会评估结果是否满意，如果不满意", "code": "Thought → Action → Observation\n │\n ▼\n 结果是否满意？\n ╱ ╲\n 是 否\n │ │\n ▼ ▼\n 输出结果 Reflection（反思）\n │\n ▼\n 为什么失败了？\n 如何改进？\n │\n ▼\n 调整策略，重新执行", "section_ref": "4.2.3", "runnable": false, "dependencies": [] }, { "id": "code-8", "language": "python", "description": "调整策略，重新执行", "code": "class ReflexionAgent(ReActAgent):\n \"\"\"带自我反思能力的 Agent\"\"\"\n \n def __init__(self, llm, tools, evaluator):\n super().__init__(llm, tools)\n self.evaluator = evaluator # 结果评估器\n self.reflection_history = []\n \n def run(self, task: str, max_attempts: int = 3) -> str:\n \"\"\"带反思重试的执行循环\"\"\"\n for attempt in range(max_attempts):\n # 使用 ReAct 执行任务\n result = super().run(task)\n \n # 评估结果\n evaluation = self.evaluator.evaluate(task, result)\n \n if evaluation.is_satisfactory:\n return result\n \n # 反思失败原因\n reflection = self._reflect(task, result, evaluation)\n self.reflection_history.append({\n \"attempt\": attempt + 1,\n \"result\": result,\n \"evaluation\": evaluation,\n \"reflection\": reflection\n })\n \n # 将反思注入下一次执行的上下文\n task = f\"\"\"原始任务：{task}\n \n 上一次尝试的结果：{result}\n 评估反馈：{evaluation.feedback}\n 反思总结：{reflection}\n \n 请根据以上反馈重新完成任务。\"\"\"\n \n return result # 返回最后一次尝试的结果\n \n def _reflect(self, task, result, evaluation):\n \"\"\"让 LLM 反思失败原因\"\"\"\n prompt = f\"\"\"任务：{task}\n 我的回答：{result}\n 评估反馈：{evaluation.feedback}\n \n 请分析为什么我的回答不够好，并给出具体的改进建议。\"\"\"\n \n return self.llm.chat(prompt)", "section_ref": "4.2.3", "runnable": true, "dependencies": [] }, { "id": "code-9", "language": "python", "description": "LLM 是 Agent 的\"大脑\"，负责理解输入、进行推理、生成决策。但 Agent 对 LLM 的要求不同于普通对话：", "code": "class AgentLLM:\n \"\"\"为 Agent 场景优化的 LLM 封装\"\"\"\n \n def __init__(self, model: str, api_key: str):\n from openai import OpenAI\n self.client = OpenAI(api_key=api_key)\n self.model = model\n self._call_count = 0\n self._total_tokens = 0\n \n def chat(\n self,\n messages: list[dict],\n tools: list[dict] | None = None,\n temperature: float = 0.1, # Agent 场景下温度宜低\n response_format: dict | None = None\n ) -> dict:\n \"\"\"Agent 专用的聊天接口\"\"\"\n kwargs = {\n \"model\": self.model,\n \"messages\": messages,\n \"temperature\": temperature,\n }\n \n if tools:\n kwargs[\"tools\"] = tools\n kwargs[\"tool_choice\"] = \"auto\"\n \n if response_format:\n kwargs[\"response_format\"] = response_format\n \n response = self.client.chat.completions.create(**kwargs)\n \n # 统计 Token 使用\n self._call_count += 1\n self._total_tokens += response.usage.total_tokens\n \n return response.choices[0].message\n \n @property\n def stats(self) -> dict:\n return {\n \"call_count\": self._call_count,\n \"total_tokens\": self._total_tokens,\n \"avg_tokens_per_call\": (\n self._total_tokens / self._call_count\n if self._call_count > 0 else 0\n )\n }", "section_ref": "4.3.1", "runnable": true, "dependencies": [] }, { "id": "code-10", "language": "python", "description": "工具赋予 Agent 与外部世界交互的能力。第6章将深入讨论，这里先了解基本概念。", "code": "from pydantic import BaseModel, Field\nfrom typing import Any\n\nclass ToolDefinition(BaseModel):\n \"\"\"工具定义的统一格式\"\"\"\n name: str = Field(description=\"工具名称，需唯一\")\n description: str = Field(description=\"工具功能的自然语言描述\")\n parameters: dict = Field(description=\"JSON Schema 格式的参数定义\")\n handler: Any = Field(exclude=True, description=\"实际的处理函数\")\n \n class Config:\n arbitrary_types_allowed = True\n\n# 示例：定义一个计算器工具\ncalculator_tool = ToolDefinition(\n name=\"calculator\",\n description=\"执行数学计算。支持加减乘除、幂运算等。\",\n parameters={\n \"type\": \"object\",\n \"properties\": {\n \"expression\": {\n \"type\": \"string\",\n \"description\": \"数学表达式，如 '2 + 3 * 4'\"\n }\n },\n \"required\": [\"expression\"]\n },\n handler=lambda expression: str(eval(expression)) # 仅演示，生产环境需安全处理\n)\n\n# 示例：定义一个文件读取工具\nimport os\n\ndef read_file_safe(filepath: str) -> str:\n \"\"\"安全地读取文件内容\"\"\"\n filepath = os.path.normpath(filepath)\n # 防止路径遍历攻击\n if not filepath.startswith(\"/allowed/path/\"):\n return \"错误：不允许访问该路径\"\n try:\n with open(filepath, \"r\", encoding=\"utf-8\") as f:\n return f.read()[:10000] # 限制长度\n except FileNotFoundError:\n return \"错误：文件不存在\"\n\nfile_reader_tool = ToolDefinition(\n name=\"read_file\",\n description=\"读取指定路径的文本文件内容\",\n parameters={\n \"type\": \"object\",\n \"properties\": {\n \"filepath\": {\n \"type\": \"string\",\n \"description\": \"文件的绝对路径\"\n }\n },\n \"required\": [\"filepath\"]\n },\n handler=read_file_safe\n)", "section_ref": "4.3.2", "runnable": true, "dependencies": [ "pydantic" ] }, { "id": "code-11", "language": "python", "description": "核心类型：", "code": "from dataclasses import dataclass, field\nfrom datetime import datetime\nfrom typing import Any\n\n@dataclass\nclass MemoryEntry:\n \"\"\"记忆条目\"\"\"\n content: str\n timestamp: datetime = field(default_factory=datetime.now)\n metadata: dict = field(default_factory=dict)\n importance: float = 0.5 # 0-1, 用于记忆排序\n embedding: list[float] | None = None # 用于语义检索\n\nclass MemorySystem:\n \"\"\"Agent 记忆系统\"\"\"\n \n def __init__(self):\n self.short_term: list[MemoryEntry] = [] # 短期记忆（对话上下文）\n self.long_term: list[MemoryEntry] = [] # 长期记忆（持久化）\n self.max_short_term = 20\n \n def add(self, entry: MemoryEntry, memory_type: str = \"short\"):\n \"\"\"添加记忆\"\"\"\n if memory_type == \"short\":\n self.short_term.append(entry)\n # 短期记忆满时，重要的转移到长期记忆\n if len(self.short_term) > self.max_short_term:\n self._evict()\n else:\n self.long_term.append(entry)\n \n def _evict(self):\n \"\"\"短期记忆淘汰策略\"\"\"\n # 按重要性排序，保留最重要的\n self.short_term.sort(key=lambda x: x.importance, reverse=True)\n evicted = self.short_term[self.max_short_term:]\n self.short_term = self.short_term[:self.max_short_term]\n # 高重要性的淘汰记忆转移到长期记忆\n for entry in evicted:\n if entry.importance > 0.7:\n self.long_term.append(entry)\n \n def recall(self, query: str, top_k: int = 5) -> list[MemoryEntry]:\n \"\"\"检索相关记忆\"\"\"\n # 简单实现：先从短期记忆中查找\n # 生产环境应使用向量检索（详见第7章）\n all_memories = self.short_term + self.long_term\n # TODO: 实现 embedding 相似度检索\n return all_memories[:top_k]", "section_ref": "4.3.3", "runnable": true, "dependencies": [] }, { "id": "code-12", "language": "python", "description": "规划器负责将复杂任务分解为可执行的子任务序列：", "code": "class TaskDecomposer:\n \"\"\"任务分解器\"\"\"\n \n def __init__(self, llm):\n self.llm = llm\n \n def decompose(self, task: str) -> list[dict]:\n \"\"\"将复杂任务分解为子任务\"\"\"\n prompt = f\"\"\"请将以下任务分解为具体的、可执行的子任务。\n \n 要求：\n 1. 每个子任务应该独立、可验证\n 2. 标注子任务之间的依赖关系\n 3. 标注每个子任务需要的工具或能力\n \n 任务：{task}\n \n 请用 JSON 格式返回：\n {{\n \"subtasks\": [\n {{\n \"id\": 1,\n \"description\": \"...\",\n \"depends_on\": [],\n \"tool\": \"...\",\n \"success_criteria\": \"...\"\n }}\n ]\n }}\"\"\"\n \n response = self.llm.chat(\n messages=[{\"role\": \"user\", \"content\": prompt}],\n temperature=0.1\n )\n \n result = json.loads(response.content)\n return result[\"subtasks\"]", "section_ref": "4.3.4", "runnable": true, "dependencies": [] }, { "id": "code-13", "language": "text", "description": "一个 Agent 从创建到完成任务，会经历以下生命周期阶段：", "code": "┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐\n│ 初始化 │───▶│ 接收任务 │───▶│ 执行循环 │───▶│ 输出结果 │───▶│ 清理资源 │\n│ (Init) │ │ (Receive)│ │ (Execute)│ │ (Output) │ │ (Cleanup)│\n└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘\n │ │\n │ │\n ▼ ▼\n 配置LLM、工具 Thought → Action → \n 记忆系统、规划器 Observation 循环", "section_ref": "4.4", "runnable": false, "dependencies": [] }, { "id": "code-14", "language": "python", "description": "", "code": "import asyncio\nfrom typing import AsyncIterator\nfrom dataclasses import dataclass, field\n\n@dataclass\nclass AgentConfig:\n \"\"\"Agent 配置\"\"\"\n name: str = \"Agent\"\n model: str = \"gpt-4o\"\n temperature: float = 0.1\n max_iterations: int = 15\n max_tokens_per_step: int = 4096\n verbose: bool = True\n\n\nclass Agent:\n \"\"\"完整的 Agent 实现\"\"\"\n \n def __init__(self, config: AgentConfig):\n self.config = config\n self.llm = AgentLLM(model=config.model)\n self.tools: dict[str, ToolDefinition] = {}\n self.memory = MemorySystem()\n self._running = False\n \n def register_tool(self, tool: ToolDefinition):\n \"\"\"注册工具\"\"\"\n self.tools[tool.name] = tool\n \n def register_tools(self, tools: list[ToolDefinition]):\n \"\"\"批量注册工具\"\"\"\n for tool in tools:\n self.register_tool(tool)\n \n async def run(self, task: str) -> str:\n \"\"\"执行任务（异步版本）\"\"\"\n self._running = True\n \n # 阶段1：初始化上下文\n system_prompt = self._build_system_prompt()\n messages = [\n {\"role\": \"system\", \"content\": system_prompt},\n {\"role\": \"user\", \"content\": task}\n ]\n \n # 阶段2：执行循环\n for i in range(self.config.max_iterations):\n if not self._running:\n break\n \n # 调用 LLM\n tool_defs = [\n {\n \"type\": \"function\",\n \"function\": {\n \"name\": t.name,\n \"description\": t.description,\n \"parameters\": t.parameters\n }\n }\n for t in self.tools.values()\n ]\n \n response = self.llm.chat(\n messages=messages,\n tools=tool_defs if tool_defs else None,\n temperature=self.config.temperature\n )\n \n # 如果没有工具调用，说明 Agent 认为任务完成了\n if not response.tool_calls:\n self._log(f\"[完成] {response.content}\")\n return response.content\n \n # 阶段3：处理工具调用\n messages.append(response.model_dump())\n \n for tool_call in response.tool_calls:\n func_name = tool_call.function.name\n func_args = json.loads(tool_call.function.arguments)\n \n self._log(f\"[工具调用] {func_name}({func_args})\")\n \n # 执行工具\n try:\n tool = self.tools[func_name]\n result = await self._execute_tool(tool, func_args)\n tool_result = str(result)\n except Exception as e:\n tool_result = f\"工具执行错误：{str(e)}\"\n \n self._log(f\"[工具结果] {tool_result[:200]}\")\n \n # 记录工具结果\n messages.append({\n \"role\": \"tool\",\n \"tool_call_id\": tool_call.id,\n \"content\": tool_result\n })\n \n # 存入记忆\n self.memory.add(MemoryEntry(\n content=f\"调用 {func_name} 得到：{tool_result[:500]}\",\n importance=0.5\n ))\n \n self._running = False\n return \"达到最大迭代次数。\"\n \n async def _execute_tool(self, tool: ToolDefinition, args: dict):\n \"\"\"执行工具（带超时保护）\"\"\"\n try:\n return await asyncio.wait_for(\n asyncio.to_tool(tool.handler, **args),\n timeout=30.0\n )\n except asyncio.TimeoutError:\n return \"工具执行超时（30秒）\"\n \n def _build_system_prompt(self) -> str:\n \"\"\"构建系统提示词\"\"\"\n tool_descriptions = \"\\n\".join(\n f\"- {t.name}: {t.description}\" for t in self.tools.values()\n )\n \n return f\"\"\"你是 {self.config.name}，一个 AI Agent。\n\n## 你的能力\n你可以使用以下工具：\n{tool_descriptions}\n\n## 工作方式\n1. 分析用户的请求\n2. 决定需要使用哪些工具\n3. 按逻辑顺序调用工具\n4. 综合工具的返回结果，给出最终回答\n\n## 注意事项\n- 每次只调用必要的工具\n- 如果工具返回错误，尝试其他方法\n- 在给出最终回答前，确保信息充分\n\"\"\"\n \n def _log(self, message: str):\n \"\"\"日志输出\"\"\"\n if self.config.verbose:\n print(message)\n \n def stop(self):\n \"\"\"停止 Agent 执行\"\"\"\n self._running = False", "section_ref": "4.4.1", "runnable": true, "dependencies": [] }, { "id": "code-15", "language": "python", "description": "在长期运行中，Agent 需要管理自己的状态：", "code": "from enum import Enum\n\nclass AgentState(Enum):\n \"\"\"Agent 状态枚举\"\"\"\n IDLE = \"idle\" # 空闲\n PLANNING = \"planning\" # 规划中\n EXECUTING = \"executing\" # 执行中\n WAITING = \"waiting\" # 等待外部输入\n REFLECTING = \"reflecting\" # 反思中\n FINISHED = \"finished\" # 已完成\n ERROR = \"error\" # 出错\n\n@dataclass\nclass AgentContext:\n \"\"\"Agent 运行上下文\"\"\"\n task: str\n state: AgentState = AgentState.IDLE\n current_step: int = 0\n total_steps: int = 0\n tool_call_history: list[dict] = field(default_factory=list)\n error_count: int = 0\n started_at: datetime | None = None\n finished_at: datetime | None = None\n \n @property\n def duration(self) -> float | None:\n if self.started_at and self.finished_at:\n return (self.finished_at - self.started_at).total_seconds()\n return None", "section_ref": "4.4.2", "runnable": true, "dependencies": [] }, { "id": "code-16", "language": "text", "description": "Agent 的核心是一个持续运转的循环，每个循环周期包含三个阶段：", "code": " ┌─────────────────────────────────┐\n │ │\n ▼ │\n ┌─────────┐ ┌─────────┐ ┌─────────┐\n │ 感知 │───▶│ 推理 │───▶│ 行动 │\n │Perceive │ │ Reason │ │ Act │\n └─────────┘ └─────────┘ └─────────┘\n │ │\n │ ┌───────────┐ │\n └──────│ 环境 │◀──────────┘\n │Environment│\n └───────────┘", "section_ref": "4.5.1", "runnable": false, "dependencies": [] }, { "id": "code-17", "language": "python", "description": "感知是 Agent 获取环境信息的过程：", "code": "class AgentPerception:\n \"\"\"Agent 感知模块\"\"\"\n \n def __init__(self):\n self._sensors: list[Callable] = []\n \n def add_sensor(self, sensor: Callable):\n \"\"\"添加感知器\"\"\"\n self._sensors.append(sensor)\n \n async def perceive(self) -> dict:\n \"\"\"收集所有感知信息\"\"\"\n observations = {}\n for sensor in self._sensors:\n try:\n result = await sensor()\n observations[sensor.__name__] = result\n except Exception as e:\n observations[sensor.__name__] = f\"感知错误：{e}\"\n return observations\n\n# 示例感知器\nasync def get_current_time() -> str:\n from datetime import datetime\n return datetime.now().isoformat()\n\nasync def check_file_exists(filepath: str) -> str:\n import os\n return f\"exists: {os.path.exists(filepath)}\"\n\nasync def get_system_info() -> str:\n import platform\n return f\"{platform.system()} {platform.release()}\"", "section_ref": "4.5.2", "runnable": true, "dependencies": [] }, { "id": "code-18", "language": "python", "description": "推理是 Agent 分析感知信息、做出决策的过程：", "code": "class AgentReasoner:\n \"\"\"Agent 推理模块\"\"\"\n \n def __init__(self, llm, memory):\n self.llm = llm\n self.memory = memory\n \n def reason(self, task: str, observations: dict) -> dict:\n \"\"\"\n 基于任务和观察进行推理\n 返回：{\n \"thought\": \"推理过程\",\n \"action\": \"要执行的行动\",\n \"action_args\": {...}\n }\n \"\"\"\n # 检索相关记忆\n relevant_memories = self.memory.recall(task)\n memory_context = \"\\n\".join(\n f\"- {m.content}\" for m in relevant_memories\n )\n \n prompt = f\"\"\"## 当前任务\n{task}\n\n## 环境观察\n{json.dumps(observations, ensure_ascii=False, indent=2)}\n\n## 相关经验\n{memory_context if memory_context else \"无相关经验\"}\n\n请分析当前情况，决定下一步行动。用 JSON 格式返回：\n{{\n \"thought\": \"你的思考过程\",\n \"action\": \"要调用的工具名称（如果没有合适的工具，填 'finish'）\",\n \"action_args\": {{}},\n \"confidence\": 0.0-1.0\n}}\"\"\"\n \n response = self.llm.chat(\n messages=[{\"role\": \"user\", \"content\": prompt}],\n temperature=0.1\n )\n \n return json.loads(response.content)", "section_ref": "4.5.3", "runnable": true, "dependencies": [] }, { "id": "code-19", "language": "python", "description": "行动是 Agent 改变环境的过程：", "code": "class AgentActor:\n \"\"\"Agent 行动模块\"\"\"\n \n def __init__(self, tools: dict[str, ToolDefinition]):\n self.tools = tools\n \n async def act(self, action: str, args: dict) -> dict:\n \"\"\"执行行动\"\"\"\n if action == \"finish\":\n return {\"status\": \"done\", \"result\": args.get(\"result\", \"\")}\n \n if action not in self.tools:\n return {\n \"status\": \"error\",\n \"error\": f\"未知工具：{action}，可用工具：{list(self.tools.keys())}\"\n }\n \n tool = self.tools[action]\n \n try:\n # 参数验证\n validated_args = self._validate_args(tool, args)\n \n # 执行\n result = await asyncio.to_tool(tool.handler, **validated_args)\n \n return {\n \"status\": \"success\",\n \"result\": result,\n \"tool_used\": action\n }\n except Exception as e:\n return {\n \"status\": \"error\",\n \"error\": str(e),\n \"tool_used\": action\n }\n \n def _validate_args(self, tool: ToolDefinition, args: dict) -> dict:\n \"\"\"验证工具参数\"\"\"\n from pydantic import validate_json\n schema = tool.parameters\n return validate_json(json.dumps(args), schema)", "section_ref": "4.5.4", "runnable": true, "dependencies": [] }, { "id": "code-20", "language": "python", "description": "如何评估一个 Agent 的好坏？以下是常用的评估维度。", "code": "class AgentEvaluator:\n \"\"\"Agent 评估器\"\"\"\n \n def __init__(self, llm):\n self.llm = llm\n \n def evaluate_completion(\n self,\n task: str,\n result: str,\n criteria: list[str] | None = None\n ) -> dict:\n \"\"\"评估任务完成度\"\"\"\n criteria_str = \"\\n\".join(\n f\"- {c}\" for c in (criteria or [\"正确性\", \"完整性\"])\n )\n \n prompt = f\"\"\"请评估以下 Agent 的任务完成情况。\n\n## 任务\n{task}\n\n## Agent 的输出\n{result}\n\n## 评估标准\n{criteria_str}\n\n请用 JSON 格式返回评分：\n{{\n \"score\": 0-10,\n \"correctness\": 0-10,\n \"completeness\": 0-10,\n \"efficiency\": 0-10,\n \"feedback\": \"具体的改进建议\"\n}}\"\"\"\n \n response = self.llm.chat(prompt, temperature=0.1)\n return json.loads(response.content)", "section_ref": "4.6.1", "runnable": true, "dependencies": [] }, { "id": "code-21", "language": "python", "description": "", "code": "@dataclass\nclass AgentMetrics:\n \"\"\"Agent 运行指标\"\"\"\n # 任务指标\n task_success: bool = False\n task_score: float = 0.0\n \n # 效率指标\n total_steps: int = 0\n tool_calls: int = 0\n successful_tool_calls: int = 0\n failed_tool_calls: int = 0\n \n # 资源消耗\n total_tokens: int = 0\n total_duration_seconds: float = 0.0\n llm_api_calls: int = 0\n \n # 质量指标\n hallucination_count: int = 0\n self_corrections: int = 0\n unnecessary_steps: int = 0\n \n @property\n def tool_success_rate(self) -> float:\n if self.tool_calls == 0:\n return 0.0\n return self.successful_tool_calls / self.tool_calls\n \n @property\n def tokens_per_step(self) -> float:\n if self.total_steps == 0:\n return 0.0\n return self.total_tokens / self.total_steps\n \n def summary(self) -> str:\n return f\"\"\"\n=== Agent 运行报告 ===\n任务状态: {'✅ 成功' if self.task_success else '❌ 失败'}\n任务评分: {self.task_score}/10\n\n执行步骤: {self.total_steps}\n工具调用: {self.tool_calls} (成功率: {self.tool_success_rate:.1%})\nToken消耗: {self.total_tokens:,} (平均: {self.tokens_per_step:.0f}/步)\n运行时间: {self.total_duration_seconds:.1f}s\n\n幻觉次数: {self.hallucination_count}\n自我修正: {self.self_corrections}\n冗余步骤: {self.unnecessary_steps}\n\"\"\"", "section_ref": "4.6.2", "runnable": true, "dependencies": [] }, { "id": "code-22", "language": "python", "description": "", "code": "class AgentBenchmark:\n \"\"\"Agent 基准测试\"\"\"\n \n def __init__(self, agent, evaluator):\n self.agent = agent\n self.evaluator = evaluator\n \n def run_benchmark(\n self,\n test_cases: list[dict]\n ) -> dict:\n \"\"\"\n 运行基准测试\n test_cases: [\n {\n \"task\": \"任务描述\",\n \"expected\": \"预期结果（可选）\",\n \"criteria\": [\"评估标准1\", \"评估标准2\"]\n }\n ]\n \"\"\"\n results = []\n \n for i, case in enumerate(test_cases):\n print(f\"\\n{'='*50}\")\n print(f\"测试用例 {i+1}/{len(test_cases)}\")\n print(f\"任务：{case['task']}\")\n print(f\"{'='*50}\")\n \n # 运行 Agent\n start = time.time()\n result = self.agent.run(case[\"task\"])\n duration = time.time() - start\n \n # 评估\n evaluation = self.evaluator.evaluate_completion(\n task=case[\"task\"],\n result=result,\n criteria=case.get(\"criteria\")\n )\n \n results.append({\n \"task\": case[\"task\"],\n \"result\": result,\n \"evaluation\": evaluation,\n \"duration\": duration\n })\n \n # 汇总统计\n avg_score = sum(r[\"evaluation\"][\"score\"] for r in results) / len(results)\n success_rate = sum(\n 1 for r in results if r[\"evaluation\"][\"score\"] >= 7\n ) / len(results)\n \n return {\n \"total_cases\": len(test_cases),\n \"average_score\": avg_score,\n \"success_rate\": success_rate,\n \"results\": results\n }", "section_ref": "4.6.3", "runnable": true, "dependencies": [] }, { "id": "code-23", "language": "python", "description": "- 设置检查点，在关键步骤验证中间结果", "code": "# ❌ 错误：描述太模糊\nToolDefinition(\n name=\"search\",\n description=\"搜索东西\" # 太模糊！\n)\n\n# ✅ 正确：描述清晰具体\nToolDefinition(\n name=\"search_web\",\n description=\"在互联网上搜索最新信息。\"\n \"返回搜索结果的标题、URL和摘要。\"\n \"适合查找实时信息、新闻、技术文档。\"\n \"不适合数学计算或代码执行。\"\n)", "section_ref": "4.7.1", "runnable": true, "dependencies": [] }, { "id": "code-24", "language": "python", "description": "解决方案：", "code": "# 在 Agent 循环中加入防护\nclass LoopDetector:\n \"\"\"循环检测器\"\"\"\n \n def __init__(self, max_retries: int = 3, lookback: int = 5):\n self.max_retries = max_retries\n self.lookback = lookback\n self._action_history: list[str] = []\n \n def check(self, action: str, args: dict) -> bool:\n \"\"\"检查是否陷入循环，返回 True 表示检测到循环\"\"\"\n action_sig = f\"{action}:{json.dumps(args, sort_keys=True)}\"\n self._action_history.append(action_sig)\n \n # 检查最近 N 步是否有重复\n recent = self._action_history[-self.lookback:]\n if len(recent) >= self.max_retries:\n # 如果同一动作重复超过阈值\n if len(set(recent)) == 1:\n return True\n \n # 如果出现循环模式（如 A→B→A→B）\n for pattern_len in range(1, len(recent)//2 + 1):\n pattern = recent[:pattern_len]\n repetitions = len(recent) // pattern_len\n if recent[:pattern_len * repetitions] == pattern * repetitions:\n return True\n \n return False", "section_ref": "4.7.1", "runnable": true, "dependencies": [] }, { "id": "code-25", "language": "python", "description": "解决方案：", "code": "class TokenBudget:\n \"\"\"Token 预算管理器\"\"\"\n \n def __init__(self, max_tokens: int, warning_threshold: float = 0.8):\n self.max_tokens = max_tokens\n self.warning_threshold = warning_threshold\n self.used_tokens = 0\n \n def consume(self, tokens: int) -> bool:\n \"\"\"消耗 Token，返回是否还有预算\"\"\"\n self.used_tokens += tokens\n \n if self.used_tokens >= self.max_tokens:\n return False # 预算耗尽\n \n if self.used_tokens >= self.max_tokens * self.warning_threshold:\n print(f\"⚠️ Token 预算警告：已使用 {self.used_tokens}/{self.max_tokens}\")\n \n return True\n \n @property\n def remaining(self) -> int:\n return self.max_tokens - self.used_tokens", "section_ref": "4.7.1", "runnable": true, "dependencies": [] }, { "id": "code-26", "language": "text", "description": "不要一开始就构建最复杂的 Agent。从简单开始，逐步增加能力。", "code": "Level 1: 纯对话 → 验证 Prompt 效果\nLevel 2: 单工具 → 验证 Function Calling\nLevel 3: 多工具 → 验证工具选择逻辑\nLevel 4: 记忆系统 → 验证上下文管理\nLevel 5: 规划能力 → 验证复杂任务处理", "section_ref": "4.7.2", "runnable": false, "dependencies": [] }, { "id": "code-27", "language": "python", "description": "Agent 的决策过程应该是可观测的：", "code": "import logging\nfrom contextlib import asynccontextmanager\n\nlogger = logging.getLogger(\"agent\")\n\n@asynccontextmanager\nasync def trace_step(step_name: str, **metadata):\n \"\"\"追踪 Agent 步骤\"\"\"\n logger.info(f\"[开始] {step_name}\", extra=metadata)\n start = time.time()\n \n try:\n yield\n duration = time.time() - start\n logger.info(\n f\"[完成] {step_name} ({duration:.2f}s)\",\n extra={**metadata, \"duration\": duration, \"status\": \"success\"}\n )\n except Exception as e:\n duration = time.time() - start\n logger.error(\n f\"[失败] {step_name} ({duration:.2f}s): {e}\",\n extra={**metadata, \"duration\": duration, \"status\": \"error\", \"error\": str(e)}\n )\n raise", "section_ref": "4.7.2", "runnable": true, "dependencies": [ "contextlib" ] }, { "id": "code-28", "language": "python", "description": "当工具不可用时，Agent 应该有备选方案：", "code": "class ResilientAgent(Agent):\n \"\"\"具备降级能力的 Agent\"\"\"\n \n async def _execute_tool(self, tool: ToolDefinition, args: dict):\n \"\"\"带降级的工具执行\"\"\"\n try:\n return await super()._execute_tool(tool, args)\n except asyncio.TimeoutError:\n # 降级策略：使用 LLM 的内置知识\n self._log(f\"⚠️ 工具 {tool.name} 超时，使用降级策略\")\n return await self._fallback(tool.name, args)\n except ConnectionError:\n self._log(f\"⚠️ 工具 {tool.name} 连接失败，使用降级策略\")\n return await self._fallback(tool.name, args)\n \n async def _fallback(self, tool_name: str, args: dict) -> str:\n \"\"\"降级处理\"\"\"\n fallback_prompt = f\"\"\"工具 {tool_name} 不可用。\n 原始参数：{json.dumps(args)}\n 请基于你的知识给出最佳估计。\"\"\"\n \n response = self.llm.chat(\n messages=[{\"role\": \"user\", \"content\": fallback_prompt}],\n temperature=0.3\n )\n return f\"[降级结果] {response.content}\"", "section_ref": "4.7.2", "runnable": true, "dependencies": [] } ], "tables": [ { "headers": [ "特性", "Chatbot", "Agent" ], "data": [ [ "交互方式", "单轮/多轮对话", "持续的感知-推理-行动循环" ], [ "能力边界", "限于文本生成", "可以调用外部工具、操作 API" ], [ "自主性", "被动响应", "主动规划和执行" ], [ "状态管理", "无状态或简单对话历史", "维护长期记忆和世界模型" ], [ "目标导向", "回答问题", "完成任务" ] ] }, { "headers": [ "维度", "ReAct", "Plan-and-Execute", "Reflexion" ], "data": [ [ "**决策方式**", "边想边做", "先想后做", "做完再想" ], [ "**适合任务**", "中等复杂度", "高复杂度、多步骤", "需要高质量输出的任务" ], [ "**推理透明度**", "高（每步可见）", "高（计划可见）", "极高（含反思）" ], [ "**执行效率**", "中等", "高（可并行）", "低（多轮尝试）" ], [ "**Token 消耗**", "中等", "较高（规划阶段）", "高（反思消耗）" ], [ "**实现复杂度**", "低", "中", "中高" ] ] }, { "headers": [ "参数", "推荐值", "原因" ], "data": [ [ "`temperature`", "0.0 - 0.3", "低随机性确保稳定决策" ], [ "`top_p`", "0.9 - 1.0", "与低 temperature 配合" ], [ "`max_tokens`", "4096+", "确保有足够空间生成完整响应" ], [ "`response_format`", "按需", "结构化输出时可指定 JSON" ] ] } ], "key_takeaways": [], "common_pitfalls": [], "related_chapters": [ "ch01", "ch03", "ch05", "ch06", "ch07", "ch08", "ch09", "ch10", "ch11", "ch12", "ch14", "ch15", "ch24", "ch31", "ch41", "ch43", "ch45", "ch46", "ch48" ] }