{ "metadata": { "id": "ch02", "title": "第2章：Agent技术演进史", "volume": "vol1", "volume_title": "认知篇", "word_count": 5290, "difficulty": "beginner", "prerequisites": [ "ch01" ], "key_concepts": [ "引言：从\"计算\"到\"行动\"的范式转变", "ELIZA：对话式Agent的起点", "SHRDLU：自然语言理解的里程碑", "Terry Winograd的贡献与局限", "专家系统：知识即力量", "规划系统：STRIPS与行动序列", "符号主义的局限", "DeepMind的革命：从Atari到AlphaGo", "OpenAI Five：团队协作的极致", "强化学习Agent的局限", "从GPT到Agent：范式的质变", "WebGPT：让LLM上网", "AutoGPT：自主Agent的引爆点", "BabyAGI：任务驱动的Agent架构", "关键里程碑总结" ], "learning_objectives": [], "estimated_tokens": 3174, "source_file": "vol1/ch02_Agent技术演进史.md" }, "overview": "", "sections": [ { "id": "2.1", "title": "2.1 引言：从\"计算\"到\"行动\"的范式转变", "level": 2, "content": "计算机科学的发展史，在某种意义上就是一部从\"被动计算\"到\"主动行动\"的演进史。早期的计算机是纯粹的数学工具，接受指令、执行计算、返回结果。而 Agent 技术的核心愿景，则是让计算机从\"工具\"进化为\"行动者\"——能够感知环境、做出决策、采取行动，并在与世界的交互中不断学习和进化。\n\nAgent（智能体）这个概念源于哲学和认知科学。在亚里士多德的伦理学中，一个\"agent\"是有意图和行动能力的实体。当这个概念被引入计算机科学后，它就成为了人工智能研究中最具吸引力的目标之一：创造一个能够自主行动的软件实体。\n\n本章将沿着时间的脉络，回顾 Agent 技术从20世纪60年代至今的演进历程，梳理每一个关键转折点，理解技术演进的内在逻辑，并为读者建立对 Agent 技术的宏观认知。\n\n---", "subsections": [] }, { "id": "2.2", "title": "2.2 早期AI Agent（1960s-1970s）：对话与理解的萌芽", "level": 2, "content": "", "subsections": [ { "id": "2.2.1", "title": "2.2.1 ELIZA：对话式Agent的起点", "content": "1966年，MIT的Joseph Weizenbaum开发了ELIZA——世界上第一个对话式计算机程序。ELIZA模拟了一个罗杰斯学派的心理治疗师，通过模式匹配和简单的规则来生成回应。\n\n\nELIZA的意义不在于它的技术深度（实际上非常简单），而在于它提出了一个深刻的问题：**一个看似理解人类语言的程序，是否真的需要\"理解\"语言？** 这个问题至今仍是AI Agent研究的核心议题之一。" }, { "id": "2.2.2", "title": "2.2.2 SHRDLU：自然语言理解的里程碑", "content": "1971年，Terry Winograd在MIT开发了SHRDLU，这是AI历史上一个真正的里程碑。SHRDLU能够理解自然语言指令，并在一个虚拟的\"积木世界\"中执行操作。\n\nSHRDLU的核心创新在于它将自然语言理解与物理世界模型结合了起来：\n\n- **世界模型**：维护一个积木世界的内部表示\n- **语法分析**：将自然语言解析为结构化指令\n- **推理能力**：基于世界模型进行逻辑推理\n- **执行能力**：通过操作世界模型来执行指令" }, { "id": "2.2.3", "title": "2.2.3 Terry Winograd的贡献与局限", "content": "Terry Winograd的工作代表了早期AI Agent研究的最高水平。他的博士论文《 Procedures as a Representation for Knowledge in Comprehending Conversational Language 》是AI领域最具影响力的论文之一。\n\n然而，Winograd自己也认识到了这些系统的根本局限性：它们只能处理高度受限的\"微世界\"（microworld），一旦面对现实世界的复杂性，就显得无能为力。这种认识直接导致了AI领域的第一次\"寒冬\"。\n\n---" } ] }, { "id": "2.3", "title": "2.3 符号主义Agent时期（1980s-1990s）：知识与规则的黄金年代", "level": 2, "content": "", "subsections": [ { "id": "2.3.1", "title": "2.3.1 专家系统：知识即力量", "content": "20世纪80年代，AI研究找到了一个商业上可行的方向——专家系统（Expert System）。专家系统的核心思想是：将人类专家的知识编码为规则，让计算机模拟专家的决策过程。\n\n最著名的专家系统之一是MYCIN（1970年代中期开发），用于诊断细菌感染并推荐抗生素治疗方案。虽然MYCIN的诊断准确率甚至超过了某些人类医生，但它从未真正投入临床使用——因为AI系统无法承担医疗决策的法律责任。" }, { "id": "2.3.2", "title": "2.3.2 规划系统：STRIPS与行动序列", "content": "在符号主义时期，另一个重要方向是AI规划（AI Planning）。1971年，Richard Fikes和Nils Nilsson在SRI International开发了STRIPS（Stanford Research Institute Problem Solver），它定义了一种用操作符（operator）来表示行动的方式，每个操作符包含：\n\n- **前置条件（preconditions）**：执行前必须满足的条件\n- **添加效果（add effects）**：执行后新增的事实\n- **删除效果（delete effects）**：执行后移除的事实" }, { "id": "2.3.3", "title": "2.3.3 符号主义的局限", "content": "符号主义Agent虽然在特定领域取得了成功，但面临着根本性的挑战：\n\n1. **知识获取瓶颈**：手工编码专家知识极其耗时，且领域专家的知识往往是隐性的\n2. **脆弱性**：一旦遇到规则库之外的输入，系统就会崩溃\n3. **缺乏学习能力**：符号系统本质上是静态的，无法从经验中学习\n4. **组合爆炸**：随着规则和状态空间的增大，推理的计算复杂度急剧上升\n\n这些局限最终导致了符号主义的衰落，但它的核心思想——将知识显式表示、将推理形式化——至今仍是Agent系统设计的重要参考。\n\n---" } ] }, { "id": "2.4", "title": "2.4 强化学习Agent的兴起（2010s-2020s）：从感知到决策", "level": 2, "content": "", "subsections": [ { "id": "2.4.1", "title": "2.4.1 DeepMind的革命：从Atari到AlphaGo", "content": "2013年，DeepMind发表了Deep Q-Network（DQN）论文，展示了深度神经网络可以学会直接从原始像素输入来玩Atari游戏。这标志着深度强化学习（Deep RL）时代的开始。\n\n2016年，AlphaGo击败围棋世界冠军李世石，震撼了整个世界。AlphaGo的成功证明了AI Agent可以在复杂、高维度的环境中做出超越人类的决策。" }, { "id": "2.4.2", "title": "2.4.2 OpenAI Five：团队协作的极致", "content": "2019年，OpenAI的Five系统在Dota 2中击败了世界冠军OG战队（虽然后来正式比赛中失利）。OpenAI Five展示了多个强化学习Agent如何在一个极其复杂的环境中实现高水平的团队协作。\n\nOpenAI Five的关键创新：\n\n- **自我对弈（Self-Play）**：通过Agent之间的对抗来不断学习\n- **长视野规划**：游戏中的决策需要考虑数分钟后的后果\n- **隐式通信**：五个Agent通过共享的奖励信号学习协作策略\n- **大规模并行训练**：使用了数千个GPU进行并行模拟" }, { "id": "2.4.3", "title": "2.4.3 强化学习Agent的局限", "content": "尽管取得了令人瞩目的成就，强化学习Agent也面临着挑战：\n\n1. **样本效率低**：AlphaGo需要数千万局对弈，而人类只需要数万局\n2. **模拟到现实（Sim2Real）的鸿沟**：在模拟器中学到的策略难以直接迁移到现实世界\n3. **奖励函数设计困难**：如何定义一个好的奖励函数本身就是一个大问题\n4. **缺乏常识和语言理解**：RL Agent无法理解自然语言指令\n\n这些局限性为下一阶段——大语言模型Agent的出现——埋下了伏笔。\n\n---" } ] }, { "id": "2.5", "title": "2.5 大语言模型时代的Agent革命（2020s-至今）：语言即行动", "level": 2, "content": "", "subsections": [ { "id": "2.5.1", "title": "2.5.1 从GPT到Agent：范式的质变", "content": "2022年底，ChatGPT的发布引爆了全球对AI的热情。但真正让研究者们兴奋的是2023年初出现的一系列LLM-based Agent项目。这些项目展示了一个令人震惊的可能性：**大语言模型可以不仅仅是对话工具，它可以是自主行动的Agent。**\n\n这个质变的核心逻辑是：\n\n1. **语言即世界模型**：LLM在训练过程中已经内化了大量关于世界运行规律的知识\n2. **思维链（Chain of Thought）**：LLM可以展示其推理过程，使决策过程可解释\n3. **工具使用（Tool Use）**：LLM可以通过API调用外部工具，突破其自身能力的边界\n4. **记忆系统**：结合外部存储，LLM Agent可以维持长期记忆" }, { "id": "2.5.2", "title": "2.5.2 WebGPT：让LLM上网", "content": "2021年12月，OpenAI发表了WebGPT，展示了如何让GPT-3模型浏览网页来回答问题。WebGPT的关键在于：\n\n- 将网页浏览任务形式化为一个决策过程\n- LLM自主决定何时搜索、点击哪些链接、何时给出最终答案\n- 使用人类反馈的强化学习（RLHF）来提升浏览效率\n\n虽然WebGPT在当时并未引起广泛关注，但它在技术上奠定了LLM Agent的基础。" }, { "id": "2.5.3", "title": "2.5.3 AutoGPT：自主Agent的引爆点", "content": "2023年3月，Significant Gravitas发布的AutoGPT项目在GitHub上迅速获得了超过10万星标，成为了AI Agent概念的\"引爆点\"。\n\nAutoGPT的核心理念是\"给LLM一个目标，让它自主完成\"：" }, { "id": "2.5.4", "title": "2.5.4 BabyAGI：任务驱动的Agent架构", "content": "2023年4月，Yohei Nakajima发布的BabyAGI展示了另一种Agent设计理念：**基于任务列表的自主管理**。\n\nBabyAGI的核心循环极其优雅：" }, { "id": "2.5.5", "title": "2.5.5 关键里程碑总结", "content": "以下是LLM Agent发展中的关键里程碑：\n\n| 时间 | 项目/事件 | 意义 |\n|------|-----------|------|\n| 2021.12 | WebGPT | 首个展示LLM自主浏览网页能力 |\n| 2022.12 | ChatGPT | LLM能力质变，Agent基础奠定 |\n| 2023.03 | AutoGPT | 自主Agent概念引爆全球 |\n| 2023.03 | GPT-4 Plugins | 官方工具使用能力 |\n| 2023.04 | BabyAGI | 任务驱动Agent架构 |\n| 2023.06 | AutoGen (Microsoft) | 多Agent对话框架 |\n| 2023.09 | CrewAI | 角色扮演式多Agent框架 |\n| 2023.10 | LangGraph | 有状态的Agent工作流 |\n| 2024.01 | OpenAI Assistants API | 官方Agent API |\n| 2024.03 | Claude 3 + MCP | 工具协议标准化 |\n| 2024.06 | DevIn (字节) | 端到端软件Agent |\n| 2024.12 | 多个Agent框架成熟 | 生产级Agent系统涌现 |\n\n---" } ] }, { "id": "2.6", "title": "2.6 演进脉络的深层逻辑", "level": 2, "content": "回顾Agent技术的演进历程，我们可以发现几条清晰的脉络：", "subsections": [ { "id": "2.6.1", "title": "2.6.1 从\"微世界\"到\"开放世界\"", "content": "早期的Agent（如SHRDLU）只能在高度受限的微世界中运作，而现代Agent已经能够在开放的互联网环境中导航。这个转变的关键是**世界知识的内化**——LLM在预训练过程中已经学习了关于世界的海量知识。" }, { "id": "2.6.2", "title": "2.6.2 从\"手工规则\"到\"学习驱动\"", "content": "符号主义Agent依赖人工编码的规则，强化学习Agent通过试错学习策略，而LLM Agent则通过大规模预训练自动习得通用的推理和行动能力。这个趋势的终点可能是**完全自主的学习Agent**。" }, { "id": "2.6.3", "title": "2.6.3 从\"单一目标\"到\"开放目标\"", "content": "从Atari游戏中的固定目标，到AutoGPT的开放式目标，Agent面对的任务越来越模糊、越来越接近人类实际面对的复杂目标。这要求Agent具备更强的规划和分解能力。" }, { "id": "2.6.4", "title": "2.6.4 从\"孤立个体\"到\"社会协作\"", "content": "从单Agent系统到多Agent协作（如AutoGen、CrewAI），Agent正在学会像人类一样进行团队协作、角色分工和知识共享。这可能是通向真正AGI的必经之路。\n\n---" } ] }, { "id": "2.7", "title": "2.7 展望：Agent技术的下一个十年", "level": 2, "content": "站在2026年的时间节点上，Agent技术正处在一个激动人心的时刻。我们可以预见几个重要方向：\n\n1. **多模态Agent**：不仅能处理文本，还能理解图像、音频、视频，并在物理世界中行动（机器人Agent）\n2. **持久化Agent**：具有长期记忆和持续学习能力，不再是\"每次对话从零开始\"\n3. **自进化Agent**：能够自主改进自己的代码、策略和工具使用方式\n4. **Agent即服务（AaaS）**：Agent成为新的软件交付形态，用户描述需求，Agent自动构建解决方案\n5. **可信Agent**：具备可解释性、可控性和安全性的Agent系统\n\nAgent技术的演进历程告诉我们：**从被动工具到主动行动者，这条路已经走了六十年，而最好的部分才刚刚开始。**\n\n---", "subsections": [] }, { "id": "2.8", "title": "2.8 本章小结", "level": 2, "content": "本章回顾了Agent技术从1960年代到2026年的演进历程：\n\n- **萌芽期（1960s-1970s）**：ELIZA和SHRDLU展示了对话理解和世界交互的雏形\n- **符号主义时期（1980s-1990s）**：专家系统和规划系统将知识工程推向顶峰\n- **强化学习时期（2010s-2020s）**：AlphaGo等系统展示了通过学习获得超人决策能力的可能\n- **LLM Agent时期（2020s-至今）**：大语言模型赋予了Agent前所未有的通用语言理解和推理能力\n\n每一次范式的转变，都不是简单的技术迭代，而是对\"什么是Agent\"这个根本问题的重新回答。理解这个演进历程，是我们构建下一代Agent系统的基础。\n\n在下一章中，我们将深入探讨现代Agent的编程范式——如何用代码来定义、构建和控制Agent系统。", "subsections": [] } ], "code_blocks": [ { "id": "code-1", "language": "python", "description": "1966年，MIT的Joseph Weizenbaum开发了ELIZA——世界上第一个对话式计算机程序。ELIZA模拟了一个罗杰斯学派的心理治疗师，通过模式匹配和简单的规则来生成回应。", "code": "# ELIZA 的简化实现：模式匹配式对话\nimport re\n\nclass ELIZA:\n \"\"\"最早的对话式Agent——ELIZA的简化实现\"\"\"\n\n def __init__(self):\n self.name = \"ELIZA\"\n self.patterns = {\n r\"(.*)我是(.*)\": [\n \"你好，{1}。告诉我更多关于你自己的事。\",\n \"你觉得{1}怎么样？\",\n \"为什么你是{1}？\"\n ],\n r\"(.*)我觉得(.*)\": [\n \"你确定你觉得{1}吗？\",\n \"你为什么觉得{1}？\",\n \"你觉得{1}已经多久了？\"\n ],\n r\"(.*)(母亲|爸爸|家人)(.*)\": [\n \"告诉我更多关于你家庭的事。\",\n \"你的家庭对你的影响很大吗？\",\n \"家庭关系往往反映了我们内心的状态。\"\n ],\n r\"(.*)\": [\n \"请继续。\",\n \"多告诉我一些。\",\n \"很有趣，请继续说。\",\n \"我理解。\"\n ]\n }\n\n def respond(self, user_input):\n \"\"\"基于模式匹配生成回应\"\"\"\n for pattern, responses in self.patterns.items():\n match = re.match(pattern, user_input, re.IGNORECASE)\n if match:\n response = responses[len(user_input) % len(responses)]\n return response.format(*match.groups())\n return \"请继续说。\"\n\n# 运行示例\neliza = ELIZA()\nprint(eliza.respond(\"我觉得很难过\"))\n# 输出: \"你确定你觉得很难过吗？\"\nprint(eliza.respond(\"我的母亲不理解我\"))\n# 输出: \"告诉我更多关于你家庭的事。\"", "section_ref": "2.2.1", "runnable": true, "dependencies": [] }, { "id": "code-2", "language": "python", "description": "- 执行能力：通过操作世界模型来执行指令", "code": "# SHRDLU 的概念性实现：积木世界Agent\nfrom dataclasses import dataclass, field\nfrom typing import Optional\nfrom enum import Enum\n\nclass Color(Enum):\n RED = \"红色\"\n BLUE = \"蓝色\"\n GREEN = \"绿色\"\n YELLOW = \"黄色\"\n\n@dataclass\nclass Block:\n \"\"\"积木世界中的积木\"\"\"\n name: str\n color: Color\n x: int = 0\n y: int = 0\n z: int = 0 # 堆叠高度\n on_top_of: Optional[str] = None\n\nclass BlockWorld:\n \"\"\"SHRDLU的积木世界\"\"\"\n\n def __init__(self):\n self.blocks: dict[str, Block] = {}\n self._init_world()\n\n def _init_world(self):\n \"\"\"初始化积木世界\"\"\"\n a = Block(\"A\", Color.RED, x=0, y=0, z=1)\n b = Block(\"B\", Color.BLUE, x=0, y=0, z=2, on_top_of=\"A\")\n c = Block(\"C\", Color.GREEN, x=1, y=0, z=1)\n self.blocks = {\"A\": a, \"B\": b, \"C\": c}\n\n def pick_up(self, block_name: str) -> str:\n \"\"\"拿起一个积木\"\"\"\n block = self.blocks.get(block_name)\n if not block:\n return f\"我不知道{block_name}是什么。\"\n if block.on_top_of is None:\n return f\"{block_name}已经在桌面上，可以直接拿起。\"\n\n # 检查上面是否有积木\n for other in self.blocks.values():\n if other.on_top_of == block_name:\n return f\"无法拿起{block_name}，因为{other.name}在它上面。\"\n\n self.blocks[block.on_top_of].on_top_of = None # 这行逻辑有问题，但展示概念\n return f\"已经拿起了{block_name}。\"\n\n def put_on(self, block_name: str, target_name: str) -> str:\n \"\"\"将一个积木放到另一个上面\"\"\"\n if block_name not in self.blocks or target_name not in self.blocks:\n return \"我不认识这个积木。\"\n self.blocks[block_name].on_top_of = target_name\n return f\"已经把{block_name}放到了{target_name}上面。\"\n\n def describe(self) -> str:\n \"\"\"描述当前世界状态\"\"\"\n lines = []\n for name, block in self.blocks.items():\n loc = f\"在{block.on_top_of}上面\" if block.on_top_of else \"在桌面上\"\n lines.append(f\"{name}（{block.color.value}积木）{loc}\")\n return \"\\n\".join(lines)\n\n# 模拟 SHRDLU 的自然语言交互\nworld = BlockWorld()\nprint(\"=== 积木世界 ===\")\nprint(world.describe())\nprint(\"\\n用户: 把B放到C上面\")\nprint(f\"SHRDLU: {world.put_on('B', 'C')}\")", "section_ref": "2.2.2", "runnable": true, "dependencies": [] }, { "id": "code-3", "language": "python", "description": "最著名的专家系统之一是MYCIN（1970年代中期开发），用于诊断细菌感染并推荐抗生素治疗方案。虽然MYCIN的诊断准确率甚至超过了某些人类医生，但它从未真正投入临床使用——因为AI系统无法承担医疗决", "code": "# 专家系统的简化实现：故障诊断Agent\nfrom dataclasses import dataclass\nfrom typing import Optional\n\n@dataclass\nclass Rule:\n \"\"\"产生式规则\"\"\"\n condition: str # 条件描述\n conclusion: str # 结论\n confidence: float # 置信度 (0-1)\n\nclass ExpertSystemAgent:\n \"\"\"基于规则的产生式系统Agent\"\"\"\n\n def __init__(self, name: str):\n self.name = name\n self.rules: list[Rule] = []\n self.facts: set[str] = set()\n self.inferred: list[tuple[str, float]] = []\n\n def add_rule(self, condition: str, conclusion: str, confidence: float = 1.0):\n \"\"\"添加规则\"\"\"\n self.rules.append(Rule(condition, conclusion, confidence))\n\n def add_fact(self, fact: str):\n \"\"\"添加已知事实\"\"\"\n self.facts.add(fact)\n\n def reason(self, max_iterations: int = 10) -> list[tuple[str, float]]:\n \"\"\"前向链推理\"\"\"\n for _ in range(max_iterations):\n new_inferences = False\n for rule in self.rules:\n # 简单匹配：规则条件中的关键词都在已知事实中\n keywords = set(rule.condition.split())\n if keywords.issubset(self.facts):\n if rule.conclusion not in self.facts:\n self.facts.add(rule.conclusion)\n self.inferred.append((rule.conclusion, rule.confidence))\n new_inferences = True\n if not new_inferences:\n break\n return self.inferred\n\n# 使用示例：汽车故障诊断Agent\ndiagnostician = ExpertSystemAgent(\"汽车故障诊断专家\")\n\n# 添加规则\ndiagnostician.add_rule(\"发动机 嘎吱异响 冷启动\", \"正时皮带磨损\", 0.85)\ndiagnostician.add_rule(\"正时皮带磨损\", \"需要更换正时皮带\", 0.95)\ndiagnostician.add_rule(\"发动机抖动 怠速不稳\", \"火花塞故障\", 0.75)\ndiagnostician.add_rule(\"火花塞故障 里程超过5万公里\", \"需要更换火花塞\", 0.90)\ndiagnostician.add_rule(\"冷却液温度过高 散热风扇不转\", \"散热风扇故障\", 0.88)\n\n# 添加已知事实\ndiagnostician.add_fact(\"发动机\")\ndiagnostician.add_fact(\"嘎吱异响\")\ndiagnostician.add_fact(\"冷启动\")\n\n# 推理\nresults = diagnostician.reason()\nprint(f\"=== {diagnostician.name} 推理结果 ===\")\nfor conclusion, confidence in results:\n print(f\" → {conclusion} (置信度: {confidence:.0%})\")", "section_ref": "2.3.1", "runnable": true, "dependencies": [] }, { "id": "code-4", "language": "python", "description": "- 删除效果（delete effects）：执行后移除的事实", "code": "# STRIPS 规划器的简化实现\nfrom dataclasses import dataclass\nfrom typing import Optional\nfrom copy import deepcopy\n\n@dataclass\nclass StripsAction:\n \"\"\"STRIPS操作符\"\"\"\n name: str\n preconditions: set[str]\n add_effects: set[str]\n delete_effects: set[str]\n\n def is_applicable(self, state: set[str]) -> bool:\n \"\"\"检查是否可以执行\"\"\"\n return self.preconditions.issubset(state)\n\n def apply(self, state: set[str]) -> set[str]:\n \"\"\"执行操作，返回新状态\"\"\"\n new_state = state - self.delete_effects\n new_state = new_state | self.add_effects\n return new_state\n\nclass StripsPlanner:\n \"\"\"简单的STRIPS规划器\"\"\"\n\n def __init__(self):\n self.actions: list[StripsAction] = []\n\n def add_action(self, action: StripsAction):\n self.actions.append(action)\n\n def plan(self, initial: set[str], goal: set[str], max_depth: int = 10):\n \"\"\"使用广度优先搜索找到从initial到goal的行动序列\"\"\"\n from collections import deque\n\n queue = deque()\n queue.append((initial, []))\n\n visited = set()\n\n while queue:\n current_state, actions_taken = queue.popleft()\n\n # 到达目标\n if goal.issubset(current_state):\n return actions_taken\n\n # 超过深度限制\n if len(actions_taken) >= max_depth:\n continue\n\n state_key = frozenset(current_state)\n if state_key in visited:\n continue\n visited.add(state_key)\n\n # 尝试所有可用操作\n for action in self.actions:\n if action.is_applicable(current_state):\n new_state = action.apply(current_state)\n queue.append((new_state, actions_taken + [action]))\n\n return None # 无解\n\n# 使用示例：积木世界规划\nplanner = StripsPlanner()\n\nplanner.add_action(StripsAction(\n name=\"拿起积木A\",\n preconditions={\"A在桌上\", \"手为空\"},\n add_effects={\"手持A\", \"手不为空\"},\n delete_effects={\"A在桌上\", \"手为空\"}\n))\n\nplanner.add_action(StripsAction(\n name=\"把A放到B上\",\n preconditions={\"手持A\", \"A上方为空\", \"B上方为空\"},\n add_effects={\"A在B上\"},\n delete_effects={\"手持A\", \"B上方为空\"}\n))\n\nplanner.add_action(StripsAction(\n name=\"放下积木A\",\n preconditions={\"手持A\"},\n add_effects={\"A在桌上\", \"手为空\"},\n delete_effects={\"手持A\", \"A在B上\"}\n))\n\n# 求解\ninitial_state = {\"A在桌上\", \"B在桌上\", \"A上方为空\", \"B上方为空\", \"手为空\"}\ngoal_state = {\"A在B上\", \"手为空\"}\n\nplan = planner.plan(initial_state, goal_state)\nif plan:\n print(\"=== 找到的规划 ===\")\n for i, action in enumerate(plan, 1):\n print(f\" 步骤 {i}: {action.name}\")\nelse:\n print(\"未找到可行规划\")", "section_ref": "2.3.2", "runnable": true, "dependencies": [] }, { "id": "code-5", "language": "python", "description": "2016年，AlphaGo击败围棋世界冠军李世石，震撼了整个世界。AlphaGo的成功证明了AI Agent可以在复杂、高维度的环境中做出超越人类的决策。", "code": "# 简化的强化学习Agent：Q-Learning\nimport numpy as np\nfrom collections import defaultdict\n\nclass QLearningAgent:\n \"\"\"经典Q-Learning Agent\"\"\"\n\n def __init__(\n self,\n n_actions: int,\n learning_rate: float = 0.1,\n discount_factor: float = 0.95,\n epsilon: float = 0.1\n ):\n self.n_actions = n_actions\n self.lr = learning_rate\n self.gamma = discount_factor\n self.epsilon = epsilon\n self.q_table: dict[tuple, np.ndarray] = defaultdict(\n lambda: np.zeros(n_actions)\n )\n\n def choose_action(self, state: tuple, training: bool = True) -> int:\n \"\"\"ε-贪心策略选择动作\"\"\"\n if training and np.random.random() < self.epsilon:\n return np.random.randint(self.n_actions)\n\n q_values = self.q_table[state]\n return int(np.argmax(q_values))\n\n def learn(\n self,\n state: tuple,\n action: int,\n reward: float,\n next_state: tuple,\n done: bool\n ):\n \"\"\"Q-Learning更新\"\"\"\n current_q = self.q_table[state][action]\n\n if done:\n target = reward\n else:\n target = reward + self.gamma * np.max(self.q_table[next_state])\n\n # Q(s,a) ← Q(s,a) + α[r + γ·max(Q(s')) - Q(s,a)]\n self.q_table[state][action] += self.lr * (target - current_q)\n\n def get_policy(self) -> dict[tuple, int]:\n \"\"\"获取学到的策略\"\"\"\n return {\n state: int(np.argmax(q_values))\n for state, q_values in self.q_table.items()\n }\n\n# 使用示例：简单的网格世界导航\nclass GridWorld:\n \"\"\"4x4网格世界环境\"\"\"\n\n def __init__(self):\n self.size = 4\n self.start = (0, 0)\n self.goal = (3, 3)\n self.obstacles = {(1, 1), (2, 2)}\n self.agent_pos = self.start\n self.actions = [\"上\", \"下\", \"左\", \"右\"]\n\n def reset(self):\n self.agent_pos = self.start\n return self.agent_pos\n\n def step(self, action: int):\n \"\"\"执行动作，返回 (next_state, reward, done)\"\"\"\n moves = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n dr, dc = moves[action]\n new_r = self.agent_pos[0] + dr\n new_c = self.agent_pos[1] + dc\n\n # 边界检查\n if not (0 <= new_r < self.size and 0 <= new_c < self.size):\n return self.agent_pos, -1.0, False\n\n # 障碍物检查\n if (new_r, new_c) in self.obstacles:\n return self.agent_pos, -5.0, False\n\n self.agent_pos = (new_r, new_c)\n\n # 到达目标\n if self.agent_pos == self.goal:\n return self.agent_pos, 100.0, True\n\n return self.agent_pos, -0.1, False\n\n# 训练Agent\nenv = GridWorld()\nagent = QLearningAgent(n_actions=4, epsilon=0.2)\n\nprint(\"=== 训练 Q-Learning Agent ===\")\nfor episode in range(500):\n state = env.reset()\n total_reward = 0\n done = False\n\n while not done:\n action = agent.choose_action(state)\n next_state, reward, done = env.step(action)\n agent.learn(state, action, reward, next_state, done)\n state = next_state\n total_reward += reward\n\n if (episode + 1) % 100 == 0:\n print(f\" 第 {episode+1} 轮，总奖励: {total_reward:.1f}\")\n\nprint(\"\\n=== 学到的策略 ===\")\npolicy = agent.get_policy()\nfor r in range(4):\n row_actions = []\n for c in range(4):\n if (r, c) == (3, 3):\n row_actions.append(\"🏆\")\n elif (r, c) in env.obstacles:\n row_actions.append(\"⬛\")\n else:\n row_actions.append(env.actions[policy.get((r, c), 0)])\n print(f\" {row_actions}\")", "section_ref": "2.4.1", "runnable": true, "dependencies": [ "numpy" ] }, { "id": "code-6", "language": "text", "description": "AutoGPT的核心理念是\"给LLM一个目标，让它自主完成\"：", "code": "目标：调研某个市场并写一份报告\n→ AutoGPT自主分解任务\n→ 自主搜索信息\n→ 自主编写报告\n→ 自主保存结果", "section_ref": "2.5.3", "runnable": false, "dependencies": [] }, { "id": "code-7", "language": "python", "description": "→ 自主保存结果", "code": "# AutoGPT 概念的简化实现：自主任务Agent\nimport json\nfrom typing import Callable\n\nclass AutonomousAgent:\n \"\"\"简化版自主Agent——模拟AutoGPT的核心循环\"\"\"\n\n def __init__(self, name: str, goal: str, llm_func: Callable):\n self.name = name\n self.goal = goal\n self.llm = llm_func\n self.memory: list[str] = []\n self.max_steps = 10\n\n def think(self) -> str:\n \"\"\"让LLM思考下一步行动\"\"\"\n prompt = f\"\"\"\n你是一个自主AI Agent '{self.name}'。\n你的目标: {self.goal}\n历史记忆: {json.dumps(self.memory[-5:], ensure_ascii=False, indent=2)}\n\n请决定下一步行动。可用的动作类型:\n- THINK: 分析当前情况\n- SEARCH: 搜索信息（需要提供搜索关键词）\n- WRITE: 写入文件（需要提供文件名和内容）\n- COMPLETE: 任务完成\n\n请以JSON格式回复: {{\"action\": \"THINK|SEARCH|WRITE|COMPLETE\", \"content\": \"...\"}}\n\"\"\"\n return self.llm(prompt)\n\n def execute(self, action_str: str):\n \"\"\"执行行动\"\"\"\n try:\n action_data = json.loads(action_str)\n except json.JSONDecodeError:\n self.memory.append(f\"执行失败: 无法解析动作 {action_str}\")\n return\n\n action_type = action_data.get(\"action\", \"THINK\")\n content = action_data.get(\"content\", \"\")\n\n if action_type == \"THINK\":\n self.memory.append(f\"思考: {content}\")\n elif action_type == \"SEARCH\":\n self.memory.append(f\"搜索 '{content}': 找到相关结果...\")\n elif action_type == \"WRITE\":\n self.memory.append(f\"写入完成: {content[:50]}...\")\n elif action_type == \"COMPLETE\":\n self.memory.append(f\"任务完成: {content}\")\n else:\n self.memory.append(f\"未知动作: {action_type}\")\n\n def run(self):\n \"\"\"主循环：思考→执行→反思\"\"\"\n print(f\"=== {self.name} 启动 ===\")\n print(f\"目标: {self.goal}\\n\")\n\n for step in range(1, self.max_steps + 1):\n print(f\"--- 步骤 {step} ---\")\n thought = self.think()\n self.execute(thought)\n\n # 检查是否完成\n if \"COMPLETE\" in self.memory[-1]:\n print(f\"\\n✅ {self.name} 在 {step} 步内完成任务\")\n return True\n\n print(f\"\\n⏱️ 达到最大步数限制，任务未完成\")\n return False\n\n# 模拟LLM函数（实际中应调用真正的LLM API）\ndef mock_llm(prompt: str) -> str:\n \"\"\"模拟LLM响应\"\"\"\n if \"自主AI Agent\" in prompt and \"目标\" in prompt:\n if len([l for l in prompt.split('\\n') if '历史记忆' in l or 'THINK' in prompt]) < 5:\n return json.dumps({\"action\": \"THINK\", \"content\": \"我需要先分析任务，然后搜索相关信息\"})\n return json.dumps({\"action\": \"COMPLETE\", \"content\": \"任务已完成\"})\n return json.dumps({\"action\": \"THINK\", \"content\": \"继续分析...\"})\n\n# 运行示例\nagent = AutonomousAgent(\"ResearchBot\", \"调研Python异步编程最佳实践\", mock_llm)\nagent.run()", "section_ref": "2.5.3", "runnable": true, "dependencies": [] }, { "id": "code-8", "language": "text", "description": "BabyAGI的核心循环极其优雅：", "code": "1. 从任务列表中取出最优先的任务\n2. 用LLM执行任务（可能创建子任务）\n3. 用LLM评估结果并更新任务列表\n4. 重复", "section_ref": "2.5.4", "runnable": false, "dependencies": [] }, { "id": "code-9", "language": "python", "description": "4. 重复", "code": "# BabyAGI 简化实现：任务驱动Agent\nimport heapq\nfrom dataclasses import dataclass, field\n\n@dataclass(order=True)\nclass PrioritizedTask:\n priority: int\n task_id: int = field(compare=False)\n description: str = field(compare=False)\n status: str = field(default=\"pending\", compare=False)\n\nclass BabyAGIAgent:\n \"\"\"BabyAGI风格的任务驱动Agent\"\"\"\n\n def __init__(self, objective: str, llm_func):\n self.objective = objective\n self.llm = llm_func\n self.tasks: list[PrioritizedTask] = []\n self.completed: list[str] = []\n self.task_counter = 0\n self.max_iterations = 15\n\n def add_task(self, description: str, priority: int = 5):\n \"\"\"添加新任务\"\"\"\n self.task_counter += 1\n heapq.heappush(self.tasks, PrioritizedTask(priority, self.task_counter, description))\n\n def execute_task(self, task: PrioritizedTask) -> str:\n \"\"\"执行单个任务\"\"\"\n prompt = f\"\"\"\n目标: {self.objective}\n当前任务: {task.description}\n已完成: {self.completed[-3:] if self.completed else '无'}\n\n请执行此任务。如果需要创建新的子任务，请在结果末尾列出。\n\"\"\"\n return self.llm(prompt)\n\n def prioritize_tasks(self):\n \"\"\"重新排序任务优先级\"\"\"\n if not self.tasks:\n return\n prompt = f\"\"\"\n目标: {self.objective}\n待完成任务: {[t.description for t in self.tasks]}\n\n请根据与目标的关联度，为每个任务分配1-10的优先级分数。\n返回JSON数组: [{{\"task\": \"描述\", \"priority\": 分数}}]\n\"\"\"\n result = self.llm(prompt)\n # 简化：实际中应解析JSON并更新优先级\n return\n\n def run(self):\n \"\"\"主循环\"\"\"\n print(f\"=== BabyAGI Agent 启动 ===\")\n print(f\"目标: {self.objective}\\n\")\n\n # 初始任务\n self.add_task(f\"创建实现'{self.objective}'的详细计划\", priority=1)\n\n for iteration in range(self.max_iterations):\n if not self.tasks:\n print(\"所有任务已完成！\")\n break\n\n task = heapq.heappop(self.tasks)\n print(f\"[迭代 {iteration+1}] 执行: {task.description} (优先级: {task.priority})\")\n\n result = self.execute_task(task)\n self.completed.append(task.description)\n print(f\" 结果: {result[:80]}...\")\n\n self.prioritize_tasks()\n\n print(f\"\\n=== 完成 {len(self.completed)} 个任务 ===\")\n for task_desc in self.completed:\n print(f\" ✅ {task_desc}\")\n\n# 运行示例\nbaby_agi = BabyAGIAgent(\"创建一个简单的Web爬虫\", mock_llm)\nbaby_agi.run()", "section_ref": "2.5.4", "runnable": true, "dependencies": [ "heapq" ] } ], "tables": [ { "headers": [ "时间", "项目/事件", "意义" ], "data": [ [ "2021.12", "WebGPT", "首个展示LLM自主浏览网页能力" ], [ "2022.12", "ChatGPT", "LLM能力质变，Agent基础奠定" ], [ "2023.03", "AutoGPT", "自主Agent概念引爆全球" ], [ "2023.03", "GPT-4 Plugins", "官方工具使用能力" ], [ "2023.04", "BabyAGI", "任务驱动Agent架构" ], [ "2023.06", "AutoGen (Microsoft)", "多Agent对话框架" ], [ "2023.09", "CrewAI", "角色扮演式多Agent框架" ], [ "2023.10", "LangGraph", "有状态的Agent工作流" ], [ "2024.01", "OpenAI Assistants API", "官方Agent API" ], [ "2024.03", "Claude 3 + MCP", "工具协议标准化" ], [ "2024.06", "DevIn (字节)", "端到端软件Agent" ], [ "2024.12", "多个Agent框架成熟", "生产级Agent系统涌现" ] ] } ], "key_takeaways": [ "萌芽期（1960s-1970s）：ELIZA和SHRDLU展示了对话理解和世界交互的雏形", "符号主义时期（1980s-1990s）：专家系统和规划系统将知识工程推向顶峰", "强化学习时期（2010s-2020s）：AlphaGo等系统展示了通过学习获得超人决策能力的可能", "LLM Agent时期（2020s-至今）：大语言模型赋予了Agent前所未有的通用语言理解和推理能力" ], "common_pitfalls": [], "related_chapters": [ "ch01" ] }