AI Agent 架构基础组成模块深度解析

• 文件操作工具
• 网络请求工具
• 数据处理工具
• 外部 API 工具

四、几个核心实现思路

Agent 的实现方式很多，但从入门角度看，最值得先理解的是'基础执行流程'和'ReAct 循环'。这两种思路几乎能覆盖大多数早期 Agent 设计。

4.1 基础执行框架

一个典型的 Agent，通常会经历'理解任务 → 制定计划 → 执行步骤 → 校验结果 → 汇总输出'这条链路。下面这段代码就是一个简化版框架，适合用来理解整体运行机制。

class AIAgent:
    """AI Agent 执行框架"""

    def __init__(self, llm, tools=None):
        self.llm = llm
        self.tools = tools or []
        self.memory = []

    def execute(self, task):
        """执行任务的主入口"""
        understanding = self._understand(task)
        plan = self._plan(understanding)

        results = []
        for step in plan:
            result = self._execute_step(step)
            results.append(result)

            if not self._verify(result):
                plan = self._replan(step, result)

        return self._summarize(results)

    def _understand(self, task):
        """理解任务意图"""
        prompt = f"分析以下任务的核心目标：{task}"
        return self.llm.generate(prompt)

    def _plan(self, understanding):
        """规划执行步骤"""
        prompt = f"为以下目标制定执行计划：{understanding}"
        plan_text = self.llm.generate(prompt)
        return self._parse_plan(plan_text)

    def _execute_step(self, step):
        """执行单个步骤"""
        tool = self._select_tool(step)
        result = tool.execute(step)
        self.memory.append({'step': step, 'tool': tool.name, 'result': result})
        return result

    def _verify(self, result):
        """验证执行结果"""
        return result.get('success', False)

    def _replan(self, failed_step, result):
        """重新规划"""
        prompt = f"步骤'{failed_step}'执行失败，结果：{result}，请调整计划"
        new_plan = self.llm.generate(prompt)
        return self._parse_plan(new_plan)

    def _summarize(self, results):
        """总结执行结果"""
        prompt = f"总结以下执行结果：{results}"
        return self.llm.generate(prompt)

    def _parse_plan(self, plan_text):
        """解析计划文本为步骤列表"""
        return [line.strip() for line in plan_text.split('\n') if line.strip()]

    def _select_tool(self, step):
        """选择合适的工具"""
        for tool in self.tools:
            if tool.can_handle(step):
                return tool
        return DefaultTool()


# 使用示例
agent = AIAgent(llm=MockLLM(), tools=[FileTool(), WebTool()])
result = agent.execute("帮我整理桌面的所有PDF文件")
print(result)

这段代码的重点不在'能不能直接跑通'，而在于它把 Agent 的基本职责拆得很清楚。任务理解、计划生成、工具选择、结果校验，这几个环节缺一块，Agent 就容易退化成一个'只会一次性回答'的普通对话模型。

4.2 ReAct 执行循环

ReAct 是另一个非常经典的设计思路，它把 Agent 的行为描述成'思考（Reason）-行动（Act）-观察（Observe）'的循环。这个范式很适合需要多步推理、逐步探索的任务。

# ReAct: 思考-行动-观察循环
class ReActAgent:
    """基于 ReAct 范式的 AI Agent"""

    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = {tool.name: tool for tool in tools}
        self.max_iterations = 10

    def run(self, task):
        """运行 ReAct 循环"""
        context = f"任务：{task}\n"

        for _ in range(self.max_iterations):
            thought = self._think(context)
            print(f"[思考] {thought}")

            if "任务完成" in thought or "Final Answer:" in thought:
                return self._extract_answer(thought)

            action, action_input = self._decide_action(thought)
            print(f"[行动] {action}({action_input})")

            observation = self._observe(action, action_input)
            print(f"[观察] {observation}")

            context += f"\n思考：{thought}\n行动：{action}({action_input})\n观察：{observation}"

        return "达到最大迭代次数，任务未完成"

    def _think(self, context):
        """思考下一步"""
        prompt = f"""
{context}
请思考下一步应该做什么。如果任务已完成，请回答"任务完成：[结果]"
"""
        return self.llm.generate(prompt)

    def _decide_action(self, thought):
        """决定执行什么行动"""
        prompt = f"根据思考'{thought}'，选择要执行的工具和参数"
        response = self.llm.generate(prompt)
        return self._parse_action(response)

    def _observe(self, action, action_input):
        """执行行动并观察结果"""
        if action in self.tools:
            return self.tools[action].execute(action_input)
        return f"未知工具：{action}"

    def _extract_answer(self, thought):
        """提取最终答案"""
        return thought.split("任务完成：")[-1].strip()

    def _parse_action(self, response):
        """解析行动响应"""
        lines = response.strip().split('\n')
        action = "default"
        action_input = ""
        for line in lines:
            if "工具：" in line or "tool:" in line.lower():
                action = line.split("：")[-1].strip()
            if "参数：" in line or "input:" in line.lower():
                action_input = line.split("：")[-1].strip()
        return action, action_input


