Agent Memory 全解析:从 SQLite、向量库 + RAG 到 Zep、Mem0

1. 为什么 Agent 需要 Memory

大模型本身是"无状态"的:每次调用都是一次全新的推理,除了上下文窗口里塞进去的内容,它对之前发生过什么一无所知。这带来几个直接问题:

  • 多轮对话会"失忆":用户上一轮说"我叫小王,做后端",下一轮问"帮我写个接口",模型未必还记得身份信息。
  • 上下文窗口有限且昂贵:把全部历史都塞进 prompt,token 成本线性增长,还会触发"中间遗忘"(lost in the middle)。
  • 跨会话无法延续:今天聊完,明天再来,一切归零。
  • 无法沉淀长期知识:用户偏好、项目背景、历史决策这些"越用越值钱"的信息没有被保存。

Agent Memory(智能体记忆) 就是为解决这些问题而生的机制:它让 Agent 能够写入、存储、检索、更新、遗忘信息,从而在多轮对话、跨会话、长周期任务中保持连贯性和个性化。

一个直观的类比:

人类记忆 Agent Memory
工作记忆(当前在想什么) 上下文窗口 / Prompt
短期记忆(今天发生的事) 会话历史、滚动摘要
长期记忆(人生经验) 向量库、知识图谱、结构化数据库
遗忘机制 过期淘汰、重要性衰减、冲突覆盖

2. Memory 的核心动机

把动机拆开看,大致是四类需求:

  1. 连贯性(Coherence):多轮对话中保持指代、上下文、任务状态一致。
  2. 个性化(Personalization):记住用户偏好、身份、习惯,做到"越用越懂你"。
  3. 知识沉淀(Knowledge Accumulation):把交互中产生的结论、事实、决策存下来,供后续复用。
  4. 成本与效果平衡(Efficiency):不是把所有东西都塞进 prompt,而是"按需检索"最相关的一小部分。

这四类需求决定了 Memory 系统的设计目标:写得进、存得住、找得准、管得好。

3. Memory 的发展脉络

