狂揽55000+ Star！MemPalace：当好莱坞女星联手 Claude Code 打造 AI 记忆宫殿——从零 LLM 写路径到 4 层渐进加载的生产级完全指南（2026）

引言：AI 的「失忆症」终于有了根治方案

你有没有过这样的体验：跟 Claude Code 聊了一下午的技术方案，关掉窗口，第二天重新打开，它就像失忆了一样——完全不记得昨天讨论的架构决策、你偏好的代码风格、项目的历史背景。一切从零开始，你被迫反复「补习」上下文。

这不是 bug，这是 LLM 的本质特征：无状态。每次对话都是独立的，模型本身不携带任何跨会话记忆。对偶尔使用 AI 的用户来说，这不过是个小麻烦。但对于每天重度依赖 AI 编程助手的开发者来说，这个问题的时间成本是惊人的——独立开发者每月因重建上下文而白白损失 200-600 欧元的时间价值。

2026 年 4 月，一个让人意外的项目横空出世：MemPalace。它用 2000 年前古希腊演说家发明的「记忆宫殿」技法，为 AI 构建了一套完整的持久化记忆系统。更戏剧化的是，这个项目的联合创始人竟然是好莱坞动作女星米拉·乔沃维奇——对，就是《生化危机》里打丧尸的 Alice。她没有技术背景，但凭着一腔对现有 AI 记忆方案的愤怒，借助 Claude Code 用数月时间从零构建了这个项目。

发布 48 小时内狂揽 22000 Star，如今已突破 55000 Star，成为 2026 年最受关注的 AI 基础设施项目之一。

本文将从架构设计、核心原理、代码实战、性能优化、竞品对比五个维度，带你完整理解 MemPalace 的技术内核。

一、为什么 AI 需要记忆系统？

1.1 LLM 无状态困境的三个层次

第一层：会话级失忆

每次新会话，LLM 对你一无所知。即使你昨天花了 3 小时跟它讨论微服务架构的细节，今天它只会给出通用建议。

# 传统 LLM 会话：每次都是全新开始
session_1 = llm.chat("帮我设计一个订单系统")  # 讨论了 saga 模式
session_2 = llm.chat("继续昨天的设计")        # 完全不知道你昨天说了什么

第二层：上下文窗口限制

即使在单次会话内，上下文窗口也是有限的。Claude 的 200K 上下文、GPT-4 的 128K 看似很大，但长对话很快就会被填满，旧信息被截断丢失。

第三层：成本与延迟

通过在每次对话中注入历史摘要来「模拟记忆」是常见的变通方案，但这意味着每个 Token 都要付钱，而且上下文越长、响应越慢、成本越高。

1.2 现有方案的痛点

MemPalace 的回答很直接：本地优先、零 LLM 写路径、空间结构化组织。

二、核心架构：记忆宫殿的空间隐喻

2.1 从古希腊到 AI：Method of Loci 的数字转译

记忆宫殿（Method of Loci）是一种古老的记忆术：古希腊演说家将要记住的内容「放置」在想象的建筑空间中——客厅放政治、书房放哲学、卧室放军事。回忆时，在脑中漫步这座宫殿，走到对应房间就能唤起记忆。

现代神经科学已经证实：这种空间编码会激活海马体的位置细胞系统，建立比纯文本更稳固的记忆关联。

MemPalace 将这套 2000 年的空间隐喻转译为 AI 记忆架构：

记忆宫殿（Palace）
└── 翼廊（Wing）         ← 顶层：一个人 / 一个项目 / 一个主题
    └── 房间（Room）      ← 二层：具体话题（auth, billing, 架构设计）
        └── 走廊（Hall）  ← 三层：记忆类型分类
            │ facts       （事实：项目使用 TypeScript）
            │ events      （事件：上周部署了 v2.0）
            │ decisions   （决策：选择了 PostgreSQL 而非 MongoDB）
            │ preferences（偏好：喜欢函数式风格）
            │ emotional   （情感：对这个 deadline 很焦虑）
            ├── 抽屉（Drawer）  ← 原文逐字存储（800 字符块）
            └── 壁橱（Closet）  ← AAAK 压缩摘要版本

