为 AI Agent 打造持久记忆：深入 Mem0 架构与 LangGraph 集成实战

与 AI 助手交互时，我们常常会因其“短暂记忆”而感到困扰。前一天刚讨论过个人偏好，第二天它就忘得一干二净，导致我们需要反复重申相同的信息。这种体验不仅效率低下，也削弱了 AI 的智能化观感。

Mem0 是一个专为解决 AI “健忘”问题而设计的开源记忆层。它能为 AI 应用提供跨会札、跨平台的持久化记忆能力，让 AI 真正“记住”你。

根据 Mem0 团队发布的技术论文，在十万级对话记忆的检索测试中，其响应速度比 OpenAI 的原生记忆方案快 10 倍，准确率高出 26%。更重要的是，Mem0 支持数据本地化存储，确保了用户隐私与数据安全。

Mem0 核心架构：三层记忆模型

Mem0 通过一个分层的记忆架构来高效管理信息，确保关键信息能够被准确记录和调用。

用户级记忆 (User-level Memory)：这是一个跨会话、跨应用的“个人档案库”。它持久化存储用户的核心信息，如饮食禁忌（不吃辣）、工作领域（互联网运营）、长期偏好等。无论切换到哪个 AI 工具，这些核心记忆都能被调用。
会话级记忆 (Session-level Memory)：这是当前对话的“上下文快照”。它记录了本次交互中的具体信息，例如正在讨论的“项目 B 的第三版修改意见”。这避免了因对话中断而需要重复沟通先前進度的麻烦。
智能体级记忆 (Agent-level Memory)：这是 AI 自身的“知识储备库”。它存储了 AI 系统的通用知识（如 Markdown 语法规则）和工具调用逻辑（如如何连接 Excel 读取数据），确保 AI 在为不同用户服务时，其基础能力保持一致。

Mem0 工作原理：从信息提取到智能检索

Mem0 的记忆管理并非简单的文本存储，而是一套完整的语义处理与检索流程。

核心工作流

以用户输入“我怕辣，吃火锅只选清汤锅底，偏爱番茄味”为例，Mem0 的处理流程如下：

信息提取：利用大语言模型（LLM）深度分析对话，自动抓取关键信息，如“饮食禁忌：怕辣”和“火锅偏好：清汤、番茄味”，并过滤掉无关的闲聊内容。
向量化：使用嵌入模型（如 mxbai-embed-large）将提取的信息转化为高维向量，即将文本信息转换为计算机可以快速比对的数值序列。
存储：将向量化的记忆单元存入向量数据库（如 Qdrant），同时将实体间的关联关系（如“怕辣-火锅-番茄味”）存入图数据库。
检索：当用户再次提问“推荐适合我的火锅锅底”时，系统将查询同样转化为向量，在数据库中快速匹配到“怕辣、番茄清汤”等相关记忆。
整合：将检索到的记忆与当前对话上下文结合，生成更具个性化的响应，如：“根据您的偏好，推荐番茄清汤锅底。是否需要为您推荐附近的清汤火锅门店？”

关键技术：向量嵌入与图结构

Mem0 的长效记忆能力主要依赖两大核心技术：

向量嵌入技术：解决了语义相似性匹配的问题。即使用户的提问措辞不同（如“想吃不辣的热食”），系统也能通过向量相似度计算，准确关联到“怕辣、番茄火锅”等相关记忆。
图数据库关联：解决了信息之间的关联与串联问题。例如，当用户先后提供了“项目 A 的对接人是张三”和“张三的邮箱是 [email protected]”两条信息后，图记忆会自动建立“项目 A -> 对接人 -> 张三 -> 邮箱”的关联链。当下次询问“项目 A 对接人的邮箱”时，系统能直接返回完整信息。

核心 API

Mem0 提供了简洁的核心 API 接口供开发者调用：

add: 用于从对话中提取信息并将其存储为结构化的记忆单元。
search: 根据用户查询，从记忆库中检索并返回最相关的历史记忆。

图记忆 (Graph Memory) 示例

Mem0 已支持图记忆，通过引入图数据库，可以捕捉和利用信息片段间的复杂关系，实现更具情境感知的响应。

以下代码展示了如何使用图记忆功能。随着记忆的不断添加，实体和关系会被自动提取并连接，形成一个动态演化的记忆网络。

# 添加关于用户 Alice 的多条记忆
m.add("I like going to hikes", user_id="alice123")
m.add("I love to play badminton", user_id="alice123")
# 新记忆会与旧记忆进行比对和冲突解决
m.add("I hate playing badminton", user_id="alice123") 
# 提取实体及其关系
m.add("My friend name is john and john has a dog named tommy", user_id="alice123")
m.add("My name is Alice", user_id="alice123")
m.add("John loves to hike and Harry loves to hike as well", user_id="alice123")
m.add("My friend peter is the spiderman", user_id="alice123")