从工程实践看,Agent Memory 大致经历了几个阶段:
#mermaid-svg-cLRVLZJl0jB3LGDn{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-cLRVLZJl0jB3LGDn .error-icon{fill:#552222;}#mermaid-svg-cLRVLZJl0jB3LGDn .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-cLRVLZJl0jB3LGDn .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-cLRVLZJl0jB3LGDn .marker{fill:#333333;stroke:#333333;}#mermaid-svg-cLRVLZJl0jB3LGDn .marker.cross{stroke:#333333;}#mermaid-svg-cLRVLZJl0jB3LGDn svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-cLRVLZJl0jB3LGDn p{margin:0;}#mermaid-svg-cLRVLZJl0jB3LGDn .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-cLRVLZJl0jB3LGDn .cluster-label text{fill:#333;}#mermaid-svg-cLRVLZJl0jB3LGDn .cluster-label span{color:#333;}#mermaid-svg-cLRVLZJl0jB3LGDn .cluster-label span p{background-color:transparent;}#mermaid-svg-cLRVLZJl0jB3LGDn .label text,#mermaid-svg-cLRVLZJl0jB3LGDn span{fill:#333;color:#333;}#mermaid-svg-cLRVLZJl0jB3LGDn .node rect,#mermaid-svg-cLRVLZJl0jB3LGDn .node circle,#mermaid-svg-cLRVLZJl0jB3LGDn .node ellipse,#mermaid-svg-cLRVLZJl0jB3LGDn .node polygon,#mermaid-svg-cLRVLZJl0jB3LGDn .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-cLRVLZJl0jB3LGDn .rough-node .label text,#mermaid-svg-cLRVLZJl0jB3LGDn .node .label text,#mermaid-svg-cLRVLZJl0jB3LGDn .image-shape .label,#mermaid-svg-cLRVLZJl0jB3LGDn .icon-shape .label{text-anchor:middle;}#mermaid-svg-cLRVLZJl0jB3LGDn .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-cLRVLZJl0jB3LGDn .rough-node .label,#mermaid-svg-cLRVLZJl0jB3LGDn .node .label,#mermaid-svg-cLRVLZJl0jB3LGDn .image-shape .label,#mermaid-svg-cLRVLZJl0jB3LGDn .icon-shape .label{text-align:center;}#mermaid-svg-cLRVLZJl0jB3LGDn .node.clickable{cursor:pointer;}#mermaid-svg-cLRVLZJl0jB3LGDn .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-cLRVLZJl0jB3LGDn .arrowheadPath{fill:#333333;}#mermaid-svg-cLRVLZJl0jB3LGDn .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-cLRVLZJl0jB3LGDn .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-cLRVLZJl0jB3LGDn .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-cLRVLZJl0jB3LGDn .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-cLRVLZJl0jB3LGDn .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-cLRVLZJl0jB3LGDn .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-cLRVLZJl0jB3LGDn .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-cLRVLZJl0jB3LGDn .cluster text{fill:#333;}#mermaid-svg-cLRVLZJl0jB3LGDn .cluster span{color:#333;}#mermaid-svg-cLRVLZJl0jB3LGDn div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-cLRVLZJl0jB3LGDn .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-cLRVLZJl0jB3LGDn rect.text{fill:none;stroke-width:0;}#mermaid-svg-cLRVLZJl0jB3LGDn .icon-shape,#mermaid-svg-cLRVLZJl0jB3LGDn .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-cLRVLZJl0jB3LGDn .icon-shape p,#mermaid-svg-cLRVLZJl0jB3LGDn .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-cLRVLZJl0jB3LGDn .icon-shape .label rect,#mermaid-svg-cLRVLZJl0jB3LGDn .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-cLRVLZJl0jB3LGDn .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-cLRVLZJl0jB3LGDn .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-cLRVLZJl0jB3LGDn :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 阶段一:全量上下文
阶段二:摘要压缩
阶段三:向量检索 RAG
阶段四:结构化记忆管理
阶段五:记忆操作系统

  • 阶段一:全量上下文。把历史对话全部拼进 prompt。简单直接,但受窗口限制、成本高。
  • 阶段二:摘要压缩 。用 LLM 对历史做滚动摘要(如 LangChain 的 ConversationSummaryMemory),控制 token,但会丢失细节。
  • 阶段三:向量检索 RAG。把历史/知识向量化存入向量库,按语义相似度召回 Top-K。解决了"存得多"的问题。
  • 阶段四:结构化记忆管理。引入记忆类型(事实/偏好/事件)、重要性打分、时间衰减、冲突消解,从"能检索"走向"会管理"。
  • 阶段五:记忆操作系统。以 Zep、Mem0 为代表,把记忆抽象成独立服务,提供写入、抽取、更新、检索、遗忘的完整生命周期管理。

下面按"基础 → 进阶"的顺序展开。

4. 基础方案一:基于 SQLite 的本地记忆

最朴素也最可靠的记忆方案,就是用关系型数据库存结构化数据。SQLite 因为零依赖、单文件、嵌入式,非常适合本地 Agent 或原型验证。

4.1 数据模型设计

一个最小可用的记忆表设计:

sql 复制代码
CREATE TABLE memories (
    id          INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id     TEXT    NOT NULL,           -- 记忆归属
    session_id  TEXT,                       -- 所属会话
    mem_type    TEXT    NOT NULL,           -- fact / preference / event / summary
    content     TEXT    NOT NULL,           -- 记忆正文
    importance  REAL    DEFAULT 0.5,        -- 重要性 0~1
    created_at  INTEGER NOT NULL,           -- 创建时间戳
    updated_at  INTEGER NOT NULL,           -- 更新时间戳
    last_access INTEGER,                    -- 最近访问时间
    access_cnt  INTEGER DEFAULT 0           -- 访问次数
);

CREATE INDEX idx_mem_user ON memories(user_id, mem_type);
CREATE INDEX idx_mem_time ON memories(user_id, created_at DESC);

4.2 读写流程

python 复制代码
import sqlite3
import time