隧道（Tunnel）  ← 跨翼廊连接通路（相同 Room 名的快速导航）

这不仅仅是个花哨的比喻。这种分层结构解决了实际工程问题：

• Wing 隔离：不同项目/用户的记忆完全隔离，互不干扰
• Room 聚类：相关话题自动聚合，语义检索更精准
• Hall 分类：区分事实、事件、决策等类型，避免混淆
• Drawer + Closet 双层：原文保存 + 压缩摘要，兼顾精度与效率

2.2 4 层渐进式加载：170 Token 启动完整记忆系统

这是 MemPalace 最精妙的工程设计。传统方案要么全量加载（Token 浪费），要么完全不加（零记忆）。MemPalace 采用了渐进式按需加载：

L0：身份文件（约 50-100 Token）
    "我是谁，我在哪个项目上工作"
    ↓ 对话需要更多上下文时

L1：重要度排名前 15 条记忆（约 500-800 Token）
    最近的决策、关键偏好、重要事实
    ↓ 需要深入某个话题时

L2：当前翼廊/房间范围的语义召回
    当前项目相关的记忆，通过向量检索获取
    ↓ 需要全局搜索时

L3：全量语义搜索（无上限）
    跨所有翼廊的全库检索

为什么这个设计很重要？

大多数 AI 对话其实只需要极少的记忆就能正常工作。你跟 AI 聊今天的 bug 修复，它只需要知道项目名称和当前技术栈就够了——不需要加载去年讨论过的架构历史。只有当你主动问「我们之前是怎么设计认证模块的？」时，才需要深入到 L2 层检索。

实际效果：日常对话只消耗 50-100 Token 的记忆成本，对比全量注入历史摘要可能消耗 5000+ Token，成本降低 50-100 倍。

2.3 零 LLM 写路径：存储时不花一分钱

传统 AI 记忆系统的工作流：

用户说了什么 → 调用 LLM 提取关键信息 → 生成摘要 → 存储
                ↑ 花钱 + 慢 + 依赖网络

MemPalace 的写路径：

用户内容 → 正则规则 + 关键词评分 → 自动分类到 Wing/Room/Hall
         → 原文切块（800 字符 + 100 字符重叠）→ ChromaDB
         ↑ 完全本地，零 API 调用，零成本

核心思路：记忆存储是一个纯工程问题，不需要 AI 参与。用正则表达式做基础分类，用 Embedding 模型做向量化（本地运行，无需 API），用规则引擎做优先级排序。

只有记忆的读取和消费才需要 LLM，而这部分成本由 4 层渐进加载来控制。

三、代码实战：从安装到深度集成

3.1 快速安装与初始化

# 安装
pip install mempalace

# 初始化项目记忆宫殿
mempalace init ~/projects/myapp

# 扫描并导入项目文件
mempalace mine ~/projects/myapp

# 查看记忆宫殿结构
mempalace status

# 语义搜索
mempalace search "认证方案"

# 生成当前上下文摘要（适合粘贴到 AI 对话开头）
mempalace wake-up > context.txt

mempalace init 会创建如下目录结构：

~/.mempalace/
├── palaces/
│   └── myapp/
│       ├── palace.json          # 宫殿配置
│       ├── wings/
│       │   ├── project.json     # 项目翼廊
│       │   ├── personal.json    # 个人翼廊
│       │   └── decisions.json   # 决策翼廊
│       ├── rooms/
│       │   ├── auth/
│       │   ├── billing/
│       │   ├── architecture/
│       │   └── general/
│       └── drawers/             # 原文存储（ChromaDB）
├── knowledge_graph.db          # SQLite 知识图谱
└── config.yaml                 # 全局配置

3.2 项目挖掘（mine）深度解析

