Mem0: Memory Layer untuk Aplikasi AI yang Personalized

Salah satu tantangan terbesar dalam membangun aplikasi AI adalah kemampuan untuk mengingat konteks dan preferensi pengguna lintas sesi. Secara default, LLM seperti GPT atau Claude tidak memiliki memori persisten. Setiap percakapan dimulai dari nol. Di sinilah Mem0 hadir sebagai solusi.

Mem0 adalah memory layer open-source yang memungkinkan aplikasi AI Anda menyimpan, mengambil, dan mengelola memori secara cerdas. Dengan Mem0, chatbot Anda bisa mengingat preferensi pengguna, riwayat interaksi, dan konteks penting lainnya.

Mengapa Mem0?

Bayangkan Anda membangun AI assistant untuk customer service. Tanpa memory layer, setiap kali pelanggan menghubungi, AI harus menanyakan ulang informasi dasar. Dengan Mem0:

• AI mengingat nama, preferensi, dan riwayat pelanggan
• Respons menjadi lebih personal dan kontekstual
• Pengalaman pengguna meningkat drastis
• Efisiensi operasional meningkat

Mem0 menggunakan semantic search untuk menemukan memori yang relevan, bukan sekadar keyword matching. Ini berarti AI bisa memahami konteks dan mengambil informasi yang benar-benar relevan.

Instalasi

Pertama, install Mem0 menggunakan pip:

pip install mem0ai

Untuk menggunakan fitur lengkap dengan vector database, install juga dependensi opsional:

pip install mem0ai[qdrant]

Anda juga memerlukan API key dari OpenAI (default) atau provider LLM lainnya:

export OPENAIAPIKEY="sk-your-api-key-here"

Inisialisasi Mem0

Ada dua cara menggunakan Mem0: versi in-memory untuk development dan versi persistent untuk production.

Setup Dasar (In-Memory)

from mem0 import Memory

Inisialisasi dengan konfigurasi default
m = Memory()

Setup dengan Qdrant (Persistent)

from mem0 import Memory

config = {
    "vectorstore": {

        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
            "collectionname": "mem0memories"

        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o-mini",
            "temperature": 0.1
        }
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small"
        }
    }
}

m = Memory.fromconfig(config)

Operasi Memori Dasar

Mem0 menyediakan empat operasi utama: add, get, search, dan delete.

Menambahkan Memori (Add)

# Menambahkan memori untuk user tertentu
result = m.add(
    "Saya suka kopi hitam tanpa gula dan biasanya minum di pagi hari",
    userid="user123"
)
print(result)
Output: {'results': [{'id': '...', 'memory': 'Suka kopi hitam tanpa gula', 'event': 'ADD'}]}

Mem0 secara otomatis mengekstrak informasi penting dari teks yang diberikan. Perhatikan bahwa Mem0 tidak menyimpan teks mentah, melainkan mengekstrak fakta dari teks tersebut.

Mengambil Semua Memori (Get)

# Mengambil semua memori untuk user tertentu
memories = m.getall(userid="user123")


for memory in memories:
    print(f"ID: {memory['id']}")
    print(f"Memory: {memory['memory']}")
    print(f"Created: {memory['createdat']}")
    print("---")

Mencari Memori (Search)

# Semantic search - mencari memori yang relevan
results = m.search(
    "Apa minuman favorit user ini?",
    userid="user123"
)

for result in results:
    print(f"Memory: {result['memory']}")
    print(f"Score: {result['score']}")

Search menggunakan semantic similarity, sehingga query "minuman favorit" akan menemukan memori tentang "kopi hitam" meskipun kata-katanya berbeda.

Menghapus Memori (Delete)

# Menghapus memori spesifik berdasarkan ID
m.delete(memoryid="memoryidhere")


Menghapus semua memori user
m.deleteall(userid="user123")

Tipe-Tipe Memori

Mem0 mendukung tiga level memori yang berbeda, masing-masing untuk use case yang berbeda.

1. User-Level Memory

Memori yang terkait dengan pengguna tertentu dan persisten lintas semua sesi:

# Menyimpan preferensi user
m.add("Saya alergi kacang dan tidak suka makanan pedas", userid="user123")
m.add("Saya tinggal di Jakarta Selatan", userid="user123")
m.add("Bahasa pemrograman favorit saya adalah Python", userid="user123")

