Phần 2: State, Memory & Context Management — Phân Tầng Bộ Nhớ & GraphRAG

Phiên bản Tiếng Anh: 📖 Bản tiếng Anh (English Edition)

Answer-first: Quản trị bộ nhớ Agentic đòi hỏi kiến trúc phân tầng kết hợp Working Memory, Episodic Memory và Semantic Knowledge Graphs. Áp dụng kỹ thuật nén rolling compaction và truy xuất hybrid vector-graph giúp loại bỏ suy giảm chú ý, tối ưu chi phí token và duy trì ngữ cảnh nhất quán qua hàng ngàn phiên tương tác.

Điều kiện tiên quyết: Đã nghiên cứu Phần 1: Agent Topology, nắm vững các nguyên lý của Vector Embeddings (Cosine Similarity, Approximate Nearest Neighbors), cơ sở dữ liệu đồ thị (Graph Databases / Cypher), và cấu trúc lưu trữ cache in-memory (Redis/KeyDB).

← Chương trước: Phần 1: Agent Topology & Orchestration | Mục lục Series | Chương tiếp theo: Phần 3: Secure Tool Calling & Guardrails →

1. Nghịch Lý Cửa Sổ Ngữ Cảnh: Tại Sao Cửa Sổ Hàng Triệu Tokens Vẫn Không Thể Giải Quyết Vấn Đề Bộ Nhớ?

Khi các nhà cung cấp mô hình biên (Frontier Model Providers) công bố các cửa sổ ngữ cảnh mở rộng lên tới 1 triệu hoặc 2 triệu tokens, nhiều kỹ sư phần mềm đã lầm tưởng rằng bài toán “Bộ Nhớ Của Tác Nhân” (Agent Memory) đã được giải quyết triệt để: chỉ cần nhét toàn bộ lịch sử trò chuyện, tài liệu cơ sở tri thức và log thực thi vào mỗi lệnh gọi API.

Tuy nhiên, trong kỹ thuật phần mềm doanh nghiệp thực chiến năm 2026–2027, cách tiếp cận ngây thơ này lập tức vấp phải ba bức tường vật lý không thể vượt qua:

1. Hiện Tượng “Lạc Lối Ở Giữa” (Lost in the Middle) & Suy Giảm Tỷ Lệ Tín Hiệu Trên Nhiễu (SNR): Các nghiên cứu thực nghiệm chuyên sâu chứng minh rằng mặc dù mô hình có thể chấp nhận hàng triệu tokens đầu vào, khả năng trích xuất chính xác một sự kiện cụ thể nằm ở đoạn giữa văn bản suy giảm nghiêm trọng khi kích thước context vượt quá 64K tokens. Tạp âm thông tin khiến tác nhân sinh ra ảo giác (hallucination) hoặc bỏ qua các ràng buộc nghiệp vụ quan trọng.
2. Kinh Tế Học Token (Token FinOps Disaster): Cơ chế tính tiền của các API LLM dựa trên tổng số tokens xử lý ở mỗi lượt gọi. Nếu một phiên làm việc kéo dài 30 lượt và mỗi lượt đều gửi kèm 100K tokens lịch sử, tổng lượng token tiêu thụ sẽ là $30 \times 100\text{K} = 3\text{ triệu tokens}$. Chi phí cho một phiên hỗ trợ khách hàng đơn giản có thể lên tới hàng chục USD—hoàn toàn phá sản bài toán kinh doanh.
3. Độ Trễ Phản Hồi Ban Đầu (Time-To-First-Token - TTFT): Thời gian tính toán ma trận Attention của kiến trúc Transformer tăng theo độ phức tạp $O(L^2)$ hoặc $O(L)$ đối với FlashAttention. Việc xử lý một context 500K tokens khiến độ trễ TTFT kéo dài từ 5 đến 15 giây, phá vỡ trải nghiệm người dùng thời gian thực.

