Blog

Cách Thêm Bộ Nhớ Vĩnh Viễn Cho AI Agent (Để Nhớ Được Hôm Qua)

Ashley Innocent

Ashley Innocent

19 tháng 3 2026

Cách Thêm Bộ Nhớ Vĩnh Viễn Cho AI Agent (Để Nhớ Được Hôm Qua)

TÓM TẮT

Thêm bộ nhớ bền vững cho các tác nhân AI qua 4 bước: (1) Thiết lập máy chủ bộ nhớ MCP với các công cụ remember, recall, search và rollback, (2) Thêm hướng dẫn bộ nhớ vào lời nhắc của tác nhân, (3) Cấu hình ~/.claude/settings.json cho Claude Code hoặc .cursor/mcp.json cho Cursor, (4) Sử dụng các mẫu bộ nhớ để ghi nhật ký quyết định, chuyển giao tác nhân và điểm kiểm tra phiên. Các tác nhân giữ ngữ cảnh qua các phiên — không còn sao chép-dán các cuộc trò chuyện trước đó nữa.

Giải quyết vấn đề “Tôi không nhớ ngày hôm qua”. Thêm bộ nhớ bền vững cho các tác nhân AI bằng giao thức MCP, và chúng sẽ nhớ các quyết định, sản phẩm bàn giao và ngữ cảnh từ các phiên trước đó.

Bạn biết quy trình rồi đấy:

Ngày 1: "Xây dựng hệ thống xác thực người dùng"
Tác nhân: [Xây dựng xác thực JWT, tạo bảng người dùng, triển khai mã thông báo làm mới]

Ngày 2: "Tiếp tục từ ngày hôm qua"
Tác nhân: "Tôi không có ngữ cảnh từ các phiên trước đó. Bạn có thể dán những gì chúng ta đã làm không?"

Bạn sao chép-dán cuộc trò chuyện trước đó. Tác nhân đọc 2000 dòng ngữ cảnh. Cả hai bạn lãng phí 15 phút để lấy lại tốc độ.

Bộ nhớ bền vững khắc phục điều này. Với bộ nhớ MCP (Model Context Protocol), các tác nhân tự động lưu trữ các quyết định và thu hồi chúng khi cần. Không sao chép-dán. Không giải thích lại.

Trong hướng dẫn này, bạn sẽ thiết lập bộ nhớ MCP cho các tác nhân AI. Bạn sẽ học cách lưu trữ các quyết định từ các phiên Kiến trúc sư Backend, thu hồi ngữ cảnh khi chuyển sang Tối ưu hóa Cơ sở dữ liệu và chuyển giao sản phẩm bàn giao cho Nhà phát triển Frontend — tất cả mà không mất ngữ cảnh. Các mẫu bộ nhớ tương tự hoạt động cho dù bạn đang xây dựng API với tích hợp Apidog hay quản lý các đợt phát triển nhiều ngày.

button

Bộ nhớ MCP là gì?

Bộ nhớ MCP cho phép các tác nhân AI lưu trữ và truy xuất thông tin qua các phiên. Hãy coi nó như một cuốn sổ ghi chú dùng chung mà các tác nhân có thể viết vào và đọc từ đó.

Bốn công cụ hỗ trợ bộ nhớ MCP:

Công cụ Mục đích Ví dụ
remember Lưu trữ thông tin với các thẻ Lưu "bảng người dùng với UUID, bcrypt"
recall Tìm kiếm theo từ khóa hoặc thẻ Tìm "quyết định xác thực"
rollback Khôi phục về trạng thái trước đó Hoàn tác các thay đổi lược đồ tồi
search Tìm kiếm trên các phiên "Kiến trúc sư Backend đã quyết định gì?" 
┌─────────────────┐         ┌──────────────────┐         ┌─────────────┐
│  Tác nhân AI    │         │  Máy chủ bộ nhớ  │         │  Lưu trữ    │
│  (Claude Code)  │◄───────►│  MCP             │◄───────►│  (SQLite)   │
└─────────────────┘   JSON  └──────────────────┘  I/O    └─────────────┘

