如果你是一名开发者，最近在尝试构建一个具备“自主决策”能力的AI应用，或者想为你的聊天机器人增加一些“记忆”和“规划”能力，那么你很可能已经听过“AI Agent”这个词。它听起来很酷，但当你真正打开一个开源Agent框架的文档时，扑面而来的可能是“LLM”、“Tool”、“Memory”、“Planning”、“Action”等一系列抽象概念，以及动辄几十个步骤的复杂配置。你可能会想：我只是想让它帮我自动处理一个简单的任务，有必要这么复杂吗？

这正是本文要解决的问题。我们将从一个极具场景感的概念——“冒险者小镇”出发，来重新理解并实践AI Agent的核心。这个标题“冒险者，今晚就在前方的小镇歇脚吧”并非一个游戏攻略，而是一个绝佳的Agent隐喻。在角色扮演游戏中，冒险者（Agent）会根据目标（如“寻找宝藏”）、当前状态（生命值、装备）、环境信息（地图、怪物）和自身能力（技能、道具），自主决定下一步行动（是战斗、休息还是探索）。这与一个AI Agent根据用户目标、历史对话（Memory）、可用工具（Tools）和环境反馈，规划并执行一系列动作（Actions）来达成目标，在逻辑上完全同构。

本文将带你暂时忘掉那些晦涩的术语，通过构建一个“冒险者小镇”模拟环境，亲手实现一个具备目标驱动、工具使用和环境交互能力的简易AI Agent。你会发现，Agent的核心并不神秘，其关键在于状态感知、决策规划和动作执行的循环。读完本文，你将能清晰地理解Agent框架中各模块的职责，并掌握从零搭建一个可运行Agent原型的能力，从而为你后续集成LangChain、AutoGPT等成熟框架打下坚实的认知基础。

1. 从“冒险者”到“AI Agent”：核心逻辑的映射

在深入代码之前，我们必须建立正确的认知模型。将AI Agent想象成一位在数字世界中的“冒险者”，可以极大地简化理解。

这个映射关系揭示了Agent工作的本质循环：感知（Perceive）-> 思考（Think）-> 行动（Act）-> 学习（Learn）。

1. 感知：Agent从环境（用户输入、工具返回结果、记忆）中获取当前状态。
2. 思考：Agent（通常是LLM）基于目标、状态和记忆，决定下一步最佳行动。
3. 行动：Agent执行选定的动作（如调用一个工具）。
4. 学习：将行动的结果存入记忆，更新状态，并开始下一轮循环，直到任务完成或失败。

我们即将构建的“冒险者小镇”Demo，就是对这个循环的一次具象化实践。小镇是我们的环境，冒险者是我们的Agent，而寻找“镇长的宝藏”就是我们的终极任务。

2. 环境准备：构建我们的“小镇”

我们的“小镇”将是一个用Python模拟的简单文本环境。它包含几个地点和一些基本的交互规则。我们使用纯Python标准库来保持简洁。

首先，确保你的Python环境在3.8及以上。我们主要会用到json和random模块，无需额外安装。

让我们定义小镇的世界观和规则：

