MemPalace 深度实战：当 AI 学会「记忆宫殿」——从原话存储到跨项目知识图谱的生产级完全指南（2026）

一、为什么 AI 需要记忆？

你有没有这样的经历：用 Claude Code 做了一周的项目，每次新会话都要重新解释一遍架构决策；上个月调试的那个诡异的并发 bug，当时怎么解决的完全想不起来；团队里 AI 辅助开发产生的知识，从来没法沉淀。

这不是你的问题，这是当前 AI 工具的根本缺陷——无状态。每次对话都是一张白纸，AI 对你、对项目、对历史毫无记忆。

2026 年 4 月，一个叫 MemPalace 的开源项目在 GitHub 上线，48 小时内涨到 22K Star，至今已超 55K Star。它的创始人不是什么硅谷大佬，而是《生化危机》女主角 Milla Jovovich 和开发者 Ben Sigman。这个跨界组合用 Anthropic 的 Claude Code 协作完成了整个系统。

但别被明星效应迷惑——MemPalace 之所以爆火，是因为它提出了一个真正不同的 AI 记忆解法：不替你决定什么重要，全部原话存储，让检索来解决问题。

本文将从架构设计、核心原理、代码实战到生产部署，带你彻底搞懂 MemPalace。

二、MemPalace 的核心设计哲学

2.1 与传统记忆系统的根本区别

现有的 AI 记忆方案主要分三类：

方案一：摘要提取（如 Mem0）

• AI 读完对话后提取"用户偏好 PostgreSQL"、"项目用 Next.js"等关键事实
• 优点：存储紧凑
• 致命缺陷：丢失因果链。"用户偏好 PostgreSQL"这句话，丢掉了"因为团队有 DBA 经验且需要 JSON 查询能力，所以选 PostgreSQL 而不是 MongoDB"这个决策过程

方案二：全量上下文注入（如 OpenClaw 默认的 MEMORY.md）

• 把所有记忆文件塞进上下文窗口
• 优点：实现简单
• 致命缺陷：Token 成本线性增长，文件超限静默截断，大规模场景检索退化

方案三：MemPalace 的原话存储 + 结构化检索

• 所有对话/代码/文档原文不动，存入本地向量数据库
• 用宫殿式层级结构组织，支持语义搜索
• 按需检索，只把相关记忆注入上下文
• 优点：零信息损失，Token 按需使用
• 代价：存储占用较大（但磁盘便宜，Token 贵）

2.2 记忆宫殿：从古希腊到 AI

MemPalace 的名字来自古希腊的"记忆宫殿法"（Method of Loci）。古希腊演说家将要记的内容"放置"在想象的建筑空间里来增强记忆——走到"客厅"想起第一段论点，走到"书房"想起第二段。

MemPalace 把这个空间隐喻变成了代码：

Palace（宫殿）
├── Wing（翼廊）—— 一个人或一个项目
│   ├── Hall（大厅）—— 主题领域
│   │   ├── Room（房间）—— 具体话题
│   │   │   ├── Closet（柜子）—— 关键实体
│   │   │   │   └── Drawer（抽屉）—— 原始内容片段

这个五层结构不是装饰——它直接映射到向量数据库的 Collection 和 Metadata，决定了检索的精度和效率。

三、架构深度解析

3.1 整体数据流

用户输入/文件/对话
      │
      ▼
  Ingestion Layer（摄入层）
      │
      ├── 文本分块（Chunking）
      ├── 实体识别（Entity Mining）
      └── 关系抽取（Relation Extraction）
      │
      ▼
  Storage Layer（存储层）
      │
      ├── ChromaDB（向量索引 + 元数据）
      ├── SQLite（结构化索引 + 事务日志）
      └── 文件系统（原始文件）
      │
      ▼
  Retrieval Layer（检索层）
      │
      ├── L0: 元数据过滤（快速定位 Wing/Room）
      ├── L1: 向量相似度搜索（语义召回）
      ├── L2: 知识图谱遍历（关联发现）
      └── L3: LLM 重排序（精准排序，可选）
      │
      ▼
  MCP Server（对外接口）
      │
      ▼
  Claude Code / OpenClaw / 任意 MCP 客户端

3.2 存储引擎：ChromaDB + SQLite 双引擎

MemPalace 用 ChromaDB 做向量存储，SQLite 做结构化索引。这两者的分工非常清晰：