class SQLiteMemory:
    def __init__(self, path="agent_memory.db"):
        self.conn = sqlite3.connect(path, check_same_thread=False)
        self.conn.row_factory = sqlite3.Row
        self._init_schema()

    def _init_schema(self):
        self.conn.executescript("""
        CREATE TABLE IF NOT EXISTS memories (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id TEXT NOT NULL,
            session_id TEXT,
            mem_type TEXT NOT NULL,
            content TEXT NOT NULL,
            importance REAL DEFAULT 0.5,
            created_at INTEGER NOT NULL,
            updated_at INTEGER NOT NULL,
            last_access INTEGER,
            access_cnt INTEGER DEFAULT 0
        );
        """)
        self.conn.commit()

    def add(self, user_id, content, mem_type="fact",
            session_id=None, importance=0.5):
        now = int(time.time())
        cur = self.conn.execute(
            """INSERT INTO memories
               (user_id, session_id, mem_type, content, importance,
                created_at, updated_at)
               VALUES (?, ?, ?, ?, ?, ?, ?)""",
            (user_id, session_id, mem_type, content, importance, now, now),
        )
        self.conn.commit()
        return cur.lastrowid

    def search(self, user_id, keyword=None, mem_type=None, limit=10):
        sql = "SELECT * FROM memories WHERE user_id = ?"
        args = [user_id]
        if mem_type:
            sql += " AND mem_type = ?"
            args.append(mem_type)
        if keyword:
            sql += " AND content LIKE ?"
            args.append(f"%{keyword}%")
        sql += " ORDER BY importance DESC, updated_at DESC LIMIT ?"
        args.append(limit)
        rows = self.conn.execute(sql, args).fetchall()
        # 更新访问统计
        ids = [r["id"] for r in rows]
        if ids:
            now = int(time.time())
            self.conn.executemany(
                "UPDATE memories SET last_access=?, access_cnt=access_cnt+1 WHERE id=?",
                [(now, i) for i in ids],
            )
            self.conn.commit()
        return [dict(r) for r in rows]

4.3 优缺点

优点:

  • 零依赖、部署简单,单文件即可迁移;
  • 支持事务、精确查询、结构化过滤;
  • 数据完全可控,便于审计和调试。

缺点:

  • 只能做关键词/精确匹配,无法语义检索;
  • 记忆多了以后,LIKE 查询性能差;
  • 需要自己设计抽取、去重、更新逻辑。

适用场景:单机 Agent、原型验证、对隐私要求高且数据量不大的场景。

5. 基础方案二:向量库 + RAG

SQLite 解决了"存",但没解决"找得准"。向量库 + RAG 的思路是:把记忆转成向量,用语义相似度召回。

5.1 整体架构

