从零搭建AIAgent框架：理解智能体核心原理与实现

1. 从零到一：为什么我们需要亲手搭建一个AIAgent框架？

最近和几个做产品的朋友聊天，发现一个挺有意思的现象：大家一提到AIAgent，第一反应就是去调用OpenAI的API，或者直接用LangChain、AutoGen这类成熟的框架。这当然没问题，对于快速验证想法或者构建一个功能性的原型来说，这些工具是绝佳的选择。但问题也随之而来——当你需要深度定制Agent的行为逻辑，或者想搞清楚它内部到底是怎么“思考”和“决策”的时候，这些黑盒框架就有点让人摸不着头脑了。你只知道输入和输出，中间那个“大脑”是怎么运转的，你很难插手，出了问题也不知道从何查起。

这就是我决定动手从头搭建一个简易AIAgent框架的初衷。不是为了替代那些强大的开源项目，而是为了“解剖麻雀”。通过亲手实现最核心的循环（感知-思考-行动-反馈），你能真正理解一个智能体是如何与环境交互、如何管理记忆、如何做出决策的。这个过程，远比直接调用一个agent.run()命令要来得深刻。你会发现，原来所谓的“智能”，背后是一套清晰、可控的状态机在驱动。这对于想深入AIAgent领域，或者未来需要设计复杂多智能体系统的开发者来说，是一次不可多得的“底层思维训练”。

这个简易框架的目标很明确：可理解、可扩展、够用就好。我们不追求大而全，而是聚焦于最核心的“智能体循环”（Agent Loop）的实现。你会看到，我们如何用一个简单的while循环，配合几个关键组件（大脑、工具、记忆），就能让一个AI程序具备自主完成任务的能力。无论是让它帮你查天气、总结网页内容，还是进行多轮对话，这个框架都能提供一个清晰的骨架，让你可以轻松地往上“添砖加瓦”。

2. 核心蓝图：一个简易AIAgent框架的四大支柱

在开始写代码之前，我们需要先画一张蓝图。一个最基本的AIAgent，无论简单还是复杂，通常都离不开下面这四个核心组件。理解它们之间的关系，是搭建框架的第一步。

1. 大脑 (Brain / LLM Core)这是Agent的“CPU”，负责所有的推理和决策。它接收来自外部的观察（Observation）和内部的记忆（Memory），然后“思考”下一步该做什么。在实现上，它本质上是一个对大语言模型（LLM）的封装。我们向LLM提供一个精心设计的提示词（Prompt），让它以特定的格式（比如JSON）输出决策。这个决策通常包含两个部分：思考过程（让我们知道它为什么这么想）和具体行动（告诉我们要执行哪个工具，以及传入什么参数）。

2. 工具集 (Toolkit)这是Agent的“手和脚”。大脑想得再好，最终也需要通过工具来影响外部世界。一个工具就是一个可执行的函数，比如“搜索网络”、“执行计算”、“读写文件”。框架需要提供一个统一的机制来注册、管理和调用这些工具。当大脑决定使用某个工具时，框架要能准确地找到对应的函数，传入参数并执行，然后将执行结果返回给大脑，作为下一轮思考的输入。

3. 记忆系统 (Memory)这是Agent的“经验簿”。没有记忆的Agent就像金鱼，每一轮对话都是全新的开始。一个实用的记忆系统至少需要两部分：

• 短期记忆/对话历史：保存当前会话中用户和Agent的交互记录，这是进行连贯多轮对话的基础。
• 长期记忆/向量存储：将重要的信息（如用户偏好、任务关键事实）通过嵌入（Embedding）存入向量数据库，供未来快速检索。对于简易框架，我们可以先从实现一个简单的对话历史管理器开始。

4. 控制循环 (Agent Loop)这是将以上所有组件串联起来的“主程序”。它是一个循环，不断重复“观察-思考-行动”的过程，直到任务完成或达到停止条件。这个循环的逻辑大致如下：

1. 观察：收集当前环境的状态（例如用户的提问、上一个工具的执行结果）。
2. 思考：将观察和记忆一起送给大脑（LLM），让它决定下一步行动。
3. 行动：解析大脑的决策，调用指定的工具并获取结果。
4. 反馈与记忆：将行动结果作为新的观察，存入记忆，并进入下一轮循环。
5. 终止：当大脑输出一个特殊的“最终答案”动作，或循环次数达到上限时，循环结束。

