Zep 核心原理与实现机制
目录
核心原理：双时间知识图谱
问题本质
传统 AI 记忆系统的根本缺陷：
静态记忆：事实 = 永远为真
实际需求：事实 = 在特定时间为真
Zep 的突破
给每个事实加上"时间有效期"：
传统知识图谱：
用户 → 喜欢 → 咖啡
Zep 时间图谱：
用户 → 喜欢 → 咖啡 [2024-01-01 至 2024-02-15]
用户 → 喜欢 → 茶 [2024-02-15 至 现在]
时间有效性系统
每个事实包含三个关键时间戳：
Fact {
fact: "User prefers coffee",
valid_at: "2024-01-15T10:30:00Z", # 何时变为真
invalid_at: "2024-03-20T14:00:00Z", # 何时变为假 (null = 当前有效)
expired_at: null, # 软删除标记
episodes: ["ep-123", "ep-456"] # 来源追踪
}
事实生命周期：
- 活跃事实:
valid_at已设置，invalid_at为 null - 历史事实: 两个时间戳都设置 - 过去为真
- 过期事实:
expired_at已设置 - 软删除但保留审计
实现机制：五层架构
第1层：数据摄入与预处理
# 输入：对话、文档、事件
raw_input = "我最近开始跑步了，之前我讨厌运动"
# 处理流程：
1. 识别Episode（对话单元）
2. 提取时间戳
3. 分词和语义分析
第2层：LLM驱动的信息提取
# 使用GPT-4等模型提取结构化信息
prompt = """
从这段文本提取：
1. 实体（人、事、物）
2. 关系（谁做什么、什么属性）
3. 时间（何时发生）
文本："我最近开始跑步了，之前我讨厌运动"
"""
# 提取结果：
entities = ["用户"]
relations = [
{"用户": "讨厌运动", "时间": "过去"},
{"用户": "开始跑步", "时间": "最近"}
]
第3层：实体解析与去重
# 向量化 + 相似度匹配
def match_entity(new_entity, existing_entities):
# 将实体转向量
new_embedding = model.encode(new_entity)
# 与现有实体比较
for existing in existing_entities:
similarity = cosine_similarity(
new_embedding,
existing.embedding
)
if similarity > 0.85: # 阈值
return existing # 是同一实体
return new_entity # 新实体
第4层：冲突检测与时间推理
# 核心算法：检测并解决事实冲突
def detect_conflicts(new_fact, existing_facts):
for old_fact in existing_facts:
if is_contradiction(new_fact, old_fact):
# 发现冲突！
# 1. 标记旧事实为过期
old_fact.invalid_at = new_fact.valid_at
# 2. 激活新事实
new_fact.invalid_at = None
# 3. 记录变化原因
new_fact.episodes.append(current_episode)
return updated_facts
# 示例：
# 新事实：用户开始跑步（2024-03-01）
# 旧事实：用户讨厌运动（2024-01-01）
#
# 系统自动：
# 用户讨厌运动 [2024-01-01 → 2024-03-01] # 现在过期
# 用户开始跑步 [2024-03-01 → 现在] # 新状态
第5层：图存储与检索
# 使用Neo4j存储图结构
# Cypher查询语言示例
# 存储实体和关系
CREATE (u:User {name: "张三"})
CREATE (e:Exercise {name: "跑步"})
CREATE (u)-[:PREFERS {
valid_at: "2024-03-01",
invalid_at: null,
episodes: ["ep-123"]
}]->(e)
# 时间感知查询
MATCH (u:User {name: "张三"})-[r:PREFERS]->(e)
WHERE r.valid_at <= $query_time
AND (r.invalid_at IS NULL OR r.invalid_at > $query_time)
RETURN u, r, e
关键技术实现
1. 自主图构建
class GraphBuilder:
def process_episode(self, episode):
# 步骤1：提取实体和关系
extracted = llm_extract(episode.content)
# 步骤2：实体解析
for entity in extracted.entities:
matched = self.resolve_entity(entity)
if not matched:
self.create_entity(entity)
# 步骤3：提取和验证事实
for fact in extracted.facts:
conflicts = self.find_conflicts(fact)
self.resolve_conflicts(conflicts)
self.add_fact(fact)
# 步骤4：连接源头
self.link_provenance(fact, episode)
2. 时间推理引擎
class TemporalReasoner:
def query_state_at_time(self, entity, time_point):
# 查找特定时间点的状态
facts = self.get_facts(entity)
valid_facts = []
for fact in facts:
if (fact.valid_at <= time_point and
(fact.invalid_at is None or
fact.invalid_at > time_point)):
valid_facts.append(fact)
return valid_facts
def detect_state_change(self, entity):
# 检测状态变化模式
facts = self.get_facts(entity)
changes = []
for i in range(len(facts)-1):
if facts[i].invalid_at == facts[i+1].valid_at:
changes.append({
'from': facts[i],
'to': facts[i+1],
'change_time': facts[i].invalid_at
})
return changes
3. 混合检索系统
class HybridRetriever:
def search(self, query, query_time=None):
# 阶段1：实体搜索（向量相似度）
entity_results = self.vector_search(query)
# 阶段2：图遍历获取相关事实
fact_results = []
for entity in entity_results:
facts = self.get_entity_facts(entity)
fact_results.extend(facts)
# 阶段3：时间过滤
if query_time:
fact_results = [
f for f in fact_results
if self.is_valid_at_time(f, query_time)
]
# 阶段4：重新排序
ranked_results = self.rerank(
fact_results,
query,
query_time
)
return ranked_results
数据结构示例
实体节点
{
"uuid": "entity-123",
"name": "张三",
"type": "person",
"embedding": [0.1, 0.2, ...],
"summary": "用户，最近开始跑步",
"created_at": "2024-01-01T00:00:00Z"
}
事实边
{
"uuid": "fact-456",
"relation": "PREFERS",
"valid_at": "2024-03-01T10:00:00Z",
"invalid_at": null,
"expired_at": null,
"episodes": ["ep-123", "ep-456"],
"confidence": 0.95,
"created_at": "2024-03-01T10:00:00Z"
}
Episode节点
{
"uuid": "ep-123",
"content": "我最近开始跑步了",
"source": "conversation",
"timestamp": "2024-03-01T10:00:00Z",
"entities": ["entity-123"],
"facts_created": ["fact-456"]
}
性能优化策略
1. 向量索引
# 使用FAISS或Milvus进行快速向量搜索
vector_index = faiss.IndexFlatIP(768) # 768维embedding
faiss_index.add(entity_embeddings)
2. 图查询优化
# Neo4j索引优化
CREATE INDEX ON :User(name)
CREATE INDEX ON :Episode(timestamp)
# 查询缓存
@lru_cache(maxsize=1000)
def get_entity_state(entity_id, time_point):
# 缓存常用查询
pass
3. 增量更新
# 只处理新的episodes，不重建整个图
def incremental_update(new_episodes):
for episode in new_episodes:
process_single_episode(episode)
核心创新总结
技术突破点
1. 双时间模型
- 事件时间: 事件实际发生时间
- 摄入时间: 信息被系统摄取时间
2. 自主构建
- 无需手动模式维护
- 从非结构化数据自动构建
- 持续学习和更新
3. 智能冲突解决
- 自动检测信息矛盾
- 时间戳驱动的失效机制
- 保持知识一致性
4. 完整源头追踪
- 每个事实可追溯到原始对话
- 支持可信度评估
- 审计和分析能力
实现精要
Zep = LLM提取 + 向量匹配 + 图数据库 + 时间推理
↑ ↑ ↑ ↑
理解语义 去重合并 存储关系 状态演变
处理流程示例
用户输入处理
# 用户输入
input_text = "我最近开始跑步了，之前我讨厌运动"
# 处理流程
episode = create_episode(input_text, timestamp="2024-03-01")
extracted = llm_extract(episode.content)
# => entities: ["用户"], relations: [{"讨厌运动", "开始跑步"}]
resolved = resolve_entities(extracted.entities)
# => 匹配到现有用户实体
validated = detect_conflicts(extracted.relations, existing_facts)
# => 发现冲突：用户现在讨厌运动 vs 开始跑步
# => 自动解决：讨厌运动[过期]，开始跑步[激活]
stored = store_to_graph(validated)
# => Neo4j存储时间关系
查询处理
# 用户查询："用户过去喜欢什么运动？"
query = "用户过去喜欢什么运动？"
query_time = "2024-02-01" # 去年
# 检索流程
entities = vector_search(query) # 找到用户实体
facts = graph_traverse(entities) # 获取相关事实
filtered = temporal_filter(facts, query_time) # 时间过滤
# => 结果：用户讨厌运动（在2024-02-01有效）
技术栈
| 组件 | 技术选择 | 用途 |
|---|---|---|
| LLM | GPT-4/Claude | 信息提取和推理 |
| 向量数据库 | FAISS/Milvus | 实体嵌入和相似度搜索 |
| 图数据库 | Neo4j | 时间知识图谱存储 |
| 向量化 | sentence-transformers | 文本嵌入 |
| 框架 | LangChain/LlamaIndex | AI 框架集成 |
总结
核心理念
Zep = AI + 侦探式记忆 + 时间感知 + 关系推理
通过给 AI 配备"超级记忆系统"，使其能够：
- 记住你说过的每一句话
- 理解信息如何随时间变化
- 推理复杂关系演变
- 提供准确相关的响应
技术突破
Zep 将静态的知识图谱升级为时间感知的动态知识系统，代表了下一代 AI 记忆系统的技术方向：
- 时间有效性追踪 - 理解知识的演变
- 自主图构建 - 从非结构化数据学习
- 智能冲突解决 - 自动处理信息变化
- 完整源头追踪 - 可信度和审计能力
这使得 AI 智能体能够在动态的企业环境中提供更准确、更相关的响应，真正实现了从"健忘的助手"到"拥有超级记忆的智能体"的跨越。
文档生成时间: 2025-01-09 基于 Zep 技术论文和官方文档