#mermaid-svg-Ld8igR5locCCFYU0{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-Ld8igR5locCCFYU0 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Ld8igR5locCCFYU0 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Ld8igR5locCCFYU0 .error-icon{fill:#552222;}#mermaid-svg-Ld8igR5locCCFYU0 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Ld8igR5locCCFYU0 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Ld8igR5locCCFYU0 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Ld8igR5locCCFYU0 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Ld8igR5locCCFYU0 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Ld8igR5locCCFYU0 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Ld8igR5locCCFYU0 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Ld8igR5locCCFYU0 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Ld8igR5locCCFYU0 .marker.cross{stroke:#333333;}#mermaid-svg-Ld8igR5locCCFYU0 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Ld8igR5locCCFYU0 p{margin:0;}#mermaid-svg-Ld8igR5locCCFYU0 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-Ld8igR5locCCFYU0 .cluster-label text{fill:#333;}#mermaid-svg-Ld8igR5locCCFYU0 .cluster-label span{color:#333;}#mermaid-svg-Ld8igR5locCCFYU0 .cluster-label span p{background-color:transparent;}#mermaid-svg-Ld8igR5locCCFYU0 .label text,#mermaid-svg-Ld8igR5locCCFYU0 span{fill:#333;color:#333;}#mermaid-svg-Ld8igR5locCCFYU0 .node rect,#mermaid-svg-Ld8igR5locCCFYU0 .node circle,#mermaid-svg-Ld8igR5locCCFYU0 .node ellipse,#mermaid-svg-Ld8igR5locCCFYU0 .node polygon,#mermaid-svg-Ld8igR5locCCFYU0 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Ld8igR5locCCFYU0 .rough-node .label text,#mermaid-svg-Ld8igR5locCCFYU0 .node .label text,#mermaid-svg-Ld8igR5locCCFYU0 .image-shape .label,#mermaid-svg-Ld8igR5locCCFYU0 .icon-shape .label{text-anchor:middle;}#mermaid-svg-Ld8igR5locCCFYU0 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-Ld8igR5locCCFYU0 .rough-node .label,#mermaid-svg-Ld8igR5locCCFYU0 .node .label,#mermaid-svg-Ld8igR5locCCFYU0 .image-shape .label,#mermaid-svg-Ld8igR5locCCFYU0 .icon-shape .label{text-align:center;}#mermaid-svg-Ld8igR5locCCFYU0 .node.clickable{cursor:pointer;}#mermaid-svg-Ld8igR5locCCFYU0 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-Ld8igR5locCCFYU0 .arrowheadPath{fill:#333333;}#mermaid-svg-Ld8igR5locCCFYU0 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-Ld8igR5locCCFYU0 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-Ld8igR5locCCFYU0 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Ld8igR5locCCFYU0 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-Ld8igR5locCCFYU0 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Ld8igR5locCCFYU0 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-Ld8igR5locCCFYU0 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-Ld8igR5locCCFYU0 .cluster text{fill:#333;}#mermaid-svg-Ld8igR5locCCFYU0 .cluster span{color:#333;}#mermaid-svg-Ld8igR5locCCFYU0 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-Ld8igR5locCCFYU0 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-Ld8igR5locCCFYU0 rect.text{fill:none;stroke-width:0;}#mermaid-svg-Ld8igR5locCCFYU0 .icon-shape,#mermaid-svg-Ld8igR5locCCFYU0 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Ld8igR5locCCFYU0 .icon-shape p,#mermaid-svg-Ld8igR5locCCFYU0 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-Ld8igR5locCCFYU0 .icon-shape .label rect,#mermaid-svg-Ld8igR5locCCFYU0 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Ld8igR5locCCFYU0 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-Ld8igR5locCCFYU0 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-Ld8igR5locCCFYU0 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 用户输入
Embedding 模型
向量检索 Top-K
召回相关记忆
拼装 Prompt
LLM 生成回答
抽取新记忆

5.2 最小实现

以 Chroma 为例(也可换成 FAISS、Milvus、Qdrant、pgvector):

python 复制代码
import chromadb
from chromadb.utils import embedding_functions

class VectorMemory:
    def __init__(self, persist_dir="./chroma_mem"):
        self.client = chromadb.PersistentClient(path=persist_dir)
        self.embed_fn = embedding_functions.DefaultEmbeddingFunction()
        self.col = self.client.get_or_create_collection(
            name="agent_memory",
            embedding_function=self.embed_fn,
        )

    def add(self, user_id, text, mem_id=None, metadata=None):
        meta = {"user_id": user_id}
        if metadata:
            meta.update(metadata)
        self.col.add(
            documents=[text],
            metadatas=[meta],
            ids=[mem_id or f"{user_id}-{hash(text)}"],
        )

    def search(self, user_id, query, top_k=5):
        res = self.col.query(
            query_texts=[query],
            n_results=top_k,
            where={"user_id": user_id},
        )
        docs = res["documents"][0]
        metas = res["metadatas"][0]
        dists = res["distances"][0]
        return [
            {"content": d, "metadata": m, "score": 1 - dist}
            for d, m, dist in zip(docs, metas, dists)
        ]

5.3 写入策略:什么时候存

RAG 记忆的关键不在"检索",而在"写什么"。常见做法:

  • 每轮对话后抽取:用 LLM 判断本轮是否产生值得记住的事实/偏好,输出结构化 JSON 再入库。
  • 滑动窗口 + 摘要:保留最近 N 轮原文,更早的压缩成摘要再向量化。
  • 显式记忆:用户说"记住......"时直接写入高重要性记忆。

一个抽取 Prompt 示例:

text 复制代码
请从以下对话中抽取值得长期记住的信息,输出 JSON 数组:
[{"type": "fact|preference|event", "content": "...", "importance": 0.0~1.0}]
若无值得记住的信息,输出 []。

