Day 4：用后端思维拆解Agent核心架构——三元组、工具调用、错误处理

🤖 系列：Java工程师转AI Agent 3个月学习计划 👤 作者：宸丶一 | 28岁Java程序员，规划狂魔，正在被AI Agent按头学习 🎯 今日目标： 理解Agent核心架构、工具调用机制、错误处理策略 💬 个人格言： 代码改不改变世界我不知道，但先让我准时下班。

---

前言

大家好，我是宸一，一个28岁的Java程序员。

今天是第4天，学习内容是：Agent核心架构全解析。

前三天我们学了：

• Day 1：大模型API基础
• Day 2：LangChain与工具调用
• Day 3：记忆系统与向量数据库

今天要把这些串起来，看看一个完整的Agent到底是怎么工作的。

这次的学习方式有点不一样------我用的是"1对1问答式"学习。

什么意思？就是我问AI老师问题，它秒回我，我再追问，它再解答。不像传统学习那样"看视频→做笔记→忘了"，而是"问→答→理解→追问→深入"。

下面我把今天的核心内容整理出来，全是问答中碰撞出来的干货。

---

一、Agent三元组：规划、工具、记忆

1.1 最简模型

Agent的本质就是三个核心模块：

flowchart LR User["👤 用户"] Agent["🤖 Agent"] Planning["📋 Planning"] Action["🔧 Action"] Memory["💾 Memory"] User --> Agent Agent --> Planning Planning --> Action Action --> Memory Memory --> Planning Planning --> Result["✅ 输出结果"] classDef main fill:#3B82F6,color:white,stroke:none classDef agent fill:#111827,color:white,stroke:none classDef result fill:#10B981,color:white,stroke:none class Planning,Action,Memory main class Agent agent class Result result

1.2 用后端思维理解

Agent概念	Java后端对应	说明
Planning	Service层业务逻辑	拆解任务、决定执行流程
Action	调用外部API/工具类	执行具体操作
Memory	数据库 + 缓存	存储历史和上下文

这就是我们天天干的事儿：

1. 接收请求 → 理解用户意图
2. 查数据库 → 获取历史上下文
3. 执行业务逻辑 → 调用各种Service
4. 返回结果 → 生成回答

---

二、系统提示词：全局变量

2.1 什么是System Prompt？

系统提示词就是Agent的"人设"，一次创建，全程不变。

# 就像Java中的常量
public static final String ROLE = "再战Java工程师的28岁程序员";

# 或者Python中的配置
SYSTEM_PROMPT = """
你是一个正在学习AI Agent的Java工程师，名叫宸一。
你的特点是：用后端思维理解AI概念。
"""

2.2 为什么重要？

System Prompt决定了Agent的"性格"和"能力边界"：

没有System Prompt的Agent：
  用户：你是谁？
  Agent：我是一个AI助手

有System Prompt的Agent：
  用户：你是谁？
  Agent：我是宸一，一个28岁的Java程序员，正在学习AI Agent

2.3 用后端思维理解

System Prompt = 全局配置 = CONFIG对象

// Java中我们这样写
@Configuration
public class AgentConfig {
    @Value("${agent.role}")
    private String role;  // "再战Java工程师"
    
    @Value("${agent.max_history}")
    private int maxHistory;  // 10
}

一次创建，全程使用，不会改变。

---

三、对话历史：滑动窗口

3.1 为什么需要滑动窗口？

大模型的上下文窗口有限，不能无限存储对话历史。

flowchart LR classDef problem fill:#FFEBEE,stroke:#C62828,color:#B71C1C,stroke-width:2px classDef solution fill:#E8F5E9,stroke:#2E7D32,color:#1B5E20,stroke-width:2px classDef node fill:#FFFFFF,stroke:#90A4AE,stroke-width:1px subgraph Problem["❌ 问题"] P1["用户聊了100轮对话"] P2["全部塞给大模型"] P3["Token爆炸 💥<br/>费用爆炸 💰"] P1 --> P2 --> P3 class P1,P2,P3 node end subgraph Solution["✅ 解决方案"] S1["100轮对话"] S2["滑动窗口<br/>只保留最近10轮"] S3["Token可控 ✅<br/>费用可控 ✅"] S1 --> S2 --> S3 class S1,S2,S3 node end Problem -.->|采用| Solution class Problem problem class Solution solution

