Sebagai pengembang, Anda mencari solusi memori yang canggih yang juga menjamin privasi data, kontrol, dan interoperabilitas yang lancar antara alat AI. Tren jelas mengarah pada sistem memori yang mengutamakan lokal dan berfokus pada pengembang. Konsep **OpenMemory MCP Server**, yang diwujudkan oleh teknologi seperti kerangka kerja sumber terbuka Mem0, memimpin perubahan ini. Ini menawarkan lapisan memori lokal yang privat, memungkinkan agen AI mengingat konteks di berbagai aplikasi sementara data Anda tetap aman di mesin Anda. Panduan ini untuk pengembang seperti Anda. Ini adalah panduan lengkap tentang cara menginstal komponen penting menggunakan **Mem0**, menjalankan OpenMemory MCP Server lokal Anda sendiri, dan dengan terampil menggunakan API REST-nya untuk membuat aplikasi AI yang lebih cerdas dan sadar konteks. Mari kita mulai membuka memori AI lokal yang persisten. Want a great API Testing tool that generates beautiful API Documentation? Want an integrated, All-in-One platform for your Developer Team to work together with maximum productivity? Apidog delivers all your demans, and replaces Postman at a much more affordable price!
button
Langkah 1: Mempersiapkan Lingkungan Pengembangan Anda
Sebelum masuk ke instalasi, penting untuk menyiapkan alat pengembangan dasar Anda dan memahami komponen inti yang akan kita gunakan. Kita akan terutama menggunakan kerangka kerja sumber terbuka **Mem0** yang serbaguna untuk membangun dan kemudian berinteraksi dengan OpenMemory MCP Server lokal kita. Interaksi ini sebagian besar akan terjadi melalui API REST-nya, menyediakan cara standar untuk mengelola memori AI Anda.
Anda akan memerlukan lingkungan Python terbaru, sebaiknya versi 3.8 atau yang lebih baru, untuk memastikan kompatibilitas penuh dengan **Mem0** dan dependensinya. Anda dapat mengunduh Python terbaru dari python.org. Selain Python, Anda akan memerlukan pip, penginstal paket Python, yang sangat penting untuk menginstal **Mem0** dan biasanya sudah ter bundled dengan instalasi Python. Pustaka Python mem0ai akan menjadi mesin kita; sifat sumber terbukanya memungkinkan Anda menjalankan server lokal yang secara efektif menjadi OpenMemory MCP Server Anda. Seluruh pengaturan ini memprioritaskan menjalankan server memori di mesin lokal Anda, memberi Anda kontrol penuh atas data dan operasi Anda—prinsip utama filosofi OpenMemory. Server kemudian mengekspos fungsionalitasnya melalui API REST, dengan titik akhir untuk menambahkan, mencari, dan mengelola memori yang selaras dengan operasi standar yang ditentukan oleh Model Context Protocol (MCP).
Tips Pro: Menggunakan lingkungan virtual (seperti venv atau conda) adalah langkah cerdas. Ini membantu mengelola dependensi proyek dan mencegah konflik dengan proyek Python lainnya.
Langkah 2: Cara Menginstal Kerangka Kerja Mem0
Menginstal paket mem0ai adalah langkah praktis pertama Anda untuk memiliki server memori AI lokal. Ini dilakukan dengan perintah sederhana yang melengkapi sistem Anda dengan pustaka inti **Mem0** dan semua komponen yang diperlukan.
Buka terminal Anda (dan aktifkan lingkungan virtual Anda jika Anda menggunakannya). Kemudian, jalankan perintah instalasi:
pip install mem0ai
Perintah ini menginstal pustaka mem0ai, yang mencakup kelas inti Memory untuk manajemen memori langsung di Python. Anda juga mendapatkan dukungan untuk berbagai Large Language Models (LLM) dan basis data vektor, ditambah komponen FastAPI dan Uvicorn yang diperlukan untuk menjalankan server API REST **Mem0**. Setelah instalasi selesai, Anda dapat memverifikasinya dengan memeriksa versi paket yang terinstal dengan pip show mem0ai, atau dengan mencoba impor cepat dalam sesi Python:
import mem0
print(mem0.__version__)
pip juga secara otomatis menangani instalasi dependensi yang diperlukan seperti FastAPI (untuk membangun API), Uvicorn (sebagai server ASGI), dan berbagai pustaka penanganan data. Dengan mem0ai terinstal, Anda memiliki perangkat lunak dasar. Anda dapat menggunakan pustaka secara langsung dalam skrip Python untuk operasi memori, tetapi untuk aspek "server" yang dapat berinteraksi dengan klien MCP, kita akan menggunakan fungsionalitas server bawaannya.
Langkah 3: Cara Mengonfigurasi Server Memori Lokal Anda
Sebelum memulai server, Anda memiliki opsi untuk mengonfigurasi instance **Mem0** yang mendasarinya. Konfigurasi ini penting karena menentukan Large Language Model (LLM), basis data vektor, dan model embedding mana yang akan mendukung kemampuan pemrosesan dan pengambilan memori server Anda—pada dasarnya, Anda menyesuaikan "otaknya."
Server **Mem0** (dan kelas Memory yang menjadi dasarnya) terutama dikonfigurasi menggunakan variabel lingkungan. Ini adalah pendekatan fleksibel yang memungkinkan Anda menyiapkan backend Anda tanpa memodifikasi kode apa pun. Misalnya, untuk mengonfigurasi LLM, Anda mungkin mengatur OPENAI_API_KEY untuk OpenAI, ANTHROPIC_API_KEY untuk Anthropic, atau variabel seperti MEM0_LLM_PROVIDER="ollama" untuk model lokal melalui Ollama. Demikian pula, untuk basis data vektor, meskipun **Mem0** secara default menggunakan LanceDB (yang lokal dan tidak memerlukan pengaturan tambahan), Anda dapat menentukan alternatif seperti Qdrant menggunakan variabel seperti MEM0_VECTOR_STORE_PROVIDER="qdrant". Konfigurasi model embedding sering kali terkait dengan penyedia LLM Anda, tetapi juga dapat ditentukan secara independen.
Jika Anda tidak mengatur variabel lingkungan tertentu, **Mem0** mencoba menggunakan default yang masuk akal. Namun, mungkin memerlukan kunci OpenAI untuk LLM default-nya jika tidak ditentukan lain. Pilihan-pilihan ini secara signifikan memengaruhi server Anda: LLM memengaruhi cara memori dipahami, sementara basis data vektor memengaruhi efisiensi penyimpanan dan kecepatan pencarian. Untuk daftar lengkap semua variabel lingkungan yang dapat dikonfigurasi dan opsi untuk LLM, penyimpanan vektor, dan embedder yang berbeda, selalu konsultasikan dokumentasi resmi **Mem0**.
Tips Pro: Mulailah dengan pengaturan lokal sederhana (seperti Ollama untuk LLM dan LanceDB default). Ini membantu Anda merasa nyaman dengan sistem. Kemudian, jelajahi pengaturan yang lebih canggih seiring berkembangnya kebutuhan Anda.
Langkah 4: Cara Menjalankan OpenMemory MCP Server Anda
Dengan mem0ai terinstal dan (opsional) dikonfigurasi sesuai keinginan Anda, Anda sekarang dapat memulai proses server lokal. Server inilah yang mengekspos titik akhir API REST, memungkinkan aplikasi atau skrip lain untuk melakukan operasi memori.
Paket mem0ai menawarkan skrip baris perintah yang praktis untuk menjalankan server. Di terminal Anda, cukup ketik:
mem0-server
Anda juga dapat menentukan host dan port kustom jika diperlukan, misalnya: mem0-server --host 127.0.0.1 --port 8000. Default biasanya 0.0.0.0 (semua antarmuka jaringan yang tersedia) pada port 8000. Setelah dimulai, Uvicorn (server yang menjalankan aplikasi FastAPI Anda) akan mengeluarkan log ke konsol, menunjukkan bahwa server sedang berjalan dan mendengarkan permintaan. Anda akan melihat pesan seperti: INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit).
OpenMemory MCP Server Anda sekarang berjalan secara lokal! Klien yang kompatibel dengan MCP, jika dikonfigurasi untuk menunjuk ke http://localhost:8000 (atau alamat kustom Anda), dapat berinteraksi dengannya. Anda juga dapat langsung menggunakan API REST-nya, yang akan kita jelajahi selanjutnya. Untuk menghentikan server, cukup tekan CTRL+C di terminal tempat ia berjalan. Perintah mem0-server pada dasarnya meluncurkan server ASGI Uvicorn, yang menjalankan aplikasi FastAPI yang ditentukan dalam **Mem0**. Aplikasi ini menghosting titik akhir API REST, dan instance yang berjalan ini adalah OpenMemory MCP Server lokal Anda.
Langkah 5: Memahami Kemampuan API Server
Server **Mem0** menyediakan API REST yang komprehensif yang memungkinkan Anda mengelola memori AI secara terprogram. API ini mematuhi prinsip-prinsip inti Model Context Protocol dengan menawarkan cara standar untuk menambahkan, mencari, membuat daftar, dan menghapus informasi.
API menggunakan protokol HTTP/HTTPS standar, dan JSON adalah format data untuk badan permintaan dan respons. Jika Anda menjalankan server secara lokal dengan pengaturan default, URL dasar Anda akan menjadi http://localhost:8000. Operasi inti yang tersedia melalui API (berdasarkan implementasi API REST Mem0 yang umum) meliputi POST /add untuk menyimpan informasi baru, POST /search untuk mengambil memori yang relevan, GET /get_all untuk membuat daftar beberapa memori (dengan opsi filter), GET /get untuk mengambil satu memori berdasarkan ID-nya, PUT /update untuk memodifikasi memori yang ada, DELETE /delete untuk menghapus memori tertentu, dan DELETE /delete_all untuk menghapus memori, berpotensi difilter oleh pengguna.
Secara default, mem0-server yang berjalan secara lokal tidak mengimplementasikan autentikasi, karena terutama ditujukan untuk pengembangan dan penggunaan lokal. Jika Anda mempertimbangkan penyebaran produksi atau yang terekspos (yang tidak disarankan tanpa lapisan keamanan tambahan yang signifikan), autentikasi akan menjadi aspek penting untuk diimplementasikan.
Tips Pro: Anda sering dapat menjelajahi API secara interaktif. Coba kunjungi http://localhost:8000/docs di browser Anda setelah server aktif. Server FastAPI **Mem0** biasanya menawarkan halaman dokumentasi yang membantu ini melalui Swagger UI.
Langkah 6: Cara Menambahkan Memori Menggunakan API
Titik akhir /add adalah alat utama Anda untuk memasukkan data ke dalam server memori. Ini memungkinkan Anda menyimpan informasi tekstual, mengaitkannya dengan pengguna tertentu, dan menyertakan metadata opsional untuk organisasi dan pengambilan yang lebih baik.
Untuk menggunakannya, Anda mengirim permintaan POST ke titik akhir /add. Badan permintaan harus berupa JSON dan menyertakan data (konten string memori), user_id (pengenal untuk pengguna yang terkait dengan memori ini – penting untuk mengatur dan mengambil memori spesifik pengguna), dan secara opsional metadata (objek JSON yang berisi pasangan kunci-nilai tambahan apa pun yang ingin Anda simpan, seperti {"source": "chat_log"}).
Berikut adalah contoh menggunakan curl:
curl -X POST http://localhost:8000/add \
-H "Content-Type: application/json" \
-d '{
"data": "Alice prefers Python for web development.",
"user_id": "user_alice",
"metadata": {"topic": "preferences", "language": "Python"}
}'
Dan berikut cara Anda melakukannya dengan pustaka Python requests:
import requests
import json
url = "http://localhost:8000/add"
payload = {
"data": "Alice prefers Python for web development.",
"user_id": "user_alice",
"metadata": {"topic": "preferences", "language": "Python"}
}
headers = {"Content-Type": "application/json"}
response = requests.post(url, data=json.dumps(payload), headers=headers)
print(response.json())
Server akan merespons dengan JSON yang mengonfirmasi penambahan, seringkali menyertakan ID unik dari memori yang baru dibuat, misalnya: {"message": "Memory added successfully", "memory_id": "some-unique-id"}. Setiap panggilan ke /add membuat catatan memori baru. user_id sangat penting untuk aplikasi multi-pengguna atau memisahkan konteks, dan metadata secara signifikan meningkatkan kemampuan pencarian dan organisasi.
Langkah 7: Cara Mencari Memori yang Tersimpan melalui API
Setelah memori disimpan, titik akhir /search memungkinkan Anda melakukan pencarian semantik. Ini berarti Anda dapat mengambil informasi yang relevan dengan kueri dan konteks pengguna tertentu, bahkan jika istilah pencarian Anda tidak persis cocok dengan teks yang tersimpan.
Anda mengirim permintaan POST ke /search dengan badan JSON yang berisi string query, user_id yang memorinya ingin Anda cari, dan parameter opsional seperti filters (untuk kriteria yang lebih spesifik, berdasarkan bidang metadata – struktur persisnya bergantung pada implementasi **Mem0**) dan limit (untuk membatasi jumlah hasil pencarian).
Contoh curl terlihat seperti ini:
curl -X POST http://localhost:8000/search \
-H "Content-Type: application/json" \
-d '{
"query": "What are Alices language preferences?",
"user_id": "user_alice",
"limit": 3
}'
Menggunakan Python requests:
import requests
import json
url = "http://localhost:8000/search"
payload = {
"query": "What are Alices language preferences?",
"user_id": "user_alice",
"limit": 3
}
headers = {"Content-Type": "application/json"}
response = requests.post(url, data=json.dumps(payload), headers=headers)
print(response.json())
Respons yang diharapkan adalah array JSON dari objek memori yang cocok dengan kueri pencarian. Objek-objek ini biasanya menyertakan konten memori, metadatanya, dan skor relevansi yang menunjukkan seberapa dekat kecocokannya dengan kueri, misalnya:[{"id": "some-unique-id", "data": "Alice prefers Python for web development.", ..., "score": 0.85}].
Tips Pro: Menggunakan user_id dengan benar dalam pencarian sangat penting. Ini memastikan bahwa pengguna hanya mengambil memori relevan mereka sendiri, yang vital untuk menjaga privasi dan memberikan pengalaman yang dipersonalisasi.
Langkah 8: Cara Mengambil Memori Spesifik dengan API
Selain pencarian, API menyediakan titik akhir untuk membuat daftar beberapa memori atau mengambil satu memori spesifik berdasarkan pengenal uniknya. Ini berguna untuk menjelajahi bank memori atau mengakses informasi yang diketahui secara langsung.
Untuk membuat daftar beberapa memori, Anda menggunakan titik akhir GET /get_all. Anda dapat meneruskan parameter kueri seperti user_id untuk memfilter memori berdasarkan pengguna, limit untuk menentukan jumlah memori yang akan dikembalikan, dan page untuk penomoran halaman jika ada banyak memori. Misalnya, curl -X GET "http://localhost:8000/get_all?user_id=user_alice&limit=5" akan mengambil 5 memori pertama untuk "user_alice". Responsnya akan berupa array JSON dari objek memori.
Untuk mendapatkan memori spesifik, gunakan GET /get dengan parameter kueri memory_id: curl -X GET "http://localhost:8000/get?memory_id=some-unique-id". Ini akan mengembalikan objek JSON yang mewakili memori tunggal tersebut, atau kesalahan jika tidak ditemukan.
Berikut cara menggunakan Python requests untuk /get_all:
import requests
url = "http://localhost:8000/get_all"
params = {"user_id": "user_alice", "limit": 5}
response = requests.get(url, params=params)
print(response.json())
Titik akhir /get_all sangat baik untuk tugas administratif atau ketika Anda perlu menelusuri memori pengguna. /get adalah pilihan Anda ketika Anda sudah memiliki ID memori, mungkin dari respons /add atau hasil pencarian sebelumnya.
Langkah 9: Cara Memperbarui dan Menghapus Memori Menggunakan API
Untuk memastikan basis pengetahuan AI Anda tetap akurat dan relevan, API menyediakan kontrol yang diperlukan untuk memperbarui catatan memori yang ada atau menghapusnya sepenuhnya.
Untuk memperbarui memori, kirim permintaan PUT ke /update dengan memory_id sebagai parameter kueri. Badan permintaan harus berupa JSON dan dapat menyertakan data baru (konten teks) atau metadata baru (yang akan menggantikan metadata yang ada untuk memori tersebut). Misalnya:
curl -X PUT "http://localhost:8000/update?memory_id=some-unique-id" \
-H "Content-Type: application/json" \
-d '{"data": "Alice now also enjoys Go for systems programming."}'
Untuk menghapus memori spesifik, gunakan permintaan DELETE ke /delete dengan memory_id sebagai parameter kueri: curl -X DELETE "http://localhost:8000/delete?memory_id=some-unique-id".
Untuk pembersihan yang lebih luas, titik akhir DELETE /delete_all dapat digunakan. Jika Anda memberikan parameter kueri user_id (misalnya, curl -X DELETE "http://localhost:8000/delete_all?user_id=user_alice"), ini akan menghapus semua memori untuk pengguna spesifik tersebut. Jika user_id dihilangkan, perilakunya mungkin menghapus semua memori dalam sistem, jadi gunakan ini dengan sangat hati-hati dan selalu verifikasi perilaku pastinya dalam dokumentasi **Mem0**. Server biasanya akan merespons dengan pesan JSON yang mengonfirmasi keberhasilan atau kegagalan operasi ini.
Tips Pro: Selalu terapkan pemeriksaan yang cermat dan konfirmasi pengguna dalam logika aplikasi Anda sebelum memanggil titik akhir penghapusan, terutama delete_all, untuk mencegah kehilangan data yang tidak disengaja.
Kesimpulan
Anda sekarang telah menelusuri langkah-langkah penting dalam menyiapkan OpenMemory MCP Server lokal dengan kerangka kerja sumber terbuka **Mem0** dan menggunakan API REST-nya. Dengan mengikuti instruksi ini untuk menginstal **Mem0**, menjalankan server, dan berinteraksi dengan API-nya, Anda mendapatkan kontrol langsung atas memori aplikasi AI Anda. Ini mendorong tingkat persistensi, personalisasi, dan privasi yang baru. Kekuatan untuk mengelola memori secara terprogram secara lokal membuka kemungkinan luas untuk sistem yang lebih cerdas dan sadar konteks—mulai dari chatbot yang mengingat preferensi pengguna hingga asisten pengembang yang mengingat detail proyek. Kemampuan untuk membuat memori AI lokal yang digerakkan oleh API kini ada di tangan Anda. Bereksperimenlah dengan API ini, dan mulailah membangun aplikasi AI yang benar-benar belajar dan berkembang.