Để giải quyết triệt để nghịch lý này, các kiến trúc sư hệ thống phải học tập mô hình nhận thức của não bộ con người: Phân chia bộ nhớ thành các phân tầng chuyên biệt với tốc độ truy xuất, dung lượng và cơ chế quên (forgetting mechanisms) khác nhau.

graph TD
    subgraph MemoryHierarchy ["Kiến Trúc Phân Tầng Bộ Nhớ Đa Tác Nhân (3-Tier Agentic Memory)"]
        subgraph L1Tier ["Tầng L1: Working Scratchpad (RAM / Fast Cache)"]
            L1["Context Buffer Hiện Tại<br/>(Dung lượng: 8K - 16K Tokens)<br/>Lưu: Goal, Current Step, Immediate Variables"]
        end

        subgraph L2Tier ["Tầng L2: Episodic Memory (Vector DB / Qdrant)"]
            L2["Nhật Ký Tình Huống Quá Khứ<br/>(Dung lượng: Hàng Triệu Vector Embeddings)<br/>Lưu: User Preferences, Past Interactions, Error Retries"]
        end

        subgraph L3Tier ["Tầng L3: Semantic Knowledge Graph (GraphRAG / Neo4j)"]
            L3["Đồ Thị Tri Thức Thực Thể & Quan Hệ<br/>(Nodes & Directed Typed Edges)<br/>Lưu: Domain Ontologies, Code AST, Business Rules"]
        end
    end

    L1 -- "Compaction & Flush khi Context Đầy" --> L2
    L2 -- "Trích Xuất Thực Thể (Entity Extraction)" --> L3
    L3 -- "Sub-graph Traversal & Khôi Phục Ngữ Cảnh" --> L1
    L2 -- "Semantic Nearest Neighbor Search" --> L1

2. Giải Phẫu Ba Tầng Bộ Nhớ Cốt Lõi

2.1. Tầng L1: Bộ Nhớ Làm Việc (Working Memory / Scratchpad)

Bộ nhớ L1 tồn tại ngắn hạn trong suốt vòng đời của một tác vụ cụ thể. Nó được duy trì trực tiếp trong bộ nhớ RAM của tiến trình Go/Python hoặc một cấu trúc dữ liệu Redis In-Memory với độ trễ truy xuất dưới 1 mili giây.

• Nội dung lưu trữ: Mục tiêu hiện tại của người dùng (Goal Objective), kế hoạch các bước đã phân rã (Execution Plan), kết quả của 3 đến 5 bước gọi tool gần nhất, và các biến tạm thời.
• Chiến lược nén cuộn (Rolling Compaction Buffer): Khi số lượng tokens trong L1 chạm ngưỡng 75% ngân sách cho phép, một bộ xử lý nền (Background Compactor) sẽ kích hoạt một mô hình SLM nhẹ để tóm tắt các bước trung gian thành một bản tóm tắt súc tích, giải phóng không gian cho các bước tiếp theo mà không làm mất thông tin then chốt.

2.2. Tầng L2: Bộ Nhớ Tình Huống Dài Hạn (Episodic Memory)

Episodic Memory lưu trữ những trải nghiệm cụ thể mà tác nhân đã trải qua trong quá khứ cùng với người dùng hoặc hệ thống:

• Cấu trúc dữ liệu: Mỗi bản ghi (Episode) bao gồm ngữ cảnh ban đầu, chuỗi hành động đã thực hiện, kết quả thành công hay thất bại, và vector nhúng (embedding) của tình huống đó.
• Cơ sở dữ liệu hỗ trợ: Được lưu trữ trong các Vector Database hiệu năng cao như Qdrant, Milvus hoặc pgvector.
• Cơ chế suy giảm theo thời gian (Time-Decay Scoring): Không phải mọi ký ức trong quá khứ đều có giá trị tương đương nhau. Ký ức xảy ra ngày hôm qua phải được ưu tiên cao hơn ký ức xảy ra từ 6 tháng trước, trừ khi ký ức cũ đó có tần suất truy cập đặc biệt cao.