ChromaDB 负责：

• 文本 Embedding 的存储和 ANN 搜索
• 按 Collection（对应 Wing/Hall）分区
• 元数据过滤（时间范围、实体标签等）

SQLite 负责：

• 实体-关系图谱的存储
• 事务日志（WAL 模式保证写入原子性）
• 统计信息（每个 Wing 有多少 Room/Drawer）
• 修复和恢复操作的数据源

# MemPalace 的 ChromaDB Collection 设计
# 每个 Wing 对应一个 Collection
collection = chroma_client.get_or_create_collection(
    name=f"wing_{wing_id}",
    metadata={
        "hnsw:space": "cosine",
        "hnsw:M": 64,          # HNSW 的 M 参数，影响召回率
        "hnsw:construction_ef": 256,
        "hnsw:batch_size": 500
    }
)

# 每个 Drawer 是 Collection 中的一条记录
# 包含原文、向量、元数据
drawer_record = {
    "ids": [drawer_id],
    "documents": [raw_text],           # 原话存储，不做摘要
    "embeddings": [embedding_vector],   # 通过 Embedding 模型生成
    "metadatas": [{
        "wing": wing_name,
        "hall": hall_name,
        "room": room_name,
        "closet": closet_name,
        "source": "claude_code",       # 来源标记
        "timestamp": "2026-06-15T07:00:00Z",
        "entities": "PostgreSQL,DBA,JSON",  # 实体标签
        "char_count": len(raw_text)
    }]
}

3.3 Embedding 模型：从默认到多语言

MemPalace v3.3.6 默认使用 embeddinggemma-300m 作为 Embedding 模型，替代了早期的 all-MiniLM-L6-v2。这个选择有重要意义：

• 多语言支持：中文、日文、韩文等 CJK 语言不再需要翻译后检索
• 维度适中：768 维，比 384 维的 MiniLM 信息量更大，比 1536 维的 OpenAI 模型更省空间
• 本地运行：通过 Ollama 或直接 ONNX Runtime 加载，无需 API Key

# 配置 Embedding 模型
# 方式一：使用 Ollama 本地模型（推荐）
ollama pull embeddinggemma
mempalace config set embedding.model "embeddinggemma"
mempalace config set embedding.provider "ollama"

# 方式二：使用 OpenAI API（云端，需 API Key）
mempalace config set embedding.model "text-embedding-3-small"
mempalace config set embedding.provider "openai"
mempalace config set embedding.api_key "sk-..."

3.4 四级渐进加载（L0-L3）

这是 MemPalace 最精妙的设计之一。它把记忆检索分为四个层级，每级递增成本、递减召回量：

L0：元数据定位（~0 tokens，毫秒级）

• 根据 Wing/Hall/Room 的层级结构，快速缩小搜索范围
• 比如"我要找关于 PostgreSQL 的记忆"，L0 直接定位到 wing:my-project/hall:database 目录
• 不涉及任何向量计算

L1：向量语义搜索（~100-300 tokens，百毫秒级）

• 在 L0 缩小的范围内，用 Embedding 相似度召回 Top-K 条目
• 默认 K=5，也就是 LongMemEval 上的 96.6% R@5 的来源

L2：知识图谱遍历（~200-500 tokens，秒级）

• 从 L1 命中的实体出发，沿 Hallway（同翼走廊）和 Tunnel（跨翼隧道）遍历关联实体
• Hallway：同一 Wing 内的实体共现关系图
• Tunnel：跨 Wing 的主题关联，由系统自动发现和维护

L3：LLM 重排序（~500-1000 tokens，数秒级，可选）

• 把 L1+L2 的结果送给 LLM 做最终排序
• 这是那个"100% 满分"的来源——需要额外调用 Claude Haiku API
• 生产环境通常不用，因为成本不划算