mempalace mine 是批量导入项目知识的入口。它按四优先级规则自动分类：

# 源码简化版：mempalace mine 的核心分类逻辑
import os
import re
from pathlib import Path

# 优先级 1：文件夹名映射
FOLDER_ROOM_MAP = {
    'auth': 'auth', 'authentication': 'auth',
    'billing': 'billing', 'payment': 'billing',
    'api': 'api', 'routes': 'api',
    'config': 'config', 'settings': 'config',
    'middleware': 'middleware',
    'models': 'models', 'schemas': 'schemas',
    'services': 'services',
    'utils': 'utils', 'helpers': 'utils',
}

# 优先级 2：文件名关键词映射
FILE_KEYWORDS = {
    'billing': ['invoice', 'payment', 'pricing', 'subscription'],
    'auth': ['login', 'register', 'jwt', 'token', 'session', 'oauth'],
    'config': ['config', 'setting', 'env', 'deploy'],
    'architecture': ['architecture', 'design', 'system', 'overview'],
}

# 优先级 3：内容关键词评分
CONTENT_KEYWORDS = {
    'auth': ['JWT', 'OAuth', 'bcrypt', 'session', 'token'],
    'billing': ['Stripe', 'invoice', 'payment', 'pricing'],
    'database': ['SQL', 'PostgreSQL', 'Redis', 'migration'],
    'testing': ['test', 'spec', 'coverage', 'jest', 'pytest'],
}

def classify_file(filepath: Path, content: str) -> str:
    """四优先级分类"""
    # 优先级 1：父文件夹名
    for parent in filepath.parents:
        if parent.name in FOLDER_ROOM_MAP:
            return FOLDER_ROOM_MAP[parent.name]

    # 优先级 2：文件名匹配
    for room, keywords in FILE_KEYWORDS.items():
        if any(kw in filepath.stem.lower() for kw in keywords):
            return room

    # 优先级 3：内容关键词评分
    scores = {}
    for room, keywords in CONTENT_KEYWORDS.items():
        scores[room] = sum(
            content.lower().count(kw.lower()) for kw in keywords
        )
    best = max(scores, key=scores.get)
    if scores[best] > 0:
        return best

    # 优先级 4：默认
    return 'general'

def mine_project(project_path: str):
    """扫描项目目录，自动分类并存储记忆"""
    project = Path(project_path)
    for filepath in project.rglob('*.md'):
        if '.git' in filepath.parts or 'node_modules' in filepath.parts:
            continue
        content = filepath.read_text(encoding='utf-8')
        room = classify_file(filepath, content)
        # 切块存储（800 字符 + 100 字符重叠）
        chunks = chunk_text(content, chunk_size=800, overlap=100)
        for chunk in chunks:
            store_drawer(room=room, content=chunk, source=str(filepath))

def chunk_text(text: str, chunk_size: int = 800, overlap: int = 100) -> list:
    """带重叠的文本切块"""
    chunks = []
    start = 0
    while start < len(text):
        chunk = text[start:start + chunk_size]
        chunks.append(chunk)
        start += chunk_size - overlap
    return chunks

3.3 MCP 集成 Claude Code：29 个工具详解

MemPalace 通过 MCP（Model Context Protocol）协议与 Claude Code 深度集成，提供 29 个工具：

# 一键添加 MCP 服务器到 Claude Code
claude mcp add mempalace -- python -m mempalace.mcp_server

工具分类与关键 API：

// 记忆宫殿导航工具
navigate_to_wing(wing: string)          // 切换到指定翼廊
navigate_to_room(room: string)          // 切换到指定房间
tunnel_jump(room: string, wing?: string) // 跨翼廊隧道跳转
list_wings()                            // 列出所有翼廊
list_rooms(wing: string)                // 列出翼廊下所有房间

// 记忆读写工具
store_memory(content: string, room?: string, hall?: string, importance?: number)
retrieve_memory(query: string, max_results?: number)
search_across_palace(query: string, wings?: string[], max_results?: number)

