框架

Agent Memory 真正難在哪:聊天紀錄不等於記憶

Agent Memory 並非保存更多對話,而是讓 Agent 能跨任務寫入、組織、召回、更新與遺忘資訊。本文以 SQLite + FTS5 打造最小實作,並提出一套衡量記憶品質的評測指標。

字級

Anthropic 拆解了 Agent Memory 的組成機制。上下文窗口只是暫存區。真正困難的是寫入、更新、召回與刪除。

Agent Memory 真正難在哪:聊天紀錄不等於記憶

Anthropic 最近發表研究文章《The Components of Agent Memory》,探討 Agent 如何持續累積並再次调用歷史資訊。

文章登上 Hacker News 首頁時,獲得 97 分與 55 則留言。討論頁在這裡:https://news.ycombinator.com/item?id=50402212

這組數字顯示開發者相當關注 Agent Memory。但討論中最容易混淆的一點是:聊天紀錄不等於記憶。

即使上下文窗口擴展到數十萬 token,也不代表 Agent 具備長期記憶。它可能只是把更多舊文字塞回 prompt。

HN 首頁上的 Agent 記憶論文

Anthropic 的《The Components of Agent Memory》不是一篇「替 Agent 加上向量資料庫」的教學。它關注的是更底層的問題:Agent 要形成可用記憶,需要哪些元件,以及這些元件如何組成完整生命週期。

文章聚焦如何為 Agent 建立能持續累積並调用歷史資訊的記憶系統。現有材料將關鍵環節分為四類:

  • 儲存:將需要保留的資訊寫入上下文窗口之外
  • 組織:決定資訊以何種結構保存
  • 檢索:在需要時找到相關片段
  • 更新:處理新增、修改與已失效的資訊

這也是為什麼 Agent Memory 不應被理解成「更長的聊天紀錄」。聊天紀錄是 append-only 的事件串流;記憶系統則必須做出選擇:什麼值得保存、如何建立關聯、何時重新讀取,以及舊內容是否應該刪除。

Anthropic 原文:https://www.anthropic.com/research/components-of-agent-memory

聊天紀錄不等於 Agent 記憶

先看一個最小反例。

假設 Agent 第一次執行任務時,使用者說:

我的部署腳本放在 infra/ 目錄,使用 make deploy。

兩週後,使用者問:

怎麼部署這個專案?

如果系統只保存聊天紀錄,第二次任務可能根本看不到第一次對話。Agent 會重新猜測目錄、命令與專案結構。

把整段歷史直接塞回上下文,也沒有解決問題。

第一,歷史越長,雜訊越多。使用者曾說過的暫存路徑、已淘汰方案與臨時猜測,都會一起被召回。

第二,重要事實通常需要改寫。例如部署命令從 make deploy 改成 make release。原始聊天中同時存在兩個答案,但當前有效狀態只有一個。

第三,召回是有成本的。上下文越滿,留給當前任務、工具輸出與程式碼修改的空間就越少。

因此,上下文窗口更像暫存區。它讓模型在當前請求中看見材料,卻不負責跨任務的長期狀態管理。

真正的記憶至少必須回答四個問題:

  1. 哪些資訊可以寫入長期儲存?
  2. 記憶應採用什麼結構組織?
  3. 當前任務應該召回哪些內容?
  4. 新事實出現後,舊記憶應如何處理?

少了寫入、檢索或更新其中任何一環,都只是「歷史資訊快取」,還不是完整的 Agent Memory。

記憶的元件與生命週期

我將 Agent Memory 拆成一條生命週期,而不是一組產品名稱。

1. 寫入:從事件中擷取狀態

Agent 完成一次任務後,系統不能無差別保存整份 transcript。它必須先判斷哪些內容具有長期價值。

通常值得寫入的內容包括:

  • 使用者偏好,例如「用中文回答」
  • 穩定事實,例如專案使用的語言與框架
  • 決策紀錄,例如「驗證方案採用 Auth0」
  • 工作流程規則,例如「部署前先執行測試」

不適合長期保存的內容則包括:

  • 一次性的工具錯誤
  • 目前 shell 中的暫存路徑
  • Agent 尚未驗證的猜測
  • 已完成任務中的大量中間過程

寫入環節需要保留來源資訊與信賴狀態。否則,系統只會把模型幻覺固化為「使用者事實」。

2. 組織:讓記憶具有結構

原始文字適合閱讀,卻未必適合程式處理。

一種實務做法是同時保存兩類資料:

  • 供人閱讀的可讀記憶
  • 供程式處理的結構化欄位

