🎯 今日核心问题
- 用户 3 月说「只发顺丰」,11 月说「顺丰太慢改京东」,两条记忆都在库里,召回时模型信哪个?
- 冲突能不能靠模型在 prompt 里「自己判断」?为什么必须落成数据库约束?
- 删掉的偏好,三个月后用户又提起来,怎么恢复?
📖 精读提纲
【一】冲突检测是三元组问题,不是语义问题
冲突的定义因此可以做得极其廉价:同一 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 反过来指回历史节点,验证「改回原值」不新增语义重复行。
🔖 明日预告
冲突解决了,但记忆还是零散的。用户的偏好应该被压缩成一份画像——只留稳定特征,扔掉一次性需求。明天讲用户画像构建。