3.2 实现方式

from collections import deque

class ConversationHistory:
    def __init__(self, max_size=10):
        # 双向队列，两端都是O(1)操作
        self.history = deque(maxlen=max_size)
    
    def add(self, role, content):
        """添加新对话，自动淘汰最旧的"""
        self.history.append({
            "role": role,
            "content": content
        })
    
    def get_recent(self, n=5):
        """获取最近n轮对话"""
        return list(self.history)[-n:]

3.3 用后端思维理解

滑动窗口 = 固定大小的环形缓冲区

┌─────────────────────────────────────────────────────────┐
│  conversation_history (maxlen=10)                       │
├─────────────────────────────────────────────────────────┤
│ [0] 最旧 → 新消息插入时自动淘汰                         │
│ [1] ...                                                 │
│ ...                                                     │
│ [8] ...                                                 │
│ [9] 最新 ← 新消息插入这里                               │
└─────────────────────────────────────────────────────────┘

数据结构选择：
- 数组：O(n)删除头部，不推荐
- 链表：O(1)删除头部，但Python没有原生支持
- deque：最佳选择！两端O(1)操作

---

四、工具调用：四步走

4.1 完整流程

flowchart TD classDef start fill:#1E3A5F,stroke:#0D47A1,color:#FFFFFF,stroke-width:2px classDef answer fill:#2E7D32,stroke:#1B5E20,color:#FFFFFF,stroke-width:2px classDef step fill:#E3F2FD,stroke:#1565C0,color:#1565C0,stroke-width:2px classDef node fill:#FFFFFF,stroke:#90A4AE,stroke-width:1px classDef success fill:#C8E6C9,stroke:#388E3C,stroke-width:1px classDef fail fill:#FFCDD2,stroke:#D32F2F,stroke-width:1px Start["👤 用户输入<br/>帮我查一下明天北京天气"] class Start start subgraph Step1["第1步：工具注册表"] TR["📋 get_weather / search_web"] class TR node end subgraph Step2["第2步：语义匹配"] SM["🔍 意图分析"] SM1["查询天气 → 0.95"] SM2["搜索网页 → 0.32"] SM --> SM1 SM --> SM2 class SM node class SM1 success class SM2 fail end subgraph Step3["第3步：参数提取"] PE["📝 NLP解析"] PE1["city: 北京"] PE2["date: 明天"] PE --> PE1 PE --> PE2 class PE node class PE1,PE2 node end subgraph Step4["第4步：调用执行"] EX["⚡ get_weather(北京, 明天)"] RES["📊 25°C / 晴"] EX --> RES class EX node class RES success end Answer["💬 明天北京天气晴，25°C，适合出行~"] class Answer answer Start --> Step1 --> Step2 --> Step3 --> Step4 --> Answer class Step1,Step2,Step3,Step4 step

4.2 用后端思维理解

工具调用 = 策略模式 + 工厂模式

// 策略接口
public interface Tool {
    String getName();
    String getDescription();
    Object execute(Map<String, Object> params);
}

// 工具注册表（工厂）
public class ToolRegistry {
    private Map<String, Tool> tools = new HashMap<>();
    
    public void register(Tool tool) {
        tools.put(tool.getName(), tool);
    }
    
    public Tool findByName(String name) {
        return tools.get(name);
    }
}

// 具体工具
public class WeatherTool implements Tool {
    @Override
    public Object execute(Map<String, Object> params) {
        String city = (String) params.get("city");
        // 调用天气API
        return weatherApi.getWeather(city);
    }
}

4.3 两种工具选择方式

方式	原理	优点	缺点
向量匹配	语义相似度搜索	灵活，能处理模糊表达	需要向量数据库
大模型直接选择	把工具列表塞给LLM	简单，LLM本身就懂语义	工具太多时prompt很长

