AI 聊完就忘、连你不吃香菜都记不住？Mem0 焊死 Agent 长期记忆，从向量检索到图记忆全栈打通

当你的AI助手聊完就忘、每次都要重新自我介绍、永远记不住你不吃香菜的时候，你是不是想给它一拳？

Mem0 就是那个能让 AI Agent 真正"记住你"的记忆层。本文从架构原理到 API 实战，从图记忆到自定义提取，从本地部署到生态集成，一次性把 Mem0 扒个底朝天。

免责声明：本文为第三方学习整理，不属于 Mem0 官方文档。Mem0 迭代速度极快（v3 记忆算法于 2026 年发布），文中所有代码、API 仅供学习参考，生产使用请务必查阅官方文档；因版本变更导致的问题，本文不承担责任。

版权与来源声明：文中所有代码仅用于学习演示，不构成生产实施建议；所有 API 以项目官方 GitHub 与官方文档为准；开源项目的商标、项目名称归各项目官方所有。

⚠️ 提示：Mem0 更新迭代非常快，复制代码前优先核对官方最新示例，部分参数 / 方法名可能已经变更。例如 v3 中 search / get_all 的实体 ID 必须放入 filters，而 add / delete_all 仍可用顶层 user_id。

目录

一、Mem0概述：AI Agent的记忆困境与破局

1.1 什么是Mem0

Mem0（读作 “mem-zero”）是一个为 AI Agent 设计的持久化记忆层。它的核心使命只有一个：让 AI 真正记住你。

想象一下，你跟一个聊天机器人说"我对花生过敏"，结果下一轮对话它给你推荐了花生酱三明治——这种"金鱼脑"体验，就是 Mem0 要解决的问题。

Mem0 不是一个大模型，也不是一个 Agent 框架。它是夹在你的应用和大模型之间的记忆中间件，负责：

  • 从对话中自动提取关键信息（用户偏好、事实、关系）
  • 智能存储到向量库 + 键值库 + 图数据库的混合架构中
  • 在需要时精准检索相关记忆注入 Prompt
  • 持续更新和去重，确保记忆的一致性和准确性

一句话总结：Mem0 = AI Agent 的海马体，负责把短期对话转化为长期记忆。

1.2 核心问题：为什么AI总是"金鱼脑"

在 Mem0 出现之前，AI Agent 的记忆方案主要有三种，每种都有致命缺陷：

方案 原理 致命缺陷
全上下文（Full Context） 把所有历史对话塞进 Prompt Token 成本爆炸，90% 的 token 被浪费在无关历史上；响应慢 91%
RAG 检索增强 对话切块存向量库，语义检索相关片段 只做相似度匹配，不理解实体关系；无法处理"用户改主意了"这种更新场景
OpenAI Memory 等内置记忆 模型厂商提供的黑盒记忆 不可控、不可迁移、数据在厂商手里；准确率比 Mem0 低 26%

Mem0 的论文（发表于 ECAI 2025，arXiv:2504.19413）在 LoCoMo 基准测试上首次对十种记忆方案做了头对头对比，结论很明确：传统方案都不够好。

1.3 解决方案：Mem0的记忆哲学

Mem0 的核心设计理念可以概括为**"提取-评估-管理"三段式**：

  1. 提取（Extraction）：用 LLM 从对话中自动识别值得记忆的事实和偏好，而不是无脑存全部
  2. 评估（Evaluation）：对提取出的记忆进行重要性评分、去重、矛盾检测
  3. 管理（Management）：持续更新已有记忆，处理信息变更，维护记忆的生命周期

这种设计带来了三个关键优势：

  • +26% 准确率：在 LoCoMo 基准上超过 OpenAI Memory
  • 91% 更快响应：相比全上下文方案，只检索相关记忆
  • 90% 更低 Token 消耗：不用把所有历史都塞进 Prompt

1.4 发展历程：从学术论文到56K Star工业级项目

Mem0 的发展速度堪称现象级：

  • 2024年：项目启动，最初名为 “Mem0”，定位为开源记忆层
  • 2025年4月：论文《Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory》被 ECAI 2025 接收
  • 2025年中：GitHub Star 突破 30K，成为 AI Agent 记忆领域最热门的开源项目
  • 2026年：发布全新记忆算法（v3），图记忆自动激活，实体匹配融入综合评分；GitHub Star 突破 56K

如今 Mem0 已经从一个学术原型成长为支持 Python / TypeScript 双 SDK、REST API、Docker 自托管、云平台托管的全栈记忆解决方案。

二、架构与核心概念

2.1 整体架构：三层存储混合引擎

Mem0 的架构核心是混合存储（Hybrid Storage），不是单一的向量库，而是三种数据库各司其职：

┌─────────────────────────────────────────────────────┐
│                    应用层 / Agent 框架                │
│         (LangChain / CrewAI / 自定义应用)            │
└──────────────────────┬──────────────────────────────┘
                       │ API 调用
┌──────────────────────▼──────────────────────────────┐
│                   Mem0 核心引擎                       │
│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐  │
│  │ 记忆提取  │  │ 记忆检索  │  │ 记忆管理(更新/去重)│  │
│  │ (LLM)    │  │ (混合排序)│  │ (矛盾检测)        │  │
│  └──────────┘  └──────────┘  └──────────────────┘  │
└──────┬──────────────┬──────────────┬────────────────┘
       │              │              │
┌──────▼─────┐  ┌─────▼──────┐  ┌──▼───────────────┐
│ 向量数据库   │  │ 键值数据库  │  │ 图数据库          │
│ (语义检索)   │  │ (元数据/ID) │  │ (实体关系追踪)    │
│ Qdrant/Chroma│ │ Redis/SQLite│ │ Neo4j/Kuzu/Memgraph│
└────────────┘  └────────────┘  └───────────────────┘

三层存储的分工：

存储层 职责 典型实现
向量数据库 存储记忆的 embedding 向量，支持语义相似度检索 Qdrant, Chroma, pgvector, Milvus
键值数据库 存储记忆的元数据（ID、用户ID、时间戳、版本），支持快速按 ID 查找 SQLite, Redis, PostgreSQL
图数据库 存储实体之间的关系，支持基于关系的检索增强 Neo4j, Kuzu, Memgraph（平台版内置）

注意：Mem0 Platform（云平台版）的图记忆是内置的，不需要外部图数据库。实体从每条记忆中自动提取，跨记忆关联，检索时自动 boost 相关实体的记忆。

2.2 核心概念速查表

在深入 API 之前，先把这些概念搞清楚：