# MemPalace 的渐进加载实现（简化版）
class ProgressiveLoader:
    def __init__(self, palace: Palace):
        self.palace = palace

    async def recall(self, query: str, budget_tokens: int = 900) -> list[Drawer]:
        results = []

        # L0: 元数据定位 —— 零成本
        wings = self.palace.match_wings(query)  # 关键词匹配 Wing 名称
        if not wings:
            wings = self.palace.all_wings       # 没匹配到就全量搜索

        # L1: 向量语义搜索 —— 低成本
        candidates = []
        for wing in wings:
            collection = self.palace.get_collection(wing)
            query_embedding = self.palace.embed(query)
            hits = collection.query(
                query_embeddings=[query_embedding],
                n_results=5,
                include=["documents", "metadatas", "distances"]
            )
            candidates.extend(hits)

        # 按距离排序，取 Top-K
        candidates.sort(key=lambda x: x["distance"])
        results = candidates[:5]

        # L2: 知识图谱遍历 —— 中等成本
        if budget_tokens > 600:
            entities = self._extract_entities(results)
            connected = self.palace.graph.traverse(
                entities, max_depth=2, max_hops=3
            )
            results.extend(connected)

        # L3: LLM 重排序 —— 高成本，可选
        if budget_tokens > 1200 and self.palace.config.enable_rerank:
            ranked = await self.palace.llm_rerank(query, results)
            results = ranked

        return results

四、代码实战：从零搭建你的 AI 记忆宫殿

4.1 安装与初始化

# 方式一：pip 安装（推荐）
pip install mempalace

# 方式二：从源码安装（需要最新功能时）
git clone https://github.com/MemPalace/mempalace.git
cd mempalace
pip install -e ".[all]"

# 初始化
mempalace init
# 会交互式询问：
# - 宫殿名称（如 my-dev-palace）
# - 是否使用本地 LLM（推荐 Ollama）
# - 是否立即导入当前目录的文件

初始化完成后，目录结构如下：

~/.mempalace/
├── config.yaml           # 全局配置
├── palaces/
│   └── my-dev-palace/
│       ├── chroma_db/    # ChromaDB 数据目录
│       ├── sqlite.db     # SQLite 索引
│       ├── wings/        # Wing 的原始文件存储
│       │   ├── my-project/
│       │   │   ├── hall_database/
│       │   │   └── hall_frontend/
│       │   └── personal/
│       └── graph.db      # 知识图谱存储
└── logs/

4.2 导入你的对话和代码

# 导入 Claude Code 的对话历史
mempalace mine --source claude_code --path ~/.claude/projects/

# 导入一组 Markdown 文档
mempalace mine --source files --path ./docs/ --wing my-project

# 导入 Git 仓库的 commit 历史（提取决策上下文）
mempalace mine --source git --path ./my-repo/ --wing my-project --hall decisions

# 增量导入（只处理新增内容）
mempalace mine --source files --path ./docs/ --incremental

mine 命令是 MemPalace 的核心摄入操作，它的工作流：

1. 扫描：遍历指定路径，识别新增/修改的文件
2. 分块：按语义段落切分文本（不是简单按行切）
3. 实体识别：提取人名、项目名、技术术语等实体
4. 关系抽取：识别实体间的共现和引用关系
5. 向量化：用 Embedding 模型生成向量
6. 入库：写入 ChromaDB + SQLite + 文件系统

4.3 用 Python API 集成

from mempalace import Palace, PalaceConfig

# 创建/打开宫殿
config = PalaceConfig(
    name="my-dev-palace",
    embedding_provider="ollama",
    embedding_model="embeddinggemma",
    palace_root="~/.mempalace/palaces/my-dev-palace"
)
palace = Palace(config)

# 手动写入记忆
palace.store(
    content="我们决定用 PostgreSQL 而不是 MongoDB，因为团队有 3 个 DBA，且需要 JSON 查询能力做动态 Schema。",
    wing="my-project",
    hall="architecture",
    room="database-decision",
    entities=["PostgreSQL", "MongoDB", "DBA", "JSON"],
    source="manual"
)

# 语义检索
results = palace.recall(
    query="为什么选了 PostgreSQL？",
    top_k=5,
    wings=["my-project"],     # 限定 Wing 范围
    min_relevance=0.7          # 最低相似度阈值
)

for result in results:
    print(f"[{result.relevance:.2f}] {result.wing}/{result.hall}/{result.room}")
    print(f"  {result.content[:200]}...")
    print(f"  实体: {', '.join(result.entities)}")
    print()

# 知识图谱查询
graph_results = palace.graph_query(
    entity="PostgreSQL",
    relation_type="used_with",   # 可选：限定关系类型
    max_depth=2
)

for node in graph_results:
    print(f"{node.entity} --[{node.relation}]--> {node.target}")
    # 可能输出：
    # PostgreSQL --[used_with]--> Prisma ORM
    # PostgreSQL --[used_with]--> Docker
    # PostgreSQL --[decision_by]--> team-DBA

