Agent 记不住东西?基于分层记忆架构打造 AI Agent 长期记忆与个性化上下文引擎

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 消息对加上工具调用结果:

json 复制代码
{
  "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 对象,本轮内所有组件只读这个对象。

java 复制代码
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%。

后来改成只存三类东西:

  1. 显式声明的偏好:用户说「我回答要简短」「我用 Java 不用 Go」,这类是高价值信息,存。
  2. 常用工具与参数 :从工具调用日志里聚合出来的,比如「这个用户 80% 的任务走 query_order 工具」。
  3. 已完成的任务摘要:不是完整对话,是一句话结果 + 关键 ID,用来避免重复劳动。

然后是隐私。用户手机号、身份证号、详细地址这类东西,我们一律不存明文。做法是:识别 → 脱敏 → 加密存储。加密用 AES-256-GCM,密钥走 KMS,不落配置文件。

java 复制代码
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,方便本地排查和审计:

sql 复制代码
-- 语义记忆知识表,跨用户共享的领域知识
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 侧关键操作,包括一个原子写入脚本:

bash 复制代码
# 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
lua 复制代码
-- 原子写入一条情景事件:追加事件 + 裁剪超出上限的旧事件 + 续期
-- 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 点跑一次清理,把过期数据、脏数据、低价值数据一次性处理掉。
  • 用户负责显式遗忘:设置页面上有「清除我的所有记忆」按钮,点了就真的删干净,不是标记删除。
java 复制代码
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 秒的(理由是「用户可能中途去开个会」)。两种都能跑,但背后的假设完全不同。你的假设是什么?评论区聊聊,我挑几个典型的在下一篇里拆解。

相关推荐
草莓熊Lotso31 分钟前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构
Keith Guo2 小时前
ESP32-S31芯片架构中文件系统在不同的Flash的位置对PSRAM的性能影响
性能优化·架构·esp32
一条Go3 小时前
SSH 命令审核流:为什么「能执行」必须先「被批准」
后端·架构·github
超低空4 小时前
一文说清LRU算法
后端·算法·架构
AAA修煤气灶刘哥6 小时前
32 GB 内存跑起 1800 亿参数模型,代价是什么?
人工智能·后端·架构
AAA修煤气灶刘哥6 小时前
同一个项目,为什么换个 Agent 又得从头解释?
后端·架构·代码规范
谙弆悕博士7 小时前
多智能体架构详解:网状去中心化架构(Mesh对等P2P)
人工智能·架构·去中心化·p2p·多智能体·智能体·langgraph
微订校园外卖系统18 小时前
自己做校园外卖跑腿小程序用什么系统:多商户与单店架构
小程序·架构·外卖系统·本地生活·微订
深入云栈21 小时前
Netty 4.2.x 源码深度解析 (二十四):池化内存分配 —— PoolArena、PoolChunk 与 PoolSubpage
java·后端·架构