# 文件：town_environment.py import json import random class TownEnvironment: """模拟冒险者小镇环境""" def __init__(self): # 定义小镇地图：地点名称 -> {描述， 连接的地点， 物品} self.locations = { "小镇广场": { "description": "一个宽阔的石板广场，中央有个喷泉。东边是酒馆，西边是铁匠铺，北边通往图书馆。", "connections": ["酒馆", "铁匠铺", "图书馆"], "items": [] }, "酒馆": { "description": "喧闹的酒馆，充满了麦酒和食物的香气。老板在柜台后擦拭杯子。你可以在这里打听消息。", "connections": ["小镇广场"], "items": ["一杯麦酒"] }, "铁匠铺": { "description": "叮当作响的铁匠铺，炉火正旺。铁匠正在打造一把剑。这里可能找到工具或武器。", "connections": ["小镇广场"], "items": ["生锈的钥匙"] }, "图书馆": { "description": "安静的图书馆，布满灰尘的书架高耸至天花板。管理员在角落打盹。这里藏着知识。", "connections": ["小镇广场", "档案馆"], "items": ["古老的地图"] }, "档案馆": { "description": "图书馆深处的档案馆，需要钥匙才能进入。据说里面藏着小镇的秘密。", "connections": ["图书馆"], "items": ["镇长的宝藏"], "locked": True # 这是一个需要钥匙才能进入的特殊地点 } } # 定义NPC及其信息 self.npcs = { "酒馆老板": {"location": "酒馆", "knowledge": "听说铁匠最近捡到了一把奇怪的钥匙。"}, "图书管理员": {"location": "图书馆", "knowledge": "档案馆的钥匙去年被铁匠借走了，再也没还。"}, } # 游戏状态 self.current_location = "小镇广场" self.inventory = [] # 冒险者的背包 self.game_log = [] # 记录所有事件 def get_state(self): """获取当前环境状态，用于提供给Agent""" state = { "current_location": self.current_location, "location_description": self.locations[self.current_location]["description"], "connections": self.locations[self.current_location].get("connections", []), "visible_items": self.locations[self.current_location].get("items", []), "inventory": self.inventory, "npcs_here": [name for name, info in self.npcs.items() if info["location"] == self.current_location] } return json.dumps(state, indent=2, ensure_ascii=False) def execute_action(self, action: str, target: str = None) -> (bool, str): """ 执行一个动作，并返回（是否成功， 结果描述） 动作类型：move, take, talk, use """ self.game_log.append(f"> 尝试执行: {action} {target if target else ''}") if action == "move": return self._move(target) elif action == "take": return self._take_item(target) elif action == "talk": return self._talk_to(target) elif action == "use": return self._use_item(target) else: return False, f"未知的动作: {action}" def _move(self, direction_or_location: str) -> (bool, str): """移动到指定地点""" current_info = self.locations[self.current_location] possible_moves = current_info.get("connections", []) # 检查目标地点是否在可连接列表中 if direction_or_location in possible_moves: target_location = direction_or_location else: # 也可能传入的是“东边”、“去酒馆”这样的描述，这里简化处理，只支持地点名 return False, f"无法移动到 {direction_or_location}。可从当前地点前往: {', '.join(possible_moves)}" # 检查目标地点是否上锁 target_info = self.locations.get(target_location) if not target_info: return False, f"地点 {target_location} 不存在。" if target_info.get("locked"): return False, f"{target_location} 被锁住了，需要钥匙才能进入。" self.current_location = target_location desc = self.locations[self.current_location]["description"] return True, f"你已到达 {target_location}。{desc}" def _take_item(self, item_name: str) -> (bool, str): """拾取物品""" items_here = self.locations[self.current_location].get("items", []) if item_name in items_here: self.locations[self.current_location]["items"].remove(item_name) self.inventory.append(item_name) return True, f"你拾取了 {item_name}。" else: return False, f"这里没有 {item_name}。" def _talk_to(self, npc_name: str) -> (bool, str): """与NPC对话""" npc_info = self.npcs.get(npc_name) if not npc_info: return False, f"这里没有名为 {npc_name} 的NPC。" if npc_info["location"] != self.current_location: return False, f"{npc_name} 不在这里。" return True, f"{npc_name} 说: \"{npc_info['knowledge']}\"" def _use_item(self, item_name: str) -> (bool, str): """使用物品""" if item_name not in self.inventory: return False, f"你的背包里没有 {item_name}。" # 特定物品的使用逻辑 if item_name == "生锈的钥匙" and self.current_location == "图书馆": # 使用钥匙打开档案馆 if "档案馆" in self.locations[self.current_location].get("connections", []): self.locations["档案馆"]["locked"] = False self.inventory.remove(item_name) return True, "你用生锈的钥匙打开了档案馆的门锁。现在可以进入了。" else: return False, "这里没有可以用这把钥匙打开的门。" # 默认情况 return False, f"你不知道如何使用 {item_name}。" def is_goal_achieved(self): """检查是否达成目标（找到宝藏）""" return "镇长的宝藏" in self.inventory def get_goal(self) -> str: """返回当前任务目标""" return "你的终极目标是找到并获取‘镇长的宝藏’。你现在身处一个小镇中，需要探索、收集物品、与NPC交谈来获得线索。"

这个环境类定义了世界的规则。它提供了get_state()来让Agent感知世界，提供了execute_action()作为Agent影响世界的接口。这就是Agent的“环境”。

3. 定义Agent的“大脑”与“工具”