有了这个蓝图，我们就可以开始动手搭建了。接下来，我们将从最核心的“大脑”开始，一步步用代码实现这个框架。

3. 搭建“大脑”：与大模型对话的标准化接口

大脑是整个框架的指挥中心，它的核心职责是：根据当前的对话历史和观察，决定下一步该做什么。为了实现这一点，我们需要设计一个能与LLM稳定通信，并能解析其结构化输出的模块。

首先，我们来定义大脑的输出格式。为了让程序能理解LLM的“想法”，我们不能让它自由发挥，必须要求它按照一个固定的JSON格式来回答。这个格式通常被称为“动作规范”（Action Specification）。

# 定义Agent动作的数据结构 from pydantic import BaseModel from typing import Optional class AgentAction(BaseModel): """Agent思考后决定执行的动作""" thought: str # 它的思考过程，便于我们调试和理解 action: str # 要执行的动作名称，例如 "search_web", "calculate", "final_answer" action_input: dict # 执行动作所需的输入参数，是一个字典

提示：使用Pydantic进行数据验证是个好习惯。它能确保从LLM那里得到的JSON数据格式正确，类型匹配，避免后续处理时出现意外错误。

接下来，我们需要构造提示词（Prompt）。这是引导LLM按照我们期望的方式思考和输出的关键。一个好的提示词应该包含：

1. 角色定义：告诉LLM它现在是谁，扮演什么角色。
2. 核心指令：清晰说明它的任务和决策流程。
3. 可用工具列表：列出所有它能使用的工具及其描述、参数。
4. 输出格式要求：强制要求它以指定的JSON格式回应。
5. 对话历史与当前观察：提供上下文信息。

def construct_prompt(tools: list, history: str, observation: str) -> str: """ 构造发送给LLM的提示词。 :param tools: 可用工具列表，每个工具应有name, description, args属性 :param history: 字符串形式的对话历史 :param observation: 当前的观察（用户问题或上一个工具的结果） :return: 构造好的提示词字符串 """ tools_description = "\n".join([f"- {t['name']}: {t['description']} 参数: {t['args']}" for t in tools]) prompt = f""" 你是一个专业的AI助手，能够使用工具来完成用户的任务。 你的决策必须遵循以下流程： 1. 根据对话历史和当前观察，思考你需要做什么。 2. 如果你有足够信息直接回答用户，请选择 `action: "final_answer"`。 3. 如果需要使用工具，请从可用工具中选择一个，并填写正确的参数。 可用工具列表： {tools_description} 对话历史： {history} 当前观察： {observation} 请严格按照以下JSON格式输出你的决策： {{ "thought": "你的详细思考过程，解释为什么选择这个动作。", "action": "动作名称，必须是 'final_answer' 或上述工具名之一", "action_input": {{}} // 动作参数，字典格式。如果是final_answer，则用 {{"answer": "你的回答内容"}} }} 现在，请输出你的决策JSON： """ return prompt

最后，我们来实现大脑类。它负责调用LLM API并解析返回的JSON。这里我以OpenAI的API为例，但设计上应该易于切换其他模型。