// 知识图谱工具
add_entity(subject: string, predicate: string, object: string, valid_from?: string, valid_to?: string)
query_relationships(entity: string, depth?: number)
update_fact(subject: string, predicate: string, new_object: string)

// 记忆管理工具
forget_memory(memory_id: string)        // 删除指定记忆
merge_memories(memory_ids: string[])   // 合并多条记忆
set_importance(memory_id: string, level: number) // 设置重要度

// 智能体日记工具
start_diary_session(agent_name: string)
append_diary_entry(entry: string)
query_diary(agent_name: string, query: string)

// 自动钩子
auto_compact_on_session_end()           // 会话结束时自动压缩
auto_extract_on_pre_compaction()        // 上下文压缩前自动提取

3.4 实战：用 MemPalace 构建项目级记忆

假设你有一个 Node.js 后端项目，现在要给 Claude Code 配置持久化记忆：

# 步骤 1：初始化
cd ~/projects/my-saas-app
mempalace init .

# 步骤 2：挖掘项目知识
mempalace mine . --include "*.md,*.ts,*.json" --exclude "node_modules,.git,dist"

# 步骤 3：查看自动分类结果
mempalace status
# 输出示例：
# Palace: my-saas-app
# ├── Wing: project (12 rooms, 156 memories)
# │   ├── Room: auth (23 memories, importance: high)
# │   ├── Room: billing (18 memories, importance: high)
# │   ├── Room: api (31 memories, importance: medium)
# │   ├── Room: database (15 memories, importance: high)
# │   └── Room: general (69 memories, importance: low)
# └── Wing: personal (3 rooms, 42 memories)
#     ├── Room: preferences (12 memories)
#     ├── Room: decisions (18 memories)
#     └── Room: emotional (12 memories)

# 步骤 4：手动修正分类（可选）
mempalace move --memory-id mem_abc123 --room "architecture"

# 步骤 5：添加手动记忆
mempalace remember "项目决定使用 tRPC 替代 REST API，因为类型安全对全栈开发至关重要" \
    --room "decisions" --hall "decisions" --importance 9

# 步骤 6：测试语义检索
mempalace search "我们用什么做 API 通信"
# 匹配到：
# [0.94] decisions/tRPC替代REST: "项目决定使用 tRPC..."
# [0.87] api/route-structure: "API 路由结构..."

# 步骤 7：配置 Claude Code MCP
claude mcp add mempalace -- python -m mempalace.mcp_server

配置完成后，Claude Code 在每次对话中会自动感知你的项目记忆：

你：继续上次讨论的支付模块重构

Claude Code（内部 MCP 调用）：
→ navigate_to_wing("project")
→ navigate_to_room("billing")
→ retrieve_memory("支付模块重构", max_results=5)
→ [L2 层加载：billing 房间相关记忆]

Claude Code：好的，根据记忆，我们上次讨论了将 Stripe
集成从同步改为异步队列处理的方案。你当时提到了三个
关键决策点...

3.5 wake-up 机制：170 Token 冷启动

# 生成上下文摘要
mempalace wake-up

# 输出示例（实际 Token 消耗约 170）：
# [MemPalace Active] Palace: my-saas-app | Wing: project
# Key Facts: TypeScript, PostgreSQL, Docker, tRPC
# Recent Decisions: (1) tRPC over REST [Jun 12] (2) Redis cache for sessions [Jun 10]
# Active Rooms: auth(23), billing(18), api(31)
# Load more: ask about specific topics

这个摘要可以被自动注入到 Claude Code 的系统提示中，让 AI 在不消耗大量 Token 的前提下快速「进入状态」。

四、核心组件深度解析

4.1 AAAK 压缩格式：Agent 可读的摘要

AAAK（Agent Accessible Abbreviated Knowledge）是 MemPalace 独创的记忆压缩格式。设计理念很独特：不是为人类读的，也不是二进制压缩，而是为 LLM 原生可读的结构化缩写。