对话:
{conversation}

5.4 优缺点

优点:

  • 语义检索,能召回"意思相近但用词不同"的记忆;
  • 扩展性好,支持海量记忆;
  • 与 RAG 生态天然兼容。

缺点:

  • 只增不改:容易产生重复、矛盾记忆(用户先说喜欢 A,后说喜欢 B);
  • 缺乏时间维度,旧记忆可能压过新记忆;
  • 纯向量检索对"精确事实"(如订单号、日期)不友好;
  • 需要额外维护 Embedding 模型和向量库。

适用场景:知识库问答、长文档记忆、需要语义召回的对话 Agent。

6. 进阶方案一:Zep

Zep 是面向 Agent 的记忆层服务,核心卖点是时序知识图谱(Temporal Knowledge Graph)。

6.1 核心设计

Zep 把对话中的信息抽取成实体(Entity)和关系(Relationship),构建成随时间演化的知识图谱:

  • Episode:原始对话片段,作为事实来源;
  • Entity:人、地点、项目、概念等节点;
  • Edge(Fact) :带时间有效区间的三元组,如 (小王, 就职于, A公司, 2023-01 ~ 2025-06);
  • Community:对图谱做社区聚类,生成高层摘要。

6.2 关键能力

  1. 时序有效性 :每条事实带 valid_at / invalid_at,新事实会失效旧事实,而不是简单覆盖。这解决了 RAG "只增不改"的痛点。
  2. 混合检索:向量检索 + 图遍历 + 全文检索,多路召回后重排。
  3. 自动摘要:对会话和实体生成滚动摘要,控制上下文长度。
  4. 低延迟:官方宣称相比全量上下文方案,可显著降低响应延迟和 token 消耗。

6.3 使用示例

python 复制代码
from zep_cloud.client import Zep

client = Zep(api_key="YOUR_API_KEY")

# 写入会话消息
client.memory.add(
    session_id="session_001",
    messages=[{
        "role": "user",
        "content": "我最近从 A 公司跳槽到了 B 公司,做基础架构。",
    }],
)

# 检索相关记忆
results = client.memory.search(
    session_id="session_001",
    text="用户现在在哪家公司?",
    limit=5,
)
for r in results:
    print(r.message.content, r.score)

6.4 适用与局限

  • 适合:需要长期记忆、事实会随时间变化、对"记忆准确性"要求高的场景(客服、个人助理、CRM)。
  • 局限:依赖外部服务,图谱构建有额外延迟和成本;抽取质量强依赖 LLM。

7. 进阶方案二:Mem0

Mem0 定位是"为 AI 应用提供通用记忆层",主打轻量、易集成、可自托管。

7.1 核心设计