例如:

{
  "key": "project.deploy_command",
  "value": "make release",
  "scope": "project:web-api",
  "source": "user",
  "confidence": 1.0,
  "updated_at": "2026-08-24T10:30:00Z"
}

key 負責去重與覆寫,scope 控制隔離,source 記錄依據,updated_at 則用來判斷新舊。

這比將十筆記憶塞進同一個向量更容易稽核。向量適合尋找相似語意,卻不適合單獨承擔一致性判斷。

3. 檢索:先精確,再擴展

檢索不應只有「向量搜尋 top-k」這一條路徑。

可靠的小型系統通常會混合使用:

  • 精確比對:依 key、專案 ID、使用者 ID 讀取
  • 關鍵字檢索:尋找命令、錯誤碼與專有名詞
  • 向量檢索:處理自然語言改寫與語意近似
  • 時間過濾:排除已過期的候選項目
  • 權限過濾:只查詢目前 Agent 有權存取的记忆

召回結果還需要重新排序。例如,精确命中的當前設定,應排在語意相似但已過期的討論之前。

4. 更新與遺忘:讓舊事實退場

更新不是單純追加。

新記憶與舊記憶衝突時,至少要處理:

  • 覆寫:使用者明確修改舊偏好
  • 合併:兩項資訊描述的是同一件事實
  • 失效:時間條件已經結束
  • 保留歷史:目前值已變更,但仍需稽核舊值
  • 刪除:內容不應繼續保存

如果系統只做 append,記憶越多,衝突就越多。Agent 每次召回兩三個版本,再自行選擇一個。這等於把治理成本轉嫁給模型,而且沒有任何保證。

工程實作:先建立最小閉環

別一開始就導入複雜的多 Agent 記憶圖譜。

我建議先實作一個能運作的閉環:結構化儲存、混合檢索、時間戳與覆寫更新。再加入一組固定評測集,檢查記憶究竟有幫助 Agent,還是只製造雜訊。

以下範例使用 SQLite,不需要向量資料庫,可以跑通「寫入、依 key 讀取、關鍵字召回」這條最小鏈路。

import sqlite3
from datetime import datetime, timezone

DB_PATH = "agent_memory.db"

def init_db():
    with sqlite3.connect(DB_PATH) as conn:
        conn.execute(
            """
            CREATE TABLE IF NOT EXISTS memories (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                key TEXT NOT NULL,
                value TEXT NOT NULL,
                scope TEXT NOT NULL,
                source TEXT NOT NULL,
                confidence REAL NOT NULL DEFAULT 1.0,
                updated_at TEXT NOT NULL,
                UNIQUE(key, scope)
            )
            """
        )
        conn.execute(
            """
            CREATE VIRTUAL TABLE IF NOT EXISTS memory_search
            USING fts5(key, value, scope, content='memories', content_rowid='id')
            """
        )
        conn.execute(
            """
            CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
                INSERT INTO memory_search(rowid, key, value, scope)
                VALUES (new.id, new.key, new.value, new.scope);
            END
            """
        )
        conn.execute(
            """
            CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
                INSERT INTO memory_search(memory_search, rowid, key, value, scope)
                VALUES ('delete', old.id, old.key, old.value, old.scope);
            END
            """
        )
        conn.execute(
            """
            CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
                INSERT INTO memory_search(memory_search, rowid, key, value, scope)
                VALUES ('delete', old.id, old.key, old.value, old.scope);
                INSERT INTO memory_search(rowid, key, value, scope)
                VALUES (new.id, new.key, new.value, new.scope);
            END
            """
        )

def remember(key, value, scope="global", source="user", confidence=1.0):
    now = datetime.now(timezone.utc).isoformat()
    with sqlite3.connect(DB_PATH) as conn:
        conn.execute(
            """
            INSERT INTO memories(key, value, scope, source, confidence, updated_at)
            VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT(key, scope) DO UPDATE SET
                value = excluded.value,
                source = excluded.source,
                confidence = excluded.confidence,
                updated_at = excluded.updated_at
            """,
            (key, value, scope, source, confidence, now),
        )

def get_exact(key, scope="global"):
    with sqlite3.connect(DB_PATH) as conn:
        row = conn.execute(
            "SELECT key, value, scope, source, confidence, updated_at "
            "FROM memories WHERE key = ? AND scope = ?",
            (key, scope),
        ).fetchone()
    return dict(zip(
        ["key", "value", "scope", "source", "confidence", "updated_at"], row
    )) if row else None