class Tool:
    name = "base_tool"

    def execute(self, input_data):
        raise NotImplementedError

    def can_handle(self, task):
        return False


class FileTool(Tool):
    name = "file_tool"

    def execute(self, input_data):
        return f"文件操作完成：{input_data}"

    def can_handle(self, task):
        return "文件" in task or "file" in task.lower()


class WebTool(Tool):
    name = "web_tool"

    def execute(self, input_data):
        return f"网络请求完成：{input_data}"

    def can_handle(self, task):
        return "搜索" in task or "网页" in task or "web" in task.lower()


class DefaultTool(Tool):
    name = "default"

    def execute(self, input_data):
        return f"默认处理：{input_data}"


class MockLLM:
    def generate(self, prompt):
        if "思考" in prompt:
            return "我需要先搜索相关信息"
        elif "选择" in prompt:
            return "工具：web_tool\n参数：搜索AI Agent"
        return "处理完成"

ReAct 的关键价值在于，它把'推理'和'执行'绑在一起了。模型不需要一次性给出所有答案，而是可以边做边看结果，再决定下一步。实际项目里，这种方式特别适合搜索、信息整理、表单处理、文件操作等多轮任务。

五、技术为什么会朝这个方向演进

如果回头看这几年 Agent 的演进，会发现它不是突然冒出来的，而是大模型能力增强之后，顺势长出来的一条工程路径。

这条路径背后，其实是一个很朴素的事实：单纯回答问题的模型已经不够用了，真正有价值的，是能把任务往下推进、把事情做完的系统。

六、落到实践里，Agent 通常怎么用

在企业里，Agent 最常见的落地方向并不是'完全替代人'，而是帮人处理那些重复、标准化、步骤明确的工作。

6.1 典型应用场景

企业自动化 常见于：

个人效率 则更常见于：

• 写作辅助：大纲生成、内容扩写、润色修改
• 工作效率：邮件处理、会议纪要、任务管理
• 创意工作：灵感激发、方案生成、素材整理
• 信息处理：文档总结、数据清洗、知识管理

6.2 实施时怎么推进更稳妥

真正做项目时，最怕的不是技术难，而是一下子摊太大。比较稳的做法，是先把需求边界收紧，再慢慢扩展。

• 先明确要解决什么问题
• 再确认现有流程是什么样的
• 然后判断 Agent 能覆盖到哪一段
• 最后再考虑指标、监控和兜底机制

方案设计时，可以按这个思路组织：项目目标、Agent 角色、工具配置、技术方案、实施计划、风险控制。这样写出来的方案不会飘在空中，后面也更容易落地。

6.3 一个容易被忽略的点

很多 Agent 项目失败，不是因为模型不够强，而是因为边界没画清楚。什么任务该自动化，什么任务必须人工确认，什么异常要回退，这些都要事先定好。否则系统越聪明，出错时的代价也可能越大。

七、怎么评估一个 Agent 是否真的好用

评估 Agent，不能只看'它答对了没有'，还要看过程是否稳定、成本是否可控、执行是否高效。

常见的关注点包括：

如果要做自动化评估，通常还会结合测试集、任务回放、人工抽检和日志分析一起看。单看一次结果，很容易被偶然性带偏。

八、未来会往哪里走

接下来几年，Agent 大概率会沿着几个方向继续发展：

从应用层面看，企业服务、个人助理、专业行业工具和创意协作，都会继续被重塑。尤其是那些流程明确、重复度高、对实时性有要求的场景，Agent 的优势会越来越明显。

九、本章小结

如果把这一章压缩成一句话，那就是：AI Agent 的本质，不是'会聊天的模型'，而是'能把任务推进到结果的系统'。

你需要记住的核心点有三个：

• Agent 不是单一模型，而是一个由模型、工具、规划和反馈组成的系统
• ReAct、计划执行、结果校验，是理解 Agent 的关键路径
• 真正的落地，永远离不开边界、评估和兜底机制

十、课后练习

• 用自己的话解释什么是 AI Agent，并举一个真实场景
• 设计一个简单的 Agent 流程图，标出模型层、工具层和执行层
• 找一个你熟悉的业务场景，思考哪些环节适合由 Agent 接手，哪些必须保留人工确认

十一、参考阅读

• ReAct: Synergizing Reasoning and Acting in Language Models
• Toolformer: Language Models Can Teach Themselves to Use Tools
• AutoGPT: An Autonomous GPT-4 Experiment

如果你已经接触过大模型应用开发，接下来最值得做的，不是继续追概念，而是亲手搭一个最小可用的 Agent 原型。很多理解，只有在真的让它跑起来之后，才会变得特别清楚。