2.3. Tầng L3: Bộ Nhớ Ngữ Nghĩa & Đồ Thị Tri Thức (Semantic GraphRAG)

Vector Search đơn thuần rất giỏi trong việc tìm kiếm các đoạn văn bản có sự tương đồng ngữ nghĩa mơ hồ, nhưng lại hoàn toàn bất lực trước các câu hỏi đòi hỏi suy luận logic đa chặng (multi-hop reasoning), ví dụ: “Những dịch vụ nào bị ảnh hưởng nếu Database Shard B bị sập và ai là kỹ sư chịu trách nhiệm chính?”.

• Cấu trúc GraphRAG: Chuyển đổi các tài liệu phi cấu trúc thành một Đồ thị Tri thức (Knowledge Graph) gồm các Thực thể (Entities: Ví dụ: Service: PaymentService, User: Alice, Server: Shard-B) và các Mối quan hệ có hướng (Directed Relations: DEPENDS_ON, OWNS, CALLS).
• Khi tác nhân cần lập luận, nó không chỉ truy xuất vector mà còn thực hiện thuật toán duyệt đồ thị (Graph Traversal - Breadth First Search hoặc Cypher query) để thu thập toàn bộ cây quan hệ liên quan.

3. Mô Hình Toán Học Về Suy Giảm Trí Nhớ & Xếp Hạng Ký Ức Đa Yếu Tố

Để quyết định bản ghi nào từ bộ nhớ dài hạn cần được nạp lại vào cửa sổ ngữ cảnh L1, hệ thống áp dụng Đường Cong Quên Lãng Ebbinghaus (Ebbinghaus Forgetting Curve) kết hợp với điểm tương đồng vector và tần suất tái sử dụng.

Hàm Suy Giảm Thời Gian (Exponential Half-Life Decay)

Khả năng lưu giữ ký ức $S_{decay}$ tại thời điểm $\Delta t$ sau khi sự kiện xảy ra được mô hình hóa theo quy luật phân rã hàm mũ:

$$S_{decay}(\Delta t) = S_0 \cdot 2^{-\frac{\Delta t}{T_{1/2}}}$$

Trong đó:

• $S_0$ là điểm độ mạnh ban đầu của ký ức ($S_0 \in [0, 1]$).
• $\Delta t = t_{current} - t_{created}$ là khoảng thời gian trôi qua tính bằng giây.
• $T_{1/2}$ là chu kỳ bán rã của ký ức (Memory Half-Life). Đối với các tương tác thông thường, $T_{1/2}$ được đặt ở mức 7 ngày; đối với các quy tắc nghiệp vụ cố định, $T_{1/2} \to \infty$.

Hàm Điểm Xếp Hạng Tổng Hợp (Composite Retrieval Score)

Khi nhận được câu truy vấn $q$, hệ thống tính toán điểm xếp hạng tổng thể của từng bản ghi ký ức $m$ theo công thức kết hợp ba thành phần:

$$\text{FinalScore}(q, m) = w_1 \cdot \text{CosineSim}(\vec{E}_q, \vec{E}m) + w_2 \cdot S{decay}(\Delta t_m) + w_3 \cdot \log(1 + \text{AccessCount}_m)$$

Với các trọng số chuẩn hóa $w_1 + w_2 + w_3 = 1.0$ (thông thường $w_1 = 0.6$, $w_2 = 0.25$, $w_3 = 0.15$).