概念 说明
Memory（记忆） 一条从对话中提取的事实或偏好，是 Mem0 的最小存储单元
User ID（用户标识） 记忆的所有者标识，用于隔离不同用户的记忆
Agent ID（Agent标识） 记忆所属的 Agent 标识，用于多 Agent 场景下的记忆隔离
Session ID（会话标识） 对话会话标识，用于区分同用户的不同对话会话
Entity（实体） 从记忆中提取的专有名词、复合名词短语等，如图记忆的节点
Relation（关系） 实体之间的语义连接，如图记忆的边（三元组：源-关系-目标）
Embedding（向量嵌入） 记忆文本的向量表示，用于语义相似度计算
Metadata（元数据） 记忆的附加信息，如创建时间、更新时间、版本号、来源等

2.3 记忆生命周期：从提取到消亡

一条记忆在 Mem0 中经历完整的生命周期：

对话输入 → 记忆提取 → 去重检测 → 存储(向量+KV+图) → 检索排序 → 注入Prompt
                ↑                                    ↓
                └──────── 更新/合并 ←───────────────┘

阶段详解：

  1. 提取阶段：LLM 分析对话内容，识别值得记忆的事实。例如用户说"我叫张三，在字节跳动做后端开发"，会提取出两条记忆：“用户姓名是张三”、“用户在字节跳动做后端开发”。

  2. 去重阶段：新提取的记忆与已有记忆进行相似度比对。如果已有一条"用户在字节跳动工作"，新记忆可能触发更新而非新增。

  3. 存储阶段：记忆同时写入三个存储层——向量库存 embedding，键值库存元数据，图数据库存实体关系。

  4. 检索阶段：当用户发起新对话时，Mem0 根据查询内容从向量库做语义检索、从图数据库做实体匹配，综合排序后返回最相关的 N 条记忆。

  5. 更新阶段：如果新对话与已有记忆矛盾（如用户说"我离职了，现在去阿里了"），Mem0 会自动更新旧记忆或标记为已过期。

2.4 记忆作用域：User / Session / Agent 三级隔离

Mem0 支持三级记忆隔离，通过 user_id、session_id、agent_id 三个参数控制：

作用域 参数 场景
用户级 user_id 跨会话、跨设备的长期用户记忆。记住"用户不吃香菜"这种永久偏好
会话级 session_id 单次对话内的上下文记忆。记住"本次对话正在讨论Mem0部署"
Agent级 agent_id 多 Agent 系统中每个 Agent 的独立记忆。客服Agent和技术支持Agent记忆互不干扰

使用建议：

  • 大多数场景只需 user_id，实现跨会话的个性化
  • 需要区分不同对话主题时加上 session_id
  • 多 Agent 协作场景必须用 agent_id 隔离，同时可以通过共享 user_id 实现跨 Agent 的用户记忆共享

三、记忆操作API：五大核心方法全解析

Mem0 的 API 设计极其简洁，核心只有五个方法：add、search、get_all、update、delete。下面逐个拆解。

3.1 添加记忆 Add

add 是最常用的方法，负责把一段对话或文本写入记忆系统。

from mem0 import MemoryClient

# 初始化客户端（云平台版）
client = MemoryClient(api_key="your-mem0-api-key")

# 添加记忆
result = client.add(
    messages="我叫张三，今年28岁，在字节跳动做后端开发，喜欢用Python和Go",
    user_id="user_001",
    agent_id="agent_assistant",
    metadata={"source": "onboarding"}
)

print(result)

Add 返回结构：

{
    "results": [
        {
            "id": "mem_abc123",           # 记忆唯一ID
            "memory": "用户姓名是张三",      # 提取出的记忆内容
            "event": "ADD",                # 事件类型（v3 的 add 为单趟「仅新增」模式，只返回 ADD，不再有 UPDATE / DELETE）
            "metadata": {"source": "onboarding"},
            "created_at": "2025-10-22T10:00:00Z"
        },
        {
            "id": "mem_def456",
            "memory": "用户28岁",
            "event": "ADD",
            "metadata": {"source": "onboarding"},
            "created_at": "2025-10-22T10:00:00Z"
        },
        {
            "id": "mem_ghi789",
            "memory": "用户在字节跳动做后端开发",
            "event": "ADD",
            "metadata": {"source": "onboarding"},
            "created_at": "2025-10-22T10:00:00Z"
        }
    ]
}

关键参数说明：

参数 类型 必填 说明
messages str / list 是 对话内容。可以是字符串，也可以是 [{"role": "user", "content": "..."}] 格式的消息列表
user_id str 否 用户标识，用于隔离不同用户的记忆
agent_id str 否 Agent 标识，多 Agent 场景下使用
session_id str 否 会话标识，区分同用户的不同对话
metadata dict 否 自定义元数据，会随记忆一起存储
filters dict 否 过滤条件，如 {"agent_id": "xxx"}
infer bool 否 是否启用推理模式，默认 True。设为 False 时直接存储原文不做提取

技巧：messages 传消息列表比传纯字符串效果更好，因为 Mem0 能区分用户说的和 AI 说的，提取更精准。

3.2 搜索记忆 Search

search 方法根据查询内容检索最相关的记忆，是实现个性化回复的核心。

# 搜索记忆（v3：实体 ID 必须放进 filters，检索数量用 top_k）
results = client.search(
    query="这个用户是做什么工作的？",
    filters={"user_id": "user_001"},
    top_k=5
)

print(results)

Search 返回结构：

{
    "results": [
        {
            "id": "mem_ghi789",
            "memory": "用户在字节跳动做后端开发",
            "score": 0.92,               # 综合相似度得分
            "metadata": {"source": "onboarding"},
            "created_at": "2025-10-22T10:00:00Z",
            "updated_at": "2025-10-22T10:00:00Z"
        },
        {
            "id": "mem_abc123",
            "memory": "用户姓名是张三",
            "score": 0.78,
            "metadata": {"source": "onboarding"},
            "created_at": "2025-10-22T10:00:00Z",
            "updated_at": "2025-10-22T10:00:00Z"
        }
    ]
}

搜索排序算法（v3 新版）：

Mem0 v3 的搜索采用三重混合排序，最终得分是三者的加权融合：

最终得分 = α × 语义相似度(向量) + β × BM25关键词匹配 + γ × 实体匹配boost
  • 语义相似度：基于 embedding 向量的余弦相似度，找到意思相近的记忆
  • BM25 关键词匹配：精确关键词匹配，对专有名词、术语特别有效
  • 实体匹配 boost：从查询中提取实体，与图记忆中的实体匹配，命中的记忆获得排名提升

注意：Mem0 Platform v3 之后，enable_graph 参数已废弃，图记忆自动激活，实体匹配自动融入综合评分。

3.3 获取所有记忆 GetAll

get_all 方法获取指定用户/Agent的所有记忆，适合做记忆管理后台或调试。

# 获取用户的所有记忆（v3：实体 ID 放进 filters；分页用 page / page_size）
all_memories = client.get_all(
    filters={"user_id": "user_001"},
    page_size=50,
    page=1
)

