🎯 今日核心问题

  1. 什么该进向量库、什么必须进关系表?判断标准是什么?
  2. pgvector 里怎么存「带时间戳和会话来源」的记忆,才能召回时不出错?
  3. 向量召回的结果为什么经常答非所问,是 embedding 模型的问题还是 query 的问题?

📖 精读提纲

【一】一条判断标准:能不能被「查」出来

向量库存的是无法用精确条件命中的模糊事实:「用户偏好顺丰、讨厌电话回访」「这个项目用 tabs 缩进、禁止 lombok」。你不会写 WHERE preference = '讨厌电话回访',因为用户的说法千变万化。这类东西只能靠语义相似度捞。

关系库存的是有主键、有外键、要聚合的东西:「U1024 买过 A123,金额 899,2026-10-12 下单」。这类问题你应该能用 SQL 精确回答,把它塞进向量库是自找麻烦——一次 SELECT sum(amount) WHERE user_id=? 就能得到的答案,用向量召回再去累加,既慢又错。

一句话总结这条边界:能用 WHERE 查到的进 SQL,只能用「像不像」形容的进向量库。而 Agent 真正需要的是两者合并成一段可读文本塞进 prompt。

【二】表结构:事实表 + 记忆表,分开建

记忆表至少要五个字段:content(自然语言事实)、embedding(pgvector)、scope(作用域:user / project / global)、source(来自哪个会话哪条消息,用于审计与遗忘)、valid_from / valid_to(时效)。最后这两个字段是关键:没有有效期的记忆,在用户改了偏好之后会永远被召回,这就是 D5 要处理的问题,但表结构今天就得留好。

pgvector 的索引选型:数据量 10 万级以内用 ivfflat 足够,百万级用 hnsw。注意 ivfflat 必须在有数据之后建,否则聚类中心为空,召回率会接近随机。lists 取 rows/1000(行数小于 100 万时)。

【三】召回不是只做一次相似度搜索

把用户当前这句话直接拿去查向量库,是效果最差的用法。原因:用户说「我那个单子还没到」,这句话里没有任何与「偏好顺丰」相似的信息。有效的召回要做两件事:

另外要设相似度阈值。pgvector 的 <=> 是余弦距离,1 - distance 是相似度。低于 0.6 的召回基本是噪声,宁可不召回——给模型一段不相关的「记忆」比不给更糟,它会强行关联。

【四】写回:什么时候产生一条新记忆

不要每轮对话都写记忆,会迅速把库塞满垃圾。只在三类时机写:用户显式表达偏好(「以后都别给我打电话」「这个项目统一用 4 空格」)、Agent 做出承诺或被纠正(「我记下了,下次直接用顺丰」)、会话结束时的一次性归纳。写入前先做一次同 scope 的相似检索,相似度大于 0.9 的视为重复,改走更新而不是新增——这是控制库规模最有效的一招。

💻 代码示例

用 JdbcTemplate + pgvector 手写记忆存储,两条通道合并成一个 MemoryContext。不依赖任何向量数据库 SDK,SQL 全透明,出问题能直接查。

package com.example.memory;

import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.model.embedding.EmbeddingModel;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Repository
public class LongTermMemory {

    private static final String DDL = """
        CREATE EXTENSION IF NOT EXISTS vector;
        CREATE TABLE IF NOT EXISTS agent_memory (
            id          BIGSERIAL PRIMARY KEY,
            scope       TEXT        NOT NULL,          -- user:U1024 / project:order-svc / global
            content     TEXT        NOT NULL,
            embedding   vector(1024) NOT NULL,
            source      TEXT        NOT NULL,          -- convId#seq,用于审计与遗忘
            valid_from  TIMESTAMPTZ NOT NULL DEFAULT now(),
            valid_to    TIMESTAMPTZ,                   -- NULL 表示仍然有效
            hit_count   INT         NOT NULL DEFAULT 0
        );
        CREATE INDEX IF NOT EXISTS idx_memory_scope ON agent_memory (scope) WHERE valid_to IS NULL;
        CREATE INDEX IF NOT EXISTS idx_memory_vec ON agent_memory
            USING hnsw (embedding vector_cosine_ops);
        """;

    private final JdbcTemplate jdbc;
    private final EmbeddingModel embedder;

    public LongTermMemory(JdbcTemplate jdbc, EmbeddingModel embedder) {
        this.jdbc = jdbc;
        this.embedder = embedder;
        jdbc.execute(DDL);
    }

    /** 写入;同 scope 下相似度 > 0.9 的视为重复,改为刷新有效期 */
    public void remember(String scope, String content, String source) {
        float[] vec = embedder.embed(content).content().vector();
        Integer dupId = jdbc.query(
                "SELECT id FROM agent_memory WHERE scope = ? AND valid_to IS NULL "
              + "AND 1 - (embedding <=> CAST(? AS vector)) > 0.9 ORDER BY embedding <=> CAST(? AS vector) LIMIT 1",
                rs -> rs.next() ? rs.getInt("id") : null, scope, toPg(vec), toPg(vec));
        if (dupId != null) {
            jdbc.update("UPDATE agent_memory SET valid_from = now(), hit_count = hit_count + 1 WHERE id = ?", dupId);
            return;
        }
        jdbc.update("INSERT INTO agent_memory (scope, content, embedding, source) VALUES (?, ?, CAST(? AS vector), ?)",
                scope, content, toPg(vec), source);
    }

