OpenMemory：打造個人 AI 記憶層的開源解決方案

OpenMemory：打造個人 AI 記憶層的開源解決方案
Ian Chou
Ian Chou•

OpenMemory是一個為大型語言模型設計的開源個人記憶層系統，提供私有、可攜帶且完全開源的解決方案。本文深入分析其架構、核心功能及應用場景，探討如何在保持數據隱私的同時實現AI的個性化體驗。

OpenMemoryAI開源記憶管理MCP

實用推薦： 創新的 OpenMemory MCP 讓你將 AI 記憶全部存在本地，然後共享給所有支援 MCP 協議的客戶端。這意味著 Claude、Cursor、Windsurf 等應用都可以讀取相同的記憶內容——您只需維護一份記憶即可。查看相關訊息

快速安裝指南

以下是安裝和使用 OpenMemory 的快速指南：

先決條件

在開始之前，確保您的系統已安裝：

  • Docker Desktop - 執行容器化服務的必要軟體，可從 Docker 官網 下載
  • Git - 用於克隆專案代碼

1. 使用 Git 下載 openmemory 代碼

由於 Git 不支援直接克隆單一子目錄，您需要先克隆整個倉庫：

# 克隆整個倉庫
git clone https://github.com/mem0ai/mem0.git

# 進入 openmemory 目錄
cd mem0/openmemory

2. 在 Windows 下設置和構建

在 Windows 下，您需要使用 WSL (Windows Subsystem for Linux) 進行構建：

# 進入 WSL
wsl

# 構建軟體
make build

3. 設置環境變量

在 C:\Users\[user]\GitHub\mem0\openmemory\api 目錄下：

# 複製環境變量樣本文件
cp .env.example .env

然後打開 .env 文件，加入您的 OpenAI API 金鑰：

OPENAI_API_KEY=sk-...
USER=username  # 這個可以保持預設值

4. 啟動服務

# 啟動 OpenMemory 服務
make up

# 啟動使用者界面
make ui

5. 設置 MCP 客戶端整合

  1. 開啟瀏覽器訪問：http://localhost:3000
  2. 在介面中複製 MCP 服務器安裝指令
  3. 將指令粘貼到終端機中執行
  4. 重啟 Claude Desktop、Cursor 或 Windsurf 等 MCP 客戶端
  5. 現在，您就可以在這些應用中使用 OpenMemory 記憶功能

6. 設置系統登入後自動啟動

為了更方便的使用體驗，您可以設置 OpenMemory 在 Windows 系統啟動時自動啟動：

步驟 1: 確認 WSL 發行版名稱

在 PowerShell 或 CMD 終端機（不是在 WSL 終端機裡）執行：

wsl -l -v

您會看到類似這樣的輸出：

NAME                STATE       VERSION
* Ubuntu-20.04      Running     2
Debian              Stopped      2
kali-linux          Stopped      2

記下您的 WSL 發行版名稱（如 Ubuntu-20.04、Debian 等），帶星號 * 的是預設發行版。

步驟 2: 編寫啟動腳本

在 Windows 上新建一個批處理文件（如 start_openmemory.bat），內容為：

@echo off
wsl -d 您的WSL發行版名稱 -- bash -ic "cd /mnt/c/Users/您的用戶名/GitHub/mem0/openmemory/api && docker-compose up -d"

例如，如果您的 WSL 發行版是 Ubuntu，使用者名為 gogotw，則腳本應為：

@echo off
wsl -d Ubuntu -- bash -ic "cd /mnt/c/Users/gogotw/GitHub/mem0/openmemory/api && docker-compose up -d"

這裡 -d 參數表示以後台模式啟動容器，不會佔用終端機視窗。

