Tutorial Mem0: Lapisan Memori Persisten untuk Aplikasi AI

Anda memberi tahu chatbot bahwa Anda seorang vegetarian. Keesokan harinya, ia menyarankan resep steak. Ini bukan bug. Begitulah cara kerja LLM. Mereka tidak memiliki memori antarsesi dan memperlakukan setiap percakapan seperti lembar kosong.

Untuk penggunaan santai, ini tidak masalah. Namun jika Anda membangun aplikasi dunia nyata dengan pengguna sebenarnya, sifat tanpa status ini menjadi masalah nyata. Pengguna Anda berharap AI mengingat mereka.

Mem0 mengatasinya dengan menambahkan lapisan memori ke LLM mana pun. Ia menyimpan, mengambil, dan memperbarui informasi tentang pengguna di berbagai sesi, sehingga AI Anda benar-benar dapat belajar dan beradaptasi seiring waktu.

Dalam tutorial ini, Anda akan membangun asisten AI pribadi yang mengingat preferensi pengguna, melacak riwayat percakapan, dan menjadi lebih cerdas pada setiap interaksi. Kami akan membahas penyiapan cloud dan self-hosted agar Anda dapat memilih yang sesuai untuk proyek Anda.

Jika Anda belum pernah menggunakannya, ikuti korsus ini untuk mempelajari cara bekerja dengan OpenAI API.

Apa Itu Mem0?

Mem0 adalah lapisan memori open-source yang berada di antara aplikasi Anda dan LLM. Ia secara otomatis mengekstrak informasi relevan dari percakapan, menyimpannya, dan mengambilnya saat diperlukan. Proyek ini menggalang dana $24 juta pada Oktober 2025 dan bekerja dengan penyedia LLM mana pun: OpenAI, Anthropic, Ollama, atau model Anda sendiri.

Mem0 mengorganisasi memori ke dalam tiga cakupan:

• Memori pengguna: Bertahan di semua percakapan dengan seseorang tertentu. Jika seseorang menyebutkan mereka lebih suka belajar di pagi hari, fakta itu akan tersedia di setiap sesi berikutnya. 

• Memori sesi: Melacak konteks dalam satu percakapan, seperti resep yang sedang dibahas. 

• Memori agen: Menyimpan informasi yang spesifik untuk suatu instance agen AI tertentu. 

Anda dapat menggabungkan cakupan-cakupan ini untuk membangun aplikasi kompleks di mana agen yang berbeda berbagi (atau mengisolasi) pengetahuan mereka tentang pengguna.

Tiga cakupan memori: pengguna, sesi, dan agen, beserta contohnya.

Di balik layar, Mem0 menggabungkan pencarian vektor dengan relasi graf. Saat Anda menambahkan percakapan ke memori, ia secara otomatis mengekstrak bagian pentingnya. Anda tidak perlu memberi tag manual pada hal-hal yang harus diingat. 

Saat aplikasi Anda membutuhkan konteks, Mem0 mengambil memori relevan berdasarkan kueri saat ini dan menyuntikkannya ke dalam prompt. Ini lebih baik dibandingkan alternatif memasukkan seluruh riwayat percakapan ke setiap permintaan.

Anda dapat menjalankan Mem0 dengan dua cara:

• Platform: Layanan terkelola berbasis cloud di app.mem0.ai menawarkan penyiapan cepat dan sebuah API.

• Self-hosted: Memberi Anda kontrol penuh atas infrastruktur, memungkinkan Anda memilih basis data vektor dan model embedding. 

Kedua opsi menggunakan SDK Python yang sama, sehingga beralih di antaranya sangat mudah.

Peningkatan kinerjanya nyata, seperti yang diungkapkan makalah riset Mem0. Pada tolok ukur LOCOMO, Mem0 mencetak 26% lebih tinggi daripada fitur memori bawaan OpenAI. Ia juga merespons 91% lebih cepat dengan secara selektif mengambil memori relevan alih-alih memproses seluruh riwayat percakapan. Penggunaan token turun sekitar 90% dibandingkan pendekatan konteks penuh.

Sekarang setelah Anda tahu apa yang dilakukan Mem0, mari kita menyiapkannya.