Mengambil memori user
usermemories = m.getall(userid="user123")

2. Session Memory

Memori yang terkait dengan sesi percakapan tertentu:

# Menyimpan konteks sesi
sessionid = "session20260513001"


m.add(
    "User sedang menanyakan tentang cara deploy model ML ke production",
    userid="user123",

    metadata={"sessionid": sessionid}

)

m.add(
    "User sudah mencoba menggunakan Flask tapi mengalami masalah scaling",
    userid="user123",

    metadata={"sessionid": sessionid}

)

3. Agent Memory

Memori yang terkait dengan AI agent tertentu, berguna saat Anda memiliki multiple agents:

# Agent-specific memory
m.add(
    "Customer service agent harus selalu menyapa dengan nama pelanggan",
    agentid="csagent01"
)

m.add(
    "Technical support agent harus selalu menanyakan versi software",
    agentid="techagent01"

)

Mengambil memori agent
agentmemories = m.getall(agentid="csagent01")

Kategori Memori

Anda bisa mengorganisir memori dengan metadata dan kategori:

# Menambahkan memori dengan metadata kategori
m.add(
    "User memiliki subscription plan Enterprise",
    userid="user123",
    metadata={
        "category": "account",
        "priority": "high"
    }
)

m.add(
    "User prefer komunikasi via email dibanding telepon",
    userid="user123",
    metadata={
        "category": "preference",
        "priority": "medium"
    }
)

m.add(
    "User menggunakan macOS dengan Python 3.11",
    userid="user123",
    metadata={
        "category": "technical",
        "priority": "low"
    }
)

Integrasi dengan OpenAI

Mem0 dapat diintegrasikan langsung dengan OpenAI untuk membuat chatbot dengan memori:

from openai import OpenAI
from mem0 import Memory

client = OpenAI()
memory = Memory()

def chatwithmemory(usermessage: str, userid: str) -> str:
    # Cari memori yang relevan
    relevantmemories = memory.search(usermessage, userid=userid)

    # Bangun konteks dari memori
    memorycontext = ""

    if relevantmemories:
        memorycontext = "Informasi yang diketahui tentang user:\n"

        for mem in relevantmemories:
            memorycontext += f"- {mem['memory']}\n"


    # Buat system prompt dengan konteks memori
    systemprompt = f"""Kamu adalah AI assistant yang helpful dan personal.
Gunakan informasi berikut tentang user untuk memberikan respons yang personal:

{memorycontext}


Jika user memberikan informasi baru tentang dirinya, catat dalam responsmu."""

    # Panggil OpenAI
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": systemprompt},
            {"role": "user", "content": usermessage}

        ]
    )

    assistantmessage = response.choices[0].message.content

    # Simpan memori baru dari percakapan
    conversation = f"User: {usermessage}\nAssistant: {assistantmessage}"
    memory.add(conversation, userid=userid)

    return assistantmessage


Contoh penggunaan
print(chatwithmemory("Hai, nama saya Budi. Saya seorang data scientist.", "user456"))
print(chatwithmemory("Rekomendasikan tools untuk data visualization dong", "user456"))

Integrasi dengan Anthropic Claude

Mem0 juga dapat digunakan dengan Anthropic Claude:

import anthropic
from mem0 import Memory

client = anthropic.Anthropic()
memory = Memory()

def chatwithclaude(usermessage: str, userid: str) -> str:

    # Ambil memori relevan
    relevantmemories = memory.search(usermessage, userid=userid)


    memorycontext = ""
    if relevantmemories:

        memorylines = [mem['memory'] for mem in relevantmemories]

        memorycontext = "Known information about the user:\n" + "\n".join(
            f"- {line}" for line in memorylines

        )

    systemprompt = f"""You are a helpful, personalized AI assistant.
Use the following context to personalize your responses:

{memorycontext}"""


    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        maxtokens=1024,
        system=systemprompt,

        messages=[
            {"role": "user", "content": usermessage}
        ]
    )

    assistantmessage = response.content[0].text


    # Simpan memori
    conversation = f"User: {usermessage}\nAssistant: {assistantmessage}"

    memory.add(conversation, userid=userid)


    return assistantmessage

Semantic Search Over Memories