4.4 MCP Server 集成（接入 Claude Code）

MemPalace 提供了完整的 MCP Server，可以直接接入支持 MCP 的 AI 工具：

# 添加到 Claude Code 的 MCP 配置
claude mcp add mempalace -- python -m mempalace.mcp_server

# 或者手动编辑 ~/.claude/claude_desktop_config.json

{
  "mcpServers": {
    "mempalace": {
      "command": "python",
      "args": ["-m", "mempalace.mcp_server"],
      "env": {
        "MEMPALACE_ROOT": "~/.mempalace/palaces/my-dev-palace"
      }
    }
  }
}

MCP Server 提供的 29 个工具包括：

# Claude Code 中使用 MemPalace 的实际效果
# 对话开始时，Claude Code 自动调用 MCP 工具

# 用户：我上次那个并发 bug 怎么修的来着？
# Claude Code 内部调用：
recall_result = mempalace.palace_recall(
    query="并发 bug 修复",
    wings=["my-project"],
    top_k=5
)

# 返回结果中包含：
# [0.92] my-project/debugging/race-condition-fix
#   "发现是 goroutine 在没有 mutex 的情况下并发写入 map，
#    改用 sync.RWMutex + 分片锁后问题解决。具体修改在
#    pkg/cache/shard.go 第 47 行..."

# Claude Code 基于检索结果回答：
# "你上次遇到的是 goroutine 并发写入 map 导致的 race condition。
#  修复方案是在 pkg/cache/shard.go 第 47 行改用了 sync.RWMutex
#  加分片锁。需要我看下当前代码有没有类似问题吗？"

五、高级特性深度剖析

5.1 AAAK 压缩：有损但实用的 Token 节省方案

AAAK（Adaptive Asymmetric Adaptive K-compression）是 MemPalace 的压缩算法，声称"30 倍压缩"。实话说，这个说法有水分——它是有损压缩，不是"无损"。

AAAK 的工作原理：

# AAAK 压缩流程（简化）
def aaak_compress(drawers: list[Drawer]) -> list[CompressedDrawer]:
    # 第一步：实体对齐
    # 识别重复出现的实体，建立统一 ID
    entity_map = align_entities(drawers)

    # 第二步：关系去重
    # 多个 Drawer 中的相同关系只保留一份
    unique_relations = deduplicate_relations(drawers, entity_map)

    # 第三步：模板化压缩
    # 把相似结构的内容压缩为模板 + 参数
    # 例如：
    # 原文1: "Alice 负责 auth 团队，使用 Rust 和 PostgreSQL"
    # 原文2: "Bob 负责 payment 团队，使用 Go 和 MySQL"
    # 压缩后: 模板 "[NAME] 负责 [TEAM] 团队，使用 [LANG1] 和 [DB1]"
    #          参数: [(Alice, auth, Rust, PostgreSQL), (Bob, payment, Go, MySQL)]
    templates = extract_templates(drawers)

    return [CompressedDrawer(t, p) for t, p in templates]

什么时候 AAAK 有效？

• 大量重复实体的场景（比如多个对话都提到了相同的 10 个微服务）
• 长文档中的表格和列表数据
• 知识库条目

什么时候 AAAK 不划算？

• 短文本（压缩后可能比原文还长）
• 高度独特的叙述性内容（无法模板化）
• 对精确性要求极高的场景（压缩会丢失细节）

在 LongMemEval 基准上，AAAK 模式的 R@5 是 84.2%，低于 Raw 模式的 96.6%。这就是取舍。

5.2 Hallway 与 Tunnel：知识图谱的双层关联

这是 v3.3.4+ 引入的重要特性，解决了"跨项目知识孤岛"问题。

Hallway（同翼走廊）

• 同一 Wing 内的实体共现关系图
• 用 Hebbian 学习法则维护：一起被检索到的实体，连接权重增强
• 用 Ebbinghaus 遗忘曲线衰减：长时间不被触发的连接，权重逐渐降低

