Cara Menambahkan Memori Persisten ke Agen AI Agar Ingat Kemarin

TL;DR

Tambahkan memori persisten ke agen AI dalam 4 langkah: (1) Siapkan server memori MCP dengan alat remember, recall, search, dan rollback, (2) Tambahkan instruksi memori ke _prompt_ agen, (3) Konfigurasi ~/.claude/settings.json untuk Claude Code atau .cursor/mcp.json untuk Cursor, (4) Gunakan pola memori untuk pencatatan keputusan, serah terima agen, dan titik periksa sesi. Agen mempertahankan konteks lintas sesi—tidak perlu lagi menyalin-tempel percakapan sebelumnya.

Selesaikan masalah "Saya tidak ingat kemarin". Tambahkan memori persisten ke agen AI menggunakan protokol MCP, dan mereka akan mengingat keputusan, hasil yang telah dikerjakan, dan konteks dari sesi sebelumnya.

Anda tahu aturannya:

Day 1: "Build the user authentication system"
Agent: [Membangun otentikasi JWT, membuat tabel pengguna, mengimplementasikan token refresh]

Day 2: "Lanjutkan dari kemarin"
Agent: "Saya tidak memiliki konteks dari sesi sebelumnya. Bisakah Anda menempelkan apa yang kita lakukan?"

Anda menyalin-tempel percakapan sebelumnya. Agen membaca 2000 baris konteks. Anda berdua membuang 15 menit untuk kembali memahami pekerjaan.

Memori persisten memperbaiki masalah ini. Dengan memori MCP (Model Context Protocol), agen secara otomatis menyimpan keputusan dan memanggilnya kembali saat dibutuhkan. Tanpa salin-tempel. Tanpa penjelasan ulang.

Dalam tutorial ini, Anda akan mengatur memori MCP untuk agen AI. Anda akan belajar cara menyimpan keputusan dari sesi Backend Architect, memanggil kembali konteks saat beralih ke Database Optimizer, dan menyerahkan hasil kerja ke Frontend Developer—semuanya tanpa kehilangan konteks. Pola memori yang sama berfungsi baik saat Anda membangun API dengan integrasi Apidog maupun mengelola _sprint_ pengembangan multi-hari.

tombol

Apa Itu Memori MCP?

Memori MCP memungkinkan agen AI menyimpan dan mengambil informasi di seluruh sesi. Bayangkan ini sebagai buku catatan bersama yang dapat ditulis dan dibaca oleh agen.

Empat alat yang menggerakkan memori MCP:

Alat	Tujuan	Contoh
`remember`	Menyimpan informasi dengan tag	Simpan “tabel pengguna dengan UUID, bcrypt”
`recall`	Mencari berdasarkan kata kunci atau tag	Temukan “keputusan otentikasi”
`rollback`	Mengembalikan ke kondisi sebelumnya	Batalkan perubahan skema yang buruk
`search`	Mencari di seluruh sesi	“Apa yang diputuskan oleh Backend Architect?”

┌─────────────────┐         ┌──────────────────┐         ┌─────────────┐
│  AI Agent       │         │  MCP Memory      │         │  Storage    │
│  (Claude Code)  │◄───────►│  Server          │◄───────►│  (SQLite)   │
└─────────────────┘   JSON  └──────────────────┘  I/O    └─────────────┘

Langkah 1: Siapkan Server Memori MCP

Anda membutuhkan server MCP yang menyediakan alat memori. Beberapa implementasi sumber terbuka tersedia.

Opsi A: Gunakan server memori yang di-hosting

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

Opsi B: Jalankan server lokal sederhana

Buat 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
server.tool(
  "remember",
  {
    content: z.string().describe("Information to store"),
    tags: z.array(z.string()).describe("Tags for retrieval (e.g., ['backend', 'auth'])"),
    agent: z.string().optional().describe("Agent name for tagging")
  },
  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: `Stored memory with tags: ${tags.join(", ")}` }] };
  }
);