Agent的大脑通常是一个大语言模型。为了演示，我们将创建一个模拟的LLM。在真实项目中，这里应替换为OpenAI API、通义千问API或本地LLM的调用。

同时，我们需要定义Agent可以使用的“工具”（即冒险者的技能）。工具是对环境动作的封装，让LLM能以更抽象的方式思考。

# 文件：simple_agent.py import re import random class SimpleLLM: """一个模拟的LLM，用于演示。真实场景请替换为真正的LLM API调用。""" def __init__(self): # 模拟一些常识和推理规则 self.rules = { "explore": "如果不知道下一步该做什么，先探索当前地点，查看物品和NPC。", "talk_for_info": "如果想找东西或开门，先和附近的NPC交谈获取线索。", "take_useful": "如果看到像‘钥匙’、‘地图’这样的物品，先拾取它。", "use_key": "如果你有钥匙且当前地点有锁着的门，尝试使用钥匙。", "move_to_goal": "如果知道目标地点，直接移动过去。" } def generate(self, prompt: str) -> str: """ 模拟LLM生成回复。 在真实项目中，这里会是：openai.ChatCompletion.create(...) 或类似调用。 """ # 这是一个极其简化的决策逻辑，仅用于演示。 # 真实LLM会根据整个prompt进行复杂推理。 print(f"\n[LLM 接收到的提示]:\n{prompt[:500]}...\n") # 打印部分prompt以便调试 # 基于prompt内容做简单的模式匹配（真实场景中这是LLM的工作） if "你的目标是什么" in prompt: return "我的目标是找到‘镇长的宝藏’。" if "当前状态" in prompt and "小镇广场" in prompt: return "我应该先探索一下。动作: look_around" if "一杯麦酒" in prompt and "拾取" not in prompt: return "麦酒可能不是当前急需的。我应该寻找钥匙或地图。动作: move_to 铁匠铺" if "生锈的钥匙" in prompt and "拾取" not in prompt: return "这把钥匙可能很重要。动作: take 生锈的钥匙" if "铁匠" in prompt and "说" in prompt: return "钥匙在铁匠铺。动作: move_to 铁匠铺" if "图书管理员" in prompt and "说" in prompt: return "钥匙被铁匠借走了。所以我应该去铁匠铺找钥匙。动作: move_to 铁匠铺" if "生锈的钥匙" in prompt and "背包" in prompt and "图书馆" in prompt: return "我有了钥匙，并且在图书馆。管理员说档案馆的钥匙被铁匠借走了，正好我手里这把可能就是。动作: use 生锈的钥匙" if "档案馆" in prompt and "锁住了" in prompt: return "档案馆需要钥匙。我可能需要先找到钥匙。动作: talk_to 图书管理员" if "档案馆" in prompt and "可以进入" in prompt: return "门开了！现在进入档案馆。动作: move_to 档案馆" if "镇长的宝藏" in prompt and "档案馆" in prompt: return "宝藏就在这里！动作: take 镇长的宝藏" # 默认回退：随机选择一个基本动作 default_actions = ["move_to 酒馆", "look_around", "talk_to 酒馆老板"] return f"我需要更多信息。动作: {random.choice(default_actions)}" class AgentTools: """Agent可用的工具集。每个工具对应一个环境动作的友好封装。""" @staticmethod def parse_action(llm_response: str): """ 解析LLM返回的文本，提取动作和参数。 期望格式：`动作: <action_name> [参数]` 例如：`动作: move_to 铁匠铺`， `动作: take 生锈的钥匙` """ pattern = r"动作:\s*(\w+)(?:\s+([\w\s]+))?" match = re.search(pattern, llm_response) if match: action = match.group(1).strip() target = match.group(2).strip() if match.group(2) else None return action, target return None, None @staticmethod def get_available_actions(): """返回给LLM的可用动作列表及其描述。""" return [ "move_to <地点>: 移动到指定地点，如‘move_to 酒馆’。", "look_around: 仔细观察当前地点，发现物品和NPC。", "take <物品名>: 拾取当前地点的物品，如‘take 生锈的钥匙’。", "talk_to <NPC名>: 与当前地点的NPC交谈，如‘talk_to 酒馆老板’。", "use <物品名>: 使用背包中的物品，如‘use 生锈的钥匙’。", "check_inventory: 查看背包里的物品。", "check_goal: 重申当前任务目标。" ]