import json import openai from typing import List, Dict, Any class AgentBrain: def __init__(self, llm_client, model: str = "gpt-3.5-turbo"): """ 初始化大脑。 :param llm_client: LLM客户端，例如openai.OpenAI() :param model: 使用的模型名称 """ self.client = llm_client self.model = model def think(self, tools: List[Dict], history: str, observation: str) -> AgentAction: """ 核心思考函数。构造提示词，调用LLM，解析返回的Action。 """ prompt = construct_prompt(tools, history, observation) try: response = self.client.chat.completions.create( model=self.model, messages=[{"role": "user", "content": prompt}], temperature=0.1, # 低温度保证输出稳定，更适合决策 response_format={"type": "json_object"} # 强制要求返回JSON ) content = response.choices[0].message.content action_dict = json.loads(content) # 使用Pydantic模型验证和转换 action = AgentAction(**action_dict) return action except json.JSONDecodeError as e: raise ValueError(f"LLM返回的不是有效JSON: {content}") from e except Exception as e: raise RuntimeError(f"调用LLM时发生错误: {e}") from e

注意：在实际操作中，LLM并不总是乖乖返回完美JSON。尽管我们使用了response_format参数和json.loads，有时它还是可能在JSON外面包裹一些解释性文字。更健壮的做法是，在解析前先用正则表达式尝试从文本中提取JSON块。这是一个常见的“坑”，在后续的“避坑指南”章节我们会详细讨论处理方案。

至此，我们的大脑就搭建好了。它能接收上下文，思考，并输出一个结构化的决策。下一步，我们需要为它配备可以执行的“工具”。

4. 打造“双手”：可扩展的工具系统设计与实现

工具是Agent能力的延伸。一个设计良好的工具系统，应该满足两个核心要求：易于注册和安全调用。我们不应该把所有的功能都硬编码在Agent的核心循环里，而是应该提供一个插件化的机制。

首先，我们来定义什么是“工具”。一个工具本质上是一个函数，加上一些元数据（名字、描述、参数schema）。我们可以用一个装饰器来优雅地实现工具的注册。

# 工具注册表，全局单例 class ToolRegistry: _tools = {} @classmethod def register(cls, name: str, description: str): """装饰器，用于注册一个工具函数""" def decorator(func): cls._tools[name] = { 'function': func, 'description': description, 'args': func.__annotations__ # 从函数注解中获取参数类型（简易版） } return func return decorator @classmethod def get_tool(cls, name): return cls._tools.get(name) @classmethod def list_tools(cls): return [{'name': k, 'description': v['description'], 'args': str(v['args'])} for k, v in cls._tools.items()]

现在，我们可以像下面这样轻松地定义和注册工具了：

@ToolRegistry.register( name="search_web", description="使用搜索引擎获取最新信息。对于需要实时数据或未知信息的问题非常有用。" ) def search_web(query: str) -> str: """ 模拟网络搜索。 注意：这里为了简化，我们模拟返回结果。真实场景应集成SerpAPI、Google Search API等。 :param query: 搜索关键词 :return: 搜索结果摘要 """ # 模拟网络请求和结果解析 print(f"[工具调用] 正在搜索: {query}") # 此处应替换为真实的API调用，例如： # results = google_search_api(query) # return summarize(results) simulated_results = { "python最新版本": "Python最新稳定版本是3.12.2，于2023年10月发布。", "今天北京天气": "北京今天晴转多云，气温5-15摄氏度，西北风3-4级。", "什么是AIAgent": "AIAgent是一种能够感知环境、自主决策并执行行动以实现目标的软件实体。" } return simulated_results.get(query, f"未找到关于'{query}'的明确信息。") @ToolRegistry.register( name="calculate", description="执行数学计算。支持加减乘除、乘方等基本运算。" ) def calculate(expression: str) -> str: """ 计算数学表达式。 警告：直接使用eval有安全风险！此处仅作演示，生产环境必须使用安全评估库（如ast.literal_eval）或解析器。 :param expression: 数学表达式，如 '2 + 3 * (4 - 1)' :return: 计算结果 """ try: # 严重安全警告：此处仅用于演示。真实项目必须禁用eval或进行严格过滤。 result = eval(expression, {"__builtins__": {}}, {}) return f"计算结果: {expression} = {result}" except Exception as e: return f"计算错误: {e}" @ToolRegistry.register( name="final_answer", description="当你有足够信息回答用户时，使用此工具输出最终答案。" ) def final_answer(answer: str) -> str: """ 输出最终答案，并终止Agent循环。 :param answer: 给用户的最终回答 :return: 答案字符串 """ return f"[最终答案] {answer}"

重要安全提示：上面的calculate工具使用了eval()，这在任何生产环境都是极度危险的，因为它允许执行任意代码。这里仅为了演示工具调用的流程。在实际开发中，你必须使用安全的替代方案，例如：

1. 使用ast.literal_eval()只评估字面量表达式。
2. 使用专门的数学表达式解析库（如numexpr）。
3. 或者，更简单地，直接告诉LLM它自己计算（对于简单算术），或者集成一个安全的计算API。

工具注册好后，我们需要一个“工具执行器”来调用它们。这个执行器需要处理参数传递和错误捕获。

class ToolExecutor: @staticmethod def execute(action: AgentAction) -> str: """ 根据Agent的决策执行对应的工具。 :param action: Agent的决策动作 :return: 工具执行的结果字符串 """ tool_info = ToolRegistry.get_tool(action.action) if not tool_info: return f"错误：未知工具 '{action.action}'。" func = tool_info['function'] try: # 将action_input字典解包作为关键字参数传入函数 result = func(**action.action_input) return str(result) except TypeError as e: return f"工具调用参数错误：{e}。期望参数：{tool_info['args']}" except Exception as e: return f"工具执行过程中发生未知错误：{e}"

现在，大脑（负责思考并发出指令）和双手（负责执行指令）都已经就位。我们需要一个“记忆”系统来让它们的工作变得连贯，并最终用一个“主循环”把它们全部驱动起来。

5. 串联与驱动：实现核心控制循环与记忆管理

有了大脑和工具，Agent已经具备了思考和行动的能力。但要完成一个多步骤的任务，它还需要记住之前发生了什么（记忆），并且需要一个“总控开关”来协调整个流程（控制循环）。我们先来实现一个最简单的记忆系统——对话历史记录。

class SimpleMemory: """简易记忆系统，仅保存对话历史。""" def __init__(self, max_turns: int = 10): self.history = [] # 列表项格式: {"role": "user|assistant|tool", "content": "..."} self.max_turns = max_turns # 最大历史轮数，防止上下文过长 def add(self, role: str, content: str): """添加一条记录到历史。""" self.history.append({"role": role, "content": content}) # 如果历史记录超过限制，移除最旧的一些记录（这里简化处理，移除最早的一条） if len(self.history) > self.max_turns * 2: # 假设每轮包含user和assistant两条 self.history = self.history[2:] def get_conversation_string(self) -> str: """将历史记录格式化为字符串，作为提示词的一部分。""" lines = [] for item in self.history: if item["role"] == "tool": lines.append(f"工具执行结果: {item['content']}") else: lines.append(f"{item['role']}: {item['content']}") return "\n".join(lines) def clear(self): """清空记忆。""" self.history.clear()

这个记忆类非常简单，只是按顺序保存了用户、助手和工具输出的所有记录。在实际更复杂的Agent中，你可能会需要短期/长期记忆分离、基于向量的记忆检索等高级功能，但作为起步，这个简易版本完全够用。

现在，是时候将大脑、工具和记忆组装起来，打造最激动人心的部分——智能体控制循环（Agent Loop）。这个循环是Agent的“心脏”，它永不停歇地跳动，直到任务完成。

class SimpleAgent: def __init__(self, brain: AgentBrain, max_iterations: int = 5): """ 初始化简易Agent。 :param brain: AgentBrain实例，负责思考决策 :param max_iterations: 最大循环迭代次数，防止无限循环 """ self.brain = brain self.memory = SimpleMemory() self.tool_executor = ToolExecutor() self.max_iterations = max_iterations def run(self, user_input: str) -> str: """ 运行Agent，处理用户输入。 :param user_input: 用户的初始问题或指令 :return: Agent的最终回答 """ print(f"用户: {user_input}") self.memory.add("user", user_input) observation = user_input # 第一轮观察就是用户输入 final_result = None for i in range(self.max_iterations): print(f"\n--- 第 {i+1} 轮思考 ---") # 1. 思考：大脑根据记忆和观察做出决策 tools_for_prompt = ToolRegistry.list_tools() history_str = self.memory.get_conversation_string() try: action = self.brain.think(tools_for_prompt, history_str, observation) except Exception as e: error_msg = f"思考过程出错: {e}" self.memory.add("assistant", error_msg) return error_msg print(f"思考: {action.thought}") print(f"决策: 执行 [{action.action}]， 参数: {action.action_input}") # 2. 行动：执行决策 if action.action == "final_answer": # 如果是最终答案，提取内容并结束循环 final_result = action.action_input.get("answer", "（未提供答案内容）") self.memory.add("assistant", final_result) print(f"最终答案: {final_result}") break else: # 否则，调用工具执行器 tool_result = self.tool_executor.execute(action) print(f"工具结果: {tool_result}") # 将工具执行结果作为下一轮的观察 observation = tool_result # 将工具调用和结果存入记忆 self.memory.add("assistant", f"我决定执行 {action.action}。") self.memory.add("tool", tool_result) else: # 如果for循环正常结束（未break），说明达到最大迭代次数 final_result = f"任务未在{self.max_iterations}步内完成。最后观察：{observation}" self.memory.add("assistant", final_result) return final_result if final_result else "任务执行完毕，但未生成最终答案。"

让我们写一个简单的main函数来测试一下我们这个亲手搭建的AIAgent框架：

def main(): # 0. 初始化（假设已设置好OPENAI_API_KEY环境变量） import os from openai import OpenAI client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY")) # 1. 创建大脑 brain = AgentBrain(client, model="gpt-3.5-turbo") # 2. 创建Agent agent = SimpleAgent(brain, max_iterations=5) # 3. 运行几个示例任务 test_queries = [ "Python的最新版本是多少？", "先搜索一下北京今天的天气，然后告诉我适不适合出门散步。", "计算一下(15 + 7) * 3 等于多少？" ] for query in test_queries: print("\n" + "="*50) print(f"处理查询: {query}") print("="*50) result = agent.run(query) print(f"\nAgent最终回复: {result}") # 清空记忆，开始下一个独立对话 agent.memory.clear() if __name__ == "__main__": main()

运行这个程序，你会看到Agent一步步地思考、调用工具、获取结果，并最终给出答案。虽然我们的工具是模拟的，但整个决策和执行流程是完整且真实的。你已经拥有了一个可以自主工作的AIAgent核心框架。

6. 避坑指南：从理论到实践必须跨越的几道坎

框架跑起来只是第一步。在实际编码和调试过程中，我遇到了不少预料之外的问题。下面分享几个最常见的“坑”及其解决方案，希望能帮你节省大量时间。

坑一：LLM不按JSON格式输出尽管我们在提示词里千叮万嘱，并且使用了OpenAI的response_format={"type": "json_object"}参数，LLM（特别是早期版本或某些开源模型）有时仍然会在JSON前后加上一些无关文本，比如“好的，这是我的决策：”，或者输出格式略有偏差。

解决方案：在解析前增加一个健壮的“JSON提取”步骤。

import re import json def safe_parse_json(llm_output: str): """ 尝试从可能包含额外文本的LLM输出中提取并解析JSON。 """ # 方法1：尝试直接解析 try: return json.loads(llm_output) except json.JSONDecodeError: pass # 方法2：使用正则表达式寻找最像JSON的块 # 这个正则匹配以{开头，以}结尾，中间内容相对平衡的字符串（简易版） json_pattern = r'\{[^{}]*\}' # 匹配不包含嵌套{}的最简单JSON # 更健壮的正则可以匹配多层嵌套，但更复杂。一个折中方案是逐字符扫描找匹配的括号。 # 这里提供一个更实用的方法：找到第一个'{'和最后一个'}' start = llm_output.find('{') end = llm_output.rfind('}') if start != -1 and end != -1 and start < end: potential_json = llm_output[start:end+1] try: return json.loads(potential_json) except json.JSONDecodeError: pass # 如果都失败，可以尝试让LLM自我修复，或者返回一个明确的错误动作 raise ValueError(f"无法从LLM输出中解析JSON: {llm_output[:200]}...")

然后在AgentBrain.think方法中，用safe_parse_json(content)替换json.loads(content)。

坑二：工具参数类型不匹配LLM输出的action_input字典中的值，默认都是字符串类型。但我们的工具函数可能期望整数、浮点数或布尔值。直接传入会导致TypeError。

解决方案：在工具执行器中进行智能类型转换。

class ToolExecutor: @staticmethod def execute(action: AgentAction) -> str: tool_info = ToolRegistry.get_tool(action.action) if not tool_info: return f"错误：未知工具 '{action.action}'。" func = tool_info['function'] # 获取函数参数的期望类型注解 import inspect sig = inspect.signature(func) params = sig.parameters processed_args = {} for arg_name, arg_value in action.action_input.items(): if arg_name in params: expected_type = params[arg_name].annotation # 如果函数有类型注解，并且不是inspect._empty，尝试转换 if expected_type != inspect.Parameter.empty: try: # 简易类型转换，可根据需要扩展 if expected_type is int: processed_args[arg_name] = int(arg_value) elif expected_type is float: processed_args[arg_name] = float(arg_value) elif expected_type is bool: # 处理字符串形式的布尔值 if isinstance(arg_value, str): processed_args[arg_name] = arg_value.lower() in ('true', '1', 'yes', 't') else: processed_args[arg_name] = bool(arg_value) else: processed_args[arg_name] = arg_value except (ValueError, TypeError): # 转换失败，使用原值，让函数自己去处理错误 processed_args[arg_name] = arg_value else: processed_args[arg_name] = arg_value else: # 传入的参数在函数签名中不存在，可以忽略或报错 print(f"警告：工具 {action.action} 不接受参数 '{arg_name}'，已忽略。") try: result = func(**processed_args) return str(result) except Exception as e: return f"工具执行错误: {e}"

坑三：无限循环或无效循环Agent可能会陷入“死胡同”，比如反复调用同一个工具却得不到进展，或者在“思考”和“调用工具”之间来回切换而不输出最终答案。

解决方案：

1. 设置硬性上限：就像我们在SimpleAgent里做的max_iterations，这是最后的安全网。
2. 在提示词中强调“最终答案”：明确告诉LLM，当信息足够时，必须使用final_answer工具。
3. 实现循环检测：在内存中记录最近几次的动作和观察，如果发现完全相同的模式重复出现（例如，连续两次search_web且查询词相同），则强制中断循环，并提示Agent“你似乎陷入了循环，请尝试其他方法或直接给出当前已知的最佳答案”。

坑四：工具描述不清导致LLM误用如果工具的描述太模糊，LLM可能无法理解何时该用这个工具，或者该传什么参数。例如，一个名为get_data的工具，如果描述只是“获取数据”，LLM会用得很困惑。

解决方案：编写清晰、具体的工具描述，最好包含使用场景和示例。

# 不好的描述 @ToolRegistry.register(name="get_data", description="获取数据") # 好的描述 @ToolRegistry.register( name="query_database", description="根据给定的SQL查询语句，从用户订单数据库中检索信息。仅用于回答关于订单历史、产品库存的问题。参数'sql'必须是一个合法的SELECT语句。" )

清晰的描述能极大提升工具调用的准确率。

7. 从简易到实用：框架的扩展方向与性能考量

我们搭建的这个框架是一个完美的起点，但它离一个生产可用的、健壮的AIAgent还有距离。如果你希望在此基础上继续深化，以下几个扩展方向值得投入精力：

1. 增强记忆系统当前的SimpleMemory只是一个对话记录器。一个真正的记忆系统应该包含：

• 短期记忆（对话历史）：可以升级为带摘要的对话历史，将长对话压缩成关键点，节省Token。
• 长期记忆（向量存储）：集成像Chroma、Pinecone或FAISS这样的向量数据库。将对话中的关键实体、事实转换成向量存储起来，当遇到相关问题时，通过语义搜索快速检索，让Agent真正“记住”过去。
• 记忆的反思与提炼：高级的Agent不仅存储记忆，还会定期“反思”，从一系列交互中总结出经验、规则或用户偏好，并存入长期记忆。

2. 实现更复杂的决策逻辑目前我们使用的是单一的“思考-行动”循环。更复杂的Agent可能需要：

• 规划（Planning）：在开始行动前，先制定一个多步骤的计划（Plan）。例如，处理“为我策划一个周末旅行”这样的任务时，Agent可以先规划出“搜索目的地->查询天气->查找酒店->规划行程”的步骤树。
• 多智能体协作：你可以创建多个具有不同专长的Agent（一个负责搜索，一个负责分析，一个负责写作），让它们通过一个“协调者”Agent或者消息队列进行协作，共同完成复杂任务。

3. 提升可靠性与安全性这是将玩具变为工具的关键。

• 输入/输出验证：对所有用户输入和LLM输出进行严格的清洗和验证，防止提示词注入攻击。
• 工具执行沙箱：对于像calculate这样可能执行代码的工具，必须在安全的沙箱环境中运行，彻底隔离风险。
• 成本与延迟监控：记录每次API调用的Token消耗和耗时，设置预算和超时限制，避免意外的高额费用或长时间挂起。

4. 优化性能与用户体验

• 流式输出（Streaming）：对于生成最终答案的过程，可以支持流式输出，让用户看到Agent是“边想边说”，而不是长时间等待后一次性给出大段文字，体验会好很多。
• 异步执行：如果某些工具调用是IO密集型的（如网络请求），可以将主循环改为异步（Async），让Agent在等待一个工具结果的同时，可以处理其他任务（在多Agent场景下尤其有用）。

5. 集成外部生态系统

• 连接真实工具：将模拟的search_web替换为真正的Google Search或Serper API，将计算连接到WolframAlpha，将文件操作连接到云存储。
• 支持多模态：让Agent不仅能处理文本，还能“看”图片、“听”音频。这需要集成多模态LLM（如GPT-4V）和相应的处理工具。

亲手搭建这个简易框架的最大价值，不在于它的功能有多强大，而在于你获得了对AIAgent内部运作机制的完全掌控力和深刻理解。当你在使用LangChain这样的大型框架时，如果遇到一个难以调试的问题，你现在的经验能让你更快地定位到问题可能出在“工具调用”、“提示词构造”还是“记忆检索”环节。这份从零构建的体验，是任何现成框架都无法给予的宝贵财富。