Mem0 的记忆流程可以概括为 Extract → Compare → Decide:
#mermaid-svg-3Ho4dleL12AkYdiS{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-3Ho4dleL12AkYdiS .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-3Ho4dleL12AkYdiS .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-3Ho4dleL12AkYdiS .error-icon{fill:#552222;}#mermaid-svg-3Ho4dleL12AkYdiS .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-3Ho4dleL12AkYdiS .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-3Ho4dleL12AkYdiS .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-3Ho4dleL12AkYdiS .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-3Ho4dleL12AkYdiS .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-3Ho4dleL12AkYdiS .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-3Ho4dleL12AkYdiS .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-3Ho4dleL12AkYdiS .marker{fill:#333333;stroke:#333333;}#mermaid-svg-3Ho4dleL12AkYdiS .marker.cross{stroke:#333333;}#mermaid-svg-3Ho4dleL12AkYdiS svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-3Ho4dleL12AkYdiS p{margin:0;}#mermaid-svg-3Ho4dleL12AkYdiS .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-3Ho4dleL12AkYdiS .cluster-label text{fill:#333;}#mermaid-svg-3Ho4dleL12AkYdiS .cluster-label span{color:#333;}#mermaid-svg-3Ho4dleL12AkYdiS .cluster-label span p{background-color:transparent;}#mermaid-svg-3Ho4dleL12AkYdiS .label text,#mermaid-svg-3Ho4dleL12AkYdiS span{fill:#333;color:#333;}#mermaid-svg-3Ho4dleL12AkYdiS .node rect,#mermaid-svg-3Ho4dleL12AkYdiS .node circle,#mermaid-svg-3Ho4dleL12AkYdiS .node ellipse,#mermaid-svg-3Ho4dleL12AkYdiS .node polygon,#mermaid-svg-3Ho4dleL12AkYdiS .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-3Ho4dleL12AkYdiS .rough-node .label text,#mermaid-svg-3Ho4dleL12AkYdiS .node .label text,#mermaid-svg-3Ho4dleL12AkYdiS .image-shape .label,#mermaid-svg-3Ho4dleL12AkYdiS .icon-shape .label{text-anchor:middle;}#mermaid-svg-3Ho4dleL12AkYdiS .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-3Ho4dleL12AkYdiS .rough-node .label,#mermaid-svg-3Ho4dleL12AkYdiS .node .label,#mermaid-svg-3Ho4dleL12AkYdiS .image-shape .label,#mermaid-svg-3Ho4dleL12AkYdiS .icon-shape .label{text-align:center;}#mermaid-svg-3Ho4dleL12AkYdiS .node.clickable{cursor:pointer;}#mermaid-svg-3Ho4dleL12AkYdiS .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-3Ho4dleL12AkYdiS .arrowheadPath{fill:#333333;}#mermaid-svg-3Ho4dleL12AkYdiS .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-3Ho4dleL12AkYdiS .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-3Ho4dleL12AkYdiS .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-3Ho4dleL12AkYdiS .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-3Ho4dleL12AkYdiS .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-3Ho4dleL12AkYdiS .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-3Ho4dleL12AkYdiS .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-3Ho4dleL12AkYdiS .cluster text{fill:#333;}#mermaid-svg-3Ho4dleL12AkYdiS .cluster span{color:#333;}#mermaid-svg-3Ho4dleL12AkYdiS div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-3Ho4dleL12AkYdiS .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-3Ho4dleL12AkYdiS rect.text{fill:none;stroke-width:0;}#mermaid-svg-3Ho4dleL12AkYdiS .icon-shape,#mermaid-svg-3Ho4dleL12AkYdiS .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-3Ho4dleL12AkYdiS .icon-shape p,#mermaid-svg-3Ho4dleL12AkYdiS .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-3Ho4dleL12AkYdiS .icon-shape .label rect,#mermaid-svg-3Ho4dleL12AkYdiS .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-3Ho4dleL12AkYdiS .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-3Ho4dleL12AkYdiS .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-3Ho4dleL12AkYdiS :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 重复
补充
矛盾
全新
新对话
LLM 抽取候选记忆
检索相似已有记忆
与已有记忆的关系
忽略 / 合并
UPDATE 更新
DELETE 旧 + ADD 新
ADD 新增

这个"增删改查 "闭环是 Mem0 与朴素 RAG 最大的区别:它不是无脑追加,而是让 LLM 判断新记忆与旧记忆的关系,执行 ADD / UPDATE / DELETE / NOOP。

7.2 记忆分层

Mem0 区分了几类记忆:

  • User Memory:跨会话的用户长期画像;
  • Session Memory:单次会话内的短期上下文;
  • Agent Memory:Agent 自身的状态与经验。

7.3 使用示例

python 复制代码
from mem0 import Memory

m = Memory()

# 写入:自动抽取并决策
m.add(
    messages=[
        {"role": "user", "content": "我喜欢用 Python,不喜欢 Java。"},
        {"role": "assistant", "content": "好的,记住了。"},
    ],
    user_id="user_001",
)

# 检索
results = m.search(query="用户喜欢什么编程语言?", user_id="user_001")
for r in results["results"]:
    print(r["memory"], r["score"])

# 获取全部记忆
all_mem = m.get_all(user_id="user_001")

7.4 存储后端

Mem0 支持多种后端组合:

组件 可选方案
向量库 Qdrant、Chroma、pgvector、Milvus
图存储 Neo4j、Memgraph(用于 Graph Memory)
历史库 SQLite、PostgreSQL
LLM OpenAI、Anthropic、Ollama 等