print(all_memories)

返回结构与 Search 类似，但不包含 score 字段（因为没有查询相关性），按创建时间倒序排列。

参数说明：

参数 说明
filters 过滤条件，实体 ID 必须放在这里，如 filters={"user_id": "user_001"}
page 页码，从 1 开始
page_size 每页返回数量（v3 替代旧版 limit，默认 50）

3.4 更新记忆 Update

update 方法用于手动修改一条已有记忆的内容。大多数情况下 Mem0 会自动更新，但有时你需要手动干预。

# 更新记忆
result = client.update(
    memory_id="mem_ghi789",
    data="用户在阿里巴巴做后端开发（已从字节跳动离职）"
)

print(result)

返回结构：

{
    "id": "mem_ghi789",
    "memory": "用户在阿里巴巴做后端开发（已从字节跳动离职）",
    "updated_at": "2025-10-22T11:00:00Z",
    "created_at": "2025-10-22T10:00:00Z"
}

提示：更新记忆后，向量 embedding 会自动重新生成，用于检索增强的实体关系也会同步更新（图记忆为 v3 Platform 内置能力，无需外部图数据库）。

3.5 删除记忆 Delete

delete 方法删除指定记忆，支持单条删除和批量删除。

# 删除单条记忆
client.delete(memory_id="mem_abc123")

# 删除用户的所有记忆
client.delete_all(user_id="user_001")

返回结构：

{"status": "ok", "message": "Memory deleted successfully"}

3.6 REST API：不用SDK也能玩

如果你用的语言没有官方 SDK，或者想在前端直接调用，Mem0 提供了完整的 REST API。

基础 URL：https://api.mem0.ai

认证方式：在 Header 中携带 Authorization: Token your-api-key

v3 变更：记忆写入 / 检索端点已升级为 /v3（如 POST /v3/memories/add/、POST /v3/memories/search/）；add 为异步，返回 event_id 供轮询；搜索请求体需用 filters 携带实体 ID，不再使用 URL query 参数。

# 添加记忆（v3：POST /v3/memories/add/，异步返回 event_id）
curl -X POST https://api.mem0.ai/v3/memories/add/ \
  -H "Authorization: Token your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": "我喜欢喝咖啡"}],
    "user_id": "user_001"
  }'

# 搜索记忆（v3：POST /v3/memories/search/，实体 ID 放在 filters 里）
curl -X POST https://api.mem0.ai/v3/memories/search/ \
  -H "Authorization: Token your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "咖啡",
    "filters": {"user_id": "user_001"}
  }'

四、Graph Memory 图记忆：让AI理解"关系"

4.1 什么是图记忆

普通的向量记忆只能回答"什么内容跟这个查询相似"，但它无法理解实体之间的关系。

举个例子：

  • 记忆A：“张三在字节跳动工作”
  • 记忆B：“李四是张三的同事”
  • 记忆C：“字节跳动的总部在北京”

当用户问"李四在哪里上班？“时，纯向量检索可能只能找到记忆B，但无法推理出"李四也在字节跳动，所以在北京”。

图记忆（Graph Memory） 就是为了解决这个问题。它把记忆中的实体提取出来作为节点，实体之间的关系作为边，构建成一张知识图谱。检索时不仅做语义匹配，还沿着图谱的边做关系推理。

4.2 架构原理：实体提取 + 关系建立 + 图谱检索

图记忆的工作流程分为三步：

步骤1：实体提取
  记忆文本 → LLM提取实体 → 实体列表
  "张三在字节跳动工作" → [张三, 字节跳动]

步骤2：关系建立
  实体列表 + 上下文 → LLM推理关系 → 三元组
  [张三, 字节跳动] + "在...工作" → (张三, WORKS_AT, 字节跳动)

步骤3：图谱检索
  查询 → 提取查询实体 → 图谱匹配 → 关联记忆boost
  "李四在哪上班？" → [李四] → 李四-同事-张三-工作-字节跳动 → boost记忆A

Mem0 Platform v3 的图记忆特性：

从 v3 版本开始，Mem0 Platform 的图记忆发生了重大变化：

特性 旧版 Mem0g 新版 v3 图记忆
配置方式 需要 enable_graph=True + 外部图数据库 自动激活，无需配置
关系类型 有标签的关系（如 WORKS_AT） 基于共现推断的关系
检索方式 返回独立的 relations 字段 实体匹配 boost 融入综合得分
基础设施 Neo4j / Memgraph / Kuzu 平台内置，无需外部 DB

重要：v3 之后，图记忆不再提供独立的图谱遍历 API，实体关系主要用于检索排名增强。如果你需要完整的知识图谱查询能力，可以使用开源版配合 Neo4j。

4.3 实体与关系：三元组的世界

图记忆的核心数据结构是三元组（Triplet）：

(源实体, 关系, 目标实体)

例如：

  • (张三, WORKS_AT, 字节跳动)
  • (李四, COLLEAGUE_OF, 张三)
  • (字节跳动, HEADQUARTERED_IN, 北京)
  • (用户, PREFERS, 咖啡)
  • (用户, ALLERGIC_TO, 花生)

实体类型：Mem0 自动提取的实体包括：

  • 人名（Person）
  • 组织名（Organization）
  • 地点（Location）
  • 产品/项目名（Product/Project）
  • 技术/工具名（Technology/Tool）
  • 复合名词短语（Compound Noun Phrases）
  • 引号中的文本（Quoted Text）

关系类型（开源版 Neo4j 实现）：

  • WORKS_AT：就职于
  • COLLEAGUE_OF：同事
  • LOCATED_IN：位于
  • PREFERS：偏好
  • ALLERGIC_TO：过敏
  • USES：使用
  • DEPENDS_ON：依赖
  • RELATES_TO：相关（通用关系）

4.4 代码示例：v3 图记忆（平台内置，自动生效）

从 v3 开始，图记忆是 Mem0 Platform 的内置能力，开箱即用，无需任何配置，也不再依赖外部图数据库（Neo4j / Memgraph / Kuzu 等）。实体会在 add 时自动抽取并存储，在 search 时自动参与排名增强——你不需要（也无法）像旧版那样手动配置 graph_store 或调用 get_relations() 去遍历图谱。

注意：v3 不再提供独立的「图谱遍历」API（get_relations 已移除）。图记忆的价值体现在检索排序上——查询中提取到的实体会与记忆中的实体做匹配，命中者获得排名提升。

下面用 Platform 客户端演示「实体关系如何在检索中生效」：

from mem0 import MemoryClient

client = MemoryClient(api_key="your-mem0-key")