Bước 1: Thiết lập Máy chủ Bộ nhớ MCP

Bạn cần một máy chủ MCP cung cấp các công cụ bộ nhớ. Có một số triển khai mã nguồn mở hiện có.

Tùy chọn A: Sử dụng máy chủ bộ nhớ được lưu trữ

npm install -g @example/mcp-memory-server

Tùy chọn B: Chạy một máy chủ cục bộ đơn giản

Tạo memory-server.js:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs/promises";
import path from "path";

const MEMORY_FILE = path.join(process.env.HOME, ".mcp-memory", "memories.json");

const server = new McpServer({
  name: "memory",
  version: "1.0.0"
});

// Ensure memory file exists
async function initMemory() {
  await fs.mkdir(path.dirname(MEMORY_FILE), { recursive: true });
  try {
    await fs.access(MEMORY_FILE);
  } catch {
    await fs.writeFile(MEMORY_FILE, JSON.stringify([]));
  }
}

// Tool: remember (Công cụ: remember)
server.tool(
  "remember",
  {
    content: z.string().describe("Thông tin cần lưu trữ"),
    tags: z.array(z.string()).describe("Thẻ để truy xuất (ví dụ: ['backend', 'auth'])"),
    agent: z.string().optional().describe("Tên tác nhân để gắn thẻ")
  },
  async ({ content, tags, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const memory = {
      id: Date.now().toString(),
      content,
      tags,
      agent,
      timestamp: new Date().toISOString()
    };
    memories.push(memory);
    await fs.writeFile(MEMORY_FILE, JSON.stringify(memories, null, 2));
    return { content: [{ type: "text", text: `Đã lưu bộ nhớ với các thẻ: ${tags.join(", ")}` }] };
  }
);

// Tool: recall (Công cụ: recall)
server.tool(
  "recall",
  {
    query: z.string().describe("Truy vấn tìm kiếm hoặc thẻ để tìm"),
    agent: z.string().optional().describe("Lọc theo tên tác nhân")
  },
  async ({ query, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories.filter(m => {
      const matchesQuery = m.content.toLowerCase().includes(query.toLowerCase()) ||
                          m.tags.some(t => t.toLowerCase().includes(query.toLowerCase()));
      const matchesAgent = !agent || m.agent === agent;
      return matchesQuery && matchesAgent;
    });
    return {
      content: [{
        type: "text",
        text: results.length === 0
          ? "Không tìm thấy bộ nhớ nào"
          : results.map(m => `[${m.timestamp}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: search (Công cụ: search)
server.tool(
  "search",
  {
    tags: z.array(z.string()).describe("Các thẻ cần tìm kiếm"),
    limit: z.number().optional().default(10)
  },
  async ({ tags, limit }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories
      .filter(m => tags.some(t => m.tags.includes(t)))
      .slice(0, limit);
    return {
      content: [{
        type: "text",
        text: results.map(m => `[${m.agent || "unknown"}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: rollback (Công cụ: rollback)
server.tool(
  "rollback",
  {
    agent: z.string().describe("Tên tác nhân để khôi phục"),
    timestamp: z.string().describe("Khôi phục về thời điểm này")
  },
  async ({ agent, timestamp }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const rolledBack = memories.filter(m =>
      m.agent !== agent || new Date(m.timestamp) <= new Date(timestamp)
    );
    await fs.writeFile(MEMORY_FILE, JSON.stringify(rolledBack, null, 2));
    return {
      content: [{
        type: "text",
        text: `Đã khôi phục ${agent} về ${timestamp}`
      }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Chạy máy chủ:

node memory-server.js

Bước 2: Thêm Hướng dẫn Bộ nhớ vào Bất kỳ Tác nhân nào

Bạn không cần sửa đổi tệp tác nhân. Thêm hướng dẫn bộ nhớ vào lời nhắc của bạn:

Bạn có quyền truy cập vào các công cụ bộ nhớ MCP: remember, recall, search, rollback.

Tuân thủ các giao thức bộ nhớ sau:

**Khi bạn bắt đầu một phiên:**
1. Thu hồi ngữ cảnh: recall(query="ecommerce-api", agent="Backend Architect")
2. Xem lại các mục đang chờ xử lý từ phiên trước

**Khi bạn hoàn thành công việc:**
1. Ghi nhớ các sản phẩm bàn giao với các thẻ:
   - remember(content="Đã tạo bảng người dùng với khóa chính UUID, băm mật khẩu bcrypt, xác thực JWT với mã thông báo làm mới", tags=["ecommerce-api", "database", "auth"], agent="Backend Architect")
2. Bao gồm các quyết định đã đưa ra và các mục đang chờ xử lý

**Khi chuyển giao cho một tác nhân khác:**
1. Để lại ngữ cảnh cho tác nhân nhận:
   - remember(content="Điểm cuối API: /auth/login, /auth/register, /products, /orders. Luồng xác thực: mã thông báo truy cập JWT (15 phút) + mã thông báo làm mới (7 ngày). Vấn đề đã biết: giới hạn tốc độ chưa được triển khai", tags=["ecommerce-api", "handoff"], agent="Backend Architect", for="Frontend Developer")

**Khi có lỗi:**
1. Tìm kiếm trạng thái tốt đã biết gần nhất
2. Sử dụng rollback để khôi phục

Ví dụ thực tế:

Bạn: "Kích hoạt chế độ Kiến trúc sư Backend. Thiết kế hệ thống người dùng cho API thương mại điện tử của chúng ta."

[Tác nhân thiết kế hệ thống, tạo lược đồ, triển khai xác thực]

Tác nhân: "Hệ thống người dùng hoàn tất. Đang lưu bộ nhớ..."
→ Gọi: remember("bảng người dùng với UUID, bcrypt, JWT + mã thông báo làm mới", tags: ["ecommerce-api", "auth", "database"])

[Kết thúc phiên]

[Ngày hôm sau]

Bạn: "Tiếp tục từ ngày hôm qua"

Tác nhân: "Đang thu hồi ngữ cảnh..."
→ Gọi: recall(query="ecommerce-api")
→ Trả về: "bảng người dùng với UUID, bcrypt, JWT + mã thông báo làm mới"

Tác nhân: "Hôm qua tôi đã thiết kế bảng người dùng với khóa chính UUID, triển khai băm mật khẩu bcrypt và thiết lập xác thực JWT với mã thông báo làm mới. Bước tiếp theo: lược đồ danh mục sản phẩm. Sẵn sàng tiếp tục."

Bước 3: Cấu hình cho Claude Code

Thêm máy chủ bộ nhớ vào cấu hình MCP của bạn:

Chỉnh sửa ~/.claude/settings.json:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"],
      "env": {
        "HOME": "/Users/your-username"
      }
    }
  }
}

Khởi động lại Claude Code. Các công cụ bộ nhớ giờ đây sẽ có sẵn.

Kiểm tra:

Sử dụng công cụ remember để lưu trữ: "Bộ nhớ thử nghiệm cho dự án thương mại điện tử"
Thẻ: ["test", "ecommerce-api"]

Sử dụng công cụ recall để tìm bộ nhớ về "test"

Bước 4: Cấu hình cho Cursor

Tạo .cursor/mcp.json trong dự án của bạn:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"]
    }
  }
}

Kiểm tra:

@memory remember "Bắt đầu dự án API thương mại điện tử với PostgreSQL"
Thẻ: ["ecommerce-api", "setup"]

@memory recall query="ecommerce"

Các Mẫu Bộ nhớ cho Luồng Công việc Thực tế

Mẫu 1: Ghi nhật ký Quyết định

Mỗi khi bạn đưa ra một quyết định kỹ thuật, hãy ghi lại:

remember({
  content: "Chọn PostgreSQL thay vì MySQL vì: (1) hỗ trợ JSONB cho các thuộc tính sản phẩm linh hoạt, (2) tìm kiếm toàn văn tốt hơn, (3) hỗ trợ UUID gốc",
  tags: ["ecommerce-api", "database", "decision"],
  agent: "Backend Architect"
})

Sau này, khi ai đó hỏi “Tại sao lại là PostgreSQL?”:

recall(query="quyết định PostgreSQL MySQL")

Mẫu 2: Chuyển giao Tác nhân

Khi chuyển đổi tác nhân, hãy để lại ghi chú chuyển giao:

remember({
  content: "Backend hoàn tất. Điểm cuối: POST /auth/login, POST /auth/register, GET /products, POST /orders. Xác thực: truy cập JWT 15 phút + làm mới 7 ngày. Đang chờ xử lý: giới hạn tốc độ, xác minh email. Frontend cần: biểu mẫu đăng nhập, danh sách sản phẩm, giỏ hàng, thanh toán.",
  tags: ["ecommerce-api", "handoff", "backend-complete"],
  agent: "Backend Architect",
  for: "Frontend Developer"
})

Nhà phát triển Frontend bắt đầu với:

recall(query="handoff", agent="Backend Architect")

Mẫu 3: Điểm kiểm soát Phiên

Khi kết thúc mỗi phiên làm việc:

remember({
  content: "Phiên hoàn tất. Đã xong: bảng người dùng, điểm cuối xác thực, lược đồ sản phẩm. Phiên tiếp theo: hệ thống đặt hàng, webhook thanh toán. Chặn: đang chờ khóa API Stripe.",
  tags: ["ecommerce-api", "checkpoint", "session-1"],
  agent: "Backend Architect"
})

Tiếp tục phiên tiếp theo:

recall(query="checkpoint session-1")

Mẫu 4: Theo dõi Lỗi

Khi bạn tìm thấy một lỗi:

remember({
  content: "LỖI: Mã thông báo làm mới không hết hạn sau khi đăng xuất. Mã thông báo được lưu trong bộ nhớ, không bền vững. Khắc phục: chuyển sang Redis với TTL.",
  tags: ["ecommerce-api", "bug", "auth"],
  agent: "Code Reviewer",
  severity: "high"
})

Tìm kiếm lỗi sau này:

search(tags=["bug", "ecommerce-api"])

Khắc phục sự cố

Bộ nhớ không bền vững:

Quá nhiều kết quả khi thu hồi:

Tệp bộ nhớ ngày càng lớn:

Những Gì Bạn Đã Xây Dựng

Thành phần Mục đích
Máy chủ Bộ nhớ MCP Lưu trữ/truy xuất thông tin qua các phiên
Công cụ remember Ghi nhật ký quyết định, sản phẩm bàn giao, chuyển giao
Công cụ recall Tìm ngữ cảnh từ các phiên trước đó
Công cụ search Truy vấn theo thẻ trên tất cả các bộ nhớ
Công cụ rollback Khôi phục về trạng thái trước đó khi cần
Các mẫu bộ nhớ Ghi nhật ký quyết định, chuyển giao, điểm kiểm tra, theo dõi lỗi

Các Bước Tiếp theo

Mở rộng máy chủ bộ nhớ:

Xây dựng bộ nhớ nhóm:

Tích hợp với các công cụ:

Khắc phục các Sự cố Thường gặp

Bộ nhớ không bền vững giữa các phiên:

Thu hồi trả về kết quả trống:

Tệp bộ nhớ ngày càng lớn:

Máy chủ không khởi động được:

Nhiều tác nhân ghi đè bộ nhớ của nhau:

Các Vấn đề Bảo mật của Máy chủ Bộ nhớ

Lưu trữ Khóa API:Nếu máy chủ bộ nhớ của bạn lưu trữ dữ liệu nhạy cảm (khóa API, mật khẩu), hãy triển khai mã hóa:

import crypto from 'crypto';

const ENCRYPTION_KEY = process.env.MEMORY_ENCRYPTION_KEY;
const ALGORITHM = 'aes-256-gcm';

function encrypt(text) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY), iv);
  const encrypted = cipher.update(text, 'utf8', 'hex');
  return {
    encryptedData: encrypted + cipher.final('hex'),
    iv: iv.toString('hex'),
    authTag: cipher.getAuthTag().toString('hex')
  };
}

function decrypt(encrypted) {
  const decipher = crypto.createDecipheriv(
    ALGORITHM,
    Buffer.from(ENCRYPTION_KEY),
    Buffer.from(encrypted.iv, 'hex')
  );
  decipher.setAuthTag(Buffer.from(encrypted.authTag, 'hex'));
  return decipher.update(encrypted.encryptedData, 'hex', 'utf8') + decipher.final('utf8');
}

Kiểm soát Truy cập:Đối với các máy chủ bộ nhớ nhóm, hãy thêm xác thực:

Các tác nhân AI của bạn giờ đây có bộ nhớ bền vững. Chúng nhớ ngày hôm qua. Chúng thu hồi các quyết định. Chúng chuyển giao ngữ cảnh mà không cần sao chép-dán.

Không còn “Tôi không có ngữ cảnh từ các phiên trước nữa.” Không còn giải thích lại. Không còn lãng phí thời gian.

Đó là sức mạnh của bộ nhớ MCP: cung cấp cho các tác nhân của bạn một cuốn sổ ghi chú dùng chung và xem chúng trở nên thực sự hữu ích trong các dự án nhiều ngày.

button

Câu hỏi thường gặp

Bộ nhớ MCP là gì?Bộ nhớ MCP là một triển khai giao thức cho phép các tác nhân AI lưu trữ và truy xuất thông tin qua các phiên. Hãy coi nó như một cuốn sổ ghi chú dùng chung mà các tác nhân có thể viết vào và đọc từ đó, duy trì ngữ cảnh vượt ra ngoài các cuộc hội thoại đơn lẻ.

Làm cách nào để thiết lập bộ nhớ bền vững cho Claude Code?Cài đặt một máy chủ bộ nhớ MCP, sau đó thêm nó vào ~/.claude/settings.json với lệnh và đường dẫn máy chủ. Khởi động lại Claude Code và các công cụ bộ nhớ (remember, recall, search, rollback) sẽ có sẵn.

Những tác nhân AI nào hỗ trợ bộ nhớ MCP?Bất kỳ tác nhân nào chạy trên các máy khách tương thích MCP (Claude Code, Cursor, Windsurf) đều có thể sử dụng các công cụ bộ nhớ. Bạn không cần sửa đổi tệp tác nhân — chỉ cần thêm hướng dẫn bộ nhớ vào lời nhắc của bạn.

Các mẫu bộ nhớ tốt nhất để chuyển giao tác nhân là gì?Sử dụng remember với các thẻ như ["handoff", "project-name"] để lại ngữ cảnh cho tác nhân tiếp theo. Bao gồm công việc đã hoàn thành, các mục đang chờ xử lý và các vấn đề đã biết. Tác nhân nhận sẽ gọi recall(query="handoff") để truy xuất.

Máy chủ MCP có thể lưu trữ bao nhiêu bộ nhớ?Tùy thuộc vào triển khai. Máy chủ tham chiếu sử dụng một tệp JSON có thể phát triển vô hạn. Các máy chủ sản xuất nên thêm chính sách hết hạn, tự động lưu trữ hoặc các backend cơ sở dữ liệu để sử dụng quy mô lớn.

Các nhóm có thể chia sẻ một máy chủ bộ nhớ trung tâm không?Có. Chạy máy chủ bộ nhớ trên một máy dùng chung hoặc phiên bản đám mây, cấu hình tất cả các máy khách của thành viên nhóm để kết nối với nó và gắn thẻ bộ nhớ theo dự án và nhà phát triển để truy xuất có tổ chức.

Nếu thu hồi bộ nhớ trả về quá nhiều kết quả thì sao?Thêm các thẻ cụ thể hơn khi lưu trữ bộ nhớ. Lọc theo tên tác nhân trong các truy vấn thu hồi của bạn. Sử dụng các cụm từ chính xác trong dấu ngoặc kép. Cân nhắc triển khai tìm kiếm ngữ nghĩa với các nhúng để truy xuất thông minh hơn.

Thực hành thiết kế API trong Apidog

Khám phá cách dễ dàng hơn để xây dựng và sử dụng API

Đăng ký miễn phíTải xuống