这意味着它可以自托管,也可以走托管服务,灵活性较高。

7.5 适用与局限

  • 适合:需要快速给应用加上"记忆"能力的团队,尤其是多用户 SaaS 场景。
  • 局限 :每次写入都要调用 LLM 做抽取和决策,写入成本较高;抽取质量依赖 Prompt 调优。

8. 方案对比与选型建议

维度 SQLite 向量库 + RAG Zep Mem0
检索方式 关键词/精确 语义相似度 向量 + 图 + 全文 向量 + 可选图
记忆更新 手动 基本只增 时序失效 LLM 决策增删改
时间维度 有字段 弱 强(valid_at) 中
部署复杂度 极低 中 低(托管)/ 中 中
写入成本 极低 低 中 较高
适合场景 原型/单机 知识库问答 长期事实型记忆 通用应用记忆层

选型建议:

  • 原型阶段:先用 SQLite,把数据模型和读写流程跑通,成本最低。
  • 需要语义召回:加向量库,注意设计好"写什么"的抽取策略。
  • 事实会随时间变化:考虑 Zep 的时序图谱思路,或自己在 RAG 上补时间戳和失效逻辑。
  • 要快速产品化:Mem0 的增删改闭环能省掉大量记忆管理代码。

9. 实践中的关键问题

无论选哪种方案,落地时都会遇到这些坑:

  1. 记忆抽取质量:抽取 Prompt 决定了记忆的上限。建议用结构化输出(JSON Schema)约束,并做人工抽检。
  2. 去重与冲突:同一事实反复写入会污染检索结果。需要相似度阈值 + LLM 判断双重把关。
  3. 遗忘机制:不是所有记忆都值得永久保留。可以按"重要性 × 时间衰减"打分,定期淘汰低分记忆。
  4. 隐私与合规:用户记忆涉及个人信息,需要支持按用户删除(GDPR 的"被遗忘权")。
  5. 评估困难:记忆效果难以量化。建议构建带标注的评测集,衡量召回准确率和回答质量。
  6. 成本控制:写入时的 LLM 调用是主要成本,可以用小模型做抽取、批量处理、缓存来优化。

10. 总结

Agent Memory 的本质,是给无状态的大模型补上"记忆能力"。它的演进路径很清晰:

  • SQLite 解决"存得住",简单可靠,适合起步;
  • 向量库 + RAG 解决"找得准",让语义检索成为可能;
  • Zep 用时序知识图谱解决"事实会变",让记忆具备时间有效性;
  • Mem0 用 LLM 驱动的增删改闭环解决"记忆会脏",让记忆能够自我维护。

实际工程中,这几种方案往往是组合使用的:用 SQLite 存结构化元数据,用向量库存语义记忆,用图谱存实体关系,再用一层调度逻辑决定"何时写、写什么、怎么更新"。理解了这条主线,再去看各种 Memory 框架,就不会被名词绕晕了。

相关推荐
一条大祥脚1 小时前
MemGPT 深度解析:让 Agent 拥有“无限上下文“的记忆架构
架构·agent·memgpt·智能体记忆
Databend3 小时前
活动邀请函|AI 时代的湖仓实践,从应用场景到 Cloud Agent 上手
大数据·数据库·agent
前端双越老师3 小时前
程序员 1v1 访谈系列第十五期:不要着急学副业
agent·ai编程·全栈
沉默王二3 小时前
真狠啊,DeepSeek 开放全家桶 API。
人工智能·agent·deepseek
Csvn15 小时前
同一个问题问 100 遍,钱就扣 100 次?精确缓存让它只扣一次(C02)
人工智能·aigc·agent
nice_lcj52016 小时前
【从零理解 Spring AI · 13】RAG 要解决什么:把“闭卷考试“变成“开卷“
java·spring·检索增强·rag·spring ai·ai应用开发
岁月宁静17 小时前
从零拆解 AI 语音模拟面试系统
人工智能·python·agent
小七-七牛开发者18 小时前
周 1 上线 | DSH 喜提原神进场动画,Anthropic 启动 IPO 路演;黄仁勋辞任;微软全球大宕机超 24 小时
ai·大模型·agent·token·工作流·claudecode·ai coding