Kekuatan utama Mem0 adalah kemampuan semantic search-nya. Berbeda dengan pencarian keyword biasa, semantic search memahami makna dari query:

# Menambahkan berbagai memori
m.add("Saya bekerja sebagai machine learning engineer di startup fintech", userid="user789")
m.add("Saya baru saja menyelesaikan kursus deep learning di Coursera", userid="user789")
m.add("Proyek terakhir saya adalah membangun fraud detection system", userid="user789")
m.add("Saya tertarik dengan NLP dan computer vision", userid="user789")
m.add("Weekend biasanya saya habiskan untuk hiking dan fotografi", userid="user789")

Semantic search - query tidak perlu exact match
results = m.search("Apa background profesional user ini?", userid="user789")
Akan menemukan memori tentang pekerjaan, kursus, dan proyek

results = m.search("Apa hobi user ini?", userid="user789")
Akan menemukan memori tentang hiking dan fotografi

Search dengan limit
results = m.search(
    "keahlian teknis",
    userid="user789",
    limit=3
)

Memory Conflict Resolution

Ketika informasi baru bertentangan dengan memori yang sudah ada, Mem0 menanganinya secara otomatis:

# Memori awal
m.add("Saya tinggal di Jakarta", userid="user100")

Update informasi - Mem0 akan mendeteksi konflik
m.add("Saya baru pindah ke Bandung bulan lalu", userid="user100")

Mem0 akan mengupdate memori, bukan membuat duplikat
memories = m.getall(userid="user100")

Memori akan menunjukkan bahwa user tinggal di Bandung (informasi terbaru)

Mem0 menggunakan LLM untuk mendeteksi apakah informasi baru merupakan:

• UPDATE: Memperbarui fakta yang sudah ada
• ADD: Informasi baru yang belum ada
• DELETE: Menghapus informasi yang tidak lagi relevan
• NOOP: Tidak ada perubahan yang diperlukan

# Contoh berbagai jenis update
m.add("Email saya budi@example.com", userid="user100")

Event: ADD

m.add("Email saya berubah menjadi budi@newcompany.com", userid="user100")

Event: UPDATE - email lama diperbarui

m.add("Saya sudah tidak menggunakan Twitter lagi", userid="user100")

Event: DELETE - jika ada memori tentang Twitter

Contoh Praktis: AI Assistant dengan Personalized Memory

Mari bangun AI assistant lengkap yang mengingat preferensi pengguna lintas sesi:

from mem0 import Memory
from openai import OpenAI
from datetime import datetime

class PersonalizedAssistant:
    def init(self):
        self.client = OpenAI()
        self.memory = Memory()
        self.conversationhistory = []

    def getmemorycontext(self, userid: str, query: str) -> str:

        """Ambil memori relevan dan format sebagai konteks."""
        memories = self.memory.search(query, userid=userid, limit=10)


        if not memories:
            return "Belum ada informasi yang diketahui tentang user ini."

        contextlines = []
        for mem in memories:
            contextlines.append(f"- {mem['memory']}")


        return "Informasi yang diketahui tentang user:\n" + "\n".join(contextlines)

    def chat(self, usermessage: str, userid: str) -> str:
        """Kirim pesan dan dapatkan respons yang dipersonalisasi."""
        # Ambil konteks memori
        memorycontext = self.getmemorycontext(userid, usermessage)


        # System prompt
        systemprompt = f"""Kamu adalah AI assistant pribadi yang cerdas dan ramah.
Kamu mengingat informasi tentang setiap user dan menggunakannya untuk
memberikan respons yang personal dan relevan.

{memorycontext}


Panduan:
Gunakan informasi yang sudah diketahui untuk mempersonalisasi respons
Jika user memberikan informasi baru, akui dan ingat
Berikan rekomendasi berdasarkan preferensi yang sudah diketahui
Bersikap natural, jangan terlalu formal

Waktu sekarang: {datetime.now().strftime('%Y-%m-%d %H:%M')}"""

        # Tambahkan ke conversation history
        self.conversationhistory.append({
            "role": "user",
            "content": usermessage

        })

        # Panggil LLM
        messages = [{"role": "system", "content": systemprompt}]
        messages.extend(self.conversationhistory[-10:])  # Keep last 10 messages


        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            temperature=0.7
        )

        assistantmessage = response.choices[0].message.content

        # Tambahkan respons ke history
        self.conversationhistory.append({

            "role": "assistant",
            "content": assistantmessage
        })

        # Simpan memori dari percakapan ini
        self.memory.add(
            f"User: {usermessage}\nAssistant: {assistantmessage}",
            userid=userid,
            metadata={
                "timestamp": datetime.now().isoformat(),
                "type": "conversation"
            }
        )

        return assistantmessage


    def getuserprofile(self, userid: str) -> dict:
        """Dapatkan profil user berdasarkan memori yang tersimpan."""
        allmemories = self.memory.getall(userid=userid)

        return {
            "userid": userid,
            "totalmemories": len(allmemories),
            "memories": [mem['memory'] for mem in allmemories]

        }

    def resetuser(self, userid: str):

        """Hapus semua memori untuk user tertentu."""
        self.memory.deleteall(userid=userid)
        print(f"Semua memori untuk {userid} telah dihapus.")