# 1. 写入对话（实体、关系会在后台自动抽取并建图，无需任何 graph 配置）
client.add(
    [
        {"role": "user", "content": "张三在字节跳动做后端开发，他的同事李四负责前端"},
        {"role": "user", "content": "字节跳动的总部在北京，公司主要做短视频和AI"},
    ],
    user_id="user_001",
)

# 2. 检索：v3 的实体匹配会自动把「李四也在字节跳动、所以在北京」这类关系融入排序
results = client.search(
    "李四在哪里上班？",
    filters={"user_id": "user_001"},   # 实体 ID 必须放在 filters
    top_k=5,
)
for r in results["results"]:
    print(f"[{r['score']:.2f}] {r['memory']}")
# 输出（示意）：
# [0.91] 张三在字节跳动做后端开发，他的同事李四负责前端
# [0.84] 字节跳动的总部在北京，公司主要做短视频和AI

如果你坚持要在**自托管（OSS）**场景使用图记忆：v3 OSS 已移除外部图存储，图记忆仅作为 Platform 内置特性提供；自托管版请使用向量 + 键值存储，并依赖 v3 的多信号混合检索（语义 + BM25 + 实体匹配）获得等价效果。

五、自定义记忆提取：打造专属记忆规则

5.1 自定义事实提取

默认情况下，Mem0 用内置的 Prompt 让 LLM 提取事实。但在特定领域（医疗、法律、金融），你可能需要自定义提取规则。

from mem0 import Memory
from mem0.configs.prompts import FACT_RETRIEVAL_PROMPT

# 自定义提取 Prompt：只提取医疗相关信息
CUSTOM_MEDICAL_PROMPT = """
你是一个医疗信息提取专家。从对话中提取与患者健康相关的事实。

只提取以下类型的信息：
1. 患者的疾病诊断
2. 患者的过敏史
3. 患者正在服用的药物
4. 患者的手术史
5. 患者的生活习惯（吸烟、饮酒等）

不要提取：
- 与健康无关的个人信息
- 医生的建议（除非是明确的诊断结论）
- 患者的情绪表达

对话内容：
{messages}

请以 JSON 数组格式输出，每个元素包含 "fact" 字段。
如果没有值得提取的医疗信息，返回空数组 []。
"""

config = {
    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini", "api_key": "xxx"}},
    "embedder": {"provider": "openai", "config": {"model": "text-embedding-3-small", "api_key": "xxx"}},
    "vector_store": {"provider": "chroma", "config": {"collection_name": "medical_mem0"}},
    # 注入自定义提取 Prompt
    "custom_prompts": {
        "fact_retrieval_prompt": CUSTOM_MEDICAL_PROMPT
    }
}

m = Memory.from_config(config)

# 现在 add 时会使用自定义的医疗提取规则
m.add("患者张三，男，45岁，确诊2型糖尿病3年，对青霉素过敏，目前服用二甲双胍，每天吸烟10支", user_id="patient_001")

5.2 自定义更新提示词

当新信息与旧记忆矛盾时，Mem0 会用更新 Prompt 决定如何处理。你可以自定义这个逻辑。

# 自定义更新 Prompt：更保守的更新策略
CUSTOM_UPDATE_PROMPT = """
你是一个记忆管理专家。判断新信息是否应该更新已有记忆。

已有记忆：
{existing_memories}

新信息：
{new_message}

规则：
1. 只有当新信息明确 contradict（矛盾）已有记忆时，才更新
2. 如果新信息只是补充信息，不更新旧记忆，而是新增
3. 如果不确定是否矛盾，保守处理——不更新
4. 更新时保留旧记忆的历史信息，在新记忆中标注"更新自旧记忆"

请输出 JSON 格式：
{
  "update": [{"id": "记忆ID", "updated_memory": "更新后的内容"}],
  "add": ["需要新增的记忆内容"],
  "delete": ["需要删除的记忆ID"]
}
"""

config = {
    # ... 其他配置
    "custom_prompts": {
        "update_prompt": CUSTOM_UPDATE_PROMPT
    }
}

5.3 自定义解析器

如果你需要完全控制记忆的提取和解析逻辑，可以实现自定义解析器。

from mem0 import Memory
from mem0.parser.base import BaseParser

class CustomMedicalParser(BaseParser):
    """自定义医疗领域解析器"""

    def parse(self, data):
        """
        解析 LLM 返回的提取结果
        Args:
            data: LLM 返回的原始文本
        Returns:
            dict: 包含 add, update, delete 的解析结果
        """
        import json
        try:
            result = json.loads(data)
        except json.JSONDecodeError:
            # 解析失败时返回空结果，不抛异常
            return {"add": [], "update": [], "delete": []}

        # 医疗领域特殊处理：确保每条记忆都有疾病标签
        parsed = {"add": [], "update": [], "delete": []}
        for item in result.get("add", []):
            memory_text = item if isinstance(item, str) else item.get("fact", "")
            # 自动添加医疗分类标签
            parsed["add"].append({
                "memory": memory_text,
                "metadata": {"category": "medical", "domain": "health"}
            })
        return parsed

# 使用自定义解析器
config = {
    # ... 其他配置
    "parser": {"provider": "custom", "config": {"class": CustomMedicalParser}}
}

m = Memory.from_config(config)

六、集成生态：Mem0不是一个人在战斗

6.1 LLM 集成：OpenAI / Anthropic / Ollama / 通义千问

Mem0 支持几乎所有主流 LLM 作为记忆提取引擎：

提供商 配置 provider 支持模型
OpenAI openai gpt-4o, gpt-4o-mini, gpt-5-nano
Anthropic anthropic claude-3-5-sonnet, claude-3-haiku
Ollama ollama llama3, qwen2, mistral（本地部署）
通义千问 dashscope qwen-max, qwen-plus, qwen-turbo
智谱AI zhipuai glm-4, glm-3-turbo
Groq groq llama-3.3-70b, mixtral-8x7b
Azure OpenAI azure_openai 同 OpenAI

Ollama 本地部署配置（完全离线）：

config = {
    "llm": {
        "provider": "ollama",
        "config": {
            "model": "qwen2.5:7b",
            "base_url": "http://localhost:11434",
            "temperature": 0.1
        }
    },
    "embedder": {
        "provider": "ollama",
        "config": {
            "model": "nomic-embed-text",
            "base_url": "http://localhost:11434"
        }
    },
    "vector_store": {
        "provider": "chroma",
        "config": {"collection_name": "local_mem0", "path": "./mem0_chroma"}
    }
}

m = Memory.from_config(config)

6.2 向量数据库集成：Qdrant / Chroma / pgvector / Milvus

向量库 provider 适用场景
Qdrant qdrant 生产环境首选，高性能，支持过滤和分片
Chroma chroma 开发/原型，零配置，本地文件存储
pgvector pgvector 已有 PostgreSQL 基础设施，不想额外维护向量库
Milvus milvus 超大规模数据（亿级向量），分布式部署
Weaviate weaviate 需要混合检索和模块化架构
Elasticsearch elasticsearch 已有 ES 集群，需要 BM25 + 向量混合检索

