Belajar AI Engineer - Memory & State Management

#Pendahuluan

Agent dari episode 11 punya satu kelemahan besar: amnesia total. Setiap percakapan baru dimulai dari nol. Episode ini memperbaiki itu dengan memory & state management — kemampuan agent mengingat apa yang dibicarakan, di dalam satu sesi (short-term) maupun lintas sesi (long-term).

Mengapa penting? Karena produk AI nyata (customer support, asisten pribadi) tidak berfungsi tanpa konteks berkelanjutan. Tapi — dan ini kuncinya — menyimpan semua riwayat lalu memasukkan semuanya ke prompt adalah bencana biaya. Memory yang baik adalah tentang menyimpan utuh dan mengambil secukupnya.

#Dua Jenis Memori

Kesalahannya: memasukkan long-term memory utuh ke prompt. Benarnya: simpan utuh di database, masukkan secukupnya ke prompt — persis prinsip yang kita bahas di episode 8.

#Short-term Memory: Riwayat Percakapan

Short-term memory adalah daftar pesan yang kita kirim ke model. Kelolanya dengan anggaran token (episode 8): trim pesan lama, ringkas yang perlu, sisakan detail untuk yang terakhir.

Kelola short-term memory

def build_prompt(history: list[dict], max_tokens: int = 4000) -> list[dict]:
    # ringkas pesan tertua, pertahankan detail terbaru
    system = [m for m in history if m["role"] == "system"]
    rest = history[len(system):]
    if est_tokens(rest) > max_tokens:  # placeholder
        rest = [{"role": "system",
                 "content": "Ringkasan: " + summarize(rest[:-6])}] + rest[-6:]
    return system + rest

#Long-term Memory: Persistensi

Untuk mengingat lintas sesi, simpan percakapan di database dengan struktur sederhana:

CREATE TABLE conversations (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id TEXT NOT NULL,
    title TEXT,
    created_at TEXT DEFAULT CURRENT_TIMESTAMP
);
 
CREATE TABLE messages (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    conversation_id INTEGER NOT NULL REFERENCES conversations(id),
    role TEXT NOT NULL,           -- system / user / assistant / tool
    content TEXT NOT NULL,
    created_at TEXT DEFAULT CURRENT_TIMESTAMP
);

persist.py - simpan dan muat riwayat

import sqlite3
from pathlib import Path
 
DB = Path.home() / "ai-engineer-lab" / "memory.db"
 
def save_message(conv_id: int, role: str, content: str) -> None:
    with sqlite3.connect(DB) as conn:
        conn.execute(
            "INSERT INTO messages (conversation_id, role, content) VALUES (?, ?, ?)",
            (conv_id, role, content))
 
def load_history(conv_id: int, limit: int = 40) -> list[dict]:
    with sqlite3.connect(DB) as conn:
        rows = conn.execute(
            "SELECT role, content FROM messages WHERE conversation_id = ? "
            "ORDER BY id DESC LIMIT ?", (conv_id, limit)).fetchall()
    return [{"role": r, "content": c} for r, c in reversed(rows)]
 
def new_conversation(user_id: str) -> int:
    with sqlite3.connect(DB) as conn:
        cur = conn.execute("INSERT INTO conversations (user_id) VALUES (?)",
                           (user_id,))
        return cur.lastrowid

Pola ini memungkinkan agent "melanjutkan" percakapan yang terputus — user kembali minggu depan dan agent masih tahu konteksnya.

#Conversation State: Lebih dari Sekadar Pesan

State percakapan bukan hanya pesan. Banyak aplikasi butuh structured state: nama pengguna, langkah wizard yang sedang berjalan, preferensi, keranjang belanja. Simpan sebagai JSON terpisah, bukan hanya dalam riwayat:

{
  "user_id": "u-4821",
  "langkah": "konfirmasi_alamat",
  "profil": {"nama": "Rina", "preferensi": "produk bayi"},
  "keranjang": [{"sku": "HD-01", "qty": 2}]
}

Bedanya dengan riwayat: state adalah data terstruktur yang bisa dibaca kode — misal untuk memvalidasi "apakah user sudah mengisi alamat" tanpa perlu memanggil LLM untuk menebak dari teks.

#Memory sebagai Retrieval

Untuk memori jangka panjang yang scalable, perlakukan memori seperti knowledge base: simpan fakta penting sebagai vector + metadata, ambil yang relevan saat dibutuhkan (pola RAG):

Memori sebagai retrieval

import chromadb
 
mem_col = chromadb.Client().get_or_create_collection("memori-user")
 
def remember(user_id: str, fakta: str) -> None:
    mem_col.upsert(ids=[f"{user_id}-{hash(fakta)}"],
                   documents=[fakta],
                   metadatas=[{"user": user_id}])
 
def recall(user_id: str, query: str, k: int = 5) -> list[str]:
    hasil = mem_col.query(query_texts=[query], n_results=k,
                          where={"user": user_id})
    return hasil["documents"][0]

Perhatikan: memori per-user (filter where={"user": user_id}) — ini juga garis pertahanan privasi yang kita perkuat di episode 20. Jangan pernah mencampur memori antar pengguna.

#Common Pitfalls

• Memori dimasukkan semua ke prompt: bom token. Retrieval + ringkasan adalah jawabannya.
• Tidak membedakan pengguna: memori tanpa user_id adalah kebocoran data antar pengguna.
• State hanya di proses: state harus di-persist (DB), bukan di variabel in-memory — server restart = semua hilang.
• Menyimpan data sensitif mentah: password/PII tidak boleh masuk memori tanpa enkripsi dan redaksi (episode 20).

#Penutup

Inti yang harus dibawa pulang:

• Short-term = riwayat sesi (di-prompt); long-term = database/vector (di-retrieve).
• Simpan percakapan utuh di DB, masukkan secukupnya ke prompt.
• Pisahkan conversation state (data terstruktur) dari riwayat pesan.
• Memory = retrieval: simpan fakta + metadata user, ambil yang relevan.

Di episode 13 selanjutnya kita melampaui teks: multimodal & vision AI — model yang membaca gambar dan audio, pipeline multimodal, dan membangun aplikasi vision pertama. Sampai jumpa di episode 13!