# Hallway 的 Hebbian 增强实现
class HallwayGraph:
    def potentiate(self, entity_a: str, entity_b: str, strength: float = 0.1):
        """当两个实体在同一检索结果中出现时，增强它们的连接"""
        edge = self.get_edge(entity_a, entity_b)
        if edge is None:
            self.add_edge(entity_a, entity_b, weight=strength)
        else:
            # Hebbian 规则：权重增量与当前激活强度成正比
            edge.weight += strength * (1.0 - edge.weight)  # 饱和增长

    def decay(self, decay_rate: float = 0.01):
        """Ebbinghaus 遗忘：定期衰减所有连接权重"""
        for edge in self.all_edges():
            edge.weight *= (1.0 - decay_rate)
            if edge.weight < 0.01:
                self.remove_edge(edge)  # 低于阈值则剪枝

Tunnel（跨翼隧道）

• 跨 Wing 的主题关联
• 当不同 Wing 的 Hallway 中出现高度相似的实体对时，自动升级为 Tunnel
• 比如 work-project 里的 "Docker + K8s" 和 side-project 里的 "Docker + Compose"，会生成一条跨翼隧道

# Tunnel 的自动发现逻辑
class TunnelManager:
    def discover_tunnels(self, palace: Palace, similarity_threshold: float = 0.85):
        """扫描所有 Wing 的 Hallway，发现跨翼关联"""
        wings = palace.all_wings()
        for wing_a, wing_b in combinations(wings, 2):
            hallway_a = palace.get_hallway(wing_a)
            hallway_b = palace.get_hallway(wing_b)

            # 找到两个 Wing 共有的实体
            shared_entities = set(hallway_a.entities) & set(hallway_b.entities)

            for entity in shared_entities:
                # 检查该实体在两个 Wing 中的邻居是否语义相似
                neighbors_a = hallway_a.get_neighbors(entity)
                neighbors_b = hallway_b.get_neighbors(entity)

                for na, nb in product(neighbors_a, neighbors_b):
                    sim = cosine_similarity(
                        palace.embed(na.name),
                        palace.embed(nb.name)
                    )
                    if sim > similarity_threshold:
                        self.create_tunnel(
                            source=f"{wing_a}:{entity}→{na}",
                            target=f"{wing_b}:{entity}→{nb}",
                            similarity=sim
                        )

5.3 Hooks 自动保存：无缝集成 Claude Code

MemPalace 提供了 Claude Code 的 Hooks 机制，可以在对话过程中自动保存关键内容，无需手动操作。

// .claude/hooks.json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "command": "mempalace hook --event post-tool-use --file $CLAUDE_FILE_PATH --content $CLAUDE_TOOL_OUTPUT"
      }
    ],
    "Stop": [
      {
        "matcher": "",
        "command": "mempalace hook --event stop --session $CLAUDE_SESSION_ID"
      }
    ],
    "PreCompact": [
      {
        "matcher": "",
        "command": "mempalace hook --event pre-compact --session $CLAUDE_SESSION_ID --content $CLAUDE_CONTEXT"
      }
    ]
  }
}

这段配置做了三件事：

1. PostToolUse：每次 Claude Code 写入/编辑文件后，自动将操作记录存入 MemPalace
2. Stop：对话结束时，自动保存会话摘要
3. PreCompact：上下文压缩前，把即将被丢弃的内容存入 MemPalace——这是最关键的，防止压缩导致记忆丢失

5.4 Office 文档挖掘（v3.3.6 新增）

v3.3.6 增加了对 Office 文档（.docx, .xlsx, .pptx）的原生支持：

# 挖掘 Office 文档
mempalace mine --source files --path ./docs/ --mode extract

# extract 模式会：
# 1. 解压 Office 文档（本质是 ZIP 包）
# 2. 提取文本内容和元数据
# 3. 保留虚拟行号（Virtual Line Numbers），方便引用
# 4. 识别表格结构和图表标题

六、生产级部署指南

6.1 Docker 部署

# docker-compose.yml
version: '3.8'

services:
  mempalace:
    image: mempalace/mempalace:3.3.6
    ports:
      - "8765:8765"     # MCP Server 端口
      - "8766:8766"     # Web UI 端口
    volumes:
      - ./palace-data:/data     # 宫殿数据持久化
      - ./config.yaml:/app/config.yaml
    environment:
      - MEMPALACE_EMBEDDING_PROVIDER=ollama
      - MEMPALACE_EMBEDDING_MODEL=embeddinggemma
      - MEMPALACE_AUTO_SAVE=true
    depends_on:
      - ollama

  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama-data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]   # GPU 加速 Embedding 计算

volumes:
  ollama-data:

6.2 性能调优