pgvector 配置示例：

config = {
    "vector_store": {
        "provider": "pgvector",
        "config": {
            "host": "localhost",
            "port": 5432,
            "user": "postgres",
            "password": "your-password",
            "dbname": "mem0_db",
            "table_name": "memories"
        }
    }
}

6.3 框架集成：LangChain / LlamaIndex / CrewAI / AutoGen

LangChain 集成（详见 9.5 节）：通过自定义 Tool 或 Runnable 把 Mem0 检索结果注入 Chain。

CrewAI 集成（详见 9.6 节）：替换 CrewAI 默认的本地记忆，实现跨会话、跨部署的持久化记忆。

LlamaIndex 集成：

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from mem0 import MemoryClient

client = MemoryClient(api_key="your-key")

# 在查询时先从 Mem0 获取用户记忆，再结合文档索引
def personalized_query(user_id, query):
    # 1. 从 Mem0 获取用户相关记忆
    memories = client.search(query, filters={"user_id": user_id}, top_k=3)
    memory_context = "\n".join([m["memory"] for m in memories["results"]])

    # 2. 构建带记忆的查询
    enhanced_query = f"""用户背景信息：
{memory_context}

用户问题：{query}"""

    # 3. 用 LlamaIndex 查询
    index = VectorStoreIndex.from_documents(documents)
    query_engine = index.as_query_engine()
    return query_engine.query(enhanced_query)

AutoGen 集成：在 AutoGen 的 Agent 对话回调中调用 Mem0 的 add 和 search。

6.4 应用集成：从客服机器人到医疗助手

Mem0 的应用场景非常广泛：

场景 记忆内容 价值
客服机器人 客户历史工单、偏好、购买记录 不用客户每次重复描述问题
AI 助手 用户习惯、日程、偏好设置 越用越懂你
医疗助手 患者病史、过敏史、用药记录 提供个性化的健康建议
教育辅导 学生的学习进度、薄弱点、学习风格 因材施教
内容推荐 用户阅读历史、兴趣标签、反馈 精准推荐
游戏 NPC 玩家行为历史、选择偏好、关系状态 沉浸式交互体验

七、部署与配置：三种姿势任选

7.1 安装方式：pip / npm / 源码

Python SDK：

pip install mem0ai

TypeScript/JavaScript SDK：

npm install mem0ai
# 或
yarn add mem0ai

源码安装（最新开发版）：

git clone https://github.com/mem0ai/mem0.git
cd mem0
pip install -e .

7.2 本地部署：5分钟跑起来

最简单的本地部署方式，使用 Chroma 作为向量库，SQLite 作为历史数据库：

# quickstart.py
from mem0 import Memory

# 最小配置：全部使用本地默认
config = {
    "llm": {
        "provider": "openai",
        "config": {"model": "gpt-4o-mini", "api_key": "your-openai-key"}
    },
    "embedder": {
        "provider": "openai",
        "config": {"model": "text-embedding-3-small", "api_key": "your-openai-key"}
    }
    # vector_store 不配置时默认使用 Chroma（本地文件）
    # history_db_path 不配置时默认使用 mem0_history.db
}

m = Memory.from_config(config)

# 添加记忆
m.add("我叫张三，喜欢打篮球", user_id="user_001")

# 搜索记忆
result = m.search("这个人喜欢什么运动？", filters={"user_id": "user_001"})
print(result)

运行：

pip install mem0ai
python quickstart.py

7.3 Docker 部署：一行命令起全家桶

Mem0 官方提供了 Docker Compose 配置，一键启动 API 服务 + Dashboard + 数据库：

# 1. 克隆仓库
git clone https://github.com/mem0ai/mem0.git
cd mem0

# 2. 配置环境变量
cp .env.example .env
# 编辑 .env，填入你的 OPENAI_API_KEY 等

# 3. 启动服务
docker compose -f docker/docker-compose.yml up -d --build

# 4. 查看状态
docker compose -f docker/docker-compose.yml ps

# 5. 查看日志
docker compose -f docker/docker-compose.yml logs -f

Docker 服务栈包含：

服务 端口 说明
mem0-api 8000 REST API 服务
mem0-dashboard 3000 可视化管理面板
postgres 5432 PostgreSQL + pgvector
qdrant 6333 Qdrant 向量数据库（可选）
redis 6379 缓存（可选）

完全离线部署（Ollama + 本地模型）：

# 修改 docker-compose.yml 中的环境变量
# LLM_PROVIDER=ollama
# LLM_MODEL=qwen2.5:7b
# OLLAMA_BASE_URL=http://host.docker.internal:11434
# EMBEDDER_PROVIDER=ollama
# EMBEDDER_MODEL=nomic-embed-text

安全提醒：Docker 默认配置没有认证且 CORS 全开。暴露到公网前必须加反向代理（Nginx/Caddy）和认证。

7.4 云平台 Mem0 Platform：开箱即用的托管服务

如果不想自己运维，可以直接使用 Mem0 的云平台：

  1. 访问 mem0.ai 注册账号
  2. 在 Dashboard 创建 Project，获取 API Key
  3. 安装 SDK 后直接使用：
from mem0 import MemoryClient

client = MemoryClient(api_key="your-platform-api-key")

# 直接用，不需要任何数据库配置
client.add("Hello, I am a developer", user_id="user_001")
result = client.search("What is this user?", filters={"user_id": "user_001"})

云平台优势：

  • 零运维，开箱即用
  • 自动扩缩容
  • 内置图记忆（v3 自动激活）
  • 可视化 Dashboard（记忆浏览、搜索、编辑）
  • 团队协作和权限管理
  • API 用量监控

云平台限制：

  • 数据存储在 Mem0 服务器（有数据合规要求的需自托管）
  • 有免费额度限制，超出需付费
  • 无法完全自定义底层基础设施

7.5 配置详解：所有参数一次说清

Mem0 的完整配置结构：