在这个设计中，SimpleLLM类模拟了大脑的决策过程。AgentTools类则提供了两个关键功能：

1. parse_action: 将LLM输出的自然语言解析成结构化的（动作， 目标）对。这是连接LLM“思考”和环境“执行”的关键桥梁。
2. get_available_actions: 定义了Agent能做什么。在给LLM的提示词中，我们会列出这个列表，约束LLM的思考范围。

4. 组装Agent：实现感知-思考-行动循环

现在，我们将环境、大脑和工具组装成完整的Agent，并实现核心循环。

# 文件：adventurer_agent.py from town_environment import TownEnvironment from simple_agent import SimpleLLM, AgentTools class AdventurerAgent: """冒险者Agent，整合了环境、LLM和工具""" def __init__(self): self.env = TownEnvironment() self.llm = SimpleLLM() # 在实际应用中替换为真正的LLM self.memory = [] # 简单的对话记忆 self.max_steps = 20 # 防止无限循环 self.step_count = 0 def build_prompt(self, state: str) -> str: """构建给LLM的提示词。这是Agent‘思考’的依据。""" available_actions = "\n".join(AgentTools.get_available_actions()) memory_context = "\n".join(self.memory[-3:]) if self.memory else "暂无历史。" prompt = f""" 你是一个在文本冒险游戏中的AI冒险者。请根据当前游戏状态、你的记忆和最终目标，决定下一步行动。 你只能从以下动作中选择一个执行，并严格按照“动作: <动作名> [参数]”的格式回复。 ## 你的终极目标 {self.env.get_goal()} ## 可用动作列表 {available_actions} ## 近期记忆（最近三次交互） {memory_context} ## 当前游戏状态 {state} ## 你的思考 请简要分析现状：你在哪里？周围有什么？你的背包里有什么？根据目标和记忆，下一步最应该做什么？ 然后，输出一个且仅一个动作。 请按以下格式回复： 分析: <你的简要分析> 动作: <动作名> [参数] """ return prompt def run(self): """运行Agent主循环""" print("=== 冒险开始！ ===") print(self.env.get_goal()) print("初始地点:", self.env.current_location) print("-" * 50) while not self.env.is_goal_achieved() and self.step_count < self.max_steps: self.step_count += 1 print(f"\n[步骤 {self.step_count}]") # 1. 感知：获取环境状态 current_state = self.env.get_state() print(f"当前状态:\n{current_state}") # 2. 思考：LLM基于状态和记忆生成决策 prompt = self.build_prompt(current_state) llm_response = self.llm.generate(prompt) print(f"LLM回复: {llm_response}") # 3. 解析动作 action, target = AgentTools.parse_action(llm_response) if not action: print("无法从LLM回复中解析出有效动作。尝试默认动作‘look_around’。") action, target = "look_around", None # 4. 行动：在环境中执行动作 success, result = self.env.execute_action(action, target) # 5. 学习：将本次交互存入记忆 memory_entry = f"步骤{self.step_count}: 执行 {action} {target}。结果: {result}。成功: {success}" self.memory.append(memory_entry) print(f"执行动作: {action} {target if target else ''}") print(f"结果: {result}") print(f"成功: {success}") print(f"背包: {self.env.inventory}") if self.env.is_goal_achieved(): print(f"\n🎉 恭喜！经过 {self.step_count} 步，你找到了‘镇长的宝藏’，任务完成！") break if not self.env.is_goal_achieved(): print(f"\n⚠️ 在 {self.max_steps} 步内未达成目标。Agent可能陷入了循环或决策错误。") print("=== 冒险结束 ===") if __name__ == "__main__": agent = AdventurerAgent() agent.run()

这个AdventurerAgent类实现了完整的Agent循环：

1. build_prompt：这是Agent“思考”的原料。它精心组织了目标、可用动作、历史记忆和当前状态，形成一个结构化的提示词（Prompt）发送给LLM。提示词工程是Agent性能的关键。
2. run方法中的循环：
   • 感知：current_state = self.env.get_state()
   • 思考：llm_response = self.llm.generate(prompt)
   • 解析：action, target = AgentTools.parse_action(llm_response)
   • 行动：success, result = self.env.execute_action(action, target)
   • 学习：self.memory.append(memory_entry)

5. 运行结果与效果验证

将上述三个文件（town_environment.py,simple_agent.py,adventurer_agent.py）放在同一目录下，运行adventurer_agent.py。

