AI Agent开发实战①｜从“问答机器人“到“智能体“：AI Agent核心架构原理解析

AI Agent开发实战①｜从"问答机器人"到"智能体"：AI Agent核心架构原理解析

同样的LLM接入，为什么有的系统能自主规划任务、调用工具、反思错误，有的只能机械回答一句话？答案不在模型本身，在于Agent架构设计。本文从原理出发，拆解AI Agent的六大核心组件，以及它们如何构成一个真正的智能闭环。

一、为什么"模型+提示词"不够用了

先看一个真实场景。

你写了一个客服机器人，接入了GPT-4，效果测试不错。但上线后发现：

• 用户问"我的订单到哪了"，它回答"请提供订单号"——但用户明明刚聊过
• 用户问"之前那个问题解决了吗"，它完全忘了上下文
• 用户要求"帮我查下快递"，它只能说"抱歉我无法访问物流系统"

这不是模型不够强，而是系统架构缺了关键模块。传统LLM调用是"问答模式"——输入→输出，结束。Agent是"行动模式"——感知→思考→行动→反馈→迭代，直到达成目标。

两者的本质区别：

二、AI Agent的六大核心组件

一个完整的AI Agent由六个模块构成，它们之间形成闭环：

感知(Perception) → 记忆(Memory) → 规划(Planning) ↓ 行动(Action) ← 工具(Tools) ← 反思(Reflection)

2.1 感知层：Agent的"眼睛和耳朵"

感知层负责接收所有输入，不只是用户对话：