def search(query, scope="global", limit=5):
    with sqlite3.connect(DB_PATH) as conn:
        rows = conn.execute(
            """
            SELECT m.key, m.value, m.scope, m.source, m.confidence, m.updated_at
            FROM memory_search AS s
            JOIN memories AS m ON m.id = s.rowid
            WHERE memory_search MATCH ? AND m.scope = ?
            ORDER BY m.updated_at DESC
            LIMIT ?
            """,
            (query, scope, limit),
        ).fetchall()
    return [dict(zip(
        ["key", "value", "scope", "source", "confidence", "updated_at"], row
    )) for row in rows]

init_db()
remember(
    "project.deploy_command",
    "make release",
    scope="project:web-api",
)
remember(
    "response.language",
    "中文",
    scope="user:42",
)

print(get_exact("project.deploy_command", "project:web-api"))
print(search("deploy", scope="project:web-api"))

這裡刻意沒有呼叫 embedding API。原因很單純:先驗證資料模型與生命週期,再決定是否需要語意檢索。

只有當關鍵字召回經常漏掉同義表述,或使用者會以多種方式描述同一件事時,再加入向量檢索。向量資料庫不是記憶系統的起點。

複雜架構也應分階段加入:

  1. 單表結構化記憶:驗證去重、覆寫與刪除
  2. SQLite + FTS5:驗證關鍵字召回
  3. 混合檢索:加入 embedding 與 reranker
  4. 獨立記憶服務:出現多租戶或跨 Agent 共用需求後再實作

真正的瓶頸是記憶治理

工程上最困難的部分不是檢索演算法,而是決定「哪些內容有資格被記住」。

這裡有四類常見問題。

過期資訊

「目前分支是 main」今天可能有效,明天就會過期。如果不記錄作用域與時間,Agent 便會把舊狀態當成事實。

衝突事實

專案 README 寫著使用 PostgreSQL,部署腳本卻顯示 MySQL。系統不能任意挑選一個,而應記錄衝突,交由使用者確認,或依來源可信度排序。

錯誤寫入

Agent 從含糊表述中推論出的內容,不應直接變成長期事實。寫入前必須區分:使用者明確陳述、工具驗證結果,以及模型推論。

權限邊界

「記住使用者說過什麼」與「記住使用者無權查看的內容」是兩回事。記憶庫必須帶有使用者、專案、租戶與 Agent 權限。檢索前的過濾不能只依賴 prompt。

還有一項容易被忽略的指標:召回準確率。

只測試 top-k 命中率並不夠,至少要分開測量:

  • Precision:召回的記憶中,有多少真正相關
  • Recall:任務需要的事實,有多少被找到
  • Freshness:召回內容是否仍然有效
  • Conflict rate:召回集合內有多少互相矛盾的內容
  • Write precision:寫入的記憶中,有多少值得長期保留

如果沒有評測集,團隊很容易被 demo 誤導。Agent 回答得不錯,可能只是恰好召回了正確的那筆記憶。換一項任務或換一種問法,系統就會失效。

Anthropic 這篇文章登上 HN 首頁並獲得 97 分、55 則留言,顯示記憶已成為 Agent 工程的核心議題。但架構越複雜,就越需要先定義可測量的行為。

編輯思考

Agent Memory 之所以重要,不是因為它能讓 Agent 記住更多,而是因為記憶會把一次對話中的暫時資訊轉換成跨任務狀態。一旦寫錯、過期或越權,錯誤便會持續影響後續任務。儲存與檢索已有成熟工具,真正難以複製的,是寫入條件、衝突處理、權限邊界與刪除規則。

我預測,團隊落地時會先建立記憶評測集,再選擇向量資料庫。原因很單純:沒有固定樣本與指標,團隊無法判斷一次召回究竟有效協助了 Agent,還是碰巧命中。評測範圍至少應涵蓋寫入、召回、覆寫與刪除,並分別統計 Precision、Recall、Freshness 與 Conflict rate。

這與過去的長上下文方案不同。長上下文主要擴大單次請求能看見的材料,Agent Memory 則要管理跨任務狀態,並允許舊事實失效。它不只是多增加一個儲存層,而是引入一套生命週期治理機制。

目前還不確定統一評測標準會多快出現。不同產品對「使用者偏好」「專案事實」與「工作流程規則」的邊界也不一致。在標準成熟前,先記錄每次寫入與召回的來源,讓行為可以稽核,比直接堆疊複雜架構更穩妥。

來源

https://www.anthropic.com/research/components-of-agent-memory

來源: https://www.anthropic.com/research/components-of-agent-memory