AI Agent 記憶管理框架深度比較：Mem0 vs Letta 2026 實戰指南

你有沒有遇過這種情況：跟 AI Agent 聊了半天，結果它轉頭就忘了你剛說過的事？或者更慘的是，你花了好幾天跟它建立的上下文，關掉視窗就全沒了。這就是為什麼記憶管理在 AI Agent 開發中變得越來越重要。

2026 年，兩個記憶管理框架殺出重圍：Mem0 和 Letta（前身是大名鼎鼎的 MemGPT）。我過去半年在生產環境中都用過，今天就來做一個不廢話的深度比較，幫你搞清楚該選哪一個。

AI Agent 為什麼需要記憶管理

先講一個殘酷的事實：大多數 LLM 的 context window 雖然越來越大（Claude 到 200K、Gemini 到 1M），但 context window 不等於記憶。Context window 是「工作記憶」，每次對話都要重新塞入，而且 token 用量直接影響成本和延遲。

真正的 AI Agent 記憶管理需要解決三個問題：

• 持久化：對話結束後資訊不會消失
• 選擇性召回：不是全部塞進去，而是只取相關的記憶
• 跨對話一致性：Agent 在不同 session 間保持人格和知識的連貫

如果你正在構建需要AI Agent 評估框架指南中提到的那種多輪對話 Agent，記憶管理就是你繞不過去的課題。

短期記憶 vs 長期記憶：基本概念

在認知科學中，人類記憶分為短期記憶（秒級，容量有限）和長期記憶（天到年，幾乎無限）。AI Agent 記憶管理借用了這個框架：

• 短期記憶（Working Memory）：當前對話的 context，通常就是 LLM 的 prompt + 最近幾輪對話
• 長期記憶（Long-term Memory）：跨 session 持久化的使用者偏好、事實知識、歷史互動摘要

Mem0 和 Letta 對這兩種記憶的處理方式截然不同，這也是它們最核心的架構差異。

Mem0：Memory-as-a-Service 的極簡哲學

Mem0 的設計哲學可以用一句話概括：把記憶當成一個獨立的微服務。它不試圖接管你的整個 Agent 架構，而是提供一個乾淨的 API 層，讓你把記憶功能「插」到任何現有系統中。

這種設計的好處是顯而易見的 —— 你不需要重構現有的 Agent 程式碼，只需要在適當的地方呼叫 Mem0 的 API。

Mem0 核心 API：add() 與 search()

Mem0 的 API 極度簡潔，核心就兩個方法：

from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

# 新增記憶
client.add(
    messages=[{"role": "user", "content": "我偏好用 TypeScript 寫後端"}],
    user_id="engineer-001"
)

# 搜尋相關記憶
results = client.search(
    query="這個用戶的技術偏好是什麼？",
    user_id="engineer-001"
)
# 回傳：[{"memory": "偏好使用 TypeScript 寫後端", "score": 0.92}]

就是這麼簡單。add() 會自動從對話中提取關鍵資訊並存儲，search() 使用向量相似度搜尋來找出最相關的記憶片段。Mem0 在背後幫你處理了 embedding、去重、衝突解決等髒活。

Graph Memory：知識圖譜進階功能

Mem0 Pro 版（$249/月）提供了一個很有意思的功能：Graph Memory。它不只是存儲扁平的記憶片段，而是建構實體之間的關係圖譜。

# Graph Memory 會自動建構關係
client.add(
    messages=[{"role": "user", "content": "我在 Google 工作，負責 TensorFlow 團隊"}],
    user_id="engineer-001",
    version="v2"  # 啟用 Graph Memory
)

# 查詢關係圖譜
graph = client.get_graph(user_id="engineer-001")
# 回傳：節點 [User, Google, TensorFlow] + 關係 [works_at, leads]

Graph Memory 讓 Agent 能夠理解「使用者在 Google 工作」和「使用者負責 TensorFlow」之間的關聯，而不是把它們當作兩個獨立的記憶片段。這在企業級客服、個人助理等場景中特別有用。

Letta（前 MemGPT）：三層記憶架構

如果說 Mem0 是「記憶微服務」，Letta 更像是一個「完整的記憶作業系統」。它的前身 MemGPT 論文提出了一個激進的想法：讓 LLM 自己管理自己的記憶，就像作業系統管理虛擬記憶一樣。

這個概念在AI Agent 記憶層架構的設計中有更深入的探討。

Core / Recall / Archival 記憶層

Letta 的三層記憶架構是它最核心的創新：

記憶層	類比	容量	存取速度	用途
Core Memory	CPU 暫存器	~2K tokens	即時（在 prompt 中）	使用者基本資訊、Agent 人格設定
Recall Memory	RAM	中等	快（向量搜尋）	最近對話歷史、短期上下文
Archival Memory	硬碟	無限	較慢（索引查詢）	長期知識、文件、歷史記錄

最特別的是，Letta 的 Agent 可以自主決定何時把資訊從一層移到另一層。比如，當 Core Memory 快滿時，Agent 會自動把不那麼重要的資訊歸檔到 Archival Memory。

from letta import create_client

client = create_client()
agent = client.create_agent(
    name="memory-demo",
    memory=ChatMemory(
        human="使用者是一位 AI 工程師，偏好 Python",
        persona="我是一個技術助手，擅長 AI 架構設計"
    )
)