# 基于图关系进行搜索
m.search("What is my name?", user_id="alice123")
m.search("Who is spiderman?", user_id="alice123")

OpenMemory MCP：统一的本地记忆协议

OpenMemory MCP (模型上下文协议) 是 Mem0 的核心协议层，旨在为 AI 交互提供一个本地化的“记忆背包”。它作为一个统一的记忆基础设施，允许多种 AI 应用（如 Claude Desktop, Cursor 等）通过标准化协议连接，实现跨工具的记忆共享。所有数据均在本地存储，确保用户对数据的绝对控制权和隐私安全。

MCP 提供了四个核心 API 端点：

add_memories: 存储新的记忆对象。
search_memory: 基于相关性和上下文检索记忆。
list_memories: 查看所有已存储的记忆。
delete_all_memories: 清除指定用户的所有记忆。

API 请求示例：

存储记忆：

POST /add_memories
{
  "memories": [
    { "role": "user", "content": "我喜欢科幻电影，尤其是星际穿越。" },
    { "role": "assistant", "content": "星际穿越确实是一部经典的科幻电影！我会记住你喜欢这类电影。" }
  ],
  "user_id": "alice",
  "metadata": { "category": "movies" }
}

检索记忆：

POST /search_memory
{
  "query": "我喜欢什么类型的电影？",
  "user_id": "alice",
  "limit": 5
}

集成实战：在 LangGraph 中使用 Mem0

下面我们将演示如何通过自托管的方式，将 Mem0 与 LangGraph 集成，为 AI Agent 赋予持久记忆能力。

1. 环境准备

本教程将使用 DeepSeek 作为 LLM，Ollama 托管的 mxbai-embed-large 作为嵌入模型，并使用 Qdrant 作为向量数据库。

安装嵌入模型 (Ollama)

# 拉取模型
ollama pull mxbai-embed-large

# 测试模型是否可用
curl http://localhost:11434/api/embeddings -d '{
 "model": "mxbai-embed-large",
 "prompt": "This is a test sentence."
}'

如果成功返回 embedding 向量，则说明模型已准备就绪。

安装向量数据库 (Qdrant)

# 拉取 Qdrant 镜像
docker pull qdrant/qdrant

# 运行 Qdrant 容器
docker run -p 6333:6333 --name qdrant -d qdrant/qdrant