原始文本（Drawers 存储）：
"The authentication module uses JWT tokens with a 24-hour expiration.
 Refresh tokens are stored in Redis with a 30-day TTL.
 Password reset flow uses bcrypt with 12 rounds of hashing."

AAAK 压缩（Closets 存储）：
"auth: JWT 24h exp; rfsh: Redis 30d; pwd: bcrypt r12"

核心规则：

• 移除冠词、介词等语法填充词
• 保留领域术语（JWT、Redis、bcrypt）
• 缩写常见词（expiration → exp, refresh → rfsh）
• 保留数值和单位（24h、30d、r12）

# AAAK 压缩器简化实现
import re

STOPWORDS = {'the', 'a', 'an', 'is', 'are', 'was', 'were', 'in', 'on',
             'at', 'to', 'for', 'with', 'and', 'or', 'but', 'of', 'from'}

ABBREVIATIONS = {
    'expiration': 'exp', 'configuration': 'config', 'authentication': 'auth',
    'authorization': 'authz', 'database': 'db', 'application': 'app',
    'response': 'resp', 'request': 'req', 'function': 'fn',
    'module': 'mod', 'service': 'svc', 'controller': 'ctrl',
}

def aaak_compress(text: str, max_chars: int = 55) -> str:
    """AAAK 压缩：保留语义核心，最大化信息密度"""
    # 1. 移除停用词
    words = text.split()
    filtered = [w for w in words if w.lower() not in STOPWORDS]
    
    # 2. 缩写常见词
    abbreviated = []
    for word in filtered:
        clean = re.sub(r'[.,;:!?]', '', word.lower())
        abbreviated.append(ABBREVIATIONS.get(clean, word))
    
    # 3. 重组为紧凑格式
    compressed = ' '.join(abbreviated)
    
    # 4. 硬截断（这是争议点之一）
    return compressed[:max_chars]

# 实测
text = "The authentication module uses JWT tokens with a 24-hour expiration"
print(aaak_compress(text))
# 输出: "authentication module uses JWT tokens 24-hour expiration"
# （实际实现更复杂，这里只是简化版）

争议点：AAAK 使用 55 字符硬截断，这在独立评测中被发现会导致 12.4% 的检索质量下降。团队后来承认了这个问题，并在后续版本中引入了语义边界感知截断。

4.2 时序知识图谱：带有效期的记忆

这是 MemPalace 中最被低估的设计细节：

-- 知识图谱核心表结构
CREATE TABLE knowledge_graph (
    subject    TEXT,           -- 主体：项目、模块、人
    predicate  TEXT,           -- 关系：使用、依赖、偏好
    object     TEXT,           -- 客体：TypeScript、PostgreSQL
    valid_from TEXT,           -- 生效时间（ISO 8601）
    valid_to   TEXT,           -- 失效时间（NULL 表示永久有效）
    wing       TEXT,           -- 所属翼廊
    confidence REAL DEFAULT 1.0 -- 置信度
);

-- 示例数据：
-- ('项目', '使用语言', 'TypeScript', '2026-01-01', NULL, 'myapp', 1.0)
-- ('部署', '使用平台', 'Vercel', '2026-01-01', '2026-03-15', 'myapp', 1.0)
--   ↑ 已过期！2026-03-15 后项目迁移到 AWS
-- ('部署', '使用平台', 'AWS', '2026-03-15', NULL, 'myapp', 1.0)
-- ('数据库', '使用引擎', 'PostgreSQL', '2026-01-01', NULL, 'myapp', 0.95)

为什么这个设计如此关键？

大多数 AI 记忆系统的一个致命缺陷：记忆只会增加，不会过期。三个月前你记录的「项目用 Vercel 部署」在你迁移到 AWS 之后还在污染 AI 的上下文。AI 可能会基于过时信息做出错误建议。

MemPalace 的有效期机制确保了：

