🎯 今日核心问题

  1. 用户 3 月说「只发顺丰」,11 月说「顺丰太慢改京东」,两条记忆都在库里,召回时模型信哪个?
  2. 冲突能不能靠模型在 prompt 里「自己判断」?为什么必须落成数据库约束?
  3. 删掉的偏好,三个月后用户又提起来,怎么恢复?

📖 精读提纲

【一】冲突检测是三元组问题,不是语义问题

冲突的定义因此可以做得极其廉价:同一 subject + 同一 predicate,但 object 不同。这是一条能写进 SQL 唯一索引的判定,不需要向量相似度,也不需要 LLM 判断。

用向量检索发现冲突是最常见的过度设计。embedding 只告诉你「两句话讲的是同一件事」,不告诉你「它们互相矛盾」——「喜欢顺丰」和「讨厌顺丰」在向量空间极其接近。冲突判定必须靠结构:结论归一化成三元组,predicate 走白名单枚举,object 走标准化(「SF」「顺丰速运」统一成 SF_EXPRESS)。归一化做不好,同一张表里会并存「顺丰」「sf」「顺丰快递」三种写法,检测全部失效。

多值 predicate 要单独标记。(用户, 掌握的编程语言, Java) 和 (用户, 掌握的编程语言, Go) 不是冲突,可以并存。所以 predicate 上必须有一列 cardinality:SINGLE 才走冲突检测,MULTI 直接追加。把「喜欢的食物」当 SINGLE 会一条条覆盖用户的偏好,这是最典型的翻车点。

【二】覆盖策略三档:按事实类型分配,不要全局一刀切

时间优先(last-write-wins)适用于会自然变化的属性:收货地址、套餐档位、常用快递。新事实的时间戳更晚,直接 supersede 旧的。简单、可解释,90% 的 predicate 应该走这档。

置信度优先适用于用户随口一说的场景。「我好像挺喜欢用 Rust 写东西」和「我们团队全栈 Rust,我天天写」置信度完全不同。抽取时让模型同时输出 confidence ∈ [0,1],新事实必须高出旧事实一个阈值(如 0.15)才允许覆盖,否则只做并存、召回时两条都带上并标注不确定。

人工裁决适用于高代价 predicate:付款方式、发票抬头、实名信息、权限范围。这类事实错一次就是事故,冲突时不自动覆盖,写一条 PENDING_REVIEW 记录,把新旧两条推给运营/用户确认。成本就是一张待审表加一个后台页,收益是避免自动覆盖引发的资金级错误。

三档策略应配在 predicate 元数据表里(strategy 列),由 resolver 读取分派,不要散在业务代码里。

【三】软删除与版本链:物理删是自断退路

被覆盖的旧事实不能删。memory_fact 表用 valid_from / valid_to 表达时间区间,用 superseded_by 指向新事实 id,形成可回溯的版本链。旧行 valid_to = now()、superseded_by = 新 id、status = 'SUPERSEDED',新行 valid_from = now()、valid_to = NULL。查当前事实就是 WHERE valid_to IS NULL,查某个时间点就是 valid_from <= T AND (valid_to IS NULL OR valid_to > T)——标准双时态建模,一次建好省无数事。

版本链的三条价值:审计——用户投诉「系统乱改我地址」时能拿出完整变更链;回溯——出问题能查「这单当时依据的是哪条事实」;恢复——用户说「还是改回顺丰吧」,不必新建事实,把最新那条 supersede 到历史节点即可。

【四】过期机制:TTL 是懒删除,衰减是排序信号

大多数事实会随时间失效——「下个月要搬家」一年后就是噪声。三种机制要分清用途:TTL(expires_at 列)用于有明确时效的事实,抽取时让模型判断,过期行查询时被过滤但不删除;定期衰减用定时任务算 decay_score = base_confidence * exp(-λ * days_since_created) / (1 + log(2 + hit_count)),低于阈值把 status 置为 DORMANT,不进召回但仍可检索;被引用次数加权是反向的——hit_count 越高说明事实被反复用到,衰减应更慢,这就是上面分母里那个对数项的来源。

关键点:衰减只影响召回排序,不改变事实真值。DORMANT 是「不主动注入 prompt」,不是「不成立」。用户三个月后又问起搬家,一次带关键词的检索就该把它捞回来,hit_count 加 1、status 恢复 ACTIVE。把衰减写成物理删除,等于让 Agent 失忆。

💻 代码示例

表设计 + 冲突裁决器。核心是:predicate 元数据决定策略,写新事实时在一个事务里同时关旧行、插新行、回填 superseded_by。

package com.example.memory;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.sql.PreparedStatement;
import java.sql.Statement;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Service
public class MemoryConflictResolver {

    public enum Strategy { TIME_FIRST, CONFIDENCE_FIRST, HUMAN_REVIEW }