步驟 3: 創建計劃任務

  1. 開啟「任務計劃程序」（Task Scheduler），點擊「創建任務」。按下Win+R，輸入taskschd.msc，然後按Enter鍵。
  2. 在「常規」頁簿：
    • 勾選「以最高權限執行」
    • 「配置為」選擇對應的 Windows 版本
  3. 在「觸發器」頁簿：
    • 新建觸發器，選擇「在登入時」觸發
    • 重要：設定延遲啓動時間（如 2-3 分鐘），等待 Docker Desktop 完全啟動
  4. 在「操作」頁簿：
    • 新建操作，程序/腳本填寫您剛剛創建的 start_openmemory.bat 文件的完整路徑
  5. 確定保存

完成上述設置後，每次系統啟動或用戶登入時，OpenMemory 就會自動在後台啟動，無需手動執行命令。

**重要提示：**在關閉電腦前，最好先在 Docker Desktop 中手動關閉 OpenMemory 容器。由於 OpenMemory 包含數據庫，正確地關閉服務可以避免數據損壞。您可以在 Docker Desktop 圖形界面中點擊容器旁的停止按鈕，或在終端機中執行 docker-compose down 命令。

在當今 AI 技術快速發展的時代，個人數據隱私和控制權變得尤為重要。OpenMemory 專案應運而生，為開發者和終端使用者提供了一個安全、可控的方式來管理 AI 與大型語言模型的記憶系統。本文將深入分析 OpenMemory 的架構、功能以及它如何改變 AI 應用的個人化體驗。

什麼是 OpenMemory？

OpenMemory 是一個為大型語言模型（LLMs）設計的個人記憶層，核心理念是讓用戶的記憶資料保存在本地，從而提供完全的數據控制權。它讓 AI 應用能夠擁有個性化記憶的同時，確保用戶數據的安全性不受侵害。

主要特點：

  • 私有性優先：所有記憶數據儲存在本地，不上傳到第三方服務
  • 開源透明：代碼完全開源，任何人都可以審查、貢獻或修改
  • 記憶管理：直觀的界面用於添加、搜索、分類和管理記憶
  • MCP 協議支持：兼容 Memory Context Protocol，易於與 LLMs 集成
  • 向量化搜索：高效的語義搜索能力
  • 訪問控制：細粒度權限系統，控制哪些應用可以訪問哪些記憶

架構概覽

OpenMemory 採用了現代化的前後端分離架構，主要由以下兩個部分組成：

OpenMemory/
├── api/          # 後端 API 和 MCP 服務器
└── ui/           # 前端 React 應用

後端技術棧

後端基於 FastAPI 和 SQLAlchemy 構建，主要模塊包括：

  • FastAPI - 高性能的 Python API 框架
  • SQLAlchemy - ORM 數據庫映射工具
  • Alembic - 數據庫遷移工具
  • Qdrant - 向量數據庫，用於記憶的語義搜索
  • Docker - 容器化部署環境
# app/mcp_server.py - MCP 服務器的核心實現示例
@mcp.tool(description="Search the user's memory for memories that match the query")
async def search_memory(query: str) -> str:
    uid = user_id_var.get(None)
    client_name = client_name_var.get(None)
    
    # 取得記憶嵌入向量
    embeddings = memory_client.embedding_model.embed(query, "search")
    
    # 執行向量搜索
    hits = memory_client.vector_store.client.query_points(
        collection_name=memory_client.vector_store.collection_name,
        query=embeddings,
        query_filter=filters,
        limit=10,
    )
    
    # 處理搜索結果
    memories = hits.points
    memories = [
        {
            "id": memory.id,
            "memory": memory.payload["data"],
            "score": memory.score,
        }
        for memory in memories
    ]
    
    return json.dumps(memories, indent=2)

前端技術棧

前端採用 React 和 Next.js 框架，提供現代化的用戶界面：

  • Next.js - React 框架
  • React 19 - 用戶界面庫
  • Tailwind CSS - 樣式方案
  • Redux Toolkit - 狀態管理
  • React Hook Form - 表單處理
  • Zod - 數據驗證