现在主流是方式2（OpenAI的Function Calling就是这个原理）：

# 把工具描述直接给大模型
prompt = f"""
你有以下工具可用：
1. get_weather - 查询指定城市的天气
2. search_web - 搜索网页信息

用户问题：{user_query}

请选择合适的工具并提取参数。
"""

---

五、错误处理：三板斧

5.1 完整流程

flowchart TD classDef start fill:#1E3A5F,stroke:#0D47A1,color:#FFFFFF,stroke-width:2px classDef success fill:#2E7D32,stroke:#1B5E20,color:#FFFFFF,stroke-width:2px classDef fail fill:#C62828,stroke:#B71C1C,color:#FFFFFF,stroke-width:2px classDef retry fill:#F57C00,stroke:#E65100,color:#FFFFFF,stroke-width:1px classDef fallback fill:#7B1FA2,stroke:#4A148C,color:#FFFFFF,stroke-width:1px classDef decision fill:#FFFFFF,stroke:#90A4AE,stroke-width:2px Start["👤 查一下东京天气"] class Start start R1["🔄 第1次调用<br/>get_weather(东京)"] D1{"成功?"} class R1 retry class D1 decision R2["🔄 第2次调用"] D2{"成功?"} class R2 retry class D2 decision R3["🔄 第3次调用"] D3{"成功?"} class R3 retry class D3 decision FB["🔀 备选方案<br/>search_web(东京天气)"] D4{"成功?"} class FB fallback class D4 decision GD["⚠️ 兜底<br/>网络异常，请稍后再试"] OK["✅ 返回结果"] class GD fail class OK success Start --> R1 --> D1 D1 -->|是| OK D1 -->|否| R2 --> D2 D2 -->|是| OK D2 -->|否| R3 --> D3 D3 -->|是| OK D3 -->|否| FB --> D4 D4 -->|是| OK D4 -->|否| GD

5.2 三板斧总结

策略	术语	说明
重试3次	Retry with Backoff	给系统恢复时间
失败换工具	Fallback Strategy	尝试备选方案
直接摊牌	Graceful Degradation	诚实告诉用户

5.3 用后端思维理解

这就是我们熟悉的异常处理：

public String getWeather(String city) {
    // 1. 重试3次
    for (int i = 0; i < 3; i++) {
        try {
            return weatherApi.getWeather(city);
        } catch (Exception e) {
            if (i == 2) break;  // 最后一次失败
            Thread.sleep(1000 * (i + 1));  // 指数退避
        }
    }
    
    // 2. 尝试备选方案
    try {
        return searchWeb(city + "天气");
    } catch (Exception e) {
        // 备选也失败了
    }
    
    // 3. 兜底
    return "抱歉，当前网络异常，请稍后再试";
}

---

六、今日收获

6.1 核心概念对照表

graph LR classDef root fill:#1E3A5F,stroke:#0D47A1,color:#FFFFFF,stroke-width:2px classDef branch fill:#E3F2FD,stroke:#1565C0,color:#1565C0,stroke-width:1px classDef leaf fill:#F5F7FA,stroke:#90A4AE,color:#37474F Root["Agent核心架构"] class Root root Root --> P["System Prompt<br/>全局配置/常量"] Root --> H["对话历史<br/>滑动窗口/deque"] Root --> T["工具调用<br/>策略模式+工厂模式"] Root --> E["错误处理<br/>try-catch+重试"] Root --> A["Agent三元组<br/>Controller+Service+DAO"] class P,H,T,E,A branch

AI概念	Java后端对应	本质
System Prompt	全局配置/常量	一次创建，全程不变
对话历史	滑动窗口/deque	只保留最近N轮
工具调用	策略模式+工厂模式	注册→匹配→执行
错误处理	try-catch+重试	重试→降级→兜底
Agent三元组	Controller+Service+DAO	规划+工具+记忆

6.2 1对1问答式学习的优势

这次学习我采用了"问答式"，发现和传统学习完全不同：