    public record Fact(Long id, Long userId, String subject, String predicate,
                       String object, BigDecimal confidence,
                       LocalDateTime validFrom, LocalDateTime validTo,
                       Long supersededBy, String status) {}

    public record PredicateMeta(String cardinality, Strategy strategy, Integer ttlDays) {}

    private static final BigDecimal CONFIDENCE_GAP = new BigDecimal("0.15");

    private final JdbcTemplate jdbc;

    public MemoryConflictResolver(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
        this.jdbc.execute("""
            CREATE TABLE IF NOT EXISTS memory_fact (
                id            BIGSERIAL PRIMARY KEY,
                user_id       BIGINT       NOT NULL,
                subject       VARCHAR(128) NOT NULL,
                predicate     VARCHAR(64)  NOT NULL,
                object        VARCHAR(512) NOT NULL,
                confidence    NUMERIC(3,2) NOT NULL DEFAULT 0.80,
                valid_from    TIMESTAMPTZ  NOT NULL DEFAULT now(),
                valid_to      TIMESTAMPTZ,
                superseded_by BIGINT REFERENCES memory_fact(id),
                status        VARCHAR(16)  NOT NULL DEFAULT 'ACTIVE',
                hit_count     INT          NOT NULL DEFAULT 0,
                expires_at    TIMESTAMPTZ,
                source_msg_id BIGINT,
                created_at    TIMESTAMPTZ  NOT NULL DEFAULT now()
            );
            CREATE INDEX IF NOT EXISTS idx_fact_lookup
                ON memory_fact (user_id, subject, predicate) WHERE valid_to IS NULL;
            CREATE TABLE IF NOT EXISTS predicate_meta (
                predicate  VARCHAR(64) PRIMARY KEY,
                cardinality VARCHAR(8)  NOT NULL,   -- SINGLE / MULTI
                strategy   VARCHAR(24) NOT NULL,    -- TIME_FIRST / CONFIDENCE_FIRST / HUMAN_REVIEW
                ttl_days   INT
            );
            CREATE TABLE IF NOT EXISTS fact_review_queue (
                id         BIGSERIAL PRIMARY KEY,
                old_fact_id BIGINT NOT NULL,
                new_object  VARCHAR(512) NOT NULL,
                new_confidence NUMERIC(3,2) NOT NULL,
                created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
                resolved_at TIMESTAMPTZ
            );
            INSERT INTO predicate_meta (predicate, cardinality, strategy, ttl_days) VALUES
                ('收货快递', 'SINGLE', 'TIME_FIRST',       NULL),
                ('常用语言', 'SINGLE', 'TIME_FIRST',       NULL),
                ('代码风格', 'MULTI',  'CONFIDENCE_FIRST', NULL),
                ('付款方式', 'SINGLE', 'HUMAN_REVIEW',     NULL),
                ('临时需求', 'MULTI',  'TIME_FIRST',       30)
            ON CONFLICT (predicate) DO NOTHING;
            """);
    }

    /** 写入一条新事实;返回 true 表示已生效,false 表示进了人工审核队列 */
    @Transactional
    public boolean upsert(long userId, String subject, String predicate, String object,
                          BigDecimal confidence, Long sourceMsgId) {
        String normPredicate = normalize(predicate);
        String normObject = normalize(object);

        var meta = jdbc.queryForObject(
                "SELECT cardinality, strategy, ttl_days FROM predicate_meta WHERE predicate = ?",
                (rs, i) -> new PredicateMeta(rs.getString(1), Strategy.valueOf(rs.getString(2)),
                        (Integer) rs.getObject(3)),
                normPredicate);
        String cardinality = meta.cardinality();
        Strategy strategy = meta.strategy();
        Integer ttlDays = meta.ttlDays();

        List<Fact> current = jdbc.query(
                "SELECT id, object, confidence FROM memory_fact "
              + "WHERE user_id = ? AND subject = ? AND predicate = ? AND valid_to IS NULL AND status <> 'DELETED'",
                (rs, i) -> new Fact(rs.getLong(1), userId, subject, normPredicate,
                        rs.getString(2), rs.getBigDecimal(3), null, null, null, "ACTIVE"),
                userId, subject, normPredicate);

        if (current.stream().anyMatch(f -> f.object().equals(normObject))) {
            return true; // 幂等:同一事实重复抽取,只刷新 hit_count
        }

        Fact existing = current.isEmpty() ? null : current.get(0);

        if (existing != null && "SINGLE".equals(cardinality)) {
            BigDecimal oldConf = existing.confidence();
            switch (strategy) {
                case CONFIDENCE_FIRST -> {
                    if (confidence.compareTo(oldConf.add(CONFIDENCE_GAP)) < 0) {
                        return false; // 差距不够大:并存,等下轮再判
                    }
                }
                case HUMAN_REVIEW -> {
                    jdbc.update("INSERT INTO fact_review_queue (old_fact_id, new_object, new_confidence) "
                              + "VALUES (?, ?, ?)", existing.id(), normObject, confidence);
                    return false;
                }
                case TIME_FIRST -> { /* 直接覆盖 */ }
            }
        }

        Long newId = insert(userId, subject, normPredicate, normObject, confidence, ttlDays, sourceMsgId);
        if (existing != null && "SINGLE".equals(cardinality)) {
            jdbc.update("UPDATE memory_fact SET valid_to = now(), superseded_by = ?, status = 'SUPERSEDED' "
                      + "WHERE id = ?", newId, existing.id());
        }
        return true;
    }