// Tool: recall
server.tool(
  "recall",
  {
    query: z.string().describe("Search query or tag to find"),
    agent: z.string().optional().describe("Filter by agent name")
  },
  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
          ? "No memories found"
          : results.map(m => `[${m.timestamp}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: search
server.tool(
  "search",
  {
    tags: z.array(z.string()).describe("Tags to search for"),
    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
server.tool(
  "rollback",
  {
    agent: z.string().describe("Agent name to rollback"),
    timestamp: z.string().describe("Rollback to this timestamp")
  },
  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: `Rolled back ${agent} to ${timestamp}`
      }]
    };
  }
);

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

Jalankan server:

node memory-server.js

Langkah 2: Tambahkan Instruksi Memori ke Agen Mana Pun

Anda tidak perlu memodifikasi file agen. Tambahkan instruksi memori di _prompt_ Anda:

Anda memiliki akses ke alat memori MCP: remember, recall, search, rollback.

Ikuti protokol memori ini:

**Saat Anda memulai sesi:**
1. Panggil kembali konteks: recall(query="ecommerce-api", agent="Backend Architect")
2. Tinjau item yang tertunda dari sesi terakhir

**Saat Anda menyelesaikan pekerjaan:**
1. Ingat hasil kerja dengan tag:
   - remember(content="Membuat tabel pengguna dengan kunci utama UUID, hashing kata sandi bcrypt, otentikasi JWT dengan token refresh", tags=["ecommerce-api", "database", "auth"], agent="Backend Architect")
2. Sertakan keputusan yang dibuat dan item yang tertunda

**Saat menyerahkan ke agen lain:**
1. Tinggalkan konteks untuk agen penerima:
   - remember(content="Endpoint API: /auth/login, /auth/register, /products, /orders. Alur otentikasi: token akses JWT (15menit) + token refresh (7 hari). Masalah yang diketahui: pembatasan _rate_ belum diimplementasikan", tags=["ecommerce-api", "handoff"], agent="Backend Architect", for="Frontend Developer")

**Saat terjadi kegagalan:**
1. Cari status terakhir yang diketahui baik
2. Gunakan rollback untuk mengembalikan

Contoh dalam tindakan:

Anda: "Aktifkan mode Backend Architect. Rancang sistem pengguna untuk API e-commerce kita."

[Agen merancang sistem, membuat skema, mengimplementasikan otentikasi]

Agen: "Sistem pengguna selesai. Menyimpan memori..."
→ Memanggil: remember("tabel pengguna dengan UUID, bcrypt, JWT + token refresh", tags: ["ecommerce-api", "auth", "database"])

[Sesi berakhir]

[Keesokan harinya]

Anda: "Lanjutkan dari kemarin"

Agen: "Memanggil kembali konteks..."
→ Memanggil: recall(query="ecommerce-api")
→ Mengembalikan: "tabel pengguna dengan UUID, bcrypt, JWT + token refresh"

Agen: "Kemarin saya merancang tabel pengguna dengan kunci utama UUID, mengimplementasikan hashing kata sandi bcrypt, dan menyiapkan otentikasi JWT dengan token refresh. Langkah selanjutnya: skema katalog produk. Siap untuk melanjutkan."

Langkah 3: Konfigurasi untuk Claude Code

Tambahkan server memori ke konfigurasi MCP Anda:

Edit ~/.claude/settings.json:

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

Mulai ulang Claude Code. Alat memori sekarang seharusnya tersedia.

Uji:

Gunakan alat remember untuk menyimpan: "Test memory for ecommerce project"
Tags: ["test", "ecommerce-api"]

Gunakan alat recall untuk menemukan memori tentang "test"

Langkah 4: Konfigurasi untuk Cursor

Buat .cursor/mcp.json di proyek Anda:

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

Uji:

@memory remember "Memulai proyek API e-commerce dengan PostgreSQL"
Tags: ["ecommerce-api", "setup"]

@memory recall query="ecommerce"

Pola Memori untuk Alur Kerja Nyata

Pola 1: Pencatatan Keputusan

Setiap kali Anda membuat keputusan teknis, catatlah:

remember({
  content: "Memilih PostgreSQL daripada MySQL karena: (1) dukungan JSONB untuk atribut produk yang fleksibel, (2) pencarian teks penuh yang lebih baik, (3) dukungan asli UUID",
  tags: ["ecommerce-api", "database", "decision"],
  agent: "Backend Architect"
})

Kemudian, ketika seseorang bertanya “Mengapa PostgreSQL?”:

recall(query="PostgreSQL MySQL decision")

Pola 2: Serah Terima Agen

Saat beralih agen, tinggalkan catatan serah terima:

remember({
  content: "Backend selesai. Endpoint: POST /auth/login, POST /auth/register, GET /products, POST /orders. Otentikasi: akses JWT 15 menit + refresh 7 hari. Tertunda: pembatasan rate, verifikasi email. Kebutuhan frontend: form login, daftar produk, keranjang, checkout.",
  tags: ["ecommerce-api", "handoff", "backend-complete"],
  agent: "Backend Architect",
  for: "Frontend Developer"
})

Frontend Developer memulai dengan:

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

Pola 3: Titik Periksa Sesi

Di akhir setiap sesi kerja:

remember({
  content: "Sesi selesai. Selesai: tabel pengguna, endpoint otentikasi, skema produk. Sesi berikutnya: sistem pesanan, webhook pembayaran. Penghambat: menunggu kunci API Stripe.",
  tags: ["ecommerce-api", "checkpoint", "session-1"],
  agent: "Backend Architect"
})

Lanjutkan sesi berikutnya:

recall(query="checkpoint session-1")

Pola 4: Pelacakan Bug

Saat Anda menemukan bug:

remember({
  content: "BUG: Token refresh tidak kedaluwarsa setelah logout. Token disimpan di memori, tidak persisten. Perbaikan: pindahkan ke Redis dengan TTL.",
  tags: ["ecommerce-api", "bug", "auth"],
  agent: "Code Reviewer",
  severity: "high"
})

Cari bug nanti:

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

Penyelesaian Masalah

Memori tidak persisten:

Periksa jalur file memori (~/.mcp-memory/memories.json)
Pastikan server MCP berjalan
Verifikasi Claude Code/Cursor memiliki konfigurasi MCP

Terlalu banyak hasil saat memanggil kembali:

Tambahkan tag yang lebih spesifik
Filter berdasarkan nama agen
Gunakan frasa persis dalam tanda kutip

Ukuran file memori semakin besar:

Arsipkan memori lama secara berkala
Gunakan rollback untuk membersihkan proyek yang sudah selesai
Tambahkan tanggal kedaluwarsa ke skema memori Anda

Apa yang Anda Bangun

Komponen	Tujuan
Server Memori MCP	Menyimpan/mengambil informasi di seluruh sesi
Alat `remember`	Mencatat keputusan, hasil yang dikerjakan, serah terima
Alat `recall`	Menemukan konteks dari sesi sebelumnya
Alat `search`	Mencari berdasarkan tag di semua memori
Alat `rollback`	Mengembalikan ke kondisi sebelumnya saat dibutuhkan
Pola memori	Pencatatan keputusan, serah terima, titik periksa, pelacakan bug

Langkah Selanjutnya

Perluas server memori:

Tambahkan pencarian semantik dengan _embeddings_
Implementasikan kedaluwarsa memori (_auto-archive_ setelah 30 hari)
Tambahkan ringkasan memori (meringkas sesi yang panjang)

Bangun memori tim:

Bagikan server memori pusat di seluruh tim Anda
Beri tag memori berdasarkan proyek dan pengembang
Buat alur _onboarding_ untuk anggota tim baru

Integrasikan dengan alat:

Catat otomatis _commit git_ sebagai memori
Sinkronkan dengan manajemen proyek (Jira, Linear)
Ekspor memori ke dokumentasi

Memecahkan Masalah Umum

Memori tidak persisten antar sesi:

Periksa apakah server MCP berjalan sebelum memulai Claude Code
Verifikasi jalur file memori ada: ls -la ~/.mcp-memory/memories.json
Pastikan izin file memungkinkan baca/tulis: chmod 644 ~/.mcp-memory/memories.json
Konfirmasi konfigurasi server di ~/.claude/settings.json menunjuk ke jalur yang benar

Panggilan kembali mengembalikan hasil kosong:

Verifikasi _query_ cocok dengan tag yang disimpan (sensitif terhadap huruf besar/kecil)
Coba istilah pencarian yang lebih luas atau gunakan search dengan tag spesifik
Periksa apakah memori benar-benar disimpan: cat ~/.mcp-memory/memories.json
Pastikan filter nama agen cocok (jika menggunakan parameter agent)

Ukuran file memori semakin besar:

Implementasikan pengarsipan otomatis untuk memori yang lebih tua dari 30 hari
Tambahkan alat prune yang menghapus memori berdasarkan rentang tanggal
Pisahkan memori ke dalam file terpisah berdasarkan proyek atau tanggal
Gunakan _backend database_ (SQLite) alih-alih JSON untuk penggunaan skala besar

Server gagal memulai:

Periksa versi Node.js: node --version (seharusnya 18+)
Instal dependensi yang hilang: npm install @modelcontextprotocol/sdk zod
Cari kesalahan sintaks dalam kode server
Jalankan langsung untuk melihat kesalahan: node memory-server.js

Beberapa agen menimpa memori satu sama lain:

Selalu sertakan bidang agent saat memanggil remember
Gunakan tag unik per proyek: ["project-x", "backend", "auth"]
Filter panggilan kembali berdasarkan nama agen saat mengambil konteks
Pertimbangkan file memori terpisah per proyek

Pertimbangan Keamanan Server Memori

Penyimpanan Kunci API:Jika server memori Anda menyimpan data sensitif (kunci API, kata sandi), implementasikan enkripsi:

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');
}

Kontrol Akses:Untuk server memori tim, tambahkan otentikasi:

Wajibkan kunci API dalam panggilan alat memori
Implementasikan _namespaces_ memori khusus pengguna
Catat semua operasi memori untuk _audit trail_
Batasi _rate request_ per pengguna

Agen AI Anda sekarang memiliki memori persisten. Mereka mengingat kemarin. Mereka memanggil kembali keputusan. Mereka menyerahkan konteks tanpa salin-tempel.

Tidak ada lagi "Saya tidak memiliki konteks dari sesi sebelumnya." Tidak ada lagi penjelasan ulang. Tidak ada lagi waktu yang terbuang.

Itulah kekuatan memori MCP: berikan agen Anda buku catatan bersama, dan saksikan mereka menjadi benar-benar berguna di seluruh proyek multi-hari.

tombol

FAQ

Apa itu memori MCP?Memori MCP adalah implementasi protokol yang memungkinkan agen AI menyimpan dan mengambil informasi di seluruh sesi. Bayangkan ini sebagai buku catatan bersama yang dapat ditulis dan dibaca oleh agen, mempertahankan konteks di luar percakapan tunggal.

Bagaimana cara mengatur memori persisten untuk Claude Code?Instal server memori MCP, lalu tambahkan ke ~/.claude/settings.json dengan perintah server dan jalurnya. Mulai ulang Claude Code dan alat memori (remember, recall, search, rollback) akan tersedia.

Agen AI mana yang mendukung memori MCP?Agen apa pun yang berjalan di klien yang kompatibel dengan MCP (Claude Code, Cursor, Windsurf) dapat menggunakan alat memori. Anda tidak perlu memodifikasi file agen—cukup tambahkan instruksi memori ke _prompt_ Anda.

Apa pola memori terbaik untuk serah terima agen?Gunakan remember dengan tag seperti ["handoff", "nama-proyek"] untuk meninggalkan konteks bagi agen berikutnya. Sertakan pekerjaan yang sudah selesai, item yang tertunda, dan masalah yang diketahui. Agen penerima memanggil recall(query="handoff") untuk mengambilnya.

Berapa banyak memori yang dapat disimpan oleh server MCP?Tergantung pada implementasinya. Server referensi menggunakan file JSON yang ukurannya dapat bertambah tanpa batas. Server produksi harus menambahkan kebijakan kedaluwarsa, pengarsipan otomatis, atau _backend database_ untuk penggunaan skala besar.

Bisakah tim berbagi server memori pusat?Ya. Jalankan server memori di mesin bersama atau instans _cloud_, konfigurasikan klien semua anggota tim untuk terhubung ke sana, dan beri tag memori berdasarkan proyek dan pengembang untuk pengambilan yang terorganisir.

Bagaimana jika pemanggilan kembali memori mengembalikan terlalu banyak hasil?Tambahkan tag yang lebih spesifik saat menyimpan memori. Filter berdasarkan nama agen dalam _query_ panggilan kembali Anda. Gunakan frasa persis dalam tanda kutip. Pertimbangkan untuk mengimplementasikan pencarian semantik dengan _embeddings_ untuk pengambilan yang lebih cerdas.