config = {
    # ========== LLM 配置（记忆提取用） ==========
    "llm": {
        "provider": "openai",          # openai / anthropic / ollama / groq / dashscope
        "config": {
            "model": "gpt-4o-mini",
            "temperature": 0.1,
            "max_tokens": 2000,
            "api_key": "xxx",
            "base_url": "https://api.openai.com/v1"  # 可选，用于兼容 OpenAI 接口的网关
        }
    },

    # ========== Embedding 配置 ==========
    "embedder": {
        "provider": "openai",          # openai / ollama / huggingface / dashscope
        "config": {
            "model": "text-embedding-3-small",
            "api_key": "xxx",
            "embedding_dims": 1536     # 向量维度
        }
    },

    # ========== 向量数据库配置 ==========
    "vector_store": {
        "provider": "qdrant",          # qdrant / chroma / pgvector / milvus / weaviate
        "config": {
            "host": "localhost",
            "port": 6333,
            "collection_name": "mem0",
            "embedding_model_dims": 1536
        }
    },

    # ========== 图数据库配置（v3 已废弃，仅作历史参考） ==========
    # ⚠️ Mem0 v3 起，OSS 版已移除外部图存储（Neo4j / Kuzu / Memgraph），
    #    图记忆改为 Platform 内置、自动激活，无需也不读取此配置。
    "graph_store": {
        "provider": "neo4j",           # neo4j / kuzu / memgraph
        "config": {
            "url": "bolt://localhost:7687",
            "username": "neo4j",
            "password": "xxx"
        }
    },

    # ========== 历史数据库配置 ==========
    "history_db_path": "mem0_history.db",  # SQLite 路径，存储记忆版本历史

    # ========== 自定义 Prompt ==========
    "custom_prompts": {
        "fact_retrieval_prompt": "自定义提取Prompt",
        "update_prompt": "自定义更新Prompt",
        "entity_extraction_prompt": "自定义实体提取Prompt"
    },

    # ========== 记忆去重配置 ==========
    "dedup": {
        "enabled": True,
        "threshold": 0.85,            # 余弦相似度阈值，超过则认为重复
        "strategy": "update"           # update / skip / merge
    }
}

八、高级特性：那些你可能不知道的骚操作

8.1 记忆去重：别让808条"用户喜欢Vim"塞满你的库

GitHub 上有个著名的 issue：有人审计了 10,134 条 Mem0 记忆，发现 97.8% 是垃圾——其中包括 808 条"用户喜欢 Vim"的重复记录。

Mem0 的去重机制：

config = {
    # ...
    "dedup": {
        "enabled": True,
        "threshold": 0.85,       # 相似度超过 0.85 视为重复
        "strategy": "update"      # update: 更新旧记忆; skip: 跳过; merge: 合并
    }
}

去重策略对比：

策略 行为 适用场景
update 用新记忆替换旧记忆内容 用户偏好变更（“我现在用VS Code了”）
skip 跳过新记忆，保留旧的 完全重复的信息
merge 合并新旧记忆，保留双方信息 互补信息（“用户喜欢Vim” + “用户也喜欢Neovim”）

图记忆的天然去重优势：在图架构中，重复的三元组（如 user → prefers → Vim）会被图数据库自动识别为已存在关系，不会重复创建。这也是为什么 Mem0 v3 强调图记忆的原因之一。

8.2 记忆版本控制：记忆也能时光回溯

Mem0 会自动记录每条记忆的变更历史，存在 SQLite 历史数据库中。

# 获取记忆的历史版本
history = m.get_history(memory_id="mem_abc123")

for version in history:
    print(f"v{version['version']} ({version['timestamp']}): {version['memory']}")
    print(f"  变更原因: {version['event']}")
    print(f"  变更来源: {version.get('metadata', {}).get('source', 'unknown')}")

# 输出示例：
# v1 (2025-10-22 10:00): 用户在字节跳动工作
#   变更原因: ADD
# v2 (2025-10-23 14:00): 用户在阿里巴巴工作（已从字节跳动离职）
#   变更原因: UPDATE

版本控制的价值：

  • 可追溯：知道每条记忆是什么时候、因为什么对话变更的
  • 可回滚：如果发现错误更新，可以恢复到之前的版本
  • 可审计：企业场景下需要知道 AI 的决策依据是怎么来的

8.3 多模态记忆：不只是文字

Mem0 原生支持文本记忆，但通过自定义提取逻辑，你可以扩展到多模态：

# 图片记忆：用 Vision LLM 提取图片描述后存入 Mem0
import base64

def add_image_memory(client, user_id, image_path, caption=""):
    # 用 GPT-4V 或其他视觉模型描述图片
    image_description = describe_image_with_vision(image_path)

    # 组合描述存入 Mem0
    memory_text = f"[图片记忆] {caption}: {image_description}"
    result = client.add(memory_text, user_id=user_id, metadata={
        "type": "image",
        "image_path": image_path,
        "original_caption": caption
    })
    return result

# 语音记忆同理：先 ASR 转文字，再存入 Mem0

8.4 记忆历史追踪：每条记忆的来龙去脉

每条记忆都带有完整的元数据追踪：

# 获取单条记忆的完整信息
memory = client.get(memory_id="mem_abc123")

print(json.dumps(memory, indent=2, ensure_ascii=False))
# {
#   "id": "mem_abc123",
#   "memory": "用户姓名是张三",
#   "user_id": "user_001",
#   "agent_id": "agent_assistant",
#   "session_id": "session_xyz",
#   "metadata": {"source": "onboarding"},
#   "created_at": "2025-10-22T10:00:00Z",
#   "updated_at": "2025-10-22T10:00:00Z",
#   "version": 1,
#   "extra": {
#     "entities": ["张三"],
#     "relations": [{"source": "用户", "relationship": "HAS_NAME", "target": "张三"}]
#   }
# }

8.5 批量操作：一次处理千条记忆

需要导入历史数据或批量处理时，使用批量接口：

# 批量添加记忆
messages_batch = [
    {"role": "user", "content": "我叫张三"},
    {"role": "user", "content": "我在字节跳动工作"},
    {"role": "user", "content": "我喜欢Python"},
    # ... 更多
]

# 批量添加（v3 自动分批处理，已移除 batch_size 参数）
results = client.add(messages_batch, user_id="user_001")

# 批量删除
client.delete_all(user_id="user_001")  # 删除用户所有记忆

九、实战案例：六个场景手把手教

9.1 对话机器人记忆：让客服记住每个客户

"""
场景：电商客服机器人，记住客户的历史订单、偏好、问题
"""
from mem0 import MemoryClient
import openai

client = MemoryClient(api_key="your-mem0-key")
openai.api_key = "your-openai-key"

def customer_support_chat(customer_id, user_message):
    # 1. 检索客户相关记忆
    memories = client.search(user_message, filters={"user_id": customer_id}, top_k=5)
    memory_context = "\n".join([
        f"- {m['memory']}" for m in memories["results"]
    ])

    # 2. 构建带记忆的 Prompt
    system_prompt = f"""你是一个专业的电商客服。请根据客户的历史信息提供个性化服务。

客户历史信息：
{memory_context}

如果客户提到新的个人信息或偏好，请在回复后标注 [SAVE_MEMORY] 以便系统记录。"""

    # 3. 调用 LLM
    response = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message}
        ]
    )
    ai_reply = response.choices[0].message.content

    # 4. 将本轮对话存入记忆
    client.add(
        messages=[
            {"role": "user", "content": user_message},
            {"role": "assistant", "content": ai_reply}
        ],
        user_id=customer_id
    )

    return ai_reply

