AI Agent 开发实战（一）：别再把 LLM 当聊天机器人了，这才是 Agent 的正确打开方式

这是「AI Agent 开发实战」系列的第 1 篇。整个系列会从最基础的概念讲起，一步步迭代到 Multi-Agent 协作、可观测性、生产落地等完整技术路径。本文先回答一个最根本的问题：AI Agent 到底是什么，它和你以为的"聊天机器人"差在哪里。

一、先泼一盆冷水：LLM ≠ Agent

很多人第一次接触 AI Agent，是从 ChatGPT 这类对话框开始的。输入一句话，模型返回一段文字，看起来很"智能"。于是很容易产生一个错觉：

把 LLM 接到我的业务系统里，加个对话框，就是 Agent 了。

这是目前最常见的认知误区。真相是：

┌─────────────────────────────────────────────┐
│  聊天机器人（Chatbot）                        │
│  人提问 → LLM 回答 → 结束                     │
│  本质：单轮或多轮的文本生成                    │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│  AI Agent                                    │
│  人下指令 → LLM 思考 → 调用工具 → 观察结果     │
│       ↑                          │           │
│       └──────────循环────────────┘           │
│  本质：一个能"感知-推理-行动"的自主循环        │
└─────────────────────────────────────────────┘

两者的本质区别在于"循环"和"行动"。 聊天机器人只会说，Agent 会做——它会调用外部工具、读写数据库、发起 HTTP 请求、甚至调用其他 Agent，然后根据结果继续思考下一步该干什么，直到任务完成。

打个比方：LLM 是一个知识渊博但手脚被绑住的专家，你问什么它都能答，但它什么都"做"不了；而 Agent 是给这位专家松了绑，配了电脑、电话和执行团队，它能自己查资料、写代码、发邮件、协调任务。

二、什么是 AI Agent

学术界有个被广泛引用的定义（来自 Lilian Weng 的《LLM Powered Autonomous Agents》）：

Agent = LLM（大脑）+ Planning（规划）+ Memory（记忆）+ Tools（工具使用）

翻译成工程语言，一个 AI Agent 是一个以 LLM 为推理核心、具备记忆能力、能够调用外部工具、并能自主规划任务步骤的软件系统。

关键词是自主（Autonomous）。传统程序是"你告诉我每一步怎么做"，Agent 是"你告诉我目标，我自己决定每一步怎么做"。

举个例子，同样是"帮我查一下今天的股票价格并分析走势"：

传统应用的做法：

1. 用户输入股票代码
2. 程序调用股票 API
3. 程序按固定算法计算均线、MACD
4. 程序返回结果

每一步都是写死的，换一个需求就得改代码。

Agent 的做法：

1. 用户："帮我看看 600519 最近走势，要不要加仓"
2. Agent 思考：需要先拿到近期价格数据
3. Agent 调用工具：get_stock_price("600519", days=30)
4. Agent 观察结果：拿到 30 天收盘价
5. Agent 思考：需要计算技术指标
6. Agent 调用工具：calc_ma(prices, 20)
7. Agent 观察结果：20 日均线拐头向上
8. Agent 思考：结合近期成交量和消息面综合判断
9. Agent 调用工具：search_news("贵州茅台")
10. Agent 综合所有信息，输出最终建议

注意第 5、7、8 步——Agent 会根据上一步的结果，动态决定下一步做什么。这就是"自主"的含义，也是 Agent 和传统程序最根本的区别。

三、Agent 与传统应用/Chatbot 的本质区别

这张对比表建议收藏，面试和写方案都用得上：

维度	传统应用	Chatbot（聊天机器人）	AI Agent
控制流	硬编码流程	一问一答	LLM 自主决定下一步
能否行动	只能按预设逻辑执行	不能（只输出文本）	能（调用工具、改外部状态）
记忆能力	通常无 / 需手动管理	短期对话历史	短期 + 长期 + 工作记忆
错误处理	异常抛出或 fallback	直接返回错误文本	可自我反思、重试、换方案
适应性	换需求改代码	换 Prompt	换工具/指令即可适应
复杂任务	需拆解为多个接口	难以完成多步任务	自主拆解、逐步完成
不可预测性	低（流程确定）	中	高（需约束管理）