def query_knowledge(subject: str, predicate: str, now: str = None):
    """查询当前有效的知识"""
    now = now or datetime.utcnow().isoformat()
    return db.execute("""
        SELECT object, confidence 
        FROM knowledge_graph 
        WHERE subject = ? AND predicate = ?
          AND valid_from <= ? 
          AND (valid_to IS NULL OR valid_to > ?)
        ORDER BY confidence DESC
    """, (subject, predicate, now, now))

# 查询：项目当前用什么部署？
results = query_knowledge("项目", "使用平台")
# 返回: [('AWS', 1.0)]  -- Vercel 已过期，不会返回

4.3 向量存储层：ChromaDB 集成

# MemPalace 的向量存储核心逻辑（简化版）
import chromadb
from sentence_transformers import SentenceTransformer

class MemoryStore:
    def __init__(self, persist_dir: str):
        self.client = chromadb.PersistentClient(path=persist_dir)
        self.model = SentenceTransformer('all-MiniLM-L6-v2')  # 本地 Embedding
        
    def store(self, room: str, content: str, metadata: dict):
        """存储记忆到向量数据库"""
        embedding = self.model.encode(content)
        collection = self.client.get_or_create_collection(
            name=f"room_{room}",
            metadata={"hnsw:space": "cosine"}
        )
        collection.add(
            embeddings=[embedding.tolist()],
            documents=[content],
            metadatas=[metadata],  # wing, room, hall, source, timestamp
            ids=[metadata['memory_id']]
        )
    
    def search(self, room: str, query: str, n_results: int = 5):
        """语义搜索"""
        embedding = self.model.encode(query)
        collection = self.client.get_collection(f"room_{room}")
        results = collection.query(
            query_embeddings=[embedding.tolist()],
            n_results=n_results,
            where={"hall": {"$ne": "emotional"}}  # 默认排除情感记忆
        )
        return results
    
    def search_global(self, query: str, wings: list = None, n_results: int = 10):
        """跨翼廊全局搜索（L3 层）"""
        embedding = self.model.encode(query)
        all_results = []
        
        wings = wings or self.list_wings()
        for wing in wings:
            for collection in self.client.list_collections():
                if collection.name.startswith(f"room_"):
                    try:
                        results = collection.query(
                            query_embeddings=[embedding.tolist()],
                            n_results=n_results
                        )
                        all_results.append(results)
                    except Exception:
                        continue
        
        # 按距离排序，返回 top-k
        return self._merge_and_sort(all_results, n_results)

4.4 自动钩子：零人工干预的记忆管理

MemPalace 提供了两个关键的自动钩子：

# 钩子 1：会话结束时自动提取关键信息
class SessionEndHook:
    """Claude Code 会话结束时触发"""
    
    def extract_key_memories(self, conversation: list) -> list:
        """从对话中提取值得记住的关键信息"""
        memories = []
        
        for message in conversation:
            content = message.get('content', '')
            
            # 规则 1：检测决策性语句
            if self._is_decision(content):
                memories.append({
                    'hall': 'decisions',
                    'importance': 8,
                    'content': content,
                    'auto_extracted': True
                })
            
            # 规则 2：检测偏好性语句
            if self._is_preference(content):
                memories.append({
                    'hall': 'preferences',
                    'importance': 6,
                    'content': content,
                    'auto_extracted': True
                })
            
            # 规则 3：检测事实性语句
            if self._is_fact(content):
                memories.append({
                    'hall': 'facts',
                    'importance': 5,
                    'content': content,
                    'auto_extracted': True
                })
        
        return memories
    
    def _is_decision(self, text: str) -> bool:
        """检测决策性语句（正则规则，零 LLM）"""
        patterns = [
            r'我们决定',
            r'选择.*而不是',
            r'go with.*over',
            r'最终方案是',
            r'settled on',
            r'agreed to use',
        ]
        return any(re.search(p, text, re.IGNORECASE) for p in patterns)