# 使用
print(customer_support_chat("cust_001", "我上次买的耳机坏了，能换吗？"))

9.2 个性化推荐：基于记忆的内容推送

"""
场景：内容推荐系统，根据用户长期记忆推荐文章/产品
"""
def personalized_recommend(user_id, candidate_items):
    """
    candidate_items: [{"id": "item_1", "title": "...", "content": "..."}]
    """
    # 1. 获取用户的兴趣记忆
    user_profile = client.get_all(filters={"user_id": user_id}, page_size=20)
    interest_tags = [m["memory"] for m in user_profile["results"]]

    # 2. 用用户兴趣构建查询
    interest_query = " ".join(interest_tags[:5])  # 取最重要的5条

    # 3. 对候选内容做语义匹配
    from mem0 import Memory
    # ... 用 embedding 计算候选内容与用户兴趣的相似度

    # 4. 返回 Top N 推荐
    return ranked_items[:10]

9.3 企业知识管理：组织级记忆共享

"""
场景：企业内部知识库，所有员工共享组织记忆
"""
# 组织级记忆：用 org_id 作为 user_id
ORG_ID = "org_byte_dance"

# 员工 A 贡献知识
client.add(
    "公司的 VPN 连接方式是：先安装 GlobalProtect，然后输入 vpn.bytedance.com，用飞书扫码登录",
    user_id=ORG_ID,
    metadata={"category": "it_support", "author": "employee_a"}
)

# 员工 B 查询时自动获取组织知识
result = client.search("怎么连公司VPN？", filters={"user_id": ORG_ID})
# 返回：公司的 VPN 连接方式是...

# 同时支持个人记忆 + 组织记忆的混合检索
def hybrid_search(employee_id, query):
    org_memories = client.search(query, filters={"user_id": ORG_ID}, top_k=3)
    personal_memories = client.search(query, filters={"user_id": employee_id}, top_k=3)
    return {
        "organization": org_memories["results"],
        "personal": personal_memories["results"]
    }

9.4 多 Agent 共享记忆：团队协作的记忆中枢

"""
场景：多 Agent 协作系统，销售Agent和技术Agent共享客户记忆
"""
# 所有 Agent 共享同一个 user_id（客户ID），但用不同的 agent_id 隔离自身记忆

# 销售 Agent 记录客户需求
client.add(
    "客户张三是某公司CTO，对我们的企业版产品感兴趣，预算50万，需要私有化部署",
    user_id="customer_001",
    agent_id="sales_agent"
)

# 技术 Agent 查询客户信息（可以看到销售Agent记录的客户记忆）
tech_context = client.search("客户的技术需求是什么？", filters={"user_id": "customer_001"})
# 返回：客户需要私有化部署...

# 技术 Agent 记录技术评估
client.add(
    "客户的私有化部署环境是 Kubernetes 1.28，需要支持离线安装，数据存储用 MinIO",
    user_id="customer_001",
    agent_id="tech_agent"
)

# 销售 Agent 后续跟进时也能看到技术评估
sales_followup = client.search("客户的部署环境？", filters={"user_id": "customer_001"})
# 返回：客户的私有化部署环境是 Kubernetes 1.28...

9.5 LangChain 集成：给你的Chain装上记忆

"""
场景：LangChain Chain + Mem0 长期记忆
"""
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage
from mem0 import MemoryClient

client = MemoryClient(api_key="your-mem0-key")
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.1)

# 定义带记忆注入的 Prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个有长期记忆的AI助手。
以下是关于用户的已知信息（长期记忆）：
{memories}

请利用这些信息提供个性化回答。如果用户提供了新信息，会自动保存。"""),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

chain = prompt | llm

def chat_with_memory(user_id, user_input, chat_history=None):
    # 1. 从 Mem0 检索相关记忆
    memories = client.search(user_input, filters={"user_id": user_id}, top_k=5)
    memory_text = "\n".join([f"- {m['memory']}" for m in memories["results"]])

    # 2. 调用 Chain
    response = chain.invoke({
        "memories": memory_text,
        "history": chat_history or [],
        "input": user_input
    })

    # 3. 保存本轮对话到 Mem0
    client.add(
        messages=[
            {"role": "user", "content": user_input},
            {"role": "assistant", "content": response.content}
        ],
        user_id=user_id
    )

    return response.content

# 使用
print(chat_with_memory("user_001", "我叫张三，是做后端开发的"))
# 下一轮：
print(chat_with_memory("user_001", "你还记得我是做什么的吗？"))
# AI 会回答：你是做后端开发的，名叫张三

9.6 CrewAI 集成：Crew的长期记忆解决方案

"""
场景：CrewAI 多 Agent 团队 + Mem0 持久化记忆