flowchart LR classDef old fill:#FFEBEE,stroke:#C62828,color:#B71C1C,stroke-width:2px classDef new fill:#E8F5E9,stroke:#2E7D32,color:#1B5E20,stroke-width:2px classDef node fill:#FFFFFF,stroke:#90A4AE,stroke-width:1px subgraph Traditional["📚 传统学习"] T1["看视频/文章"] T2["被动接收"] T3["有问题先记下"] T4["学完才能实践"] T5["容易走神 😴"] T1 --> T2 --> T3 --> T4 --> T5 class T1,T2,T3,T4,T5 node end subgraph QA["❓ 问答式学习"] Q1["问问题"] Q2["主动探索"] Q3["问题秒回，即时解决"] Q4["边学边问边理解"] Q5["保持专注 🔥"] Q1 --> Q2 --> Q3 --> Q4 --> Q5 class Q1,Q2,Q3,Q4,Q5 node end Traditional -.->|升级| QA class Traditional old class QA new

传统学习	问答式学习
看视频/文章	问问题
被动接收	主动探索
有问题先记下	问题秒回，即时解决
学完才能实践	边学边问边理解
容易走神	保持专注

举个例子：

我问：系统提示词是什么？
AI答：就是Agent的人设，类似全局变量

我追问：那对话历史呢？
AI答：滑动窗口，只保留最近10轮

我再追问：工具调用怎么知道调哪个？
AI答：语义匹配，向量相似度搜索

每个问题都是秒回，不用等，不用查资料
这种"即时反馈"让学习效率翻倍

6.3 学习感悟

AI Agent的学习曲线其实没有想象中陡峭。

flowchart LR classDef java fill:#FFF3E0,stroke:#F57C00,color:#E65100,stroke-width:2px classDef ai fill:#E3F2FD,stroke:#1565C0,color:#0D47A1,stroke-width:2px classDef arrow fill:#FFFFFF,stroke:#90A4AE,stroke-width:1px subgraph Java["☕ Java工程师已有基础"] J1["API调用"] J2["数据库"] J3["缓存"] J4["设计模式"] J5["异常处理"] class J1,J2,J3,J4,J5 java end subgraph AI["🤖 AI Agent对应概念"] A1["大模型接口"] A2["向量数据库"] A3["记忆系统"] A4["Agent架构"] A5["错误重试"] class A1,A2,A3,A4,A5 ai end J1 --> A1 J2 --> A2 J3 --> A3 J4 --> A4 J5 --> A5 class Java java class AI ai

作为Java工程师，我们已经有很好的工程基础：

• 理解API调用 → 理解大模型接口
• 理解数据库 → 理解向量数据库
• 理解缓存 → 理解记忆系统
• 理解设计模式 → 理解Agent架构
• 理解异常处理 → 理解错误重试

关键是要用熟悉的视角去理解新概念。

---

七、明日计划

按照学习计划，明天要：

• 动手实现一个迷你Agent
• 把今天学到的架构落地成代码
• 继续用后端思维拆解AI概念

---

八、写在最后

学AI不难，难的是坚持。

作为一个"规划狂魔"，我太了解那种"规划完就满足"的感觉了。

但这次不一样，我有AI老师陪我学，有问题随时问，有答案即时给。

如果你也是Java工程师，想转AI Agent，欢迎关注我的系列文章。

我们一起，用后端思维，拆解AI世界。

---

📌 系列目录

• Day 1：环境搭建与大模型API基础
• Day 2：LangChain核心与工具调用
• Day 3：记忆系统与向量数据库
• Day 4：Agent核心架构全解析（本文）
• Day 5：动手实现迷你Agent（即将更新）

---

标签： #AI Agent #Java工程师 #Agent架构 #工具调用 #错误处理 #学习笔记 #Hermes Agent #1对1学习

---

关于作者： 宸丶一，28岁Java程序员，规划狂魔，正在用AI学AI。

💬 格言： "代码改不改变世界我不知道，但先让我准时下班。"

🎯 目标： 3个月转AI Agent，用后端思维拆解AI世界。

声明： 本文为原创学习笔记，如需转载请注明出处。