最后一行是关键：Agent 的强大来自于"自主"，但"自主"也带来了不可预测性。 这正是后续文章要讲的 Harness Engineering、输出 Schema 约束等工程化手段要解决的核心问题——怎么让 Agent 既灵活又可控。

四、Agent 的四大核心组成

回到那个经典公式：Agent = LLM + Planning + Memory + Tools。逐个拆解。

4.1 LLM（大脑）

LLM 是 Agent 的推理引擎，负责：

• 理解：解析用户意图
• 推理：决定下一步该做什么
• 决策：选择调用哪个工具、传什么参数
• 总结：把工具返回的原始数据转化为用户能懂的结论

选型上的工程考量：

• 能力 vs 成本：复杂推理用大模型（如 GPT-4 级别），简单路由用小模型降本
• 上下文窗口：长任务需要大窗口，但成本和延迟都会上升
• Function Calling 支持：这是 Agent 能调工具的前提，不是所有模型都支持得好
• 私有化 vs 云端：敏感场景需考虑本地部署的开源模型

4.2 Memory（记忆）

人没有记忆就没法工作，Agent 也一样。记忆通常分三层：

┌──────────────────────────────────────────────┐
│  短期记忆（Working Memory）                   │
│  即当前对话/任务的上下文，存在 LLM 的窗口里    │
│  例如："用户刚刚让我查 600519"                │
├──────────────────────────────────────────────┤
│  长期记忆（Long-term Memory）                 │
│  跨会话持久化，通常用向量数据库存储            │
│  例如："这个用户偏好高股息央企股"              │
├──────────────────────────────────────────────┤
│  工作记忆（Scratchpad）                       │
│  当前任务的中间状态、已完成的步骤、待办事项    │
│  例如："已拿到价格，待计算指标，待查新闻"      │
└──────────────────────────────────────────────┘

记忆系统是 Agent 能处理"长任务"的关键。没有长期记忆，Agent 每次都是失忆的；没有工作记忆，Agent 做到第 5 步就忘了第 3 步做了什么。

4.3 Tools（工具）

工具是 Agent 的"手脚"。没有工具，Agent 只能说不能做。常见的工具类型：

类型	例子	说明
数据查询	查数据库、调 API、搜索引擎	让 Agent 能"看"到外部世界
计算处理	算指标、跑脚本、执行代码	让 Agent 能"算"复杂逻辑
写操作	发邮件、改文件、提工单	让 Agent 能"做"改变世界的事
Agent 工具	调用其他子 Agent	Multi-Agent 协作的基础

工程上的关键问题：怎么让 Agent 知道有哪些工具可用、每个工具怎么用。这就涉及工具注册、描述规范、参数 Schema 约束——后续"Harness Engineering"那篇会专门讲。

4.4 Planning（规划）

规划是让 Agent 从"被动应答"升级为"主动拆解"的能力。一个复杂任务来了，Agent 要能：

1. 拆解：把大目标拆成可执行的子任务
2. 排序：决定子任务的执行顺序（有依赖关系）
3. 分配：哪些自己干、哪些调工具、哪些交给子 Agent
4. 反思：执行结果不对时，调整计划重试

这就是后面要讲的 ReAct、Plan-and-Execute、Reflection 等设计模式的核心。

五、一个最小 Agent 长什么样

抛开框架，一个最小可运行的 Agent 核心循环其实就这么几行（伪代码）：

public class MiniAgent {
    private LlmClient llm;          // 大模型客户端
    private List<Tool> tools;       // 可用工具集
    private List<Message> memory;   // 记忆（对话历史）

    public String run(String userInput) {
        memory.add(new UserMessage(userInput));

        while (true) {
            // 1. 把记忆和工具描述一起喂给 LLM，让它决定下一步
            LlmResponse resp = llm.chat(memory, tools);

            if (resp.isFinish()) {
                // 2. LLM 说"任务完成"，返回最终答案
                return resp.getContent();
            }

            // 3. LLM 决定调用某个工具
            ToolCall call = resp.getToolCall();
            memory.add(call);

            // 4. 执行工具，拿到结果
            String result = executeTool(call);
            memory.add(new ToolResultMessage(result));

            // 5. 结果回到记忆，进入下一轮循环
        }
    }
}