// ui/app/memories/components/MemoriesSection.tsx 示例
export function MemoriesSection() {
  const { memories, isLoading } = useMemories();
  
  if (isLoading) {
    return <MemoriesLoader />;
  }
  
  return (
    <div className="space-y-4">
      {memories.length === 0 ? (
        <EmptyState 
          title="沒有記憶"
          description="開始添加您的第一個記憶"
          action={<AddMemoryButton />}
        />
      ) : (
        <div className="grid grid-cols-1 gap-4">
          {memories.map(memory => (
            <MemoryCard 
              key={memory.id}
              memory={memory}
              actions={
                <MemoryActions memory={memory} />
              }
            />
          ))}
        </div>
      )}
    </div>
  );
}

核心功能詳解

1. 記憶管理

OpenMemory 提供了全面的記憶管理功能，用戶可以：

  • 添加記憶：記錄任何文本內容作為記憶
  • 分類記憶：自動或手動將記憶分類到不同類別
  • 搜索記憶：通過關鍵詞或語義相似性查找記憶
  • 查看記錄：追蹤記憶的訪問歷史和使用情況
# api/app/routers/memories.py - 記憶管理的核心路由
@router.post("/")
async def create_memory(
    request: CreateMemoryRequest,
    db: Session = Depends(get_db)
):
    user = db.query(User).filter(User.user_id == request.user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    
    # 獲取或創建應用
    app_obj = db.query(App).filter(App.name == request.app).first()
    if not app_obj:
        app_obj = App(name=request.app, owner_id=user.id)
        db.add(app_obj)
        db.commit()
        db.refresh(app_obj)

    # 創建記憶
    memory = Memory(
        user_id=user.id,
        app_id=app_obj.id,
        content=request.text,
        metadata_=request.metadata
    )
    db.add(memory)
    db.commit()
    db.refresh(memory)
    return memory

2. 記憶狀態管理

每個記憶在系統中都有一個特定的狀態，可以是：

  • 活躍（Active）：正常可訪問的記憶
  • 暫停（Paused）：臨時禁用的記憶
  • 存檔（Archived）：長期保存但不活躍的記憶
  • 刪除（Deleted）：已標記為刪除的記憶

系統會追蹤記憶狀態的變化歷史，使管理更透明：

def update_memory_state(db: Session, memory_id: UUID, new_state: MemoryState, user_id: UUID):
    memory = get_memory_or_404(db, memory_id)
    old_state = memory.state

    # 更新記憶狀態
    memory.state = new_state
    if new_state == MemoryState.archived:
        memory.archived_at = datetime.now(UTC)
    elif new_state == MemoryState.deleted:
        memory.deleted_at = datetime.now(UTC)

    # 記錄狀態變更
    history = MemoryStatusHistory(
        memory_id=memory_id,
        changed_by=user_id,
        old_state=old_state,
        new_state=new_state
    )
    db.add(history)
    db.commit()
    return memory

3. 自動分類系統

OpenMemory 使用 OpenAI 模型自動為記憶內容進行分類，提高組織效率：

@event.listens_for(Memory, 'after_insert')
def after_memory_insert(mapper, connection, target):
    """記憶插入後觸發分類"""
    db = Session(bind=connection)
    categorize_memory(target, db)
    db.close()

def categorize_memory(memory: Memory, db: Session) -> None:
    """使用 OpenAI 模型為記憶分類並儲存到數據庫"""
    try:
        # 從 OpenAI 獲取分類
        categories = get_categories_for_memory(memory.content)

        # 在數據庫中獲取或創建分類
        for category_name in categories:
            category = db.query(Category).filter(Category.name == category_name).first()
            if not category:
                category = Category(
                    name=category_name,
                    description=f"自動創建的分類: {category_name}"
                )
                db.add(category)
                db.flush()

            # 建立記憶與分類的關聯
            if not db.execute(...).first():
                db.execute(
                    memory_categories.insert().values(
                        memory_id=memory.id,
                        category_id=category.id
                    )
                )

        db.commit()
    except Exception as e:
        db.rollback()
        print(f"分類記憶時出錯: {e}")

4. MCP 伺服器整合

OpenMemory 實現了 Memory Context Protocol (MCP) 伺服器，使 LLM 客戶端可以無縫訪問用戶記憶：

# app/mcp_server.py - MCP 服務器設置
mcp = FastMCP("mem0-mcp-server")

@mcp.tool(description="Add new memories to the user's memory")
async def add_memories(text: str) -> str:
    uid = user_id_var.get(None)
    client_name = client_name_var.get(None)

    if not uid or not client_name:
        return "Error: missing user_id or client_name"

    try:
        response = memory_client.add(text,
                                     user_id=uid,
                                     metadata={
                                        "source_app": "openmemory",
                                        "mcp_client": client_name,
                                    })
        return response
    except Exception as e:
        return f"Error adding to memory: {e}"

安全與權限設計

OpenMemory 將安全性放在首位，實現了細粒度的訪問控制系統：

1. 應用程序級訪問控制

定義哪些應用程序可以訪問用戶的哪些記憶：

def get_accessible_memory_ids(db: Session, app_id: UUID) -> Set[UUID]:
    """獲取應用程序有權訪問的記憶 ID 集合"""
    # 獲取應用程序級訪問控制
    app_access = db.query(AccessControl).filter(
        AccessControl.subject_type == "app",
        AccessControl.subject_id == app_id,
        AccessControl.object_type == "memory"
    ).all()

    # 處理訪問權限
    allowed_memory_ids = set()
    denied_memory_ids = set()

    for rule in app_access:
        if rule.effect == "allow":
            if rule.object_id:  # 特定記憶訪問
                allowed_memory_ids.add(rule.object_id)
            else:  # 所有記憶訪問
                return None  # 表示允許所有
        elif rule.effect == "deny":
            if rule.object_id:  # 特定記憶拒絕
                denied_memory_ids.add(rule.object_id)
            else:  # 所有記憶拒絕
                return set()  # 表示不允許訪問任何記憶

    # 從允許集中移除被拒絕的記憶
    if allowed_memory_ids:
        allowed_memory_ids -= denied_memory_ids

    return allowed_memory_ids

2. 記憶訪問日誌

系統記錄所有記憶的訪問情況，增加透明度和問責性：

# 記錄記憶訪問
access_log = MemoryAccessLog(
    memory_id=memory_id,
    app_id=app.id,
    access_type="search",
    metadata_={
        "query": query,
        "score": memory.get('score'),
        "hash": memory.get('hash')
    }
)
db.add(access_log)
db.commit()

快速上手使用

OpenMemory 提供了簡單的部署流程：

# 克隆儲存庫
git clone https://github.com/mem0/openmemory.git
cd openmemory

# 設置環境變量
cp api/.env.example api/.env
# 編輯 .env 文件添加 OPENAI_API_KEY

# 構建並運行服務
make build  # 構建 MCP 服務器
make up     # 運行 OpenMemory MCP 服務器
make ui     # 運行 OpenMemory UI

部署完成後，可通過以下地址訪問：

應用場景與使用案例

OpenMemory 在多種場景中都有廣泛應用：

1. 個人知識管理

將日常筆記、想法和信息存儲為記憶，隨時可通過語義搜索快速檢索。

2. AI 助手個性化

為聊天機器人和 AI 助手提供持久化的記憶，使其能夠記住用戶偏好和之前的互動。

3. 安全數據管理

對於關注數據隱私的用戶，提供一種不依賴雲服務的方式來與 AI 系統共享信息。

4. 開發者平台

為開發者提供一個框架，用於構建具有記憶能力的自定義 AI 應用。

使用 USB 隨身碟交換 OpenMemory 資料

**提示：**使用 USB 隨身碟是交換 OpenMemory 記憶資料的最安全方式之一，完全避免網路傳輸風險。

OpenMemory 的設計支持將記憶數據通過物理媒介（如 USB 隨身碟）進行安全交換，這是確保數據隱私的絕佳方式。以下是三種主要方法：

1. 直接複製數據庫文件

OpenMemory 的核心數據存儲在幾個關鍵文件中：

openmemory/
├── api/
│   ├── openmemory.db        # SQLite 主數據庫文件
│   └── vector_store/        # 向量數據存儲目錄

您可以通過以下步驟將這些文件複製到 USB 隨身碟：

# 1. 首先確保 OpenMemory 服務已停止
make down

# 2. 複製關鍵文件到 USB 隨身碟
cp api/openmemory.db /media/usb/
cp -r api/vector_store/ /media/usb/

接收者只需將這些文件複製到他們的 OpenMemory 安裝目錄即可使用您的記憶數據。

2. 創建結構化導出文件

如果您只想分享特定記憶，可以實現導出功能：

# 在 app/routers/memories.py 添加導出功能
@router.post("/export-to-usb")
async def export_memories_to_usb(
    memory_ids: List[UUID],
    export_path: str,
    db: Session = Depends(get_db)
):
    # 獲取指定的記憶
    memories = db.query(Memory).filter(Memory.id.in_(memory_ids)).all()
    
    # 為每個記憶獲取向量嵌入
    memory_data = []
    for memory in memories:
        vector = memory_client.get_vector(str(memory.id))
        
        memory_data.append({
            "id": str(memory.id),
            "content": memory.content,
            "vector": vector.tolist() if vector is not None else None,
            "categories": [c.name for c in memory.categories],
            "metadata": memory.metadata_,
            "created_at": memory.created_at.isoformat()
        })
    
    # 將數據保存為 JSON 文件
    with open(export_path, 'w') as f:
        json.dump({"memories": memory_data}, f, indent=2)
        
    return {"message": f"成功導出 {len(memories)} 條記憶到 {export_path}"}

3. 創建便攜式 OpenMemory 實例

更完整的解決方案是在 USB 隨身碟上創建一個完整的便攜式 OpenMemory 實例：

# 在 USB 上克隆儲存庫
cd /media/usb
git clone https://github.com/mem0/openmemory.git
cd openmemory

# 配置為使用本地存儲
echo "DB_PATH=/media/usb/openmemory/data/openmemory.db" > api/.env
echo "VECTOR_STORE_PATH=/media/usb/openmemory/data/vector_store" >> api/.env

# 複製您的數據
mkdir -p /media/usb/openmemory/data
cp /path/to/your/openmemory.db /media/usb/openmemory/data/
cp -r /path/to/your/vector_store /media/usb/openmemory/data/

安全考量

使用 USB 隨身碟交換數據時，請考慮以下安全措施：

  • 加密 USB 內容：使用 VeraCrypt、BitLocker 或 FileVault 等工具
  • 設置密碼保護：要求接收者提供密碼才能訪問數據
  • 只包含必要數據：僅導出必要的記憶，而非整個數據庫
  • 提供數據清理指南：告訴接收者使用後如何安全地刪除數據

這種離線交換方式的主要優勢在於完全掌控數據流向，無需依賴網絡傳輸，為敏感記憶提供最高級別的安全保障。

未來展望

OpenMemory 專案正在積極發展中，未來計劃包括：

  • 增強的向量搜索功能：更精確的相似度搜索
  • 多模態記憶支持：存儲和檢索圖像、音頻等非文本記憶
  • 更多集成選項：與更多 LLM 系統和 AI 平台集成
  • 改進的使用者界面：更直觀的記憶管理體驗
  • 企業級部署選項：適合團隊和組織的部署模式

結論

OpenMemory 代表了 AI 系統發展的一個重要方向：將用戶數據的控制權交還給用戶本身，同時提供強大的功能和良好的使用者體驗。作為一個開源專案，它不僅提供了實用的工具，也展示了如何在尊重隱私的前提下構建 AI 系統。

對於關注 AI 的開發者和用戶來說，OpenMemory 提供了一個值得關注的解決方案，它讓 AI 變得更加個人化，同時確保數據始終在用戶的控制之下。

相關資源：

🧩

Interactive Components

This post includes custom interactive components for enhanced experience

Thanks for reading!

Found this article helpful? Share it with others or explore more content.

More Articles
Published May 14, 2025•19 min read•5 tags