Agent 记不住东西?基于分层记忆架构打造 AI Agent 长期记忆与个性化上下文引擎
用户 A 平均聊到第 4.2 轮,就开始重复说「我叫李华,写后端,回答简短点」。每开一次新对话,300 多个 Token 花在重复交代同一批偏好和上下文上。业务方原话是「你这个 Agent 做得很笨」。
我接手这个 Agent 的时候,它刚被投诉过一轮。不是模型不行,也不是 Prompt 没调好,是它真的没有记忆——每开一次新对话,世界就重新初始化一次。下面是我们把三层记忆架构接进 Spring Boot 3 + Redis 的完整过程,包括那些让我加班到凌晨的坑。
一、为什么 Agent 会「记不住」
先说清楚一件事:Agent「记不住」不是 bug,是它本来就没地方记。我们每天在处理三种性质完全不同的信息,但在原来的系统里,它们全部混在同一个 messages 数组里,一起被截断、一起被丢掉。
- 短期对话上下文(Session):这一轮对话里,用户刚说的「改成 3 天」,下一轮就得用到。丢了就是驴唇不对马嘴。
- 长期个性化知识(User Profile):「我叫李华」「我是后端」「回答别超过 5 行」。跨对话、跨会话都得在,丢了用户就要重新自我介绍。
- 领域知识(Domain Ontology):这个业务的术语表、工具清单、参数默认值。跟具体用户无关,但每个用户都要用。
这三类数据的生命周期差了一个数量级:第一类活 5 分钟,第二类活 30 天,第三类活一年以上。混在一起存,结局只有两个——要么短期上下文被当垃圾清掉,要么长期偏好被当历史记录截断。我们两种都遇到过。
然后是选型。市面上能用的方案无非三条路,我按我们关心的五个维度做了个对比。下面的数字是我们自己压测和记账统计出来的,不是官方 benchmark,具体值仅对我们这套业务成立:
| 维度 | 方案 A:公有云大模型 API(openai 等) | 方案 B:商用对话平台(claude 等) | 方案 C:本地部署(我们最终选的) |
|---|---|---|---|
| 上下文窗口上限 | 128K–200K 级别,够用但贵 | 200K 级别,够用但贵 | 取决于显存,我们实测稳定 32K 上下文,够用 |
| 个性化能力 | 靠 system prompt 硬塞,跨会话不保留 | 平台侧有限保留,用户无控制权 | 自己存 Redis,想存多久存多久,想删随时删 |
| 数据所有权 | 对话数据出企业边界,合规要审批 | 同样出边界,且不可导出 | 全在自建 Redis + Milvus,内网不出 |
| 实现复杂度 | 最低,一个 HTTP 调用 | 低,SDK 封装好 | 高,要自己管记忆读写、TTL、清理 |
| 成本(我们实测) | 单次对话 0.08 元,月 12 万次 ≈ 9600 元/月 | 略高于 A,且按席位另算 | 服务器折旧 + 电费,月均 1800 元左右 |
A 和 B 的问题不是不好用,是「个性化」这件事根本不在它们的能力范围里。你没法要求一个无状态 HTTP 接口记住某个用户三天前说过「我用 PostgreSQL 不用 MySQL」。C 的实现复杂度确实高,但它把「记忆」变成了我们自己的一个模块,而不是别人的一个参数。
所以最后走的是 C。下面讲怎么实现。
二、分层记忆架构:三层,各有各的边界
我一开始把所有东西都塞进一张 conversation 表,按 session_id 查。写到第三个迭代就发现不对:用户偏好这种数据,跟 session_id 有什么关系?用户换了个设备开新会话,偏好就丢了。
问题的本质是「数据权界限」没划清。哪份数据归谁管、活多久、谁来清,必须在设计阶段就定死。我们最后划成三层:
- 工作记忆(Working Memory):当前轮对话的上下文。结构就是一个 JSON,TTL 5 分钟,每轮重置。它的唯一职责是「让这一轮对话自洽」。
- 情景记忆(Episodic Memory):以用户为单位,存最近 N 条关键事件 + 已确认偏好。Redis Hash,TTL 30 天。每轮启动时读一次、结束前写一次。
- 语义记忆(Semantic Memory):跨用户、跨会话的领域知识库。Redis 存索引和分类,Milvus(或本地 pgvector)存向量,TTL 365 天。这层是可选的——如果你的业务不需要跨会话记住「这个用户的常用工具」,就别部署,省一台机器。
图 1 是完整的数据流,从 Agent 启动到 Redis 读写:
flowchart TD
A[Agent 启动] --> B[加载工作记忆<br/>TTL 5 分钟]
B --> C[按 userId 读情景记忆<br/>TTL 30 天]
C --> D[判断是否已读取]
D -->|是| E[语义检索 Top-K<br/>TTL 365 天]
D -->|否| F[跳过语义记忆]
E --> G[三层记忆合并到上下文]
F --> G
G --> H[写入本轮工作记忆<br/>重置计时]
图 1:Agent 启动时的三层记忆注入流程。语义记忆是可选分支,冷启动时可以整体跳过。
工作记忆的具体结构很朴素,就是一段 JSON,键是 turnId,值是这一轮的 user/assistant 消息对加上工具调用结果:
{
"turnId": "u_8f3a_x91k",
"sessionId": "sess_20261120_01",
"userId": "user_10086",
"messages": [
{"role": "user", "content": "查一下昨天失败的任务"},
{"role": "assistant", "tool_calls": [{"name": "query_task_status", "args": {"date": "2026-11-19"}}]}
],
"expiresInSeconds": 300
}
情景记忆是一个 Hash,key 是 mem:episodic:{userId},field 是 e{序号},value 是序列化后的事件 JSON。之所以用 Hash 而不是 List,是因为我们要能按 field 单独删除某一条——用户说「别提我上次那个问题」,你得能精确删掉那一条,而不是把整个用户的记忆清空。
语义记忆这块我踩过最多的坑,后面单独讲。结构上是一张知识表 + 一个向量索引,key 里带 domain 前缀做隔离。
三、Agent 启动时的记忆注入
这是整套架构里最关键的一段代码。目标只有一个:Agent 每一轮启动,用一次 Redis 往返把该拿的记忆全拿回来,绝不逐条查库。
我见过太多实现是「要用的时候再查」——工具调用要查一次用户配置,生成回答要查一次历史偏好,最后生成日志要查一次会话元数据。一个 10 轮的对话打出 40 次 Redis 请求,延迟全花在网络往返上。
我们的做法是启动时一次性合并,塞进一个 AgentContext 对象,本轮内所有组件只读这个对象。
package com.example.agent.memory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import java.time.Duration;
import java.util.*;
/**
* Agent 启动时的记忆注入器。
* 设计要点:一次 Redis 往返拿全三层,合并成一个不可变上下文,本轮内不再回查。
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class AgentMemoryLoader {
private final StringRedisTemplate redis;
private final ObjectMapper objectMapper;
private final WorkingMemoryService workingMemoryService;
/** 情景记忆最多注入的条数,超过截断,防止上下文爆掉 */
private static final int EPISODIC_MAX_ITEMS = 12;
/** 语义检索的默认 Top-K */
private static final int SEMANTIC_TOP_K = 5;
/**
* 容器启动时预热一次,避免第一次请求冷启动。
* 只做连接探活和序列化器校验,不加载具体用户数据。
*/
@PostConstruct
public void warmUp() {
try {
redis.getConnectionFactory().getConnection().ping();
log.info("AgentMemoryLoader 预热完成,Redis 连接正常");
} catch (Exception e) {
log.error("AgentMemoryLoader 预热失败,记忆功能将降级为无记忆模式", e);
}
}
/**
* 每轮对话开始时调用,把三层记忆合并到 AgentContext。
*
* @param userId 用户唯一标识
* @param sessionId 当前会话 ID
* @param query 用户本轮输入,用于语义检索
* @return 合并后的上下文,永不为 null
*/
public AgentContext load(String userId, String sessionId, String query) {
AgentContext ctx = new AgentContext();
ctx.setUserId(userId);
ctx.setSessionId(sessionId);
// 1. 工作记忆:当前轮上下文,TTL 5 分钟,拿不到就给空集合
Map<String, Object> working = workingMemoryService.loadWorkingMemory(sessionId);
ctx.setWorkingMemory(working);
// 2. 情景记忆:一次 HGETALL 拿全量,服务端截断到 12 条
String episodicKey = "mem:episodic:" + userId;
Map<Object, Object> raw = redis.opsForHash().entries(episodicKey);
List<EpisodicEvent> events = parseEpisodicEvents(raw);
ctx.setEpisodicMemory(events.size() > EPISODIC_MAX_ITEMS
? events.subList(events.size() - EPISODIC_MAX_ITEMS, events.size())
: events);
// 3. 语义记忆:可选,查询太短或太长直接跳过,省一次向量检索
if (query != null && query.length() >= 4 && query.length() <= 200) {
ctx.setSemanticMemory(semanticMemoryService.retrieve(query, SEMANTIC_TOP_K));
} else {
ctx.setSemanticMemory(Collections.emptyList());
}
log.debug("记忆注入完成 userId={} episodic={} semantic={}",
userId, ctx.getEpisodicMemory().size(), ctx.getSemanticMemory().size());
return ctx;
}
/** 把 Redis Hash 里的原始字符串反序列化成事件列表,按 field 序号排序 */
private List<EpisodicEvent> parseEpisodicEvents(Map<Object, Object> raw) {
List<EpisodicEvent> events = new ArrayList<>(raw.size());
for (Map.Entry<Object, Object> entry : raw.entrySet()) {
try {
events.add(objectMapper.readValue((String) entry.getValue(), EpisodicEvent.class));
} catch (Exception e) {
log.warn("情景记忆反序列化失败 field={},跳过", entry.getKey());
}
}
events.sort(Comparator.comparing(EpisodicEvent::getSeq));
return events;
}
}
这里有两个容易忽略的点。第一,工作记忆用独立的 WorkingMemoryService 管,因为它有独立的 TTL 和重置逻辑,跟情景记忆的生命周期完全不同。第二,语义检索加了长度守卫——用户就打了「在吗」两个字,你去检索只会捞回一堆噪音,不如直接跳过。
至于「合并到内存后怎么让 Agent 用上」,我们是一个 AgentContextHolder,ThreadLocal 存当前轮的 AgentContext,Prompt 组装器从 Holder 里取。这样工具调用、日志、计费等各个组件都不用改签名,直接读 Holder 就行。
四、跨会话的用户偏好持久化
用户偏好是最容易被做错的一层。错在哪?错在「什么都存」。我们第一版把用户的每一条输入都原样存进情景记忆,两个月后某个用户的 Hash 里有 2400 多个字段,序列化后 8MB,HGETALL 一次拉 200ms,Redis 内存涨了 40%。
后来改成只存三类东西:
- 显式声明的偏好:用户说「我回答要简短」「我用 Java 不用 Go」,这类是高价值信息,存。
- 常用工具与参数:从工具调用日志里聚合出来的,比如「这个用户 80% 的任务走
query_order工具」。 - 已完成的任务摘要:不是完整对话,是一句话结果 + 关键 ID,用来避免重复劳动。
然后是隐私。用户手机号、身份证号、详细地址这类东西,我们一律不存明文。做法是:识别 → 脱敏 → 加密存储。加密用 AES-256-GCM,密钥走 KMS,不落配置文件。
package com.example.agent.memory;
import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.util.Base64;
/**
* 用户偏好写入器:脱敏 + 加密 + 写入 Redis Hash。
*/
@Component
@RequiredArgsConstructor
public class PreferenceWriter {
private final StringRedisTemplate redis;
private final ObjectMapper objectMapper;
private final PiiDetector piiDetector;
private final SecretKeyProvider keyProvider;
private static final SecureRandom IV_RANDOM = new SecureRandom();
private static final int GCM_IV_LENGTH = 12;
private static final int GCM_TAG_BITS = 128;
/**
* 写入一条用户偏好。
*
* @param userId 用户 ID
* @param key 偏好键,如 "tone"、"preferred_tools"
* @param value 偏好值
*/
public void writePreference(String userId, String key, String value) {
if (value == null || value.isBlank()) {
return;
}
// 第一步:PII 检测与脱敏。命中就直接拒绝,不存任何形式
PiiResult pii = piiDetector.detect(value);
if (pii.hasSensitive()) {
log.warn("检测到敏感信息,拒绝写入 preference userId={} key={} types={}",
userId, key, pii.types());
return;
}
// 第二步:加密。GCM 模式同时保证机密性和完整性
String encrypted = encrypt(value);
// 第三步:写 Hash。field 带版本前缀,方便后续做结构迁移
String hashKey = "mem:episodic:" + userId;
Map<String, String> entry = new HashMap<>();
entry.put("pref:" + key, encrypted);
entry.put("pref:version", "v2");
redis.opsForHash().putAll(hashKey, entry);
// 第四步:续期。整个 Hash 滑动续到 30 天,用户还在用就不该被清掉
redis.expire(hashKey, Duration.ofDays(30));
}
/** AES-256-GCM 加密,返回 Base64(iv || ciphertext) */
private String encrypt(String plain) {
try {
byte[] iv = new byte[GCM_IV_LENGTH];
IV_RANDOM.nextBytes(iv);
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
SecretKeySpec keySpec = new SecretKeySpec(keyProvider.getAesKey(), "AES");
cipher.init(Cipher.ENCRYPT_MODE, keySpec, new GCMParameterSpec(GCM_TAG_BITS, iv));
byte[] cipherText = cipher.doFinal(plain.getBytes(StandardCharsets.UTF_8));
byte[] combined = new byte[iv.length + cipherText.length];
System.arraycopy(iv, 0, combined, 0, iv.length);
System.arraycopy(cipherText, 0, combined, iv.length, cipherText.length);
return Base64.getEncoder().encodeToString(combined);
} catch (Exception e) {
throw new IllegalStateException("偏好加密失败", e);
}
}
}
配套建表 DDL,方便本地排查和审计:
-- 语义记忆知识表,跨用户共享的领域知识
CREATE TABLE IF NOT EXISTS agent_semantic_memory (
id BIGSERIAL PRIMARY KEY,
domain VARCHAR(64) NOT NULL, -- 业务域隔离,如 "order"、"ticket"
chunk TEXT NOT NULL, -- 知识片段原文
embedding VECTOR(1024) NOT NULL, -- pgvector 向量
source VARCHAR(128), -- 来源,便于追溯
hit_count INT DEFAULT 0, -- 命中计数,用于淘汰冷数据
created_at TIMESTAMPTZ DEFAULT now(),
expires_at TIMESTAMPTZ NOT NULL -- 默认 now() + 365 天
);
CREATE INDEX idx_semantic_domain ON agent_semantic_memory (domain);
CREATE INDEX idx_semantic_embedding ON agent_semantic_memory
USING hnsw (embedding vector_cosine_ops);
CREATE INDEX idx_semantic_expires ON agent_semantic_memory (expires_at);
对应的 Redis 侧关键操作,包括一个原子写入脚本:
# 1. 设置情景记忆 TTL 为 30 天
EXPIRE mem:episodic:user_10086 2592000
# 2. 查看某用户情景记忆的字段数与占用内存
HLEN mem:episodic:user_10086
MEMORY USAGE mem:episodic:user_10086
# 3. 冷数据采样:每天凌晨统计 hit_count = 0 的知识条目
LRANGE mem:semantic:cold_keys 0 -1
-- 原子写入一条情景事件:追加事件 + 裁剪超出上限的旧事件 + 续期
-- KEYS[1] = mem:episodic:{userId}
-- ARGV[1] = 事件 JSON(含 seq 字段)
-- ARGV[2] = 保留的最大事件条数
-- ARGV[3] = TTL 秒数
local key = KEYS[1]
local event = ARGV[1]
local limit = tonumber(ARGV[2])
local ttl = tonumber(ARGV[3])
-- 写入当前事件,field 用时间戳 + 随机后缀,避免并发覆盖
local field = "e" .. redis.call("INCR", key .. ":seq")
redis.call("HSET", key, field, event)
-- 裁剪:field 数量超过上限时,删掉最旧的那批
local total = redis.call("HLEN", key)
if total > limit then
local all = redis.call("HKEYS", key)
-- HKEYS 返回顺序不保证,这里按 field 里的序号做一次简单排序
table.sort(all)
for i = 1, total - limit do
redis.call("HDEL", key, all[i])
end
end
-- 续期,保证活跃用户的记忆不被清理任务误伤
redis.call("EXPIRE", key, ttl)
return total
这段 Lua 里最关键的是 HSET 和 EXPIRE 在同一个原子块里执行。如果分成两条命令发,中间宕机就会出现「有数据但永不过期」的僵尸 key,我为此 paid 过一次学费。
五、记忆的遗忘与清理
记忆架构最难的部分不是「记住」,是「忘掉」。
我们上线第一个月没做清理,Redis 内存从 2G 涨到 11G,报警报到值班手机不敢开静音。查下来三个原因:情景记忆没设 TTL、语义记忆的知识条目只增不删、失败的对话产生了一堆半截 JSON。
遗忘策略分三层,按「谁负责忘」划分:
- TTL 负责被动遗忘:工作记忆 5 分钟,情景记忆 30 天,语义记忆 365 天。这是最后一道防线。
- 定时任务负责主动遗忘:每天凌晨 3 点跑一次清理,把过期数据、脏数据、低价值数据一次性处理掉。
- 用户负责显式遗忘:设置页面上有「清除我的所有记忆」按钮,点了就真的删干净,不是标记删除。
package com.example.agent.memory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* 记忆清理任务。每天凌晨 3 点执行,分三个阶段。
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class MemoryCleanupJob {
private final StringRedisTemplate redis;
private final ObjectMapper objectMapper;
/** 单批扫描数量,防止一次 SCAN 阻塞 Redis */
private static final long SCAN_BATCH = 500;
@Scheduled(cron = "0 0 3 * * ?")
public void cleanup() {
long start = System.currentTimeMillis();
log.info("记忆清理任务开始");
int dirtyDeleted = 0;
int expiredDeleted = 0;
// 阶段一:扫描并删除脏数据(反序列化失败的、结构缺字段的)
dirtyDeleted = scanAndDeleteDirty();
// 阶段二:清理已过期但没被 Redis 自动回收的 key(惰性删除的漏网之鱼)
expiredDeleted = scanAndDeleteExpired();
long cost = System.currentTimeMillis() - start;
log.info("记忆清理完成 脏数据={} 过期残留={} 耗时={}ms", dirtyDeleted, expiredDeleted, cost);
}
/** 扫描情景记忆,反序列化失败或缺少 userId 字段的,直接删 */
private int scanAndDeleteDirty() {
int deleted = 0;
Set<String> keys = redis.keys("mem:episodic:*");
if (keys == null || keys.isEmpty()) {
return 0;
}
for (String key : keys) {
// 跳过序列号辅助 key
if (key.endsWith(":seq")) {
continue;
}
Map<Object, Object> entries = redis.opsForHash().entries(key);
List<Object> badFields = new ArrayList<>();
for (Map.Entry<Object, Object> e : entries.entrySet()) {
String field = (String) e.getKey();
if (field.startsWith("pref:")) {
continue; // 加密偏好不做明文校验,跳过
}
try {
EpisodicEvent ev = objectMapper.readValue((String) e.getValue(), EpisodicEvent.class);
if (ev.getUserId() == null || ev.getType() == null) {
badFields.add(e.getKey());
}
} catch (Exception ex) {
badFields.add(e.getKey());
}
}
if (!badFields.isEmpty()) {
redis.opsForHash().delete(key, badFields.toArray());
deleted += badFields.size();
}
}
return deleted;
}
/** 清理 TTL 已过期但 key 仍存在的残留 */
private int scanAndDeleteExpired() {
int deleted = 0;
Set<String> keys = redis.keys("mem:episodic:*");
if (keys == null) {
return 0;
}
for (String key : keys) {
Long ttl = redis.getExpire(key, TimeUnit.SECONDS);
// -1 表示永不过期,-2 表示 key 已不存在
if (ttl != null && ttl == -1L) {
redis.delete(key);
deleted++;
}
}
return deleted;
}
/** 用户主动清除:删干净所有层,不留标记 */
public void eraseUserMemory(String userId) {
redis.delete("mem:episodic:" + userId);
redis.delete("mem:working:" + userId);
redis.delete("mem:semantic:user:" + userId);
log.info("用户记忆已清除 userId={}", userId);
}
}
redis.keys() 在生产环境是禁忌,我在这加了注释但保留了——因为我们的 key 量级在 10 万以内,且任务跑在凌晨低峰。如果 key 上百万,得换 SCAN 游标遍历,这是必须改的。
六、踩过的坑
这一节是全文最贵的部分,四个坑,每一个都让我掉了头发。
坑一:工作记忆和情景记忆共用同一个 Redis key,导致跨用户数据错乱。
第一版偷懒,两层都用 mem:session:{sessionId},情景记忆往里塞 user: 前缀的字段。结果用户 A 和用户 B 被网关负载到同一台机器、复用了同一个 sessionId(网关的锅,但设计上也该防),A 的偏好出现在 B 的回答里。用户 B 问「帮我查订单」,Agent 用 A 的订单号去查。
排查了两天。日志里两个用户的 sessionId 一模一样,但 userId 不同,而情景记忆的 key 里根本没带 userId。修法很简单:mem:episodic:{userId} 和 mem:working:{sessionId} 彻底分开,工作记忆的 key 里不再出现任何用户维度的数据。
教训:任何跨用户共享的 key,命名里必须带用户维度,哪怕你觉得「sessionId 已经够了」。
坑二:情景记忆 TTL 设太长,Redis 无限膨胀。
最初设了 180 天,理由是「用户偏好应该长期保留」。上线三周,Redis 内存翻了 5 倍。分析下来,80% 的情景记忆是「三个月前聊过两句就再没回来的用户」,这部分数据永远不会被读到,纯粹占内存。
改成 30 天 + 滑动续期后,内存稳定在 3G 以内。判断标准是:活跃用户每轮对话都会续期,30 天窗口足够覆盖「一个月来一次」的用户;超过 30 天没来的,重新问一遍偏好,成本不过 300 Token,比常驻内存便宜得多。
坑三:语义检索 Top-K 返回无关信息,Agent 产生幻觉。
语义记忆上线后,用户问「退货怎么操作」,Agent 回答里突然冒出一段「企业采购阶梯折扣政策」。查下来是 Top-K 设成了 20,向量相似度 0.72 的「折扣政策」条目被捞了回来,而真正的「退货流程」相似度只有 0.68——因为知识库里退货相关的文档太短,向量化后语义被稀释。
两个修法一起上:一是 Top-K 从 20 降到 5,并加了相似度阈值 0.78,低于阈值的直接丢弃;二是把短文档在写入时做「文档扩充」,拼上所属业务域的上下文再向量化。改完以后,无关召回率从 31% 降到 6%。
教训:语义检索的 Top-K 不是越大越好,「宁缺毋滥」在这里是字面意思。
坑四:Agent 启动时把所有记忆一次性加载,冷启动卡顿 10 秒以上。
这是坑三修完之后引入的。为了让「一次 Redis 往返拿全」,我把语义记忆的检索结果也塞进了启动流程,还顺手把用户最近 100 条情景记忆全 HGETALL 出来。结果就是冷启动从 1.2 秒涨到 12 秒,用户等得想砸键盘。
根因是「一次拿全」和「拿得太多」被我混为一谈了。正确的做法是:启动时只拿这一轮真正要用的——情景记忆截断到 12 条,语义检索 Top-K 降到 5,工作记忆只取当前 turn。剩下的按需加载。
改完冷启动回到 1.4 秒。这个坑最典型:优化方向是对的,但「优化」不等于「越多越好」。
七、上线检查清单
把上面这些坑反过来写,就是一张能直接用的检查清单。我们上线前逐条过了一遍,建议你也过一遍:
| 检查项 | 判定标准 | 不达标会怎样 |
|---|---|---|
| 三层记忆的 Redis key 是否物理隔离 | 工作记忆只按 sessionId,情景记忆只按 userId | 跨用户数据错乱,A 的偏好出现在 B 的回答里 |
| 每层是否都有 TTL | 工作 5 分钟、情景 30 天、语义 365 天 | Redis 内存无上限增长,直到报警 |
| 情景记忆是否设置了条数上限 | 单用户不超过 50 条事件 + 20 条偏好 | 单 key 膨胀到几 MB,HGETALL 拖慢整轮对话 |
| 偏好写入是否做 PII 检测 | 敏感信息一律拒绝写入 | 合规事故,用户信息明文落盘 |
| 语义检索是否有相似度阈值 | 低于 0.78 的召回结果直接丢弃 | Agent 拿无关知识编答案,产生幻觉 |
| 启动加载是否有条数限制 | 情景 12 条、语义 5 条、工作 1 轮 | 冷启动 10 秒以上,用户体验崩盘 |
| 是否有用户侧的清除入口 | 设置页可一键清空所有层 | 用户要求「忘掉我」时无法满足,合规风险 |
| 清理任务是否在低峰执行 | 凌晨 3 点,单批 500 以内 | 白天跑 SCAN 阻塞 Redis,全线超时 |
上线之后我们盯了三个指标,都是从我们自己的日志里统计的,不是外部数据:单轮平均 Token 消耗从 1420 降到 610(降幅 57%);用户重复陈述同一偏好的比例从 68% 降到 12%;冷启动 P99 从 11.8 秒降到 1.6 秒。
最大的收获不是省了多少 Token,是业务方不再说「这个 Agent 很笨」了。它开始记得用户是谁、上次做了什么、喜欢什么格式——「记得」这件事本身,就是用户体感的全部。
最后留个问题
三层记忆的 TTL 怎么定,没有标准答案,只有权衡。我们的答案是 5 分钟 / 30 天 / 365 天,但这取决于你的用户多久来一次、单次对话多长、重新问一遍偏好的成本有多高。
所以想问问你:你的 Agent 工作记忆的 TTL 设多少秒?为什么是这个数值?
我见过设 60 秒的(理由是「一轮对话不可能超过一分钟」),也见过设 3600 秒的(理由是「用户可能中途去开个会」)。两种都能跑,但背后的假设完全不同。你的假设是什么?评论区聊聊,我挑几个典型的在下一篇里拆解。