对应的核心循环图：

        ┌──────────────────────────────────┐
        │           用户指令                │
        └──────────────┬───────────────────┘
                       ▼
        ┌──────────────────────────────────┐
        │  1. Perception（感知）            │
        │     读取记忆 + 工具列表 + 用户输入 │
        └──────────────┬───────────────────┘
                       ▼
        ┌──────────────────────────────────┐
        │  2. Reasoning（推理）             │
        │     LLM 决定：直接回答 or 调工具   │
        └──────────────┬───────────────────┘
                       ▼
        ┌──────────────────────────────────┐
        │  3. Action（行动）                │
        │     调用工具 / 输出最终结果        │
        └──────────────┬───────────────────┘
                       ▼
        ┌──────────────────────────────────┐
        │  4. Observation（观察）           │
        │     工具结果回写记忆              │
        └──────────────┬───────────────────┘
                       │
            任务完成？─┴─ 否 → 回到第 1 步
                       │
                       是
                       ▼
                   返回结果

这就是著名的 ReAct 循环（Reasoning + Acting）：思考 → 行动 → 观察 → 再思考。几乎所有 Agent 框架的核心都是这个循环的变体。

六、Java 开发者如何入门

如果你是 Java 开发者，建议按这个路径走：

6.1 先建立认知（本周）

• 读 Anthropic 的《Building Effective Agents》
• 读 Lilian Weng 的《LLM Powered Autonomous Agents》
• 手写一遍上面的 MiniAgent（不用框架，纯 HTTP 调 LLM API）

6.2 上手框架（下周）

Java 生态目前主流的两个选择：

框架	定位	适合场景
Spring AI	Spring 官方，与 Spring Boot 深度集成	已有 Spring 技术栈的团队
LangChain4j	LangChain 的 Java 版，社区活跃	想快速实验、追求灵活性

两者并不互斥，后续文章会专门做一次横评和实战对比。

6.3 进阶工程化（之后）

• Harness Engineering：用 Plan 模板、工具约束、输出 Schema 让 Agent 可控
• 可观测性：让 Agent 的推理过程从黑盒变白盒
• Multi-Agent：多 Agent 协作处理复杂任务

七、本系列预告

篇目	主题	阶段
第 1 篇	AI Agent 核心概念与架构（本文）	基础认知
第 2 篇	三大基石之 LLM 调用与 Prompt 工程	基础认知
第 3 篇	三大基石之记忆系统	基础认知
第 4 篇	三大基石之工具调用	基础认知
第 5 篇	Java 生态 Agent 框架横评	框架实战
第 6 篇	用 Spring AI 搭建第一个 Agent	框架实战
第 7 篇	Harness Engineering 与约束管理	工程化进阶
第 8 篇	输出 Schema 约束与结构化输出	工程化进阶
第 9 篇	Grill Me 反问式规划	工程化进阶
第 10 篇	Agent 设计模式（ReAct / Plan-Execute / Reflection）	工程化进阶
第 11 篇	Multi-Agent 协作编排	高级与落地
第 12 篇	Agent 可观测性与调试	高级与落地
第 13 篇	Agent 上生产（容错、成本、限流）	高级与落地

八、小结

回到开篇那个问题：LLM 和 Agent 的区别到底是什么？

一句话总结：LLM 是大脑，Agent 是把这个大脑装进一个有记忆、有手脚、能自主规划的躯体里。

• 没有 Agent，LLM 只是个会说话的百科全书
• 有了 Agent，LLM 才真正变成一个能干活的角色

下一篇我们正式进入"三大基石"，先讲最底层的 LLM 调用与 Prompt 工程。如果你在跟着这个系列一起学，建议先把本文的 MiniAgent 伪代码用你熟悉的语言手写一遍——理解了这个循环，后面所有内容都是它的扩展。

---

这是「AI Agent 开发实战」系列第 1 篇，后续会持续更新，欢迎关注。如有错误或想法，欢迎评论区交流。