以下向量、倒排与图的相似度数值均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。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}
五条输出对应五件事:
- vector_query:语义查询返回 [(‘m2’, 0.99), (‘m1’, 0.87)],按相似度降序。语义查询不承诺唯一答案,它给一个排序,取几条由调用方定。
- keyword_首页 / keyword_权限:关键词查询各自只命中一条。倒排是精确匹配,问"权限"不会带出"首页"。
- neighbors_of_m2:m2 的邻居是 m1 和 m3。图查询给出的是关系而不是分数——边本身就有方向与类型,邻居是"相关",不是"相似"。
- 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 过期 。
常见错误与边界
- 把记忆层画成一张数据表。 没有索引的记忆等于不存在;三类查询要三类结构支撑。
- 只做向量索引。 精确关键词与关系查询会落空;三种索引要并存。
- 写数据不写索引。 写入不同步,下一次查询就漏掉新记忆。
- 相似度当正确度。 0.99 只说明近,不保证对;结果要过模型判断。
- 图没有边类型。 邻居只知道"相关",不知道"怎么相关",图查询的意义减半。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。