《AI Agent 技术原理与架构·运行时、协议与系统架构》8.1 向量、倒排与图存储

记忆检索有三条路:向量相似度找语义相近的片段,倒排索引按关键词精确命中,关系图沿边找邻居。三种索引对应三类查询,同一条记忆可以被三种方式命中。实验用最小 MemoryStore 同时维护三套索引,演示查询结果与索引更新必须同步,说明为什么记忆层是检索结构而不是单纯的数据表。

以下向量、倒排与图的相似度数值均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。0.99 的相似度是演示用的数值,真实系统按 embedding 模型实测,但"三种索引对应三类查询、更新必须同步"这一条不变。

7.3 讲了上下文复用,这一节进记忆层本身。记忆层最常被画成一张表,但真正支撑检索的是三种结构:向量索引找语义相近的片段,倒排索引做关键词精确匹配,图存储沿关系找邻居。三种结构回答三类问题,同一条记忆可以被三种方式命中。

三种检索,三种查询

记忆检索不是一种操作,而是三类查询的集合:

检索结构查询方式典型问题
向量索引相似度排序“找语义相近的片段”
倒排索引关键词精确“找出含’权限’的记录”
图存储邻居遍历“谁和这条记忆有关”

三种结构缺一不可。 只做向量索引,用户问"最近一次改过权限的是谁"就答不上——关键词"权限"可能在向量空间里离问题很远;只做倒排索引,用户说"帮我回忆上次聊到浅色模式的方案"就死板——同义词、改写都不命中。记忆层要同时能回答"语义上像的"“字面上含的"和"关系上挨着的”。

同一条记忆,三种命中方式

模块里的三条记忆正好演示三种命中:

记忆内容命中方式
m1首页的统计口径关键词"首页"精确命中
m2报表的权限要求语义查询与它最相似
m3数据分析的依赖作为 m2 的邻居被找到

一条记忆进入记忆层时,要同时写进三套索引。这就是"索引更新必须同步"——向量、倒排、图三处都要有它,下一次查询才能从任何一个入口找到。

最小实验:三索引一体的记忆存储

实验提供一个最小 MemoryStore:add 同时写向量、倒排与图三套索引,search_vector 按余弦相似度排序,search_keyword 按关键词精确命中,neighbors 沿关系边取邻居。

# file: agp_lab/vector_index.py | write
# tier: 3
# verify: python3 -m unittest tests.test_vector_index
"""记忆存储与索引:向量、倒排与图三种检索结构。

记忆服务要支持三种检索:向量相似度(语义)、关键词倒排(精确)、
关系图(邻居)。本模块用一个最小 MemoryStore 同时维护三种索引,
演示同一条记忆如何被三种方式命中,以及索引更新必须同步。
"""
from __future__ import annotations

from dataclasses import dataclass, field
from typing import Any


def dot(a: list[float], b: list[float]) -> float:
    return sum(x * y for x, y in zip(a, b))


def norm(a: list[float]) -> float:
    return sum(x * x for x in a) ** 0.5 or 1.0


def cosine(a: list[float], b: list[float]) -> float:
    return dot(a, b) / (norm(a) * norm(b))


@dataclass(frozen=True)
class MemoryEntry:
    id: str
    text: str
    keywords: tuple[str, ...]
    vector: tuple[float, ...]
    related: set[str] = field(default_factory=set)


class MemoryStore:
    """同时维护向量、倒排与图三种索引。"""

    def __init__(self) -> None:
        self.entries: dict[str, MemoryEntry] = {}
        self.inverted: dict[str, set[str]] = {}

    def add(self, entry: MemoryEntry) -> None:
        self.entries[entry.id] = entry
        for keyword in entry.keywords:
            self.inverted.setdefault(keyword, set()).add(entry.id)

    def search_vector(self, query: list[float], k: int = 2) -> list[tuple[str, float]]:
        scored = [
            (entry.id, cosine(query, list(entry.vector)))
            for entry in self.entries.values()
        ]
        return sorted(scored, key=lambda pair: -pair[1])[:k]

    def search_keyword(self, term: str) -> list[str]:
        return sorted(self.inverted.get(term, set()))

    def neighbors(self, entry_id: str) -> list[str]:
        entry = self.entries[entry_id]
        return sorted(entry.related)

    def add_relation(self, left: str, right: str) -> None:
        self.entries[left].related.add(right)
        self.entries[right].related.add(left)

    def stats(self) -> dict[str, int]:
        return {
            "entries": len(self.entries),
            "keywords": len(self.inverted),
            "edges": sum(len(e.related) for e in self.entries.values()) // 2,
        }