ChromaDB HNSW 参数调优：

# config.yaml
chromadb:
  # M 参数：HNSW 图的连接数
  # 越大 → 召回率越高、内存越多、构建越慢
  # 推荐：64（默认）或 128（高精度场景）
  hnsw_m: 64

  # construction_ef：构建时的搜索深度
  # 越大 → 索引质量越好、构建越慢
  # 推荐：256（默认）或 512（大规模宫殿）
  construction_ef: 256

  # search_ef：查询时的搜索深度
  # 越大 → 查询越准、查询越慢
  # 推荐：128（快速）或 256（精准）
  search_ef: 128

存储空间估算：

一个中等活跃的开发者，6 个月的对话数据大约：

6.3 备份与恢复

# 全量备份
mempalace backup --output ./backups/palace-$(date +%Y%m%d).tar.gz

# 从备份恢复
mempalace restore --input ./backups/palace-20260615.tar.gz

# 紧急修复（ChromaDB 损坏时）
mempalace repair --mode from-sqlite
# 从 SQLite 重建 ChromaDB 索引，比从原始文件重新 mine 快 10 倍

# 修复特定 Wing
mempalace repair --wing my-project --mode legacy

6.4 已知问题与 workaround

问题 1：ChromaDB HNSW 段写入损坏

症状：Internal error: Error finding id after a big mine

原因：ChromaDB 的 HNSW 段写入器在并发写入时可能损坏索引

解决方案：

# 方法一：从 SQLite 恢复
mempalace repair --mode from-sqlite

# 方法二：旧模式修复（不调用 Collection.count()）
mempalace repair --mode legacy

# 预防：设置写入互斥
mempalace config set write_mutex true

问题 2：Windows 路径问题

症状：Hooks 的 bash wrapper 乱码路径，导致 Stop/PreCompact hooks 失败

Workaround：

# Windows 用户使用 bat 包装器
mempalace_mcp.bat
start_mempalace.bat

问题 3：大规模宫殿的冷加载

症状：status 命令耗时 60 秒以上

原因：v3.3.6 的 status 命令会加载 HNSW 向量索引仅仅为了统计 Drawer 数量

Workaround：

# 使用轻量级统计（不加载向量索引）
mempalace stats --quick

# 或者从 SQLite 直接查询
sqlite3 ~/.mempalace/palaces/my-dev-palace/sqlite.db \
  "SELECT wing, COUNT(*) FROM drawers GROUP BY wing"

七、MemPalace vs 竞品：真实对比

7.1 与 Mem0 的对比

7.2 与 OpenClaw 内建记忆的对比

但需要注意：OpenClaw 的内建记忆对于大多数个人用户已经够用。MemPalace 的价值主要体现在：

• 6 个月以上的长期积累
• 多项目并行开发
• 需要跨项目知识关联
• 对 Token 成本敏感

八、MemPalace + OpenClaw 集成实战

8.1 互补架构

用户输入
    │
    ├── OpenClaw 内建记忆（MEMORY.md）
    │   └── 核心身份、偏好、活跃项目信息
    │       始终加载，体积小，速度快
    │
    └── MemPalace MCP（按需检索）
        └── 历史决策、调试记录、跨项目关联
            按需加载，体积大，精度高

最佳实践：

• MEMORY.md 存当前活跃的信息（< 2000 字）
• MemPalace 存历史和深度信息（无上限）
• 每次对话优先读 MEMORY.md，需要时再查 MemPalace

8.2 自动同步 MEMORY.md 到 MemPalace

# hooks/openclaw_memory_sync.py
# 每次 MEMORY.md 变更时，自动同步到 MemPalace

import os
from mempalace import Palace

palace = Palace.open("my-dev-palace")

def sync_memory_md(memory_path: str = "~/.qclaw/workspace/MEMORY.md"):
    """将 MEMORY.md 的内容同步到 MemPalace"""
    path = os.path.expanduser(memory_path)
    if not os.path.exists(path):
        return

    with open(path, "r") as f:
        content = f.read()

    palace.store(
        content=content,
        wing="personal",
        hall="preferences",
        room="memory-md-snapshot",
        entities=["MEMORY.md"],  # 标记来源
        source="auto_sync",
        tags=["snapshot", "auto"]
    )

if __name__ == "__main__":
    sync_memory_md()

九、Benchmark 解读：96.6% 背后的真相