    private Long insert(long userId, String subject, String predicate, String object,
                        BigDecimal confidence, Integer ttlDays, Long sourceMsgId) {
        KeyHolder kh = new GeneratedKeyHolder();
        jdbc.update(con -> {
            PreparedStatement ps = con.prepareStatement(
                    "INSERT INTO memory_fact (user_id, subject, predicate, object, confidence, "
                  + "expires_at, source_msg_id) VALUES (?, ?, ?, ?, ?, "
                  + "CASE WHEN ?::int IS NULL THEN NULL ELSE now() + (?::int || ' days')::interval END, ?)",
                    new String[]{"id"});
            ps.setLong(1, userId);
            ps.setString(2, subject);
            ps.setString(3, predicate);
            ps.setString(4, object);
            ps.setBigDecimal(5, confidence);
            ps.setObject(6, ttlDays, java.sql.Types.INTEGER);
            ps.setObject(7, ttlDays, java.sql.Types.INTEGER);
            ps.setObject(8, sourceMsgId);
            return ps;
        }, kh);
        return kh.getKeyAs(Long.class);
    }

    /** 定时任务:只降级,不删除 */
    @Transactional
    public int decay(double lambda, double dormantThreshold) {
        return jdbc.update("""
            UPDATE memory_fact
               SET status = 'DORMANT'
             WHERE valid_to IS NULL
               AND status = 'ACTIVE'
               AND confidence * exp(-(? * EXTRACT(EPOCH FROM (now() - created_at)) / 86400.0)
                                    / (1 + ln(2 + hit_count))) < ?
            """, lambda, dormantThreshold);
    }

    /** 召回时把休眠事实激活 */
    public void touch(long factId) {
        jdbc.update("UPDATE memory_fact SET hit_count = hit_count + 1, status = 'ACTIVE' WHERE id = ?", factId);
    }

    public List<Fact> asOf(long userId, LocalDateTime t) {
        return jdbc.query(
                "SELECT id, object, confidence, valid_from, valid_to FROM memory_fact "
              + "WHERE user_id = ? AND valid_from <= ? AND (valid_to IS NULL OR valid_to > ?) "
              + "ORDER BY valid_from DESC",
                (rs, i) -> new Fact(rs.getLong(1), userId, null, null, rs.getString(2),
                        rs.getBigDecimal(3), rs.getTimestamp(4).toLocalDateTime(),
                        rs.getTimestamp(5) == null ? null : rs.getTimestamp(5).toLocalDateTime(),
                        null, null),
                userId, t, t);
    }

    public Optional<Fact> findCurrent(long userId, String subject, String predicate) {
        return jdbc.query(
                "SELECT id, object, confidence FROM memory_fact WHERE user_id = ? AND subject = ? "
              + "AND predicate = ? AND valid_to IS NULL AND status IN ('ACTIVE','DORMANT')",
                rs -> rs.next() ? new Fact(rs.getLong(1), userId, subject, predicate,
                        rs.getString(2), rs.getBigDecimal(3), null, null, null, "ACTIVE") : null,
                userId, subject, normalize(predicate)).stream().findFirst();
    }

    private String normalize(String raw) {
        return raw == null ? "" : raw.trim().toUpperCase().replace("顺丰速运", "SF_EXPRESS");
    }
}

实测:给 U1024 写 (收货快递, 顺丰),再写 (收货快递, 京东),第一行 valid_to 被填、superseded_by 指向新行。而 asOf(2026-08-01) 仍返回顺丰——回溯能力来自数据模型本身,不需要额外快照表。

✏️ 今日动手

① 建表并灌 10 条三元组,其中 3 条互相冲突,验证 upsert 后 WHERE valid_to IS NULL 的数量正确;② 把 付款方式 的 HUMAN_REVIEW 走一遍,确认新值没生效且 fact_review_queue 多了一行;③ 调 decay(0.02, 0.4),观察哪些事实被降到 DORMANT;④ 用 asOf 查昨天的视图,确认返回的是被覆盖前的值;⑤ 把某条事实的 superseded_by 反过来指回历史节点,验证「改回原值」不新增语义重复行。

🔖 明日预告

冲突解决了,但记忆还是零散的。用户的偏好应该被压缩成一份画像——只留稳定特征,扔掉一次性需求。明天讲用户画像构建。