sequenceDiagram
    autonumber
    participant U as Người Dùng / Agent Workflow
    participant M as Tiered Memory Controller (Go 1.25)
    participant L1 as L1 Scratchpad (In-Memory Buffer)
    participant V as L2 Episodic Vector Store (Qdrant)
    participant G as L3 Graph Database (Neo4j)

    U->>M: Truy vấn: "Giải quyết sự cố timeout thanh toán"
    M->>L1: Kiểm tra trạng thái phiên làm việc hiện tại
    alt Có trong Working Scratchpad
        L1-->>M: Trả về ngữ cảnh nóng tức thì (0.2ms)
    else Không đủ ngữ cảnh trong L1
        par Tìm Kiếm Tương Đồng Ngữ Nghĩa & Tương Quan Đồ Thị
            M->>V: Hybrid ANN Search (Cosine + Time-Decay Score)
            M->>G: Cypher Query: MATCH (s:Service)-[:DEPENDS_ON]->(d)
        end
        V-->>M: Trả về Top 5 tình huống sự cố tương tự trong quá khứ
        G-->>M: Trả về cấu trúc phụ thuộc của dịch vụ thanh toán
        M->>M: Áp dụng Maximal Marginal Relevance (MMR) khử trùng lặp
        M->>L1: Nạp kết quả đã nén vào L1 Scratchpad
    end
    M-->>U: Trả về ngữ cảnh tối ưu hóa (Prompt Tokens tối thiểu)

4. Mã Nguồn Tham Chiếu Sản Xuất: Tiered Agentic Memory Controller Với Thuật Toán Suy Giảm Ebbinghaus (Go 1.25)

Dưới đây là bản triển khai chuẩn sản xuất bằng Go 1.25 của bộ điều khiển bộ nhớ phân tầng đa luồng. Mã nguồn bao gồm tính toán độ tương đồng Cosine song song, thuật toán phân rã chu kỳ bán rã (Half-Life Decay), và cơ chế đồng bộ hóa an toàn bằng sync.RWMutex.

// Package agentmemory triển khai bộ điều khiển bộ nhớ đa tầng (3-tier memory engine)
// chuẩn production bằng Go 1.25, kết hợp bộ nhớ làm việc L1 in-memory, cơ sở dữ liệu
// vector L2 và thuật toán phân rã thời gian theo hàm mũ Ebbinghaus.
package agentmemory

import (
	"context"
	"math"
	"sync"
	"time"
)

// MemoryRecord đại diện cho một bản ghi quan sát rời rạc được lưu trữ trong hệ thống.
type MemoryRecord struct {
	ID        string
	Content   string
	Embedding []float64
	Timestamp time.Time
	AccessCt  int
}

// TieredMemoryEngine quản lý bộ nhớ làm việc L1 và danh sách ký ức dài hạn L2.
type TieredMemoryEngine struct {
	mu           sync.RWMutex
	l1Scratchpad map[string]*MemoryRecord
	l2Records    []*MemoryRecord
	l1Capacity   int
	halfLifeSec  float64
}

// NewTieredMemoryEngine khởi tạo bộ điều khiển bộ nhớ an toàn đa luồng.
func NewTieredMemoryEngine(l1Cap int, halfLifeSec float64) *TieredMemoryEngine {
	return &TieredMemoryEngine{
		l1Scratchpad: make(map[string]*MemoryRecord),
		l2Records:    make([]*MemoryRecord, 0),
		l1Capacity:   l1Cap,
		halfLifeSec:  halfLifeSec,
	}
}

// CosineSimilarity tính toán độ tương đồng cosin giữa hai vector số thực.
func CosineSimilarity(a, b []float64) float64 {
	if len(a) != len(b) || len(a) == 0 {
		return 0.0
	}
	var dotProduct, normA, normB float64
	for i := 0; i < len(a); i++ {
		dotProduct += a[i] * b[i]
		normA += a[i] * a[i]
		normB += b[i] * b[i]
	}
	if normA == 0.0 || normB == 0.0 {
		return 0.0
	}
	return dotProduct / (math.Sqrt(normA) * math.Sqrt(normB))
}

// Store ghi nhận một ký ức mới vào tầng L1; nếu L1 đầy, tự động đẩy bản ghi cũ xuống L2.
func (e *TieredMemoryEngine) Store(ctx context.Context, rec *MemoryRecord) error {
	e.mu.Lock()
	defer e.mu.Unlock()

	// Nếu L1 đạt giới hạn dung lượng, chuyển bản ghi có ít tương tác nhất xuống L2
	if len(e.l1Scratchpad) >= e.l1Capacity {
		var oldestKey string
		oldestTime := time.Now()
		for k, v := range e.l1Scratchpad {
			if v.Timestamp.Before(oldestTime) {
				oldestTime = v.Timestamp
				oldestKey = k
			}
		}
		if oldestKey != "" {
			e.l2Records = append(e.l2Records, e.l1Scratchpad[oldestKey])
			delete(e.l1Scratchpad, oldestKey)
		}
	}

	e.l1Scratchpad[rec.ID] = rec
	return nil
}