Mulai Menggunakan Mem0

Instal paketnya bersama python-dotenv untuk mengelola kunci API:

pip install mem0ai python-dotenvDidukung oleh

Daftar di app.mem0.ai dan ambil kunci API Anda dari dasbor. Buat berkas .env di direktori proyek Anda:

MEM0_API_KEY=your-api-key-hereDidukung oleh

Sekarang, inisialisasi klien menggunakan kunci API:

from mem0 import MemoryClient
from dotenv import load_dotenv
import os

load_dotenv()

client = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))Didukung oleh

Untuk menyimpan memori, teruskan percakapan dalam format chat OpenAI. Parameter user_id membatasi memori pada pengguna tertentu:

messages = [
	{"role": "user", "content": "I'm a vegetarian and allergic to nuts."},
	{"role": "assistant", "content": "Got it! I'll remember that."}
]
client.add(messages, user_id="user123")Didukung oleh

Pemrosesan memori terjadi di latar belakang. Metode add() langsung mengembalikan status tertunda sementara Mem0 mengekstrak dan menyimpan fakta yang relevan.

Untuk mengambil memori, gunakan search() dengan kueri bahasa natural:

results = client.search("dietary restrictions", filters={"user_id": "user123"})Didukung oleh

Respons berisi memori yang diekstraksi dengan skor relevansi:

{'results': [
	{'memory': 'User is allergic to nuts', 'user_id': 'user123', 'score': 0.66},
	{'memory': 'User is a vegetarian', 'user_id': 'user123', 'score': 0.65}
]}Didukung oleh

Perhatikan bahwa Mem0 secara otomatis memisahkan "vegetarian” dan “alergic to nuts" menjadi dua fakta terpisah. Sistem menangani ekstraksi, dan saat Anda mencari, ia mengembalikan memori paling relevan berdasarkan kemiripan semantik.

Dengan dasar-dasarnya tercakup, mari membangun sesuatu yang lebih praktis.

Membangun Agen AI Mem0

Alur kerja add/search dasar memang berguna, tetapi aplikasi nyata membutuhkan kecanggihan lebih. Mari kita bangun agen pendamping belajar yang secara otonom memutuskan kapan menyimpan, mengambil, dan memperbarui memori. Kita akan menggunakan OpenAI Agents SDK untuk memberi agen kita alat memori yang dapat ia panggil sendiri.

Jika Anda baru dalam membangun agen dengan LLM, lihat tutorial kami tentang membangun agen LangChain untuk latar belakang konsepnya. Untuk pembahasan lebih mendalam khusus OpenAI Agents SDK, lihat tutorial OpenAI Agents SDK.

Menyiapkan dependensi

Instal OpenAI Agents SDK bersama Mem0:

pip install openai-agents mem0ai python-dotenvDidukung oleh

Tambahkan kunci API OpenAI Anda ke berkas .env:

MEM0_API_KEY=your-mem0-key
OPENAI_API_KEY=your-openai-keyDidukung oleh

Sekarang, inisialisasi kedua klien dan buat kelas konteks untuk meneruskan informasi pengguna ke alat:

import os
from dataclasses import dataclass
from agents import Agent, Runner, function_tool, RunContextWrapper
from mem0 import MemoryClient
from dotenv import load_dotenv

load_dotenv()

mem0 = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))

@dataclass
class UserContext:
	user_id: strDidukung oleh

Kelas data UserContext menyimpan data khusus pengguna yang dibutuhkan alat. RunContextWrapper memungkinkan kita meneruskan konteks ini ke alat apa pun yang dipanggil agen.

Membuat alat memori

Agen memerlukan tiga alat: pencarian, simpan, dan pembaruan. Kita menggunakan dekorator @function_tool untuk mengeksposnya ke agen.

Pertama, alat pencarian mengambil memori relevan. Kita sertakan ID memori dalam keluaran agar agen dapat merujuknya untuk pembaruan:

@function_tool
def search_memory(ctx: RunContextWrapper[UserContext], query: str) -> str:
	"""Search through past learning history and memories."""
	memories = mem0.search(
    	query,
    	filters={"user_id": ctx.context.user_id},
    	limit=5
	)
	if memories and memories.get("results"):
    	return "\n".join([
         	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
 	return "No relevant memories found."Didukung oleh

Berikutnya, alat simpan menyimpan informasi baru:

@function_tool
def save_memory(ctx: RunContextWrapper[UserContext], content: str) -> str:
 	"""Save new information about the user's learning journey."""
 	mem0.add(
     	[{"role": "user", "content": content}],
     	user_id=ctx.context.user_id
 	)
 	return "Memory saved successfully."Didukung oleh

Terakhir, alat pembaruan memodifikasi memori yang ada saat informasi berubah:

@function_tool
def update_memory(ctx: RunContextWrapper[UserContext], memory_id: str, new_text: str) -> str:
 	"""Update an existing memory with new information."""
 	mem0.update(memory_id=memory_id, text=new_text)
 	return f"Memory {memory_id} updated."Didukung oleh

Mendefinisikan agen

Sekarang kita membuat agen dengan instruksi kapan menggunakan tiap alat:

agent = Agent(
 	name="Learning Companion",
 	instructions="""You are a helpful learning companion with memory. 
            Use search_memory to recall what the user is learning and their level.
            Search results include memory IDs in format [ID: xxx].
            Use save_memory to store new topics, preferences, or progress.
            Use update_memory when information changes. First search to find the memory ID, then call update_memory with that ID and the new text.
            Always check memory before responding to personalize your answers.""",
 	tools=[search_memory, save_memory, update_memory],
 	model="gpt-4o"
)Didukung oleh

Kami menggunakan gpt-4o di sini, tetapi untuk penalaran penggunaan alat yang lebih baik, saya menyarankan menggunakan GPT-5. Silakan lihat tutorial API GPT-5 kami untuk melihat fitur barunya beraksi.

Menjalankan agen

Fungsi chat meneruskan konteks pengguna ke agen:

def chat(user_input: str, user_id: str) -> str:
	result = Runner.run_sync(
     	agent,
     	user_input,
         context=UserContext(user_id=user_id)
	)
	return result.final_outputDidukung oleh

Setiap pemanggilan Runner.run_sync() sepenuhnya independen dari pemanggilan lainnya. Secara bawaan, OpenAI Agents SDK tidak mempertahankan riwayat percakapan antar panggilan. 

Ini disengaja untuk demo kita: ketika agen mengingat informasi pengguna antar panggilan, memori itu harus berasal dari Mem0, bukan dari status tersembunyi agen.

Menguji persistensi memori

Mari uji dengan kueri yang memerlukan pengambilan memori yang sebenarnya. Agen tidak dapat menebak jawaban dengan benar tanpa mengakses informasi yang tersimpan.

Pertama, simpan beberapa informasi pengguna:

response = chat(
	"My name is Alex. I am learning data visualization with matplotlib. "
	"I am at intermediate level.",
	"student_01"
)
print(response)Didukung oleh

Got it, Alex! You're learning data visualization with Matplotlib at an intermediate level. How can I assist you today?Didukung oleh

Setelah menunggu beberapa detik untuk pemrosesan async, uji penarikan kembali:

response = chat("What is my name and what library am I learning?", "student_01")
print(response)Didukung oleh

Your name is Alex, and you're learning data visualization using Matplotlib at an intermediate level.Didukung oleh

Sekarang, uji fungsionalitas pembaruan:

response = chat(
	"I switched from matplotlib to seaborn. Please update your memory.",
	"student_01"
)
print(response)Didukung oleh

Got it! I've updated your learning preference to Seaborn for data visualization at an intermediate level. If you need help with anything specific, just let me know!Didukung oleh

Verifikasi bahwa pembaruan berhasil:

response = chat("What visualization library am I using now?", "student_01")
print(response)Didukung oleh

You are currently using Seaborn for data visualization at an intermediate level.Didukung oleh

Terakhir, uji persistensi di berbagai percakapan:

response = chat("Give me a summary of everything you know about me.", "student_01")
print(response)Didukung oleh

Here's what I know about you:

- Your name is Alex.
- You are learning data visualization with Seaborn at an intermediate level.

Is there anything else you'd like to update or add?Didukung oleh

Cara kerja agen Mem0 kami

Agen memilih alat mana yang akan dipanggil berdasarkan percakapan. 

Saat pengguna menanyakan profilnya, ia memanggil search_memory. Ketika mereka berbagi informasi baru, ia memanggil save_memory. Ketika mereka mengatakan informasi telah berubah, ia mencari terlebih dahulu untuk mendapatkan ID memori, lalu memanggil update_memory. 

Kita tidak pernah secara eksplisit memberi tahu alat mana yang digunakan untuk setiap pesan.

Ini berbeda dari alur kerja add/search manual di Bagian 3. Di sana, kita secara eksplisit memanggil metode. Di sini, agen yang mengambil keputusan itu. Pola ini lebih dapat diskalakan untuk aplikasi kompleks di mana Anda tidak dapat memprediksi setiap jenis interaksi.

Perbandingan alur kerja manual dan berbasis agen untuk skalabilitas

Satu catatan penting: pemrosesan memori bersifat asinkron. Setelah memanggil save_memory, ada jeda singkat sebelum memori baru dapat dicari. Di produksi, Anda perlu memperhitungkan ini di antarmuka pengguna.

Menyetel Perilaku Mem0

Agen dasar menangani operasi memori, tetapi aplikasi produksi memerlukan kontrol lebih halus atas apa yang disimpan dan bagaimana cara pengambilannya. Mem0 menawarkan pengaturan tingkat proyek yang meningkatkan kualitas memori, termasuk kategori kustom untuk organisasi, instruksi yang ditentukan pengguna untuk penyaringan, pencarian tertarget, dan operasi pembersihan.

Kategori kustom untuk domain pembelajaran

Secara bawaan, Mem0 menggunakan kategori umum seperti makanan, perjalanan, dan hobi. Untuk aplikasi spesifik seperti pendamping belajar kita, ini kurang membantu banyak. Anda dapat mendefinisikan kategori Anda sendiri yang sesuai dengan domain Anda:

client.project.update(custom_categories=[
	{"name": "topics", "description": "Programming languages, frameworks, or subjects"},
	{"name": "skill_levels", "description": "Proficiency: beginner, intermediate, advanced"},
	{"name": "goals", "description": "Learning objectives and targets"},
	{"name": "progress", "description": "Completed courses, chapters, or milestones"},
	{"name": "preferences", "description": "Learning style, schedule, or format preferences"}
])Didukung oleh

Setelah diatur, pengklasifikasi Mem0 secara otomatis memberi tag memori masuk dengan kategori Anda. Ketika Alex berkata, "Saya belajar Python pada tingkat pemula," sistem menandainya dengan topics dan skill_levels. Anda tidak perlu mengubah kode agen. Kategorisasi terjadi saat ekstraksi memori.

Instruksi kustom untuk memori selektif

Instruksi kustom memungkinkan Anda mengontrol secara tepat apa yang diekstrak dari percakapan. Anda menulis panduan dalam bahasa natural, dan Mem0 mengikutinya saat memproses memori baru:

client.project.update(custom_instructions="""
Extract and remember:
- Programming topics and technologies mentioned
- Current skill level for each topic
- Learning goals and deadlines
- Progress updates and completions
- Preferred learning resources (videos, docs, exercises)

Do not store:
- Personal identifiers beyond the user_id
- Payment or financial information
- Off-topic conversation that isn't about learning
""")Didukung oleh

Ini penting untuk aplikasi produksi. Tanpa instruksi, Mem0 mungkin menyimpan detail yang tidak relevan atau informasi sensitif. Instruksi kustom bertindak sebagai filter, menjaga memori tetap fokus pada kebutuhan aplikasi Anda. Untuk skenario kepatuhan seperti GDPR, Anda dapat secara eksplisit mengecualikan kategori data pribadi.

Pencarian terfilter berdasarkan kategori

Dengan memori yang terkategori, alat pencarian Anda bisa lebih presisi. Alih-alih mencari semua memori, saring berdasarkan kategori untuk mendapatkan tepat yang Anda butuhkan:

@function_tool
def search_memory(
	ctx: RunContextWrapper[UserContext],
	query: str,
	category: str = None
) -> str:
	"""Search learning history. Optionally filter by category."""
	filters = {"user_id": ctx.context.user_id}
	if category:
    	filters["categories"] = {"contains": category}

	memories = mem0.search(query, filters=filters, limit=5)
	if memories and memories.get("results"):
    	return "\n".join([
        	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
	return "No relevant memories found."Didukung oleh

Saat agen perlu menjawab "Topik apa yang sudah saya pelajari?", ia dapat mencari dengan category="topics" dan melewati memori yang tidak terkait tentang preferensi atau tujuan. Instruksi agen sebaiknya menyebutkan kategori ini, sehingga ia tahu kapan menggunakan pencarian terfilter.

Pembersihan dan penghapusan memori

Pengguna mungkin ingin menghapus memori yang kedaluwarsa atau salah. Tambahkan alat hapus untuk memberi kemampuan ini pada agen:

@function_tool
def delete_memory(ctx: RunContextWrapper[UserContext], memory_id: str) -> str:
	"""Delete a specific memory by ID."""
	mem0.delete(memory_id=memory_id)
	return f"Memory {memory_id} deleted."Didukung oleh

Untuk operasi massal, Anda dapat menghapus semua memori untuk seorang pengguna secara langsung:

mem0.delete_all(user_id="student_01")Didukung oleh

Penghapusan berguna saat informasi berubah total, bukan diperbarui. Jika pengguna berkata, "lupakan semua tentang pembelajaran Python saya," agen dapat mencari memori relevan dan menghapusnya satu per satu, atau Anda dapat menawarkan opsi reset yang menghapus profil mereka sepenuhnya.

Keempat opsi konfigurasi ini membawa agen dari demo menjadi sesuatu yang siap dirilis. Kategori mengorganisasi memori secara otomatis, instruksi memastikan hanya informasi relevan yang disimpan, pencarian terfilter mengambil yang benar-benar dibutuhkan, dan penghapusan menangani pembersihan. Perubahan kode agen minimal karena sebagian besar terjadi di tingkat konfigurasi proyek.

Untuk detail lebih lanjut tentang fitur-fitur ini, lihat dokumentasi Mem0 resmi.

Melacak Relasi dengan Memori Graf

Memori standar menyimpan fakta terisolasi, seperti "Alex sedang belajar Seaborn" dan "Alex mengetahui matplotlib." Namun ia tidak menangkap bahwa Alex belajar matplotlib terlebih dahulu, lalu beralih ke Seaborn. Memori graf menambahkan lapisan relasi ini. Saat urutan, progres, atau keterkaitan antar entitas penting, memori graf memberi agen Anda konteks yang lebih kaya.

Catatan: Memori graf hanya tersedia dengan paket Pro ($249/bulan) atau lebih tinggi.

Menyalakan memori graf

Anda dapat mengaktifkan memori graf di tingkat proyek:

client.project.update(enable_graph=True)Didukung oleh

Opsi lain adalah meneruskan enable_graph=True pada permintaan individual:

client.add(messages, user_id="student_01", enable_graph=True)Didukung oleh

Setelah aktif, Mem0 secara otomatis mengekstrak entitas (orang, topik, alat, tanggal) dan relasi di antaranya dari percakapan natural.

Cara kerja pencarian graf

Saat Anda mencari dengan memori graf, Mem0 mengembalikan memori sekaligus array relations yang menunjukkan bagaimana entitas terhubung:

results = client.search(
	"What has Alex learned?",
	filters={"user_id": "student_01"},
	enable_graph=True
)

# Results include both memories and relations
print(results.get("relations"))Didukung oleh

Relasi menunjukkan koneksi seperti "Alex → belajar → matplotlib" dan "Alex → beralih ke → seaborn." Agen Anda kini dapat menjawab pertanyaan tentang progres tanpa Anda harus menyimpan relasi tersebut secara eksplisit.

Kapan menggunakan memori graf

Memori graf menambah beban pemrosesan, jadi gunakan saat relasi memang penting:

• Platform pembelajaran yang melacak progres keterampilan

• Dukungan pelanggan yang menganalisis riwayat interaksi

• Manajemen proyek yang memetakan ketergantungan tugas

• Kesehatan yang menghubungkan gejala dan perawatan dari waktu ke waktu

Untuk penarikan fakta sederhana, memori standar lebih cepat. Nyalakan memori graf saat agen Anda perlu menalar tentang urutan atau keterkaitan antar informasi yang tersimpan.

Mem0: Platform vs. Open Source

Mem0 hadir dalam dua versi: Platform dan open source. 

Sepanjang tutorial ini, kami menggunakan versi Platform, yaitu layanan cloud terkelola yang diakses melalui MemoryClient dan kunci API dari app.mem0.ai. Kedua versi berbagi operasi memori inti (add(), search(), update(), delete()), tetapi berbeda dalam penyiapan, harga, dan kontrol.

Platform

Platform adalah layanan terhosting Mem0. Anda mendaftar, mendapatkan kunci API, dan mulai menambahkan memori dalam hitungan menit. Mem0 menangani infrastruktur, penskalaan, dan sertifikasi keamanan (seperti SOC 2 Tipe II atau GDPR).

Ada empat tingkatan harga:

• Gratis: 10.000 memori, cocok untuk prototyping.

• Starter: $19/bulan, dengan batas lebih tinggi.

• Pro: $249/bulan, untuk beban kerja produksi.

• Enterprise: Harga kustom dengan dukungan khusus.

Platform mencakup fitur yang tidak tersedia di open source: memori graf untuk pelacakan relasi, webhook untuk notifikasi waktu nyata, obrolan grup dengan atribusi pembicara, dan analitik bawaan. 

Anda membayar per penggunaan tetapi menghemat waktu infrastruktur dan DevOps.

Open source

Versi open source berjalan di server Anda sendiri. Anda menginstal paket mem0ai, mengonfigurasi basis data vektor, dan mengelola deployment sendiri. Ini memerlukan penyiapan lebih banyak tetapi memberi Anda kendali penuh.

Beberapa pilihan tersedia untuk infrastruktur:

• Basis data vektor: 24+ opsi termasuk Qdrant, Chroma, Pinecone, PostgreSQL (pgvector), dan MongoDB

• Penyedia LLM: 16+ opsi termasuk OpenAI, Anthropic, Ollama, Groq, dan model lokal

• Model embedding: OpenAI, HuggingFace, atau embedder kustom

Open source menggunakan kelas Memory alih-alih MemoryClient. 

Biaya Anda adalah apa pun yang Anda bayarkan untuk infrastruktur (VM cloud, hosting basis data, panggilan API ke penyedia LLM). Pada skala besar, ini bisa lebih murah daripada harga Platform, tetapi Anda bertanggung jawab menangani pemeliharaan, pencadangan, dan kepatuhan sendiri.

Kapan memilih Platform vs. open source

Lihat tabel berikut untuk perbandingan antara versi terhosting dan open-source Mem0:

Rekomendasi saya adalah memilih Platform untuk prototyping cepat, aplikasi produksi tanpa beban DevOps, atau saat Anda memerlukan kepatuhan bawaan. 

Jika fokus Anda adalah kedaulatan data, konfigurasi model kustom, atau optimalisasi biaya pada volume tinggi, open source adalah pilihan yang tepat.

Untuk panduan penyiapan terperinci, lihat quickstart Platform atau ikhtisar open source.

Kesimpulan

Tutorial ini membahas penambahan memori persisten ke aplikasi LLM dengan Mem0. Anda memulai dengan operasi memori dasar, lalu membangun agen pendamping belajar yang secara otonom mengelola memorinya sendiri menggunakan OpenAI Agents SDK. Setelah itu, Anda mengonfigurasi perilaku memori dengan kategori kustom, instruksi, dan pencarian terfilter. Terakhir, Anda membandingkan opsi deployment Platform dan open source.

Untuk penggunaan produksi, tambahkan penanganan error di sekitar operasi memori dan perhitungkan jeda singkat setelah menyimpan memori baru. Pertimbangkan batas laju jika Anda berada di tier gratis Platform.

Siap melampaui komponen individual dan menguasai full stack pengembangan aplikasi AI? Daftar di AI Engineer for Developers career track.