CrewAI 默认记忆是本地 ChromaDB + SQLite，机器绑定、会话级。
用 Mem0 替换后实现跨会话、跨部署的持久化记忆。
"""
import os
from mem0 import MemoryClient
from crewai import Agent, Task, Crew, Process
from crewai_tools import tool

os.environ["MEM0_API_KEY"] = "your-mem0-key"
os.environ["OPENAI_API_KEY"] = "your-openai-key"

mem0_client = MemoryClient()

# 定义 Mem0 记忆工具
@tool("search_memory")
def search_memory(query: str, user_id: str) -> str:
    """搜索用户的长期记忆。输入查询内容和用户ID，返回相关记忆。"""
    result = mem0_client.search(query, filters={"user_id": user_id}, top_k=5)
    return "\n".join([f"- {m['memory']}" for m in result["results"]])

@tool("save_memory")
def save_memory(content: str, user_id: str) -> str:
    """保存信息到用户的长期记忆。输入要保存的内容和用户ID。"""
    result = mem0_client.add(content, user_id=user_id)
    return f"已保存 {len(result['results'])} 条记忆"

# 定义 Agent
researcher = Agent(
    role="研究员",
    goal="收集和分析信息",
    backstory="你是一个专业研究员，擅长收集和整理信息。你可以访问长期记忆来了解用户的历史偏好。",
    tools=[search_memory, save_memory],
    verbose=True
)

writer = Agent(
    role="写手",
    goal="根据研究结果撰写报告",
    backstory="你是一个专业写手，擅长把研究结果转化为清晰的报告。",
    verbose=True
)

# 定义任务
task1 = Task(
    description="研究 AI Agent 记忆技术的最新进展，用户ID是 user_001，请先查询用户的历史兴趣",
    expected_output="研究摘要",
    agent=researcher
)

task2 = Task(
    description="根据研究结果撰写一篇技术博客",
    expected_output="完整的博客文章",
    agent=writer
)

# 组建 Crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[task1, task2],
    process=Process.sequential
)

# 运行
result = crew.kickoff(inputs={"user_id": "user_001"})
print(result)

CrewAI 默认记忆 vs CrewAI + Mem0：

维度 CrewAI 默认记忆 CrewAI + Mem0
存储 本地 ChromaDB + SQLite Mem0 Cloud 或自托管向量库
持久化 机器绑定、会话级 跨会话、跨部署
图记忆 不支持 支持（实体关系检索增强）
去重 0.85 余弦阈值 可配置策略（update/skip/merge）
多用户 需自行实现 原生 user_id 隔离

十、最佳实践：踩过的坑都给你铺平了

1. 记忆提取质量优化

  • 用消息列表而非纯字符串：messages 传 [{"role": "user", "content": "..."}] 比传纯字符串提取质量高 30%+，因为 LLM 能区分谁说的
  • 控制单轮对话长度：单次 add 的对话不要超过 2000 token，太长会导致提取遗漏
  • 分批处理长对话：长对话按主题分段 add，每段一个明确的话题

2. 检索效果优化

  • limit 设为 3-5：太多无关记忆会干扰 LLM 判断，太少信息不够
  • 结合 session_id 做分层检索：先搜当前会话记忆，再搜长期记忆，合并去重后注入
  • 定期清理无效记忆：用 get_all 遍历，删除过时或错误的记忆

3. 性能优化

  • 生产环境用 Qdrant 不用 Chroma：Chroma 适合开发，Qdrant 性能高一个数量级
  • Embedding 用小模型：text-embedding-3-small 比 text-embedding-3-large 快 3 倍，维度少一半，效果差距不大
  • 提取用小模型：记忆提取用 gpt-4o-mini / gpt-5-nano 足够，不用上大模型
  • 异步添加：add 操作可以放后台异步执行，不阻塞用户对话

4. 数据安全与合规

  • 敏感信息过滤：在 add 之前对对话内容做 PII 脱敏（身份证号、手机号、银行卡号）
  • 自托管选择：有数据合规要求的企业必须自托管，不能用云平台
  • 用户数据隔离：严格用 user_id 隔离，不同用户的记忆绝对不能交叉
  • 遗忘权支持：实现 delete_all(user_id=xxx) 接口，支持用户要求删除全部记忆

5. 常见坑点

坑 现象 解决方案
记忆重复爆炸 同一条信息存了几百遍 开启 dedup，检查去重阈值是否过高
提取垃圾信息 存了很多"用户说了句话"这种无意义记忆 自定义 fact_retrieval_prompt，明确提取规则
检索不到相关记忆 明明存过但搜不到 检查 embedding 模型是否一致；尝试降低检索阈值
记忆更新错误 用户改主意了但旧记忆还在 自定义 update_prompt，加强矛盾检测逻辑
多用户记忆串了 A 用户看到了 B 用户的记忆 检查每次调用是否都传了正确的 user_id

十一、术语表

术语 英文 解释
记忆层 Memory Layer 为 AI 应用提供持久化记忆能力的中间件层
向量数据库 Vector Database 存储高维向量并支持相似度检索的数据库，如 Qdrant、Chroma
嵌入 Embedding 将文本转换为高维向量表示的过程，用于语义计算
语义检索 Semantic Search 基于向量相似度的检索，找到意思相近而非字面匹配的内容
图数据库 Graph Database 以节点和边存储数据的数据库，擅长表示实体关系，如 Neo4j
实体 Entity 从文本中提取的专有名词或重要概念，如图谱的节点
关系 Relation 实体之间的语义连接，如图谱的边，通常表示为三元组
三元组 Triplet (源实体, 关系, 目标实体) 的数据结构，是知识图谱的基本单元
知识图谱 Knowledge Graph 由实体和关系构成的图结构，用于表示结构化知识
RAG Retrieval-Augmented Generation 检索增强生成，先检索相关文档再生成回答的技术
LoCoMo Long-term Conversation Memory benchmark 长期对话记忆基准测试，用于评估记忆系统的性能
BM25 Best Matching 25 经典的关键词检索算法，基于词频和逆文档频率
去重 Deduplication 识别并处理重复记忆的过程，避免存储冗余
持久化 Persistence 数据在程序结束后仍然保留的特性，通常指写入磁盘或数据库
用户隔离 User Isolation 不同用户的数据严格分开存储和访问，确保隐私安全
混合检索 Hybrid Search 结合多种检索方式（语义+关键词+图匹配）的综合检索策略
MCP Model Context Protocol 模型上下文协议，一种让 AI 模型访问外部工具和数据的标准协议

写在最后：

Mem0 不是银弹，它不能解决所有 AI 记忆问题。但它是目前最成熟、生态最完善的开源记忆层方案。

如果你正在做 AI Agent 产品，并且被"AI 总是记不住用户"这个问题困扰，花一个下午把 Mem0 集成进去，你会发现用户体验的提升是质的飞跃。

记住：没有记忆的 AI 只是一个高级搜索引擎，有了记忆的 AI 才是真正的助手。

觉得有用的话，点赞收藏关注三连，我们下篇见。

免责声明：本文为第三方学习整理，非 Mem0 官方文档。Mem0 迭代极快，文中代码 / API 可能随版本变化而失效，生产环境请以 官方文档 与 GitHub 仓库 的最新内容为准；因版本差异导致的问题，作者不承担责任。

版权与来源声明：文中所有代码仅用于学习演示，不构成生产实施建议；所有 API 以项目官方 GitHub 与官方文档为准；开源项目的商标、项目名称归各项目官方所有。

本文基于 Mem0 官方文档、ECAI 2025 论文（arXiv:2504.19413）及实际项目经验整理，如有错误欢迎指正。

# 人工智能
Logo
DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

cover

连续体机器人怎么在支气管里“整段贴合“？IEEE TASE 2025东南大学曲率域连续转向方法研究丨NOKOV度量动捕助力对齐仿真及真实实验

avatar DAMO开发者矩阵

2026年FA工厂自动化零部件平台选型测评｜行业痛点+选型维度+厂商解析

当前国内制造业自动化升级进程持续深化，半导体、新能源、3C电子、智能物流、机器人装备等下游行业高速发展，带动FA工厂自动化零部件需求稳步增长。相较于传统标准件采购，现阶段自动化设备零部件采购不再局限于单一品类、大批量模式，而是转向多品类混搭、小批量补采、非标定制居多、交付时效严苛的全新需求形态。传统分散式供应商对接模式，存在沟通成本高、选型误差大、交付滞后、特殊工况适配不足等问题，已经无法适配现代

avatar DAMO开发者矩阵
cover

8月27日19点开播丨视触融合、灵巧操作到世界模型：具身智能从算法创新到工程落地实践

avatar DAMO开发者矩阵