MemPalace 在 LongMemEval 上跑出了 96.6% R@5 的成绩，这个数字需要仔细解读。

9.1 LongMemEval 是什么？

LongMemEval 是一个评估 AI 长期记忆系统的基准测试，包含多会话场景下的记忆召回任务。核心指标是 Recall@5（R@5）：在返回的 Top-5 结果中，有多少比例包含了正确答案。

9.2 不同模式的表现

关键发现：

1. Raw 模式已经足够好：96.6% 的 R@5 意味着 Top-5 结果中几乎一定有你要的答案
2. AAAK 压缩有代价：84.2% 意味着约 15% 的情况下 Top-5 会漏掉正确答案
3. 100% 是幻觉：它需要额外的 LLM API 调用做重排序，成本不实际

9.3 与竞品的公平对比

MemPalace 选择不与 Mem0、Mastra、Hindsight 等做直接对比，理由是"它们用不同的指标和数据集"。这个说法有一定道理——但也不排除是避开了不利对比。

根据社区测试，大致排序：

精度：MemPalace (Raw) > Mem0 > 纯向量搜索 > 关键词搜索
成本：关键词搜索 < 纯向量搜索 < Mem0 < MemPalace (Raw)

十、局限性与适用性分析

10.1 MemPalace 不适合的场景

1. 轻度 AI 用户：如果你只是偶尔用 Claude Code 做些小任务，MEMORY.md 就够了，MemPalace 是过度工程

2. 需要实时记忆的场景：MemPalace 的写入是异步的，不能保证写入后立即可查。如果需要"写入即查"的实时性，不如用 Redis + 简单 KV

3. 严格合规环境：虽然本地优先，但 ChromaDB 的加密和审计能力不如企业级数据库。SOC2 合规场景需要额外处理

4. 多租户场景：MemPalace 设计为个人工具，多用户隔离需要额外的权限层

10.2 社区争议

争议一：明星效应是否掩盖了技术问题？

Milla Jovovich 的参与确实带来了巨大关注，但也导致一些技术问题被忽视。早期 README 中的"30 倍无损压缩"说法后来被证伪，团队承认 AAAK 是有损压缩。这种营销话术在技术社区引发了不少批评。

争议二：是否重复造轮子？

已有 Mem0、MemGPT 等成熟方案，MemPalace 的差异化是否足够？从架构上看，原话存储确实是不同的设计哲学，但最终用户可能更关心效果而非哲学。

争议三：ChromaDB 的稳定性

社区 Issue 中有大量 ChromaDB 相关的 bug 报告（HNSW 损坏、冷加载慢等），说明 ChromaDB 可能不是最好的向量数据库选择。未来可能需要支持 Qdrant、Milvus 等更成熟的方案。

十一、未来展望

MemPalace 的 ROADMAP 中有几个值得期待的方向：

1. 可配置 Embedding 模型（v3.3.6 已部分支持）：允许用户选择不同大小和语言的 Embedding 模型

2. TurboVec 存储后端：社区提出的独立向量数据库库，可能替代 ChromaDB

3. 多模态记忆：支持图像、音频等非文本内容的存储和检索

4. 协作模式：团队共享宫殿，支持权限控制和审计日志

5. 主动回忆：AI Agent 在对话中主动检索相关记忆，而非被动等待查询

十二、总结

MemPalace 的核心贡献不是技术突破，而是设计哲学的转变：

不要让 AI 决定什么值得记住，全部存下来，让检索来解决问题。

这个哲学在 Token 成本持续下降、磁盘成本几乎可忽略的趋势下，越来越有道理。当你不再需要为"存储什么"做取舍时，记忆系统的设计就从"压缩问题"变成了"检索问题"——而检索问题，我们有成熟方案。

适合你吗？

• 如果你每天用 AI 编程工具超过 2 小时 → 值得尝试
• 如果你有多项目并行的需求 → 强烈推荐
• 如果你只是偶尔用用 → MEMORY.md 够了
• 如果你对数据隐私有严格要求 → 本地优先的设计适合你

快速开始：

pip install mempalace && mempalace init
claude mcp add mempalace -- python -m mempalace.mcp_server

三条命令，你的 AI 就有了记忆宫殿。

项目地址：https://github.com/MemPalace/mempalace
文档：https://mempalaceofficial.com
许可证：MIT
当前版本：v3.3.6（2026-05-24）