DEV Community

Cover image for Cara Menambahkan Memori Persisten ke Agen AI Agar Ingat Kemarin
Walse
Walse

Posted on • Originally published at apidog.com

Cara Menambahkan Memori Persisten ke Agen AI Agar Ingat Kemarin

#ai #mcp #agents #tutorial

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.

Coba Apidog hari ini

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?"
Enter fullscreen mode Exit fullscreen mode

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.

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    └─────────────┘
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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);
Enter fullscreen mode Exit fullscreen mode

Jalankan server:

node memory-server.js
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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."
Enter fullscreen mode Exit fullscreen mode

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"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Mulai ulang Claude Code. Alat memori sekarang seharusnya tersedia.

Uji:

Gunakan alat remember untuk menyimpan: "Test memory for ecommerce project"
Tags: ["test", "ecommerce-api"]
Enter fullscreen mode Exit fullscreen mode 
Gunakan alat recall untuk menemukan memori tentang "test"
Enter fullscreen mode Exit fullscreen mode

Langkah 4: Konfigurasi untuk Cursor

Buat .cursor/mcp.json di proyek Anda:

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

Uji:

@memory remember "Memulai proyek API e-commerce dengan PostgreSQL"
Tags: ["ecommerce-api", "setup"]
Enter fullscreen mode Exit fullscreen mode 
@memory recall query="ecommerce"
Enter fullscreen mode Exit fullscreen mode

Pola Memori untuk Alur Kerja Nyata

Pola 1: Pencatatan Keputusan

Catat setiap keputusan teknis:

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"
})
Enter fullscreen mode Exit fullscreen mode

Lalu, jika ditanya “Mengapa PostgreSQL?”:

recall(query="PostgreSQL MySQL decision")
Enter fullscreen mode Exit fullscreen mode

Pola 2: Serah Terima Agen

Saat berpindah 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"
})
Enter fullscreen mode Exit fullscreen mode

Frontend Developer mulai dengan:

recall(query="handoff", agent="Backend Architect")
Enter fullscreen mode Exit fullscreen mode

Pola 3: Titik Periksa Sesi

Di akhir 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"
})
Enter fullscreen mode Exit fullscreen mode

Lanjutkan sesi berikutnya:

recall(query="checkpoint session-1")
Enter fullscreen mode Exit fullscreen mode

Pola 4: Pelacakan Bug

Saat 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"
})
Enter fullscreen mode Exit fullscreen mode

Cari bug:

search(tags=["bug", "ecommerce-api"])
Enter fullscreen mode Exit fullscreen mode

Penyelesaian Masalah

Memori tidak persisten:

  • Pastikan jalur file memori (~/.mcp-memory/memories.json) benar
  • Server MCP berjalan
  • Konfigurasi Claude Code/Cursor sudah benar

Terlalu banyak hasil saat recall:

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

Ukuran file memori besar:

  • Arsipkan memori lama
  • Gunakan rollback untuk membersihkan proyek selesai
  • Tambahkan tanggal kedaluwarsa ke skema memori

Apa yang Anda Bangun

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

Langkah Selanjutnya

Perluas server memori:

  • Tambahkan pencarian semantik dengan embeddings
  • Implementasikan auto-archive setelah 30 hari
  • Tambahkan ringkasan memori (summarize session)

Bangun memori tim:

  • Bagikan server memori pusat ke seluruh tim
  • Tag memori berdasarkan proyek/pengembang
  • Buat alur onboarding anggota baru

Integrasi dengan alat:

  • Catat otomatis commit git sebagai memori
  • Sinkron dengan Jira/Linear
  • Ekspor memori ke dokumentasi

Memecahkan Masalah Umum

Memori tidak persisten antar sesi:

  • Pastikan server MCP berjalan sebelum Claude Code
  • Verifikasi file memori: ls -la ~/.mcp-memory/memories.json
  • Pastikan izin file: chmod 644 ~/.mcp-memory/memories.json
  • Konfirmasi konfigurasi server di ~/.claude/settings.json

Recall mengembalikan hasil kosong:

  • Verifikasi query cocok dengan tag (case sensitive)
  • Coba istilah pencarian lebih luas atau gunakan search
  • Pastikan memori benar-benar disimpan: cat ~/.mcp-memory/memories.json
  • Gunakan filter agent jika perlu

Ukuran file memori besar:

  • Implementasikan auto-archive > 30 hari
  • Tambahkan alat prune untuk hapus memori berdasarkan tanggal
  • Pisahkan file memori per proyek/tanggal
  • Gunakan backend database (SQLite) untuk skala besar

Server gagal mulai:

  • Periksa versi Node.js: node --version (minimal 18)
  • Instal dependensi: npm install @modelcontextprotocol/sdk zod
  • Periksa kesalahan sintaks kode server
  • Jalankan langsung untuk debugging: node memory-server.js

Agen saling menimpa memori:

  • Selalu sertakan field agent saat remember
  • Gunakan tag unik: ["project-x", "backend", "auth"]
  • Filter recall berdasarkan agent
  • Pertimbangkan file memori terpisah per proyek

Pertimbangan Keamanan Server Memori

Penyimpanan Kunci API:

Jika server memori Anda menyimpan data sensitif, 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');
}
Enter fullscreen mode Exit fullscreen mode

Kontrol Akses:

  • Wajibkan kunci API pada setiap panggilan alat memori
  • Implementasikan namespace memori per user
  • Logging semua operasi memori untuk audit trail
  • Batasi rate request per pengguna

Agen AI Anda sekarang memiliki memori persisten. Mereka mengingat kemarin, memanggil kembali keputusan, dan 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.

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) siap dipakai.

Agen AI mana yang mendukung memori MCP?

Agen apa pun yang berjalan di klien kompatibel MCP (Claude Code, Cursor, Windsurf) dapat pakai alat memori. Anda tidak perlu modifikasi file agen—cukup tambahkan instruksi memori di prompt.

Apa pola memori terbaik untuk serah terima agen?

Gunakan remember dengan tag seperti ["handoff", "nama-proyek"] untuk meninggalkan konteks bagi agen berikutnya. Sertakan pekerjaan selesai, item tertunda, dan masalah diketahui. Agen penerima cukup recall(query="handoff").

Berapa banyak memori yang dapat disimpan server MCP?

Tergantung implementasinya. Server referensi menggunakan file JSON yang ukurannya bertambah tanpa batas. Untuk produksi, tambahkan kebijakan kedaluwarsa, auto-archive, atau backend database untuk skala besar.

Bisakah tim berbagi server memori pusat?

Ya. Jalankan server memori di mesin bersama atau cloud, konfigurasi klien semua tim ke sana, dan tag memori berdasar proyek/pengembang untuk pengambilan terorganisir.

Bagaimana jika recall mengembalikan terlalu banyak hasil?

Tambahkan tag lebih spesifik saat menyimpan memori. Filter berdasarkan nama agen. Gunakan frasa persis dalam tanda kutip. Untuk pengambilan lebih cerdas, pertimbangkan pencarian semantik dengan embeddings.

Top comments (0)