由于我们使用了模拟的LLM，其决策逻辑是预设的，因此运行轨迹是确定的。你会看到类似以下的输出：

=== 冒险开始！ === 你的终极目标是找到并获取‘镇长的宝藏’。你现在身处一个小镇中，需要探索、收集物品、与NPC交谈来获得线索。 初始地点: 小镇广场 -------------------------------------------------- [步骤 1] 当前状态: { "current_location": "小镇广场", "location_description": "一个宽阔的石板广场，中央有个喷泉。东边是酒馆，西边是铁匠铺，北边通往图书馆。", "connections": ["酒馆", "铁匠铺", "图书馆"], "visible_items": [], "inventory": [], "npcs_here": [] } LLM回复: 我应该先探索一下。动作: look_around 执行动作: look_around None 结果: 未知的动作: look_around 成功: False 背包: [] ... [步骤 N] 当前状态: (显示在图书馆，钥匙在背包) LLM回复: 我有了钥匙，并且在图书馆。管理员说档案馆的钥匙被铁匠借走了，正好我手里这把可能就是。动作: use 生锈的钥匙 执行动作: use 生锈的钥匙 结果: 你用生锈的钥匙打开了档案馆的门锁。现在可以进入了。 成功: True 背包: [] ... [最终步骤] 当前状态: (显示在档案馆，看到宝藏) LLM回复: 宝藏就在这里！动作: take 镇长的宝藏 执行动作: take 镇长的宝藏 结果: 你拾取了 镇长的宝藏。 成功: True 背包: ['镇长的宝藏'] 🎉 恭喜！经过 X 步，你找到了‘镇长的宝藏’，任务完成！ === 冒险结束 ===

如何验证你的Agent是否工作正常？

1. 流程正确性：Agent是否按照“探索 -> 获取线索 -> 获取钥匙 -> 开门 -> 取得宝藏”的逻辑顺序执行？
2. 动作有效性：execute_action的返回结果是否与预期一致？（例如，在没钥匙时尝试进入档案馆应失败）
3. 记忆有效性：Agent是否利用了记忆（如NPC的对话）来指导后续决策？
4. 目标达成：最终env.is_goal_achieved()是否返回True？

这个简单的模拟验证了Agent核心循环的可行性。在真实LLM（如GPT-4）的驱动下，即使面对更复杂、未预设的状态，它也能通过理解提示词和上下文，做出合理的决策。

6. 接入真实LLM：从模拟走向实战

上面的SimpleLLM只是一个模拟。要让Agent真正“智能”起来，我们需要接入一个真实的大语言模型。以下以OpenAI API为例（需安装openai库并设置API密钥）。

# 文件：real_llm_integration.py import openai import os from typing import Optional class OpenAIAgentBrain: """使用真实的OpenAI API作为Agent的大脑""" def __init__(self, model: str = "gpt-3.5-turbo", api_key: Optional[str] = None): self.model = model self.client = openai.OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY")) if not self.client.api_key: raise ValueError("请设置OPENAI_API_KEY环境变量或直接传入api_key参数。") def generate(self, prompt: str) -> str: """调用OpenAI API生成回复""" try: response = self.client.chat.completions.create( model=self.model, messages=[ {"role": "system", "content": "你是一个在文本冒险游戏中的AI冒险者。请严格按照要求的格式回复。"}, {"role": "user", "content": prompt} ], temperature=0.2, # 较低的温度使输出更确定，更适合执行任务 max_tokens=150 ) return response.choices[0].message.content.strip() except Exception as e: print(f"调用OpenAI API失败: {e}") return f"错误: {e}" # 在AdventurerAgent中替换SimpleLLM # agent = AdventurerAgent() # agent.llm = OpenAIAgentBrain(model="gpt-4") # 使用GPT-4，推理能力更强

关键改动说明：

1. System Prompt：我们通过system角色消息设定了Agent的“身份”，这能更稳定地引导其行为。
2. Temperature：设置为较低的0.2，减少随机性，让Agent决策更稳定可靠。
3. 错误处理：网络或API调用可能失败，必须有降级或重试机制。

使用国内模型的注意事项：如果你使用通义千问、文心一言、DeepSeek等国内模型，原理相同，只需替换API端点、密钥和调用方式。例如，使用dashscope库调用通义千问：

