从后端视角理解 Agent 三层记忆系统
·
短期记忆、中期记忆、长期记忆 —— 和人类大脑一样的工作方式
一、先说结论
Agent 记忆系统模仿人类大脑的三层记忆：
短期记忆 → 当前对话上下文（几秒~几小时）
中期记忆 → 会话行为记录（几小时~几天）
长期记忆 → 用户画像 + 知识沉淀（永久）
👉 一句话记住：
短期记"现在"，中期记"最近"，长期记"习惯"
二、三层架构总览
┌─────────────────────────────────────────────────────────────┐
│ 三层记忆架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 长期记忆（Long-term Memory） │ │
│ │ ──────────────────────────────────────────────── │ │
│ │ 生命周期：永久 │ │
│ │ 存储内容：用户画像、偏好、知识沉淀 │ │
│ │ 后端类比：用户配置表 + 知识库 │ │
│ │ 更新频率：低（按天/周更新） │ │
│ │ 数据量：小（KB 级） │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↑ 学习 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 中期记忆（Medium-term Memory） │ │
│ │ ──────────────────────────────────────────────── │ │
│ │ 生命周期：几天~几周 │ │
│ │ 存储内容：会话记录、问答历史、行为模式 │ │
│ │ 后端类比：操作日志表 + 会话存储 │ │
│ │ 更新频率：中（每次交互更新） │ │
│ │ 数据量：中（MB 级） │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↑ 压缩 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 短期记忆（Short-term Memory） │ │
│ │ ──────────────────────────────────────────────── │ │
│ │ 生命周期：当前会话（几秒~几小时） │ │
│ │ 存储内容：对话上下文、当前意图、临时状态 │ │
│ │ 后端类比：请求上下文 + 缓存 │ │
│ │ 更新频率：高（每轮对话更新） │ │
│ │ 数据量：大（但有限制，如 4K tokens） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
👉 对标人类大脑
|
记忆层 |
人类大脑 |
Agent 系统 |
生命周期 |
|
短期 |
工作记忆（当前思考） |
对话上下文 |
当前会话 |
|
中期 |
情景记忆（最近经历） |
问答历史 |
几天~几周 |
|
长期 |
语义记忆（知识和习惯） |
用户画像 |
永久 |
三、短期记忆：对话上下文
3.1 存什么？
当前会话的对话历史：
{
"sessionId": "session-001",
"messages": [
{"role": "user", "content": "帮我格式化这段 JSON"},
{"role": "assistant", "content": "好的，请提供 JSON 内容"},
{"role": "user", "content": "{\"name\":\"test\"}"},
{"role": "assistant", "content": "格式化结果：\n{\n \"name\": \"test\"\n}"},
{"role": "user", "content": "再帮我压缩一下"} // ← 追问，依赖上下文
],
"context": {
"currentTool": "json", // 当前在用 JSON 工具
"lastResult": "{...}", // 上一次结果
"userIntent": "compress" // 推断用户想压缩
}
}
3.2 核心作用
1. 多轮对话理解
用户："再帮我压缩一下"
系统：知道是压缩刚才的 JSON（从上下文推断）
2. 意图消歧
用户："那个文件"
系统：从上下文找到用户之前提到的文件
3. 状态保持
记住当前在做什么、用了什么工具、上一步结果
3.3 技术实现
// 短期记忆结构
type Session struct {
ID string
Messages []Message // 对话历史
Context Context // 当前状态
StartTime time.Time
LastVisit time.Time
}
// 每轮对话更新
func (s *Session) AddMessage(role, content string) {
s.Messages = append(s.Messages, Message{role, content})
// 限制长度（如保留最近 20 条）
if len(s.Messages) > 20 {
s.Messages = s.Messages[len(s.Messages)-20:]
}
s.LastVisit = time.Now()
}
3.4 后端类比
短期记忆 = 请求上下文 + 会话缓存
类似于：
- HTTP Session
- Redis 会话存储
- 请求上下文 Context
3.5 关键限制
容量限制：不能无限增长
- Token 限制：如 4K / 8K / 128K tokens
- 条数限制：如保留最近 20 条消息
- 时间限制：如会话超时 2 小时
超限处理：
- 滑动窗口：只保留最近 N 条
- 摘要压缩：把早期对话压缩成摘要
- 转长期记忆：重要信息沉淀到长期记忆
四、中期记忆：行为记录
4.1 存什么？
用户最近的行为记录：
// 问答记录
{
"id": "q-001",
"userId": "user-001",
"sessionId": "session-001",
"question": "怎么格式化 JSON？",
"answer": "可以使用在线工具...",
"category": "tool",
"subCategory": "json",
"satisfaction": 5,
"duration": 1200,
"createTime": "2024-05-27T10:00:00Z"
}
// 会话记录
{
"id": "session-001",
"userId": "user-001",
"queryCount": 15,
"topics": {"tool": 10, "chat": 5},
"toolsUsed": ["json", "encode", "qrcode"],
"startTime": "2024-05-27T09:00:00Z",
"endTime": "2024-05-27T10:30:00Z"
}
4.2 核心作用
1. 历史查询
用户："我上次问的 JSON 问题是什么？"
系统：从中期记忆查找
2. 行为分析
统计用户最近用了什么工具、问了什么类型问题
3. 模式发现
发现用户的行为模式（如每天 10 点来，喜欢用 JSON 工具）
4. 数据来源
为长期记忆提供学习素材
4.3 技术实现
// 中期记忆存储（SQLite）
CREATE TABLE query_records (
id TEXT PRIMARY KEY,
user_id TEXT,
session_id TEXT,
question TEXT,
answer TEXT,
category TEXT,
satisfaction INT,
create_time DATETIME,
INDEX(user_id),
INDEX(create_time)
);
// 查询最近 N 天的记录
func GetRecentQueries(userID string, days int) []QueryRecord {
return db.Query(`
SELECT * FROM query_records
WHERE user_id = ?
AND create_time >= datetime('now', ?)
ORDER BY create_time DESC
`, userID, fmt.Sprintf("-%d days", days))
}
4.4 后端类比
中期记忆 = 操作日志 + 行为分析
类似于：
- ELK 日志系统
- 用户行为分析（UBA）
- APM 请求追踪
- 数据仓库的 ODS 层
4.5 数据流转
短期记忆（当前会话）
↓ 会话结束
中期记忆（保存记录）
↓ 定期分析
长期记忆（学习偏好）
↓ 清理
过期数据删除（保留 30~90 天）
五、长期记忆：用户画像
5.1 存什么？
用户的稳定特征和偏好：
{
"userId": "user-001",
// 模型偏好
"modelPreference": {
"favoriteModel": "MiniMax-M2.1",
"modelUsage": {
"MiniMax-M2.1": 100,
"qwen-turbo": 20
},
"modelSatisfaction": {
"MiniMax-M2.1": 4.5
}
},
// 时段偏好
"timePreference": {
"peakHours": [10, 14, 20],
"peakDays": [1, 2, 3, 4, 5] // 工作日
},
// 话题偏好
"topicPreference": {
"topTopics": ["tool", "programming", "chat"],
"topicInterest": {
"tool": 0.5,
"programming": 0.3
}
},
// 工具偏好
"toolPreference": {
"topTools": ["json", "encode", "ai"],
"toolUsage": {
"json": 50,
"encode": 30
}
}
}
5.2 核心作用
1. 个性化服务
根据偏好推荐模型、工具、问题
2. 快速响应
不用每次都分析历史，直接用画像
3. 跨会话记忆
用户关掉浏览器再回来，还记得他的习惯
4. 智能预测
预测用户可能想做什么
5.3 学习机制
// 从中期记忆学习长期记忆
func LearnPreferences(userID string) *UserPreference {
// 获取最近 30 天的行为数据
queries := GetRecentQueries(userID, 30)
pref := &UserPreference{}
// 学习模型偏好
modelCounts := make(map[string]int)
for _, q := range queries {
modelCounts[q.Model]++
}
pref.ModelPreference = FindFavorite(modelCounts)
// 学习时段偏好
hourlyStats := CountByHour(queries)
pref.TimePreference = FindPeakHours(hourlyStats)
// 学习工具偏好
toolCounts := CountByTool(queries)
pref.ToolPreference = FindTopTools(toolCounts)
// 保存
SavePreference(userID, pref)
return pref
}
5.4 后端类比
长期记忆 = 用户画像 + 知识库
类似于：
- 电商用户标签系统
- 推荐系统用户画像
- CRM 客户档案
- DMP 数据管理平台
5.5 更新策略
触发条件：
- 用户显式反馈（评分）
- 累积足够新数据（如每 100 条记录）
- 定期更新（如每天凌晨）
更新方式：
- 增量更新：只更新变化的部分
- 全量重算：定期从历史重新计算
- 加权平均：新偏好 = α × 新数据 + (1-α) × 旧偏好
六、三层记忆协作流程
6.1 用户提问时
┌─────────────────────────────────────────────────────────────┐
│ 提问处理流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 加载长期记忆 │
│ └─→ 获取用户偏好（模型、工具、话题） │
│ │
│ 2. 加载短期记忆 │
│ └─→ 获取当前会话上下文 │
│ │
│ 3. 结合两者生成 Prompt │
│ └─→ System Prompt = 基础 + 用户偏好 + 当前上下文 │
│ │
│ 4. 调用 AI 获取回答 │
│ │
│ 5. 更新短期记忆 │
│ └─→ 添加对话到上下文 │
│ │
│ 6. 写入中期记忆 │
│ └─→ 异步保存问答记录 │
│ │
│ 7. 返回回答 │
│ │
└─────────────────────────────────────────────────────────────┘
6.2 会话结束时
┌─────────────────────────────────────────────────────────────┐
│ 会话结束处理 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 保存会话到中期记忆 │
│ └─→ 记录会话统计（问题数、话题分布、工具使用） │
│ │
│ 2. 清理短期记忆 │
│ └─→ 会话超时后自动清理 │
│ │
│ 3. 触发学习（可选） │
│ └─→ 如果累积足够数据，更新长期记忆 │
│ │
└─────────────────────────────────────────────────────────────┘
6.3 定期学习时
┌─────────────────────────────────────────────────────────────┐
│ 定期学习流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 扫描中期记忆 │
│ └─→ 获取最近 N 天的问答记录 │
│ │
│ 2. 分析行为模式 │
│ └─→ 统计模型使用、时段分布、工具偏好 │
│ │
│ 3. 更新长期记忆 │
│ └─→ 计算新的偏好并保存 │
│ │
│ 4. 清理过期数据 │
│ └─→ 删除 90 天前的中期记忆 │
│ │
└─────────────────────────────────────────────────────────────┘
七、向量搜索：三层记忆的"搜索引擎"
7.1 为什么需要向量？
传统搜索问题：
用户问："JSON 美化"
系统找：必须包含 "美化" 关键词
结果：找不到 "JSON 格式化"
向量搜索：
用户问："JSON 美化"
系统理解：知道 "美化" ≈ "格式化"
结果：找到正确答案！
7.2 向量在三层记忆中的应用
短期记忆 + 向量：
└─→ 意图识别：理解用户追问的意图
用户："再压缩一下"
向量：知道是压缩刚才的 JSON
中期记忆 + 向量：
└─→ 语义搜索：搜索历史问题
用户："我之前问过 JSON 相关的"
向量：找到所有 JSON 相关问题
长期记忆 + 向量：
└─→ 相似用户：发现相似用户群体
向量：找到和当前用户相似的其他用户
7.3 技术实现
// 向量化问题
embedding := vectorSvc.GetEmbedding(question)
// 存入向量索引
vectorSvc.UpsertDocument("questions", queryID, question, metadata)
// 语义搜索
results := vectorSvc.SearchByText("questions", query, topK)
// 相似度计算
sim := vectorSvc.Similarity("JSON 格式化", "JSON 美化")
// 输出: 0.92（很相似）
八、完整代码示例
8.1 三层记忆服务
// 记忆服务
type MemoryService struct {
// 短期记忆（内存）
sessions map[string]*Session
// 中期记忆（SQLite）
store *sql.DB
// 长期记忆（SQLite + 缓存）
preferences map[string]*UserPreference
// 向量服务
vectorSvc *vector.Service
}
// 用户提问
func (m *MemoryService) Chat(userID, sessionID, question string) string {
// 1. 加载长期记忆
pref := m.GetPreference(userID)
// 2. 加载短期记忆
session := m.GetSession(sessionID)
// 3. 生成个性化 Prompt
systemPrompt := BuildPrompt(pref, session)
// 4. 调用 AI
answer := aiSvc.Chat(systemPrompt, session.Messages, question)
// 5. 更新短期记忆
session.AddMessage("user", question)
session.AddMessage("assistant", answer)
// 6. 写入中期记忆（异步）
go m.SaveQuery(userID, sessionID, question, answer)
return answer
}
8.2 长期记忆学习
// 定期学习（每天凌晨运行）
func (m *MemoryService) Learn(userID string) {
// 获取最近 30 天的中期记忆
queries := m.GetRecentQueries(userID, 30)
// 学习模型偏好
modelPref := learnModelPreference(queries)
// 学习时段偏好
timePref := learnTimePreference(queries)
// 学习工具偏好
toolPref := learnToolPreference(queries)
// 更新长期记忆
m.UpdatePreference(userID, &UserPreference{
ModelPreference: modelPref,
TimePreference: timePref,
ToolPreference: toolPref,
})
}
8.3 语义搜索
// 搜索历史问题
func (m *MemoryService) SearchHistory(userID, query string) []QueryRecord {
// 向量搜索
vectorResults := m.vectorSvc.SearchByText("questions", query, 10)
// 关键词搜索
keywordResults := m.SearchByKeyword(userID, query, 10)
// RRF 融合
return m.MergeResults(vectorResults, keywordResults)
}
九、数据库设计
9.1 短期记忆（内存）
// 不持久化，会话结束即清理
type Session struct {
ID string
UserID string
Messages []Message
Context map[string]interface{}
StartTime time.Time
LastVisit time.Time
}
9.2 中期记忆（SQLite）
-- 问答记录
CREATE TABLE query_records (
id TEXT PRIMARY KEY,
user_id TEXT,
session_id TEXT,
question TEXT,
answer TEXT,
category TEXT,
satisfaction INT,
create_time DATETIME,
INDEX(user_id),
INDEX(create_time)
);
-- 会话记录
CREATE TABLE sessions (
id TEXT PRIMARY KEY,
user_id TEXT,
query_count INT,
topics TEXT,
start_time DATETIME,
end_time DATETIME
);
9.3 长期记忆（SQLite）
-- 用户偏好
CREATE TABLE user_preferences (
user_id TEXT PRIMARY KEY,
model_preference TEXT, -- JSON
time_preference TEXT, -- JSON
topic_preference TEXT, -- JSON
tool_preference TEXT, -- JSON
update_time DATETIME
);
十、与传统后端系统对比
10.1 三层记忆 vs 传统架构
|
三层记忆 |
传统后端 |
生命周期 |
|
短期记忆 |
HTTP Session + 缓存 |
当前会话 |
|
中期记忆 |
操作日志 + 数据仓库 |
几天~几周 |
|
长期记忆 |
用户配置 + 用户画像 |
永久 |
10.2 数据流转
传统后端：
请求 → 处理 → 响应
（日志异步记录）
三层记忆：
请求 → 加载长期记忆 → 加载短期记忆 → 处理 → 更新短期 → 写入中期 → 响应
（定期：中期 → 学习 → 长期）
10.3 查询模式
传统后端：
- 查数据库
- 查缓存
三层记忆：
- 查长期记忆（用户偏好）
- 查短期记忆（上下文）
- 向量搜索（语义）
- 关键词搜索（精确）
十一、生产级考虑
11.1 容量规划
|
记忆层 |
单用户容量 |
总容量估算 |
|
短期 |
~10KB |
10KB × 在线用户数 |
|
中期 |
~1MB/月 |
1MB × 用户数 × 保留月数 |
|
长期 |
~10KB |
10KB × 用户数 |
11.2 性能优化
// 短期记忆：内存 + LRU 淘汰
var sessionCache = lru.New(10000)
// 长期记忆：缓存 + 定期刷新
var preferenceCache sync.Map
// 中期记忆：批量写入
queryBuffer := make(chan QueryRecord, 1000)
go batchWriter(queryBuffer)
11.3 数据清理
短期记忆：
- 会话超时自动清理（如 2 小时）
中期记忆：
- 保留 30~90 天
- 定期清理过期数据
长期记忆：
- 永久保留
- 定期更新（不是删除）
十二、总结
三层记忆是什么？
短期记忆 = 当前对话上下文（几秒~几分钟）
中期记忆 = 会话行为记录（几天~几周）
长期记忆 = 用户画像偏好（永久）
核心价值？
没有记忆的 Agent：
- 每次对话都是新的
- 不知道用户是谁
- 无法个性化
有记忆的 Agent：
- 短期：理解多轮对话
- 中期：知道用户最近在做什么
- 长期：了解用户习惯和偏好
后端工程师怎么理解？
短期记忆 = HTTP Session + 请求上下文
中期记忆 = 操作日志 + 行为分析
长期记忆 = 用户画像 + 配置中心
都是熟悉的东西，只是组合方式不同！
附录：API 接口
短期记忆（自动管理）
├── POST /api/chat - 对话（自动更新上下文）
└── POST /api/clear - 清除会话
中期记忆
├── GET /api/history - 问答历史
├── GET /api/sessions - 会话列表
└── GET /api/search - 搜索历史
长期记忆
├── GET /api/preferences - 用户偏好
├── POST /api/learn - 触发学习
└── GET /api/report - 行为报告
智能功能
├── GET /api/recommendations - 个性化推荐
├── GET /api/suggestions - 问题建议
└── POST /api/feedback - 满意度反馈
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
2
0- 0
已为社区贡献2条内容
所有评论(0)