// ScoredMemory chứa thông tin bản ghi kèm theo điểm xếp hạng tổng hợp.
type ScoredMemory struct {
	Record *MemoryRecord
	Score  float64
}

// Retrieve tìm kiếm các ký ức liên quan nhất dựa trên vector truy vấn, áp dụng suy giảm thời gian.
func (e *TieredMemoryEngine) Retrieve(ctx context.Context, queryEmbedding []float64, topK int) ([]ScoredMemory, error) {
	e.mu.Lock()
	defer e.mu.Unlock()

	now := time.Now()
	var scored []ScoredMemory

	// Thu thập toàn bộ bản ghi từ cả L1 và L2
	allRecords := make([]*MemoryRecord, 0, len(e.l1Scratchpad)+len(e.l2Records))
	for _, rec := range e.l1Scratchpad {
		allRecords = append(allRecords, rec)
	}
	for _, r := range e.l2Records {
		allRecords = append(allRecords, r)
	}

	for _, rec := range allRecords {
		sim := CosineSimilarity(queryEmbedding, rec.Embedding)

		// 1. Tính toán điểm suy giảm thời gian (Half-Life Decay)
		deltaSec := now.Sub(rec.Timestamp).Seconds()
		if deltaSec < 0 {
			deltaSec = 0
		}
		decay := math.Exp(-deltaSec * (math.Ln2 / e.halfLifeSec))

		// 2. Điểm tương tác (Access Frequency Weight)
		freqScore := math.Log1p(float64(rec.AccessCt)) * 0.1

		// 3. Điểm tổng hợp: 60% Tương đồng ngữ nghĩa + 30% Thời gian gần + 10% Tần suất
		compositeScore := (sim * 0.6) + (decay * 0.3) + freqScore

		rec.AccessCt++ // Cập nhật số lần đọc ký ức
		scored = append(scored, ScoredMemory{
			Record: rec,
			Score:  compositeScore,
		})
	}

	// Sắp xếp giảm dần theo điểm compositeScore bằng thuật toán Selection Sort đơn giản
	for i := 0; i < len(scored); i++ {
		maxIdx := i
		for j := i + 1; j < len(scored); j++ {
			if scored[j].Score > scored[maxIdx].Score {
				maxIdx = j
			}
		}
		scored[i], scored[maxIdx] = scored[maxIdx], scored[i]
	}

	if len(scored) > topK {
		return scored[:topK], nil
	}
	return scored, nil
}

5. Nghiên Cứu Sự Cố Thực Tế: Rò Rỉ Dữ Liệu Chéo Khách Thuê (Cross-Tenant Memory Leakage) Trong Production RAG

Bối Cảnh Sự Cố & Lỗ Hổng Kiến Trúc

Một nền tảng SaaS cung cấp trợ lý pháp lý AI phục vụ hàng trăm công ty luật độc lập. Hệ thống sử dụng một cụm Vector Database tập trung duy nhất để lưu trữ toàn bộ các cuộc đàm phán hợp đồng mật và tiền lệ tố tụng của các khách hàng khác nhau.

Để tối ưu chi phí lưu trữ, đội ngũ kỹ thuật quyết định chia sẻ chung một Vector Collection thay vì tạo các namespace riêng biệt. Việc phân quyền khách hàng được thực hiện thông qua trường metadata: tenant_id: "lawfirm_xyz".

Diễn Biến Thảm Họa Rò Rỉ