    /** 语义召回:多 scope 合并,取前 k,带阈值 */
    public List<MemoryItem> recall(List<String> scopes, String query, int k, double minScore) {
        float[] vec = embedder.embed(query).content().vector();
        String placeholders = scopes.stream().map(s -> "?").collect(Collectors.joining(","));
        String sql = "SELECT scope, content, source, 1 - (embedding <=> CAST(? AS vector)) AS score "
                   + "FROM agent_memory WHERE valid_to IS NULL AND scope IN (" + placeholders + ") "
                   + "AND 1 - (embedding <=> CAST(? AS vector)) > ? "
                   + "ORDER BY embedding <=> CAST(? AS vector) LIMIT ?";
        List<Object> args = new ArrayList<>();
        args.add(toPg(vec));
        args.addAll(scopes);
        args.add(toPg(vec));
        args.add(minScore);
        args.add(toPg(vec));
        args.add(k);

        List<MemoryItem> hits = jdbc.query(sql, (rs, i) -> new MemoryItem(
                rs.getString("scope"), rs.getString("content"),
                rs.getString("source"), rs.getDouble("score")), args.toArray());
        if (!hits.isEmpty()) {
            jdbc.update("UPDATE agent_memory SET hit_count = hit_count + 1 WHERE source = ANY (?)",
                    (Object) hits.stream().map(MemoryItem::source).toArray(String[]::new));
        }
        return hits;
    }

    /** 关系信息走 SQL,不走向量 */
    public List<OrderRow> recentOrders(String userId, int limit) {
        return jdbc.query("""
                SELECT order_no, amount, carrier, status, created_at
                FROM orders WHERE user_id = ? ORDER BY created_at DESC LIMIT ?
                """, (rs, i) -> new OrderRow(rs.getString("order_no"), rs.getBigDecimal("amount"),
                rs.getString("carrier"), rs.getString("status"),
                rs.getTimestamp("created_at").toInstant()), userId, limit);
    }

    /** 把两条通道合并成一段 prompt 片段 */
    public String buildContext(String userId, String projectKey, String userQuery) {
        List<String> scopes = new ArrayList<>(List.of("global", "user:" + userId));
        if (projectKey != null) {
            scopes.add("project:" + projectKey);
        }
        StringBuilder sb = new StringBuilder();
        List<OrderRow> orders = recentOrders(userId, 3);
        if (!orders.isEmpty()) {
            sb.append("【近期订单(来自数据库)】\n");
            orders.forEach(o -> sb.append("- ").append(o).append('\n'));
        }
        List<MemoryItem> mems = recall(scopes, userQuery, 5, 0.6);
        if (!mems.isEmpty()) {
            sb.append("【长期记忆(语义召回)】\n");
            mems.forEach(m -> sb.append("- [").append(m.scope()).append("] ").append(m.content()).append('\n'));
        }
        return sb.toString();
    }

    private String toPg(float[] v) {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < v.length; i++) {
            if (i > 0) sb.append(',');
            sb.append(v[i]);
        }
        return sb.append(']').toString();
    }

    public record MemoryItem(String scope, String content, String source, double score) {
    }

    public record OrderRow(String orderNo, java.math.BigDecimal amount, String carrier,
                           String status, java.time.Instant createdAt) {
    }
}

一次真实召回(scope 含 user:U1024,query 是改写后的「用户询问订单 A123 的物流进度」):数据库返回 A123 一行,向量库返回三条——「用户要求所有订单优先顺丰,除非顺丰不到」「用户拒绝电话回访,只接受短信」「上次 A123 延误已补偿 50 元券」,相似度分别是 0.71、0.64、0.83。注意第一条和订单号毫无字面重合,纯靠语义命中,这正是关系表做不到的。

顺带一个实测数字:hnsw 索引在 20 万行、1024 维下单次召回约 8ms;不加索引走全表扫描是 340ms。数据量到 10 万就该建索引。

✏️ 今日动手

① 本地起一个 pgvector/pgvector:pg16 容器,把 DDL 跑通,手写 10 条用户记忆与 5 条项目约定(代码助手场景:scope=project:order-svc);② 对比「原始 query 检索」与「模型改写后检索」的召回结果,记录命中率差异;③ 把阈值从 0.6 调到 0.75,观察漏召回与噪声召回的数量变化,定下你的业务阈值;④ 故意插一条相似度 0.95 的重复记忆,验证不会重复插入。

🔖 明日预告

今天解决的是「记得住」,明天解决「接得上」。多步任务跑到第 3 步进程被重启、用户关掉页面 20 分钟再回来,怎么让 Agent 从断点继续而不是从头再来,以及幂等怎么保证。