你可以通过访问 ` 来确认 Qdrant 服务是否正常运行。

2. 基本用法示例

首先，安装必要的 Python 依赖：

pip install python-dotenv langchain langgraph mem0ai ollama

以下代码演示了 Mem0 的基本操作：初始化、添加记忆和检索记忆。

import os
import json
from mem0 import Memory

# 设置你的 DeepSeek API 密钥
os.environ["DEEPSEEK_API_KEY"] = "sk-..." 

# 配置 Mem0
config = {
    "llm": {
        "provider": "deepseek",
        "model": "deepseek-chat",
    },
    "embedder": {
        "provider": "ollama",
        "model": "mxbai-embed-large"
    },
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
        }
    },
}

# 初始化 Memory 实例
m = Memory.from_config(config)

# 待添加记忆的对话内容
messages = [
    {"role": "user", "content": "我喜欢科幻电影，尤其是星际穿越。"},
    {"role": "assistant", "content": "星际穿越确实是一部经典的科幻电影！我会记住你喜欢这类电影。"},
    {"role": "user", "content": "我也喜欢克里斯托弗·诺兰的其他电影。"},
    {"role": "assistant", "content": "诺兰的作品确实很出色！"}
]

# 添加记忆
m.add(messages, user_id="alice", metadata={"category": "movies"})

# 检索记忆
memories = m.search(query="我喜欢什么类型的电影？", user_id="alice")
print(json.dumps(memories, indent=2, ensure_ascii=False))

# 获取所有记忆
all_memories = m.get_all(user_id="alice")
print(json.dumps(all_memories, indent=2, ensure_ascii=False))

运行后，search 函数会返回与查询最相关的记忆片段：

{
  "results": [
    {
      "id": "b052c579-23dd-4d89-933e-4c6ceb4e8958",
      "memory": "喜欢克里斯托弗·诺兰的其他电影",
      "metadata": { "category": "movies" },
      "score": 0.6853715,
      "user_id": "alice"
    },
    {
      "id": "2fae3fa7-0fa7-4164-b521-5c0d821d1c7a",
      "memory": "喜欢科幻电影，尤其是星际穿越",
      "metadata": { "category": "movies" },
      "score": 0.6162164,
      "user_id": "alice"
    }
  ]
}

3. 与 LangGraph 集成

现在，我们将 Mem0 集成到一个 LangGraph 工作流中，构建一个具备记忆能力的 Agent。

工作流设计：

检索记忆 (retrieve_memories)：接收用户问题，调用 m.search() 检索相关记忆。
LLM 推理 (llm_node)：将检索到的记忆注入到 System Prompt 中，引导 LLM 基于这些记忆生成回答。
存储记忆 (store_memories)：将当前的对话（包括用户的提问和 AI 的回答）存入记忆库，以备将来使用。

import os
from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langchain_deepseek import ChatDeepSeek

# --- 配置部分 (与上一示例相同) ---
os.environ["DEEPSEEK_API_KEY"] = "sk-..." 
config = { ... } # 省略与上文相同的配置
m = Memory.from_config(config)
llm = ChatDeepSeek(model="deepseek-chat")

# 定义状态
class State(TypedDict):
    messages: list
    user_id: str
    memories: list

# 定义图节点
def retrieve_memories_node(state: State) -> dict:
    """检索与最新消息相关的记忆"""
    query = state["messages"][-1]["content"]
    user_id = state.get("user_id", "default_user")
    retrieved_memories = m.search(query=query, user_id=user_id)
    return {"memories": retrieved_memories.get("results", [])}

def llm_node(state: State) -> dict:
    """基于记忆生成回答"""
    memories_str = "\n".join(f"- {mem['memory']}" for mem in state["memories"])
    system_prompt = f"你是一个有记忆能力的助手。以下是用户的相关记忆：\n{memories_str}\n请基于这些记忆回答问题。"
    
    messages_for_llm = [{"role": "system", "content": system_prompt}] + state["messages"]
    
    response = llm.invoke(messages_for_llm)
    new_message = {"role": "assistant", "content": response.content}
    
    return {"messages": state["messages"] + [new_message]}

def store_memories_node(state: State) -> dict:
    """将当前对话存入记忆库"""
    user_id = state.get("user_id", "default_user")
    m.add(state["messages"], user_id=user_id)
    return {}

# 构建图
graph_builder = StateGraph(State)
graph_builder.add_node("retrieve_memories", retrieve_memories_node)
graph_builder.add_node("llm", llm_node)
graph_builder.add_node("store_memories", store_memories_node)

graph_builder.add_edge(START, "retrieve_memories")
graph_builder.add_edge("retrieve_memories", "llm")
graph_builder.add_edge("llm", "store_memories")
graph_builder.add_edge("store_memories", END)

graph = graph_builder.compile()

# 运行图
initial_state = {
    "messages": [{"role": "user", "content": "我最喜欢什么电影？"}],
    "user_id": "alice",
    "memories": []
}
result = graph.invoke(initial_state)

print(json.dumps(result, indent=2, ensure_ascii=False))

运行结果：

Agent 成功调用了之前存储的记忆，并给出了精准的回答。

{
  "messages": [
    {
      "role": "user",
      "content": "我最喜欢什么电影？"
    },
    {
      "role": "assistant",
      "content": "根据我们的记忆，您最喜欢的电影是《星际穿越》，并且您也喜欢克里斯托弗·诺兰的其他作品。"
    }
  ],
  "user_id": "alice",
  "memories": [
    {
      "id": "2fae3fa7-0fa7-4164-b521-5c0d821d1c7a",
      "memory": "喜欢科幻电影，尤其是星际穿越",
      ...
    },
    {
      "id": "b052c579-23dd-4d89-933e-4c6ceb4e8958",
      "memory": "喜欢克里斯托弗·诺兰的其他电影",
      ...
    }
  ]
}

通过 Mem0，我们成功地为 LangGraph Agent 赋予了持久记忆的能力，使其能够提供更加个性化和连贯的交互体验。

👉 如果你需要 ChatGPT 代充 / Claude / Claude Code / 镜像 / 中转 API：

购买 / 了解更多：ai4.plus
备用入口：kk4099.com

Mem0 核心架构：三层记忆模型#

Mem0 工作原理：从信息提取到智能检索#

核心工作流#

关键技术：向量嵌入与图结构#

核心 API#

图记忆 (Graph Memory) 示例#

OpenMemory MCP：统一的本地记忆协议#

集成实战：在 LangGraph 中使用 Mem0#

1. 环境准备#

2. 基本用法示例#

3. 与 LangGraph 集成#