从算法到人工智能 · 第 27 课：AI Agent——会调用工具的智能体

前面二十六课，我们从冒泡排序一路走到了 GPT。但有个问题一直悬着：大模型只会"生成文字"，它怎么"干活"？

• 它不会真的查今天的天气——只能凭记忆猜。
• 它不会真的发邮件、写文件、执行代码——只能输出"看起来像"的代码。

直到我们给大模型装上手和脚——让它调用工具。这就从"会说话的模型"进化成了"能干活的助手"：AI Agent（智能体）。

这一课，最后一课，我们看 Agent 是怎么工作的。

一、LLM 的短板：只会说，不会做

问 ChatGPT "现在北京几度？"，如果它没联网，只能给出一个"训练时见过"的模糊答案，甚至编造。

根本原因：大模型的知识冻结在训练数据里，它没有"实时获取信息"和"改变世界"的能力。

Agent 的解法：让模型在需要时，自己决定去调用一个工具，把工具的结果拿回来继续推理。

用户：北京今天天气怎么样？
模型：我需要调用"天气查询"工具 → 查北京
工具：晴，25度
模型：北京今天晴，25度。

模型不再"硬猜"，而是查了再答。这就是 Agent 的第一步——工具调用（tool use）。

二、工具调用：给模型一张"工具清单"

我们把工具包装成模型能理解的形式：

# 一个计算器工具
def calculator(expr):
    """安全地计算数学表达式"""
    return eval(expr, {"__builtins__": {}}, {})

# 一个模拟的搜索工具
def search(query):
    db = {"北京天气": "晴，25度", "上海天气": "小雨，20度"}
    return db.get(query, "未找到")

# 工具注册表：名字 → 函数
TOOLS = {"calculator": calculator, "search": search}

print(calculator("3*4+2"))   # 14
print(search("北京天气"))     # 晴，25度

关键：模型输出的不是"答案"，而是"我要调用哪个工具、传什么参数"。系统执行工具，把结果回喂给模型。这样模型就获得了实时、准确的能力。

三、ReAct：边想、边做、边看

工具调用不是一次性的，往往要多轮。最经典的范式叫 ReAct（Reason + Act）：

Thought（思考）→ Action（行动）→ Observation（观察）→ 再思考…… 循环，直到能给出最终答案。

def solve(task):
    for step in range(3):          # 最多循环 3 轮
        # ① Thought：模型决定这次用什么工具、传什么参数
        # ② Action：调用工具
        # ③ Observation：拿到工具结果，判断是否够了
        action, args = ("search", "北京天气")
        obs = TOOLS[action](args)
        if obs != "未找到":          # 找到答案就停
            return obs
    return "无法回答"

print(solve("北京今天天气怎么样？"))
# 晴，25度

ReAct 循环是几乎所有 Agent 的骨架：模型一边推理，一边调用工具，一边观察结果，直到任务完成。

四、记忆：让 Agent 记得"说过什么"

大模型无状态，每次调用都是"失忆"的。Agent 用记忆（memory）解决：

memory = []   # 会话历史

def remember(role, msg):
    memory.append(f"{role}: {msg}")
    if len(memory) > 6:      # 只保留最近几条，控制上下文长度
        memory.pop(0)

remember("user", "你好")
remember("assistant", "你好，有什么可以帮你？")
remember("user", "北京天气")

for m in memory:
    print(m)

记忆分两种：

• 短期记忆：当前会话的上下文（就是上面这个列表）。
• 长期记忆：存到数据库/向量库，跨会话记得你的偏好、事实、约定。

这就是为什么我能记住"你是我的主人""你喜欢……"——因为我有记忆。

长期记忆的落地：RAG（检索增强生成）

"长期记忆存到向量库"这句话，值得展开——它就是当前最火的 RAG（Retrieval-Augmented Generation，检索增强生成）。

要解决的问题：大模型的知识冻结在训练数据里，会幻觉（hallucination）——一本正经地编造不存在的事实。比如问它"我公司最新财报"，它答得像模像样，其实全是编的。

RAG 的思路：让模型先查资料，再回答，而不是凭记忆硬答：

1. 把知识（文档、手册、数据库……）切块，用 embedding 转成向量，存进向量库
2. 用户提问 → 把问题也转成向量 → 在向量库里找最相似的几块（向量检索）
3. 把检索到的原文片段，连同问题一起塞进 prompt
4. 模型基于"真实的资料"回答，而不是瞎编

核心是第 25 课学的 embedding：语义相近的问题和答案，向量也相近，所以能用向量相似度"搜"出相关资料。

# 概念示意：向量相似度检索
import numpy as np