Simulasi penggunaan
def main():
    assistant = PersonalizedAssistant()
    userid = "demouser001"

    # Sesi 1: Perkenalan
    print("=== Sesi 1: Perkenalan ===")
    response = assistant.chat(
        "Hai! Nama saya Rina. Saya seorang data analyst di perusahaan e-commerce.",
        userid

    )
    print(f"Assistant: {response}\n")

    response = assistant.chat(
        "Saya sedang belajar Python dan tertarik dengan machine learning. "
        "Biasanya saya pakai Excel dan SQL untuk analisis data.",
        userid
    )
    print(f"Assistant: {response}\n")

    # Sesi 2: Kunjungan kembali (simulasi sesi baru)
    assistant.conversationhistory = []  # Reset conversation history

    print("\n=== Sesi 2: Kunjungan Kembali ===")
    response = assistant.chat(
        "Hai lagi! Bisa rekomendasikan library Python untuk data visualization?",
        userid
    )
    print(f"Assistant: {response}\n")

    # Lihat profil user
    profile = assistant.getuserprofile(userid)

    print(f"\n=== Profil User ===")
    print(f"Total memori: {profile['totalmemories']}")
    for mem in profile['memories']:
        print(f"  - {mem}")


if name == "main":
    main()

Tips dan Best Practices

1. Kelola Ukuran Memori

# Batasi jumlah memori per user
memories = m.getall(userid="user123")

if len(memories) > 100:
    # Hapus memori lama yang kurang relevan
    oldmemories = sorted(memories, key=lambda x: x['createdat'])

    for mem in oldmemories[:20]:  # Hapus 20 memori terlama
        m.delete(memoryid=mem['id'])

2. Gunakan Metadata untuk Filtering

# Tambahkan metadata yang berguna
m.add(
    "User memiliki budget $5000 untuk project ini",
    userid="user123",

    metadata={
        "category": "project",
        "projectid": "proj001",

        "importance": "high",
        "expiresat": "2026-06-30"
    }
)

3. Pisahkan Memori Berdasarkan Konteks

# Gunakan userid yang berbeda untuk konteks berbeda
m.add("Preferensi untuk project A", userid="user123projecta")

m.add("Preferensi untuk project B", userid="user123projectb")

4. Handle Error dengan Graceful

def safememorysearch(memory, query, userid, fallback=""):
    try:
        results = memory.search(query, userid=userid)
        return results
    except Exception as e:
        print(f"Memory search failed: {e}")
        return []

Kesimpulan

Mem0 adalah tool yang powerful untuk menambahkan kemampuan memori ke aplikasi AI Anda. Dengan fitur semantic search, conflict resolution otomatis, dan dukungan untuk multiple memory levels, Mem0 memudahkan Anda membangun aplikasi AI yang benar-benar personal.

Kunci keberhasilan menggunakan Mem0:

• Mulai dengan setup sederhana, lalu tingkatkan sesuai kebutuhan
• Gunakan metadata untuk mengorganisir memori
• Implementasikan memory cleanup untuk performa optimal
• Manfaatkan semantic search untuk pengambilan memori yang akurat
• Selalu handle error untuk pengalaman pengguna yang baik

Dengan menggabungkan Mem0 dengan LLM pilihan Anda (OpenAI, Anthropic, dll.), Anda bisa membangun AI assistant yang benar-benar mengingat dan memahami setiap pengguna secara unik.