# Agent 會自主管理記憶
response = client.send_message(
    agent_id=agent.id,
    message="幫我記住：我們公司的 LLM 部署用 vLLM 搭配 A100"
)
# Letta 自動決定這條資訊要存在哪一層

Context Repositories：Git-backed 記憶版本控制

Letta 在 2026 年推出的 Context Repositories 功能相當有野心 —— 它讓 Agent 的記憶像程式碼一樣可以版本控制。

概念很簡單：每次記憶變更都被記錄為一個 commit，你可以 diff、rollback、branch 記憶狀態。這在多 Agent 協作場景中特別有價值，因為你可以追蹤每個 Agent 的記憶變化軌跡。

這個概念和MCP Model Context Protocol 的上下文管理理念有異曲同工之妙。

效能實測：LoCoMo Benchmark 數據比較

LoCoMo（Long Conversation Memory）是目前最權威的 Agent 記憶管理評測基準。它測試 Agent 在超長對話（600+ 輪）中的記憶準確度。以下是兩個框架在 LoCoMo 上的表現：

指標	Mem0	Letta	說明
單跳事實回憶	82.3%	79.1%	直接事實問答準確度
多跳推理	71.5%	76.8%	需要跨記憶推理的問題
時序理解	68.2%	74.5%	理解事件發生順序
記憶更新一致性	85.1%	80.3%	資訊變更後的正確性
延遲（P95）	120ms	340ms	記憶讀取延遲

簡單來說：Mem0 在簡單召回和速度上贏，Letta 在複雜推理和時序理解上贏。這跟它們的架構設計完全一致 —— Mem0 優化了檢索效率，Letta 優化了記憶結構的表達力。

框架鎖定度分析

這是很多工程師忽略但極其重要的考量：

• Mem0：鎖定度低。它只是一個記憶層 API，你的 Agent 邏輯完全獨立。要換掉 Mem0，只需要替換幾個 API 呼叫。記憶資料可以匯出為標準 JSON。
• Letta：鎖定度高。它不只管記憶，還深度介入 Agent 的推理流程（因為 Agent 要自主決定記憶操作）。要從 Letta 遷移出來，基本上要重寫整個 Agent。

這不代表 Letta 不好，但你需要在「功能強大」和「架構靈活」之間做出取捨。

實際整合程式碼範例

以下是將兩個框架整合到一個典型 LangChain Agent 中的範例：

Mem0 整合（約 10 行程式碼）

from langchain.agents import AgentExecutor
from mem0 import MemoryClient

mem0 = MemoryClient(api_key="your-key")

def agent_with_memory(user_input: str, user_id: str):
    # 1. 召回相關記憶
    memories = mem0.search(query=user_input, user_id=user_id, limit=5)
    context = "\n".join([m["memory"] for m in memories])
    
    # 2. 注入記憶到 prompt
    enhanced_prompt = f"用戶記憶：\n{context}\n\n用戶問題：{user_input}"
    response = agent_executor.invoke({"input": enhanced_prompt})
    
    # 3. 儲存新記憶
    mem0.add(
        messages=[{"role": "user", "content": user_input},
                  {"role": "assistant", "content": response["output"]}],
        user_id=user_id
    )
    return response["output"]

Letta 整合（需要更多設定）

from letta import create_client, LLMConfig, EmbeddingConfig

client = create_client(base_url="http://localhost:8283")

# Letta 需要先建立 Agent（記憶管理是 Agent 的一部分）
agent = client.create_agent(
    name="support-agent",
    llm_config=LLMConfig(model="gpt-4o", context_window=128000),
    embedding_config=EmbeddingConfig(model="text-embedding-3-small"),
    memory=ChatMemory(
        human="新用戶，偏好未知",
        persona="專業技術支援助手"
    ),
    tools=["archival_memory_insert", "archival_memory_search",
           "core_memory_append", "core_memory_replace"]
)

# 發送訊息，Letta 自動處理記憶管理
response = client.send_message(
    agent_id=agent.id,
    role="user",
    message="我的伺服器是 Ubuntu 22.04，用 Docker 部署"
)

選擇建議：何時用 Mem0、何時用 Letta

根據我的實戰經驗，選擇建議如下：

選 Mem0 的情境

• 你已經有一個運作中的 Agent 系統，只想加上記憶功能
• 你的記憶需求以「使用者偏好」和「事實存儲」為主
• 你重視整合速度和架構靈活性
• 預算有限，免費版 1000 個記憶足夠小規模使用
• 你的團隊不想被單一框架綁定

選 Letta 的情境

• 你從零開始構建 Agent，願意接受 Letta 的整體架構
• 你的 Agent 需要處理複雜的多跳推理和長期記憶
• 你需要記憶版本控制和多 Agent 記憶共享
• 你有 DevOps 資源來維護 Letta Server
• 你的場景對記憶的時序理解有高要求（如長期追蹤型 Agent）

我的個人推薦

如果你不確定，先從 Mem0 開始。原因很簡單：它的整合成本低、鎖定度低，讓你可以快速驗證「記憶管理」對你的 Agent 到底有多大幫助。等你確認記憶管理是核心需求，而且需要更複雜的記憶結構時，再評估遷移到 Letta。

別忘了，最好的架構不是功能最強的，而是最適合你當前階段的。