classPerception:"""Agent感知层：多源信息融合"""def__init__(self):self.inputs={"user_message":None,# 用户自然语言"environment":None,# 环境状态（时间、位置、系统状态）"tool_results":[],# 工具返回结果"memory_context":[],# 记忆中的相关片段}defreceive(self,user_msg:str,env_state:dict=None)->dict:"""接收并结构化输入"""return{"user":user_msg,"env":env_stateor{},"history":self._get_recent_history(),"memory":self._retrieve_relevant_memory(user_msg)}defincorporate_tool_result(self,result:dict):"""将工具执行结果纳入感知"""self.inputs["tool_results"].append(result)

感知层的设计要点：不要只传用户消息，把环境上下文、工具历史返回、相关记忆片段一起传。这直接影响Agent对当前任务的理解深度。

2.2 记忆层：从"金鱼记忆"到"过目不忘"

这是大多数自建Agent最容易忽视的模块。记忆分三层：

┌─────────────────────────────────┐ │ 长期记忆 (Long-term) │ ← 向量数据库，存储历史经验/知识 ├─────────────────────────────────┤ │ 短期记忆 (Short-term) │ ← 当前会话上下文 ├─────────────────────────────────┤ │ 工作记忆 (Working Memory) │ ← 当前任务执行状态 └─────────────────────────────────┘

为什么很多Agent表现像金鱼？因为它们只有工作记忆，没有长期记忆。每次会话结束学到的东西全丢了。

fromdatetimeimportdatetimeclassAgentMemory:"""Agent三层记忆架构"""def__init__(self,vector_db):self.vector_db=vector_db self.short_term=[]# 当前会话历史self.working={}# 当前任务状态defstore_short_term(self,role:str,content:str):"""短期记忆：仅限当前会话"""self.short_term.append({"role":role,"content":content,"timestamp":datetime.now().isoformat()})defstore_long_term(self,content:str,metadata:dict):"""长期记忆：存入向量库"""# 嵌入后存储embedding=self._embed(content)self.vector_db.add(documents=[content],embeddings=[embedding],metadatas=[{**metadata,"stored_at":datetime.now().isoformat()}],ids=[f"lt_{metadata.get('task_id','unknown')}_{len(self.short_term)}"])defretrieve(self,query:str,top_k:int=3)->list:"""检索相关记忆"""query_emb=self._embed(query)results=self.vector_db.query(query_embeddings=[query_emb],n_results=top_k)returnresults["documents"][0]ifresults["documents"]else[]

一个反直觉的经验：不是记忆越多越好。研究表明，当记忆检索结果超过5条时，LLM的注意力会被分散，反而降低回答质量。建议对检索结果再做一次相关性过滤，只保留真正相关的记忆片段。

2.3 规划层：Agent的"大脑决策"

规划层是Agent智能的核心。不同复杂度对应不同规划策略：

策略1：直接执行（适合简单任务）

defplan_simple(task:str,tools:list,llm)->list:"""简单任务：一步到位"""response=llm.invoke(f""" 任务：{task}可用工具：{[t.namefortintools]}直接给出需要调用的工具和参数，只需一步。 """)returnparse_tool_calls(response)

策略2：思维链（适合需要推理的任务）

defplan_with_cot(task:str,context:dict,llm)->list:"""思维链：先推理步骤，再执行"""response=llm.invoke(f""" 任务：{task}当前状态：{context}请分步骤思考： 1. 分析任务目标 2. 确定需要的步骤 3. 识别潜在风险 4. 给出具体执行计划 最终输出执行步骤列表。 """)steps=parse_steps(response)returnsteps

策略3：自我反思（适合容易出错的复杂任务）

defplan_with_reflection(task:str,previous_attempt:dict,llm)->dict:"""带自我反思的规划"""# 第一次尝试plan=plan_with_cot(task,{})# 反思：检查计划是否有漏洞reflection=llm.invoke(f""" 请审查以下计划，指出潜在问题： 计划：{plan}检查维度： 1. 步骤顺序是否合理？ 2. 每个步骤的前置条件是否满足？ 3. 是否有遗漏的边界情况？ 4. 失败后的回退方案是什么？ """)# 根据反思优化计划optimized=llm.invoke(f""" 原计划：{plan}反思意见：{reflection}请给出优化后的执行计划。 """)returnparse_optimized_plan(optimized)

2.4 工具层：Agent的"手和脚"

工具是Agent与外部世界交互的桥梁。但工具设计有大量坑——设计不好，Agent一调用就崩溃。

好工具的三个标准：清晰的Schema、完善的错误处理、幂等性设计。

classTool:"""标准工具接口"""name:str# 工具唯一标识description:str# 供LLM理解工具用途parameters:dict# JSON Schema格式的参数定义defexecute(self,**kwargs)->dict:"""执行工具逻辑，返回标准化结果"""try:result=self._do_execute(**kwargs)return{"success":True,"data":result,"error":None}exceptValidationErrorase:# 参数校验失败 → 告诉LLM参数问题return{"success":False,"data":None,"error":f"参数错误：{str(e)}，请重新调用"}exceptTimeoutError:# 超时 → 可以重试return{"success":False,"data":None,"error":"请求超时，可以重试"}exceptExceptionase:# 未知错误 → 记录但不崩溃return{"success":False,"data":None,"error":f"执行异常：{type(e).__name__}，请检查输入"}# 示例：一个天气查询工具classWeatherTool(Tool):name="get_weather"description="查询指定城市的天气信息，返回温度、湿度、空气质量等"parameters={"type":"object","properties":{"city":{"type":"string","description":"城市名称（中文或英文）","examples":["北京","Shanghai"]},"date":{"type":"string","description":"查询日期，格式YYYY-MM-DD，默认今天","default":"today"}},"required":["city"]}def_do_execute(self,city:str,date:str="today")->dict:# 实际API调用逻辑...return{"temp":22,"humidity":65,"aqi":良}

2.5 行动层：Agent的"执行引擎"

行动层负责调用工具并处理返回结果。核心是一个循环：

classAgentExecutor:"""Agent执行引擎"""def__init__(self,llm,tools:list,memory:AgentMemory,max_iterations=10):self.llm=llm self.tools={t.name:tfortintools}self.memory=memory self.max_iterations=max_iterationsdefrun(self,task:str)->str:"""Agent主循环"""iteration=0context={"task":task,"steps":[],"observations":[]}whileiteration<self.max_iterations:iteration+=1# 1. 规划下一步decision=self.llm.invoke(self._build_prompt(context))# 2. 解析决策：工具调用 or 最终回答ifdecision.tool_calls:# 有工具调用forcallindecision.tool_calls:tool_name=call.function.name tool_args=json.loads(call.function.arguments)# 感知层：纳入工具结果iftool_nameinself.tools:result=self.tools[tool_name].execute(**tool_args)context["observations"].append({"tool":tool_name,"args":tool_args,"result":result})else:context["observations"].append({"tool":tool_name,"error":f"未知工具：{tool_name}"})else:# 无工具调用，返回最终答案final_answer=decision.content self.memory.store_short_term("assistant",final_answer)returnfinal_answer# 超过最大迭代次数return"抱歉，任务复杂度超出当前Agent处理能力，建议拆解后分步执行。"def_build_prompt(self,context:dict)->str:"""构建带上下文的prompt"""tool_descriptions="\n".join([f"-{name}:{t.description}"forname,tinself.tools.items()])history="\n".join([f"[{obs['tool']}] →{obs['result']}"forobsincontext.get("observations",[])])returnf""" 当前任务：{context['task']}已执行步骤：{historyifhistoryelse'（尚未开始）'}可用工具：{tool_descriptions}请根据当前状态，决定下一步： 1. 如果需要调用工具，给出工具名和参数 2. 如果任务已完成，直接给出最终回答 """

2.6 反思层：让Agent"吃一堑长一智"

反思是区分"能用"和"好用"Agent的关键。反思发生在两个时机：

• 行动前反思：检查计划是否有漏洞
• 行动后反思：评估结果是否达到目标，决定是否重试

classReflectionModule:"""Agent反思模块"""defreflect_before(self,plan:list,task:str,llm)->dict:"""行动前反思：优化计划"""critique=llm.invoke(f""" 请审查以下执行计划的风险： 任务：{task}计划：{plan}请指出： 1. 最可能失败的步骤是什么？（最大风险点） 2. 需要哪些容错处理？ 3. 是否可以并行化某些步骤？ """)return{"original":plan,"critique":critique}defreflect_after(self,result:dict,goal:str,llm)->dict:"""行动后反思：评估与修正"""evaluation=llm.invoke(f""" 评估本次执行结果： 目标：{goal}结果：{result}给出评分（0-10）和理由： 如果评分<7，说明哪里出了问题，以及如何改进。 """)# 如果结果不理想，触发重试ifevaluation.score<7:return{"status":"retry","improvement":evaluation.feedback}return{"status":"success","evaluation":evaluation}

三、完整Agent架构图

┌──────────────────────────────────────────────────────────────┐ │ 用户输入 │ └──────────────────────────┬───────────────────────────────────┘ ↓ ┌──────────────────────────────────────────────────────────────┐ │ 感知层 Perception │ │ • 用户消息 • 环境状态 • 工具历史返回 • 相关记忆检索 │ └──────────────────────────┬───────────────────────────────────┘ ↓ ┌──────────────────────────────────────────────────────────────┐ │ 记忆层 Memory │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ 短期记忆 │ │ 工作记忆 │ │ 长期记忆 │ │ │ │(会话上下文)│ │(任务状态) │ │(向量库) │ │ │ └──────────┘ └──────────┘ └──────────┘ │ └──────────────────────────┬───────────────────────────────────┘ ↓ ┌──────────────────────────────────────────────────────────────┐ │ 规划层 Planning │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ 简单任务 → 直接执行 │ │ │ │ 推理任务 → 思维链 (CoT) │ │ │ │ 复杂任务 → 思维树 (ToT) + 自我反思 │ │ │ └──────────────────────────────────────────────────────┘ │ └──────────────────────────┬───────────────────────────────────┘ ↓ ┌──────────────────────────────────────────────────────────────┐ │ ┌─────────────┐ 工具层 Tools ┌─────────────┐ │ │ │ 搜索工具 │ ←── LLM决定调用哪个 ──→ │ 天气API │ │ │ │ 计算器 │ │ 数据库查询 │ │ │ │ 文件读写 │ │ 邮件发送 │ │ │ └─────────────┘ └─────────────┘ │ └──────────────────────────┬───────────────────────────────────┘ ↓ ┌──────────────────────────────────────────────────────────────┐ │ 行动层 Action │ │ 执行工具 → 获取结果 → 反馈给规划层继续决策 │ └──────────────────────────┬───────────────────────────────────┘ ↓ ┌──────────────────────────────────────────────────────────────┐ │ 反思层 Reflection │ │ 行动前：检查计划漏洞 行动后：评估结果，决定重试或结束 │ └──────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────┐ │ 最终输出 │ └─────────────┘

四、实战：5分钟搭建一个最小可用的Agent

看了这么多理论，手痒了吧。5分钟搭一个能用的：

安装依赖

pipinstalllangchain langchain-openai langchain-community chromadb

完整代码

fromlangchain.agentsimportAgentExecutor,create_react_agentfromlangchain_openaiimportChatOpenAIfromlangchain.toolsimporttoolfromlangchainimporthub# 1. 定义工具@tooldefget_weather(city:str)->str:"""查询城市天气"""returnf"{city}今天晴，温度22-28度，适合出行"@tooldefcalculate(expression:str)->str:"""数学计算器，支持加减乘除和括号"""try:result=eval(expression,{"__builtins__":{}},{})returnstr(result)exceptExceptionase:returnf"计算错误：{e}"# 2. 初始化LLMllm=ChatOpenAI(model="gpt-4",temperature=0)# 3. 创建Agenttools=[get_weather,calculate]prompt=hub.pull("hwchase17/react")agent=create_react_agent(llm,tools,prompt)# 4. 执行agent_executor=AgentExecutor(agent=agent,tools=tools,verbose=True)result=agent_executor.invoke({"input":"北京今天的天气怎么样？顺便帮我算一下(25 + 17) * 3"})print(result["output"])# Agent会自动判断先查天气，再做计算，输出两个结果

运行效果：

• Agent自动识别出需要两个工具：天气查询 + 数学计算
• 自动推断调用顺序：先查天气，再计算
• 输出整合后的最终回答

五、为什么你搭的Agent总是不够"智能"？

常见原因排查：

六、总结

AI Agent的核心不是某个神奇的模型，而是一套架构设计：六大模块各司其职，通过闭环反馈持续迭代。理解了这个架构，你就能诊断任何Agent系统的问题，也能有针对性地优化任何一个薄弱环节。

下篇文章预告：「思维链vs ReAct：2026年Agent推理模式实测对比，附选型决策树」——同样是让Agent思考，CoT和ReAct在实际生产中性能差距有多大？不同任务类型应该如何选择？

需要完整源码的同学，可以看我主页的付费资源专栏。

有问题欢迎评论区留言，大家一起讨论！