# 钩子 2：上下文压缩前自动保存
class PreCompactionHook:
    """Claude Code 上下文即将压缩时触发"""
    
    def save_before_compaction(self, context: str):
        """在上下文被压缩前保存完整版本到记忆宫殿"""
        chunks = chunk_text(context, chunk_size=800, overlap=100)
        for chunk in chunks:
            store_memory(
                content=chunk,
                room='compacted_history',
                hall='events',
                importance=4  # 压缩历史重要度较低
            )

五、性能优化：生产环境调优指南

5.1 向量检索性能优化

# 优化 1：使用量化 Embedding 减少内存
from sentence_transformers import SentenceTransformer

# 标准：384 维 float32（每向量 1.5KB）
standard_model = SentenceTransformer('all-MiniLM-L6-v2')

# 量化：384 维 float16（每向量 768B，内存减半）
# ChromaDB 支持 hnsw 索引的量化配置

# 优化 2：按 Room 分 Collection，缩小检索范围
# 避免 10 万条记忆全量检索
# 通过 Wing → Room → Hall 的层次结构，将检索范围缩小到百级

# 优化 3：重要度预过滤
def search_with_importance_filter(room, query, min_importance=5):
    """只检索高重要度的记忆"""
    embedding = model.encode(query)
    collection = client.get_collection(f"room_{room}")
    results = collection.query(
        query_embeddings=[embedding.tolist()],
        n_results=10,
        where={
            "$and": [
                {"hall": {"$ne": "emotional"}},
                {"importance": {"$gte": min_importance}}
            ]
        }
    )
    return results

5.2 存储空间优化

# 优化 1：Drawer + Closet 双层存储
# Drawer（原文）：完整 800 字符块，用于精确检索
# Closet（AAAK）：55 字符压缩版，用于概览
# 总存储：原文 + 压缩 = 约 1.07 倍，可接受

# 优化 2：自动清理过期记忆
def cleanup_expired_memories():
    """清理过期的低重要度记忆"""
    now = datetime.utcnow()
    
    # 规则 1：超过 90 天且重要度 < 3 的记忆自动归档
    db.execute("""
        DELETE FROM drawers 
        WHERE importance < 3 AND created_at < ?
    """, (now - timedelta(days=90),))
    
    # 规则 2：超过 180 天的情感记忆降权
    db.execute("""
        UPDATE drawers 
        SET importance = importance * 0.5
        WHERE hall = 'emotional' AND created_at < ?
    """, (now - timedelta(days=180),))
    
    # 规则 3：清理无引用的孤立知识图谱节点
    db.execute("""
        DELETE FROM knowledge_graph 
        WHERE subject NOT IN (SELECT DISTINCT subject FROM drawers)
          AND object NOT IN (SELECT DISTINCT content FROM drawers LIMIT 1)
    """)

# 优化 3：ChromaDB 索引重建
def rebuild_index(collection_name: str):
    """当记忆数量增长后重建索引"""
    collection = client.get_collection(collection_name)
    # ChromaDB 使用 HNSW 算法，重建可以优化检索路径
    # 建议在记忆超过 10000 条时执行

5.3 Token 消耗优化策略

# 策略 1：动态 L0 生成
def generate_l0_summary(wing: str) -> str:
    """根据最近活动动态生成 L0 摘要"""
    # 获取最近 7 天的高重要度记忆
    recent = query_memories(
        wing=wing,
        min_importance=7,
        since_days=7,
        limit=5
    )
    
    # 纯规则提取，零 LLM
    facts = [m for m in recent if m.hall == 'facts']
    decisions = [m for m in recent if m.hall == 'decisions']
    
    summary = f"Wing: {wing}\n"
    if facts:
        summary += f"Facts: {'; '.join(f.content[:30] for f in facts)}\n"
    if decisions:
        summary += f"Decisions: {'; '.join(d.content[:40] for d in decisions)}\n"
    
    return summary[:100]  # 强制 100 Token 以内