Vào tháng 11 năm 2026, một bản cập nhật phần mềm được đẩy lên môi trường sản xuất nhằm bổ sung kỹ thuật “Query Expansion with Graph Context”. Một lỗi lập trình xuất hiện trong hàm xây dựng câu lệnh lọc metadata (Filter Builder):

• Khi câu hỏi của người dùng chứa các thuật ngữ pháp lý phức tạp khiến chuỗi filter sinh ra quá dài, hàm parser đã vô tình cắt bớt điều kiện AND tenant_id == current_tenant.
• Hệ thống rơi vào trạng thái tìm kiếm Approximate Nearest Neighbors (ANN) trên toàn bộ không gian vector của mọi khách hàng.
• Một luật sư thuộc Công ty Luật A khi soạn thảo hồ sơ thâu tóm doanh nghiệp đã nhận được các trích dẫn hợp đồng sáp nhập bí mật thuộc về Công ty Luật B—vốn là đối thủ cạnh tranh trực tiếp trong cùng thương vụ.
• Vụ rò rỉ bị phát hiện sau khi Công ty A thắc mắc về nguồn gốc của một điều khoản bảo mật lạ xuất hiện trong câu trả lời của AI. Toàn bộ nền tảng SaaS bị phong tỏa để điều tra pháp y kỹ thuật số, đối mặt với các vụ kiện tụng vi phạm thỏa thuận bảo mật (NDA) trị giá hàng chục triệu USD.

Bài Học Tái Thiết Kế Kiến Trúc (Architectural Remediation)

1. Cô Lập Cứng Ở Tầng Hạ Tầng (Physical Tenant Isolation): Tuyệt đối không bao giờ dựa vào bộ lọc metadata mềm (Soft Filtering) để phân tách dữ liệu nhạy cảm trong hệ thống Agentic. Mỗi khách thuê bắt buộc phải có Collection riêng biệt hoặc sử dụng khóa mã hóa phần cứng (KMS Key) riêng biệt.
2. Bộ Lọc Ranh Giới Trước Khi Trả Về (Zero-Trust Retrieval Interceptor): Thiết lập một lớp proxy trung gian độc lập tại cổng mạng kiểm tra bắt buộc chữ ký số và Tenant ID của mọi vector trước khi cho phép dữ liệu đi vào Context Window của Agent.
3. Audit Log Khóa Bất Biến: Mọi thao tác đọc bộ nhớ dài hạn đều phải ghi nhận log vào hệ thống nhật ký Append-Only không thể chỉnh sửa, phục vụ việc đối soát tuân thủ bảo mật định kỳ.

❓ Câu Hỏi Thường Gặp (FAQ)

🔗 Liên Kết Hệ Thống Trọng Yếu & Tham Khảo Kỹ Thuật

Để hoàn thiện bức tranh kiến trúc hệ thống và tích hợp bộ nhớ đa tầng vào hạ tầng thực tế, bạn đọc hãy tiếp tục khám phá:

• Kiến Trúc Go Microservices Toàn Diện — Xây dựng hạ tầng vi dịch vụ kết nối với các hệ thống lưu trữ phân tán, Redis cache và cơ sở dữ liệu quan hệ tối ưu hóa.
• Generative UI với Model Context Protocol (MCP) & AI-Native Frontend — Đồng bộ hóa trạng thái bộ nhớ của tác nhân với giao diện người dùng thời gian thực.
• Bản Đồ Kỹ Năng & Lộ Trình Đọc Chuyên Sâu (Reading Map) — Hướng dẫn phương pháp tiếp cận các chuyên đề kỹ thuật phân tán và AI Engineering.
• Dịch Vụ Tư Vấn Kiến Trúc & Hợp Tác Kỹ Thuật (Hire Senior Architect) — Tư vấn chuyên sâu về thiết kế giải pháp lưu trữ vector, GraphRAG và tối ưu chi phí token cho doanh nghiệp.
• Phần 3: Secure Tool Calling & Guardrails — Chương tiếp theo: Bảo vệ hệ thống khỏi Prompt Injection, chuẩn hóa giao thức MCP 1.x và sandbox cách ly Wasm.