def cosine(a, b): return a @ b / (np.linalg.norm(a)*np.linalg.norm(b))

# 知识库（真实实现用向量数据库，如 faiss/milvus/pgvector）
kb = {
    "公司2024年营收是120亿": np.array([0.9, 0.1, 0.2]),
    "周末天气晴朗适合出游": np.array([0.1, 0.9, 0.1]),
}
query = "公司去年赚了多少钱？"       # 假设 embedding 后
q_vec = np.array([0.85, 0.15, 0.25])

best = max(kb.items(), key=lambda kv: cosine(kv[1], q_vec))
print("检索到最相关的资料:", best[0])
# 把 best[0] 塞进 prompt，模型基于它回答

为什么 RAG 重要：它同时解决了三个问题——

• 幻觉：答案有据可查
• 知识过期：更新文档即可，不用重训模型
• 私有数据：能回答只存在你公司内部的知识

所以现代 Agent（包括我）的"长期记忆"，往往就是一个 RAG 系统：你的偏好、约定存进向量库，需要时检索回来用。这第 4 节末尾的"我能记住你"，背后就是这个机制。

五、规划：把大任务拆成小步骤

复杂任务不是一句话能完成的。Agent 需要规划（planning）：

把"帮我写一份市场报告"拆成：① 搜索资料 → ② 整理要点 → ③ 写初稿 → ④ 修改润色。

规划可以是提前列好计划（plan-then-execute），也可以是边走边想下一步（就像 ReAct）。你之前看到我用的"任务面板"，就是 Agent 的规划能力在落地。

六、多智能体协作：一群 Agent 各司其职

再进一步，多个 Agent 可以分工协作：

它们之间互相传递结果、互相检查。这就是多智能体系统（Multi-Agent）——把"一个大脑"变成"一个团队"。

七、Agent 与 API 的边界：能力 vs 自主

边界在于"自主性"：Agent 越自主，能力越强，但越需要权限、安全、可回滚的约束。这也是为什么真正上线的 Agent 都要"高风险操作需确认"。

八、复杂度与要点

九、动手时间 🎯

实验 1：搭一个最小的 ReAct Agent

把第二节的工具 + 第三节的循环拼起来，做一个"能查天气、能算数"的小 Agent：

TOOLS = {
    "calculator": lambda e: eval(e, {"__builtins__": {}}, {}),
    "search": lambda q: {"北京天气": "晴，25度"}.get(q, "未找到"),
}

def react(task):
    # 极简：按关键词决定用哪个工具（真实 Agent 由 LLM 决定）
    if "天气" in task:
        return TOOLS["search"]("北京天气")
    if any(c.isdigit() for c in task):
        return TOOLS["calculator"](task)
    return "我不会"

print(react("北京今天天气怎么样？"))
print(react("3*4+2"))

实验 2：给 Agent 加"记忆"

在实验 1 的基础上，加一个 memory 列表，让 Agent 能记住前一轮的对话，再回答时带上历史。

实验 3（挑战）：接一个真实的 LLM API

如果你有 OpenAI 兼容的 key，把"决定用哪个工具"这一步换成真实 LLM 输出，就得到了一个真正的 Agent。试试让它回答"北京天气"和"3*4+2"。

十、最后一课：你走过的路

回头看这 18 课，你完成了一次了不起的旅程：

算法基础（排序、查找、递归、图、DP）
    ↓
机器学习（线性回归、梯度下降）
    ↓
深度学习（神经网络、CNN、RNN）
    ↓
Transformer（注意力机制）
    ↓
大语言模型（GPT、自回归、预训练）
    ↓
AI Agent（工具调用、ReAct、记忆、规划）

这条路的每一步，都不是魔法，而是"数据 + 算法 + 算力"的必然结果：

1. 算法：从冒泡排序到 Dijkstra，你学会了"怎么高效地算"。
2. 机器学习：从梯度下降开始，你学会了"怎么从数据里学"。
3. 深度学习：从神经网络到 Transformer，你学会了"怎么学更复杂的关系"。
4. Agent：从工具调用到多智能体，你学会了"怎么让 AI 真正干活"。

你今天用到的我，就是这条路的终点——一个会调用工具、有记忆、会规划、还懂你的 AI Agent。

而这，才是开始。下一个会写 Agent 的人，也许就是你。

十一、小结

1. Agent = LLM + 工具 + 记忆 + 规划：让模型从"会说话"变成"能干活的助手"。
2. ReAct 循环：Thought → Action → Observation，边想边做边看，直到任务完成。
3. 自主性带来能力，也带来风险：越自主越强大，但越需要权限、安全与可回滚的约束。

全 18 课 · 完。愿你从"会写算法"的人，成为"会造智能"的人。