ENTRIES: list[MemoryEntry] = [
    MemoryEntry("m1", "用户常访问首页统计面板", ("首页", "统计"), (1.0, 0.0, 0.0)),
    MemoryEntry("m2", "用户上次修改了报表权限", ("报表", "权限"), (0.8, 0.6, 0.0)),
    MemoryEntry("m3", "用户是数据分析团队负责人", ("数据", "团队"), (0.0, 0.7, 0.7)),
]


def demo() -> dict[str, Any]:
    store = MemoryStore()
    for entry in ENTRIES:
        store.add(entry)
    store.add_relation("m1", "m2")
    store.add_relation("m2", "m3")
    return {
        "vector_query": store.search_vector([0.9, 0.5, 0.0], k=2),
        "keyword_首页": store.search_keyword("首页"),
        "keyword_权限": store.search_keyword("权限"),
        "neighbors_of_m2": store.neighbors("m2"),
        "stats": store.stats(),
    }


if __name__ == "__main__":
    for key, value in demo().items():
        print(f"{key}: {value}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.vector_index

输出:

vector_query: [('m2', 0.9907115796044095), ('m1', 0.8741572761215378)]
keyword_首页: ['m1']
keyword_权限: ['m2']
neighbors_of_m2: ['m1', 'm3']
stats: {'entries': 3, 'keywords': 6, 'edges': 2}

五条输出对应五件事:

  1. vector_query:语义查询返回 [(‘m2’, 0.99), (‘m1’, 0.87)],按相似度降序。语义查询不承诺唯一答案,它给一个排序,取几条由调用方定。
  2. keyword_首页 / keyword_权限:关键词查询各自只命中一条。倒排是精确匹配,问"权限"不会带出"首页"。
  3. neighbors_of_m2:m2 的邻居是 m1 和 m3。图查询给出的是关系而不是分数——边本身就有方向与类型,邻居是"相关",不是"相似"。
  4. stats:3 条记忆、6 个关键词、2 条关系边。这个计数暴露了索引是冗余的:一条记忆至少出现在三套结构里。

一个值得点破的细节:m2 在向量查询里排第一(0.99),也被"权限"关键词命中,同时还有两个邻居——三种索引从三个角度描述同一条记忆,任何一个入口都能找到它。这也是为什么记忆层最怕"只存不索引":数据写进去但没进索引,等于丢在黑暗里,任何查询都摸不到。

索引同步与一致性

写一条记忆要同时更新三套索引,这就是一致性风险。常见的失败模式是"倒排更新了、向量没更新"——下次语义查询找不到这条新记忆。记忆层的写入必须是原子的索引事务:要么三套索引都更新,要么都不更新。教学模块用一个函数顺序写完,生产上要用同一事务或同一消息管道驱动。

写入顺序风险
先写数据、后写索引索引滞后,查询间歇性漏数据
先写索引、后写数据索引指到不存在的记忆
事务内同步写三套一致但延迟更高

索引与数据分离也很常见:数据存文档库,索引是外挂的检索服务。分离的好处是检索与存储各自扩缩容,代价是两套系统要持续同步。对记忆层来说,检索性能通常比存储写入更重要——读多写少,索引的可用性优先。

向量索引的边界

向量索引有三个必须交代的边界。第一,相似度不等于正确。 0.99 只说明 embedding 空间里近,不保证语义等价——两个话题相近但结论相反的片段,相似度照样高。检索结果要交给模型判断,不能把"最相似"当"最正确"。

第二,维度与成本。 向量维度越高,内存和距离计算越贵。几十条记忆用暴力计算没问题,百万条就要上 ANN(近似最近邻)索引——但 ANN 会牺牲召回率。索引选型是精度与成本的交换,不是越精确越好。

第三,倒排的分词口径。 中文"权限"能不能命中,取决于分词器怎么切。“权限管理"切成一词还是两词,直接决定查询结果。分词口径是记忆层的一个配置决策,写进架构而不是让开发临时拍脑袋。

图存储的边类型

图存储的"边"不是任意的,要给边分类:

边类型含义例子
依赖A 的结果被 B 使用分析依赖报表
引用A 提到 B方案引用规格
对立A 与 B 结论相反两版方案互斥

边的类型让"邻居"有意义。 依赖边上的邻居是"要一起读的”,对立边上的邻居是"要小心读的"。记忆层如果只存节点不存边类型,图查询就只能回答"谁相邻",回答不了"相邻意味着什么"。

与记忆分层的接口

8.1 的三种索引服务于记忆分层:工作记忆(当前任务上下文)通常用向量+倒排,长期记忆(跨任务沉淀)需要图结构表达积累关系。索引结构的选择跟着记忆的用途走——工作记忆要快,倒排和向量足够;长期记忆要表达"这组记忆怎么关联起来的",必须加图。这与 8.2 的版本、8.3 的隐私形成记忆层的完整四件套:怎么找(8.1)、怎么防旧(8.2)、怎么删(8.3)。

索引规模与分片

记忆量大了,索引要分片。向量索引最吃内存——embedding 是稠密数组,百万条记忆的向量索引动辄数 GB。倒排与图相对稀疏,但关键词表与关系边也会随规模膨胀。分片是按记忆类型分桶,每个桶独立的索引,检索时先路由到桶再查。

规模索引策略
小(千条)单实例内存索引
中(万条)按类型分片
大(百万条)分片 + ANN

分片带来跨片查询问题:一次语义查询可能要在多个桶里各查一遍再合并排序。这是检索结构规模化的代价——单实例最一致,分片要处理合并。选择分片还是单实例,看记忆量的增长预期,而不是当前条数。

embedding 稳定性

向量检索的质量绑在 embedding 上,而 embedding 会变。换 embedding 模型,旧的向量就全失效——相似度基于旧空间的坐标,新查询在新空间,两套坐标对不上。生产上要冻结 embedding 版本,或者给向量标注模型版本,换模型时批量重建。

变化后果应对
换 embedding 模型旧向量语义失效版本标注 + 批量重建
语义漂移相似度与直觉脱节抽样校验
新增维度旧向量维度不齐迁移脚本

embedding 稳定与 7.3 的前缀缓存是同一类问题:都要求"同一个东西每次算出来一样"。embedding 不稳定,索引更新频繁,检索质量与成本都受影响。

架构判据

记忆检索结构是否合格,用五条判据检查:

判据合格的样子不合格的样子
三类查询都能答语义/关键词/邻居各有索引只有一张表,只能扫描
写入同步一次写入更新全部索引索引滞后,查询漏数据
相似度有阈值有阈值过滤低分结果最相似就当真
倒排有分词口径分词规则明确可审计分词随意、结果漂移
图边有类型邻居关系分依赖/引用/对立边无类型,关系无意义

判据第一条是"三路齐全",判据第二条才是关键:写一条记忆要么三套索引一起更新,要么明确接受暂时的不可见。 判据第五条是长期记忆才有的要求——关系没有类型,图就退化成一张无向网,问不出"为什么相关"。

小结

  • 记忆层是检索结构不是数据表:向量、倒排、图回答三类不同的问题。
  • 同一条记忆进三个索引,写操作必须原子同步。
  • 向量相似度不等于语义正确,检索结果要交给模型判断。
  • 倒排分词口径、图的边类型是必须写进架构的配置决策。
  • 索引选型跟着记忆用途走:工作记忆要快,长期记忆要能表达关系。

阅读导航:上一节:7.3 前缀缓存与上下文复用 · 下一节:8.2 版本仲裁与 TTL 过期 。

常见错误与边界

  1. 把记忆层画成一张数据表。 没有索引的记忆等于不存在;三类查询要三类结构支撑。
  2. 只做向量索引。 精确关键词与关系查询会落空;三种索引要并存。
  3. 写数据不写索引。 写入不同步,下一次查询就漏掉新记忆。
  4. 相似度当正确度。 0.99 只说明近,不保证对;结果要过模型判断。
  5. 图没有边类型。 邻居只知道"相关",不知道"怎么相关",图查询的意义减半。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图