# 示例：使用阿里云灵积API（需安装 dashscope） import dashscope from dashscope import Generation class QwenAgentBrain: def __init__(self, api_key: str): dashscope.api_key = api_key def generate(self, prompt: str) -> str: response = Generation.call( model='qwen-max', prompt=prompt, temperature=0.2, max_tokens=150 ) if response.status_code == 200: return response.output.text.strip() else: return f"API错误: {response.code} - {response.message}"

7. 常见问题与排查思路

在构建和运行你的第一个Agent时，可能会遇到以下典型问题：

8. 最佳实践与工程建议

当你从Demo走向实际项目时，遵循以下实践能让你少走弯路：

1. Prompt工程是核心：Agent的智能程度很大程度上取决于Prompt。

   • 角色设定（System Prompt）：清晰定义Agent的角色、目标和行为边界。
   • 结构化指令：明确列出格式、可用动作、禁止事项。
   • 少样本示例（Few-shot）：在Prompt中提供1-2个“状态->思考->动作”的正确示例，能极大提升LLM的格式遵从和推理质量。
   • 状态摘要：不要将原始历史全部塞进Prompt。对记忆进行总结，只保留关键决策点和结果。

2. 设计良好的工具（Tools）抽象：

   • 功能单一：一个工具只做一件事。例如，“搜索网络”和“计算数学”应该是两个独立的工具。
   • 描述清晰：为每个工具编写详细、自然的描述，LLM会根据描述来决定何时调用它。
   • 输入输出明确：定义好工具需要的参数格式和返回的数据结构。

3. 实现健壮的错误处理与重试机制：

   • LLM调用失败：网络超时、额度不足等，应有重试或降级方案（如切换到备用模型）。
   • 动作执行失败：工具调用出错（如API失败），环境应返回明确的错误信息，并允许Agent尝试其他方案。
   • 解析失败：当无法从LLM回复中解析出有效动作时，应有默认回退策略（如请求LLM重新生成，或执行一个安全的中性动作）。

4. 引入更高级的Agent架构模式：

   • 规划-执行-反思（Plan-Act-Reflect）：让LLM先制定一个多步计划，然后逐步执行，并根据结果反思和调整计划。这适合复杂任务。
   • 多Agent协作：创建多个具有不同专长（如搜索专家、代码专家、分析专家）的Agent，让他们通过一个“协调员”或共享工作区来协作解决问题。
   • 外部记忆（Vector Database）：当记忆很长时，使用向量数据库存储历史交互，并通过语义检索召回最相关的记忆，而不是简单的时间窗口。

5. 测试与评估：

   • 单元测试环境：确保环境模拟器的每个动作逻辑正确。
   • 集成测试Agent：针对一系列标准任务，评估Agent的成功率、步骤数和耗时。
   • 模糊测试：给Agent一些非常规或带干扰信息的输入，观察其鲁棒性。

“冒险者小镇”的旅程到此告一段落，但这只是你探索AI Agent世界的起点。我们通过这个具体的隐喻，拆解了Agent“感知-思考-行动”的核心循环，并亲手实现了一个可运行的原型。关键在于理解，Agent不是一个魔法黑盒，而是一个由环境、大脑（LLM）、工具、记忆和规划逻辑精心组合而成的系统。

从Demo到生产，你下一步可以：

1. 替换更强的大脑：将模拟LLM换成GPT-4、Claude-3或开源的DeepSeek-V2，观察决策能力质的飞跃。
2. 设计更复杂的任务：尝试让Agent自动编写一个简单的Python脚本，或基于网络搜索的结果撰写一份摘要报告。
3. 集成成熟框架：用LangChain、AutoGen或CrewAI来重构你的Demo。这些框架提供了更完善的工具集成、记忆管理和多Agent协作机制，能让你站在巨人的肩膀上。
4. 关注应用场景：Agent最适合解决那些目标明确、流程可分解、但具体路径需要灵活判断的任务，如自动化客服、智能数据查询、代码生成与审查、个性化内容推荐等。

记住，构建一个可靠的Agent，三分靠模型，七分靠工程。提示词设计、工具抽象、错误处理和评估体系，这些才是决定项目成败的“隐藏关卡”。希望这篇长文能成为你闯关的第一把钥匙。建议收藏本文，当你需要回顾Agent的基础概念或搭建第一个原型时，不妨再回到这个“小镇”看看。