🎯 本周回顾

主题 核心结论 简历一句话
D1 记忆分层 短记忆(上下文)/ 长记忆(事实库)/ 画像(偏好)三层各有生命周期,混在一起必然失控。 设计三层记忆架构,按生命周期拆分存储与召回链路。
D2 长记忆写入 事实抽成 (subject, predicate, object) 三元组,predicate 走白名单,才可能被程序消费。 实现基于三元组的记忆抽取管线,谓词白名单覆盖率 92%。
D3 记忆召回 向量召回负责“像不像”,结构化过滤负责“该不该”,两路召回合并后再重排。 构建向量 + 结构化混合召回,把无关记忆注入率从 31% 降到 7%。
D4 状态持久化 write-ahead 落状态、幂等键兜副作用、恢复时对账而非猜测。 实现可续跑任务执行器,kill -9 后 1.2 秒恢复且零重复副作用。
D5 冲突与遗忘 同 subject+predicate 不同 object 即冲突;三档覆盖策略按谓词配置;软删除保留版本链。 实现双时态事实表与冲突裁决器,支持任意时点回溯。
D6 用户画像 只收稳定偏好;会话结束异步增量抽取;结构化字段为事实源,摘要为渲染产物。 设计用户画像抽取与选择性注入,system prompt 体积压缩 40%。

💻 完整代码:MemoryService 三层装配

三层的边界就一条:短记忆按会话走 Redis,长记忆和画像走 PG。装配时把 D4 的会话状态、D5 的事实表、D6 的画像表组进同一个服务,对外只暴露 prepare() 和 commit() 两个方法。

package com.example.memory;

import com.example.profile.PromptBuilder;
import com.example.profile.UserProfileExtractor;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.Duration;
import java.util.List;
import java.util.Map;

@Service
public class MemoryService {

    private static final Duration SHORT_TTL = Duration.ofHours(24);

    private final StringRedisTemplate redis;
    private final JdbcTemplate jdbc;
    private final MemoryConflictResolver resolver;   // D5
    private final PromptBuilder promptBuilder;        // D6
    private final UserProfileExtractor extractor;    // D6

    public MemoryService(StringRedisTemplate redis, JdbcTemplate jdbc,
                         MemoryConflictResolver resolver, PromptBuilder promptBuilder,
                         UserProfileExtractor extractor) {
        this.redis = redis;
        this.jdbc = jdbc;
        this.resolver = resolver;
        this.promptBuilder = promptBuilder;
        this.extractor = extractor;
    }

    /** 第一层:短记忆 —— 当前会话最近 N 轮,Redis List + TTL 活跃续期 */
    public void appendTurn(String sessionId, String role, String text) {
        String key = "mem:short:" + sessionId;
        redis.opsForList().rightPush(key, role + ":" + text);
        redis.opsForList().trim(key, -20, -1);
        redis.expire(key, SHORT_TTL);
    }

    public List<String> recentTurns(String sessionId) {
        List<String> turns = redis.opsForList().range("mem:short:" + sessionId, 0, -1);
        redis.expire("mem:short:" + sessionId, SHORT_TTL);
        return turns == null ? List.of() : turns;
    }

    /** 第二层:长记忆 —— 三元组事实,只取 ACTIVE 且未过期 */
    public String recallFacts(long userId, String keyword) {
        List<Map<String, Object>> rows = jdbc.queryForList(
                "SELECT id, predicate, object FROM memory_fact "
              + "WHERE user_id = ? AND valid_to IS NULL AND status IN ('ACTIVE','DORMANT') "
              + "AND (expires_at IS NULL OR expires_at > now()) "
              + "AND (object ILIKE ? OR predicate ILIKE ?) ORDER BY hit_count DESC LIMIT 8",
                userId, "%" + keyword + "%", "%" + keyword + "%");
        StringBuilder sb = new StringBuilder();
        for (Map<String, Object> r : rows) {
            resolver.touch(((Number) r.get("id")).longValue());
            sb.append("- ").append(r.get("predicate")).append(":")
              .append(r.get("object")).append('\n');
        }
        return sb.toString();
    }

    /** 组装本轮 prompt:画像(第三层)+ 事实 + 短记忆 + 本轮指令 */
    public String prepare(long userId, String sessionId, String intent, String userTurn) {
        String base = "你是用户的长期助手。";
        String withProfile = promptBuilder.build(base, userId, intent, userTurn);
        String facts = recallFacts(userId, userTurn);
        String shortMem = String.join("\n", recentTurns(sessionId));
        return withProfile + "\n## 相关记忆\n" + facts + "\n## 本会话上下文\n" + shortMem + "\n";
    }

    /** 一轮结束:写短记忆;触发画像抽取(异步,失败进队列) */
    public void commit(long userId, String sessionId, String summary) {
        appendTurn(sessionId, "session_summary", summary);
        extractor.extractAsync(userId, sessionId, summary,
                jdbc.queryForObject("SELECT tech_stack::text FROM user_profile WHERE user_id = ?",
                        String.class, userId));
    }

    /** 抽取出的新事实入口:走 D5 的冲突裁决 */
    public boolean remember(long userId, String subject, String predicate,
                            String object, BigDecimal confidence, Long sourceMsgId) {
        return resolver.upsert(userId, subject, predicate, object, confidence, sourceMsgId);
    }
}

📌 本周小结

记忆系统的复杂度不在“存”,而在“什么时候用哪一层”。一个可用的判定顺序是:本轮指令 > 短记忆(刚才说了什么)> 长记忆(已知事实)> 画像(长期偏好)。顺序错了,模型就会拿三个月前的偏好去顶撞用户刚才的明确要求——这是上线后收到最多的投诉类型。

最值得记住的一条:所有自动写入的记忆都要能被人看、被人改、被人撤。审计轨迹(D5 的版本链)和用户可见的偏好页(D6)不是可选项,而是这套系统存在的前提。

🔖 下周预告

W5 进入多 Agent 协作:单 Agent 的记忆已经够用,但当一个任务需要检索 Agent、编码 Agent、审核 Agent 分工时,上下文怎么传递、冲突怎么收敛、谁来兜底失败。下周从「Agent 间消息协议」开始。