# 策略 2：选择性 L1 加载
def selective_l1_load(room: str, conversation_topic: str) -> list:
    """根据对话话题选择性加载 L1 记忆"""
    # 不是简单加载 top-15，而是话题相关的 top-15
    topic_embedding = model.encode(conversation_topic)
    
    # 先粗筛 room 范围
    candidates = search(room, conversation_topic, n_results=30)
    
    # 再按重要度 + 相关度综合排序
    scored = []
    for mem in candidates:
        relevance = 1 - mem['distance']
        importance = mem['metadata']['importance'] / 10.0
        scored.append({
            'memory': mem,
            'score': 0.6 * relevance + 0.4 * importance
        })
    
    scored.sort(key=lambda x: x['score'], reverse=True)
    return scored[:15]

六、竞品深度对比

6.1 四大方案横评

6.2 MemPalace 的独特优势

1. 本地优先 = 零隐私风险

你的项目架构、技术决策、代码偏好全部留在本地硬盘。对于涉及商业机密的项目，这一点至关重要。

2. 零写入成本 = 无上限使用

传统方案每条记忆的写入都要调用 LLM（Mem0 企业版月费 $249）。MemPalace 的纯规则写入路径意味着你可以无限制地存储记忆，不用担心账单。

3. 空间隐喻 = 低认知负担

「翼廊/房间/抽屉」的隐喻比「向量空间/嵌入/余弦相似度」对开发者更友好。你不需要理解向量检索的原理就能有效使用它。

4. Claude Code 原生集成 = 开箱即用

29 个 MCP 工具覆盖了所有常见场景，一行命令完成集成。

6.3 需要注意的局限

1. 基准测试争议

宣传的 96.6% LongMemEval 分数，实际上只测了 ChromaDB 原始 Embedding 能力，宫殿空间结构完全没参与。启用全部特性后：

• 开启 Room 检索：89.4%（-7.2%）
• 开启 AAAK 压缩：84.2%（-12.4%）

2. 部分功能未实现

• README 提及的「矛盾检测」在代码中完全没有实现
• 「事实核查」模块存在但未集成进主流程

3. 规则分类的局限性

• 纯正则分类不如 LLM 分类精准
• 对非英语内容的支持有限

4. 团队承认的问题

• AAAK 的 Token 计数用了 len(text)//3 替代真实 Tokenizer
• 55 字符硬截断会导致语义丢失

七、适用场景与最佳实践

7.1 谁最适合使用 MemPalace？

• AI 工具重度用户：每天使用 Claude Code、Cursor 等工具超过 4 小时的开发者
• 独立开发者：没有团队知识库，依赖 AI 做技术决策
• 隐私敏感项目：涉及金融、医疗等领域，不能将数据上传云端
• 多项目并行：同时维护 3+ 个项目，需要快速切换上下文
• AI Agent 开发者：需要为自建 Agent 提供长期记忆基础设施

7.2 最佳实践清单

✅ 使用 mempalace mine 自动导入项目知识
✅ 定期运行 mempalace cleanup 清理过期记忆
✅ 对关键决策手动设置高重要度
✅ 利用 wake-up 机制生成 L0 摘要
✅ 为不同项目使用不同 Wing 隔离
✅ 配置 PreCompactionHook 防止上下文压缩丢失
✅ 定期审查知识图谱中的有效期

❌ 不要全量加载所有记忆到上下文
❌ 不要忽略过期时间设置
❌ 不要在情感记忆中存储技术决策
❌ 不要跳过 mine 后的 status 检查

八、总结与展望

MemPalace 的出现标志着 AI 记忆系统进入了一个新阶段。它不仅仅是一个工具，更是一种设计哲学的体现：

本地优先不是退步，而是回归常识。 在数据隐私和成本敏感的场景下，把记忆存储在本地是比依赖云端更务实的选择。

零 LLM 写路径不是偷懒，而是架构智慧。 不是所有问题都需要 AI 解决——记忆存储是一个纯工程问题，用规则引擎解决既快又省。

空间隐喻不是噱头，而是有效的认知工具。 「翼廊/房间/抽屉」的层次结构降低了用户理解和管