Tutorial Supermemory: Tambahkan Memori Persisten ke Agen AI

Apa itu Supermemory?

Cara terbaik mendeskripsikan Supermemory adalah API memori AI untuk agen. Saat Anda memberikan string tentang pengguna Anda ke Supermemory, nanti ia mengembalikan ringkasan padat tentang siapa pengguna itu dan apa yang baru-baru ini mereka lakukan. Embedding, pengindeksan, dan retrieval semuanya berjalan di dalam Supermemory, sehingga kode agen Anda tetap kecil.

Tolok ukur LongMemEval menguji seberapa baik sebuah sistem memori menjawab pertanyaan di atas riwayat percakapan yang panjang. Supermemory mengingat 81,6% fakta yang benar. Zep, sistem terbaik berikutnya, mencetak 71,2%, selisih 10 poin yang kira-kira setara dengan 1 jawaban benar ekstra per 10 pertanyaan pengguna. Repositori open-source memiliki 22k+ bintang GitHub, sinyal lain dari penggunaan nyata.

Memori vs RAG

Kebanyakan pembaca yang mencari alat memori agen pernah menggunakan RAG sebelumnya. Sangat membantu menempatkan Supermemory di sebelahnya. RAG dan memori menyelesaikan masalah yang berbeda, dan sering hidup dalam agen yang sama.

Sistem RAG merujuk ke korpus dokumen yang disiapkan pengembang sekali saja. Manual produk, artikel dukungan, dokumen internal. Korpus dimuat saat deploy, diquery saat runtime, dan jarang berubah. Agen menggunakannya untuk menjawab pertanyaan yang jawabannya sudah diketahui oleh produk itu sendiri.

Sistem memori berfokus pada pengguna. Supermemory menulis fakta spesifik pengguna saat agen berbicara dengan pengguna itu, dan penyimpanannya tumbuh di setiap percakapan. Agen menggunakannya untuk menjawab pertanyaan yang hanya bisa dijawab oleh pengguna, seperti preferensi, riwayat, dan aktivitas terbaru.

Dalam produk nyata, keduanya berjalan berdampingan. RAG di atas basis pengetahuan perusahaan menjawab "apa kebijakan pengembalian dana kita?". Supermemory di atas jawaban pengguna, "Seberapa berat bench press saya pekan lalu?" Agen yang sama, dua penyimpanan data, dua tugas.

Profil pengguna: fakta statis dan dinamis

Gagasan utama Supermemory adalah profil pengguna. Setiap log dipilah ke dua keranjang: fakta statis yang jarang berubah, dan fakta dinamis tentang aktivitas saat ini. Pola yang berulang dipromosikan menjadi statis. Aktivitas terbaru tetap di dinamis.

Saat agen membaca profil, satu panggilan mengembalikan kedua keranjang plus potongan memori yang cocok.

Pemisahan ini penting karena fakta statis dan dinamis menjawab pertanyaan berbeda tentang pengguna yang sama:

Baca baris pertama. Sisi statis menjelaskan bagaimana pengguna berlatih: di rumah, dengan peralatan yang mereka miliki. Itu tidak berubah dari minggu ke minggu. Sisi dinamis mengatakan apa yang sedang mereka kerjakan sekarang: tubuh bagian atas, siklus ini.

Pemberi saran latihan membutuhkan keduanya. Sisi statis menyingkirkan latihan khusus gym, sisi dinamis memilih sesi hari ini.

Di balik profil itu, Supermemory melakukan empat pekerjaan yang seharusnya Anda bangun sendiri. Ia menyimpan memori mentah, membuat embedding setiap potongan, menjalankan pencarian kemiripan saat baca, dan mengekstrak fakta profil dari konten yang dilog. Tidak satu pun dari keempatnya muncul di kode Anda.

Setiap memori ditandai dengan string yang dipilih pengembang. Setiap pembacaan mengirimkan kembali string yang sama untuk membatasi apa yang keluar. Pelatih ini menghardcode satu tag karena satu pengguna sudah cukup untuk menunjukkan cara kerja profil. Aplikasi nyata menghitung tag dari pengguna yang terautentikasi, seperti JWT mereka.

Menyiapkan Lingkungan Supermemory Anda

Pelatih membutuhkan dua kunci API (Supermemory dan OpenAI) dan proyek Python dengan tiga dependensi. Skrip uji cepat membuktikan kedua kunci berfungsi sebelum kode agen menyentuhnya.

Mendapatkan kunci API Anda

Kunci API Supermemory ada di console.supermemory.ai, BUKAN app.supermemory.ai. Subdomain app adalah produk memori konsumen (untuk menyimpan catatan, menelusuri ruang Anda). Ia tidak memiliki halaman kunci API. Lewati itu dan langsung ke console.

Di console.supermemory.ai:

1. Masuk.

2. Klik API Keys di sidebar.

3. Klik Create API Key.

4. Namai (demo pelatih menggunakan datacamp-tutorial).

5. Salin kunci yang dihasilkan. Dimulai dengan sm_.

Anda juga memerlukan kunci OpenAI untuk panggilan LLM agen. Ambil satu di platform.openai.com/api-keys jika Anda belum memilikinya.

Buat file .env di root proyek Anda berisi kedua kunci. Jangan commit.

SUPERMEMORY_API_KEY=sm_your_key_here
OPENAI_API_KEY=sk-your_key_here

Paket gratis Supermemory mencakup tutorial ini tanpa memasukkan info pembayaran. Batas pastinya ada di halaman harga.

Menginstal dependensi

Tutorial ini menggunakan uv untuk penyiapan dan menjalankan proyek. Jika Anda belum memiliki uv, instal sekali dengan one-liner dari astral.sh/uv.

Inisialisasi proyek:

uv init supermemory-trainer
cd supermemory-trainer

Hapus README.md yang dibuat otomatis oleh uv init. File hello.py yang dibuat otomatis akan ditimpa di langkah berikutnya, jadi biarkan dulu.

Tambahkan tiga dependensi:

• supermemory==3.37.0 adalah klien memori, dipatok ke versi yang diverifikasi untuk tutorial ini.

• openai-agents adalah OpenAI Agents SDK. Nama paketnya menggunakan tanda hubung, path impor adalah agents.

• python-dotenv membaca file .env yang baru saja Anda buat.

uv add supermemory==3.37.0 openai-agents python-dotenv

pyproject.toml yang dihasilkan:

[project]
name = "supermemory-trainer"
version = "0.1.0"
description = "Personal exercise trainer agent built with Supermemory and the OpenAI Agents SDK."
requires-python = ">=3.10"
dependencies = [
	"openai-agents>=0.10.2",
	"python-dotenv>=1.2.1",
	"supermemory==3.37.0",
]

Memverifikasi penyiapan Anda

Sebelum menulis kode agen apa pun, lihat Supermemory bekerja sekali pada satu kalimat. Skrip di bawah ini mengirim satu fakta ke Supermemory, menunggu pipeline, lalu membaca profilnya kembali. Jika ini berjalan mulus, kuncinya berfungsi, dan SDK dapat dijangkau. Outputnya juga memberi Anda gambaran pertama tentang apa yang dilakukan Supermemory dengan teks mentah.

Buka hello.py di root proyek dan ganti isi yang dibuat otomatis dengan impor dan panggilan tulis:

import time
 
from dotenv import load_dotenv
from supermemory import Supermemory
 
load_dotenv()
 
client = Supermemory()
USER_ID = "demo_warmup"
 
response = client.add(
	content="The user is learning Supermemory by building a personal trainer agent.",
	container_tag=USER_ID,
)
print(f"client.add() -> id={response.id} status={response.status}")

load_dotenv() membaca kunci API dari .env ke environment sebelum Supermemory() dibuat. Klien mengambil SUPERMEMORY_API_KEY secara otomatis. Nilai container_tag="demo_warmup" membatasi fakta tunggal ini ke pengguna sementara.

Sekarang tambahkan tunggu dan baca di bagian bawah file yang sama:

print("Waiting 20 seconds for processing...")
time.sleep(20)
 
prof = client.profile(container_tag=USER_ID, q="learning")
print(f"profile.static  ({len(prof.profile.static)}): {prof.profile.static}")
print(f"profile.dynamic ({len(prof.profile.dynamic)}): {prof.profile.dynamic}")
print(f"search_results.results ({len(prof.search_results.results)}):")
for r in prof.search_results.results[:3]:
	print(f"  - {r['memory']} (similarity={r['similarity']:.3f})")

Tidur 20 detik memberi waktu pipeline embed-and-extract Supermemory untuk memroses memori baru. Tanpanya, pembacaan tidak mengembalikan apa pun, dan skrip terlihat rusak padahal tidak.

Jalankan file:

uv run python hello.py

Output yang diharapkan:

client.add() -> id=zNLsJBrY1PZupAeZ3Qn6EL status=queued
Waiting 20 seconds for processing...
profile.static  (0): []
profile.dynamic (1): ['Building a personal trainer agent to learn Supermemory.']
search_results.results (1):
  - Building a personal trainer agent to learn Supermemory. (similarity=0.650)

Ada tiga detail penting pada output ini. client.add() mengembalikan segera dengan status="queued", karena Supermemory memproses dokumen secara asinkron. Waktu tunggu 20 detik mencakup pipeline embed-and-extract. Saat pembacaan dijalankan, kalimat mentah itu sudah menjadi satu potongan memori yang dapat dicari.

Baris yang menarik adalah profile.dynamic. Inputnya adalah kalimat "The user is learning Supermemory by building a personal trainer agent." Outputnya adalah fakta dinamis 'Building a personal trainer agent to learn Supermemory.' Supermemory menulis ulang kalimat orang ketiga menjadi fakta orang pertama tentang pengguna. Itulah ekstraktor profil yang bekerja.

profile.static adalah daftar kosong. Fakta statis terkonsolidasi secara bertahap, setelah beberapa log terkait terkumpul, sehingga satu tulis pemanasan tidak menghasilkan apa pun. Alat saran pelatih mengantisipasi hal ini dan memperlakukan static sebagai bonus, bukan jaminan.

Membangun Agen Supermemory: Pelatih Olahraga Personal di Python

Pelatih membungkus client.add() dan client.profile() ke dalam dua alat agen, sehingga baca dan tulis terjadi otomatis saat pengguna mengobrol. Riwayat latihan cocok dengan memori. Peralatan, cedera, dan beban terakhir tidak ada di data pelatihan LLM, dan semua itu terakumulasi sesi demi sesi.

Struktur proyek dan agen

Pelatih cukup kecil sehingga seluruh proyek muat dalam dua file Python plus pyproject.toml yang sudah Anda punya:

supermemory-trainer/
├── .env            	# your real keys (gitignored)
├── .env.example    	# placeholders, committed
├── .gitignore
├── .python-version
├── main.py         	# agent definition, system prompt, REPL loop
├── pyproject.toml
└── tools.py        	# log_workout and suggest_next_session

tools.py menyimpan dua alat berbasis memori yang akan Anda tulis berikutnya. log_workout menulis latihan ke Supermemory melalui client.add(). suggest_next_session membaca profil pengguna melalui client.profile(). main.py mengimpor keduanya dan menyusun agen.

Sebagian besar main.py adalah boilerplate OpenAI Agents SDK. Satu kalimat di system prompt menangani pekerjaan Supermemory: setiap fakta tentang pengguna harus kembali melalui panggilan alat. Agen diberi tahu bahwa ia tidak memiliki memori sendiri. Aturan tunggal itu yang membuat pelatih ini berbasis memori.

Buka main.py dan mulai dengan impor dan system prompt:

import asyncio
 
from agents import Agent, Runner, SQLiteSession
 
from tools import log_workout, suggest_next_session
 
SYSTEM_PROMPT = """You are a personal exercise trainer who logs the user's
workouts and recommends what to do next.
 
You have no memory of the user's history on your own. Every fact about the
user lives in Supermemory and reaches you only through tool calls.
 
Two rules, no exceptions:
 
1. Whenever the user reports completing a workout, call log_workout immediately, before responding. Extract the exercise, sets, reps, weight, and any notes from what they said. If a value is missing, ask one short follow-up question instead of guessing. After logging, confirm in one short sentence and stop. Do NOT recommend the next session unless the user asks for one.
 
2. When the user explicitly asks what to do next (or asks for a recommendation, suggestion, or plan), call suggest_next_session first. Never recommend from your own training data. The tool returns the user's
 recent activity, stable preferences, and matching past sessions. Reference those facts directly in your reply.
 
Keep replies concise (2-4 sentences). Be specific: name the exercise, sets, reps, and weight. Honor any injuries or equipment constraints the tool surfaces.
"""

Kedua aturan dalam system prompt mengarahkan model melalui Supermemory. 

Aturan 1 memaksa satu penulisan log_workout setiap kali pengguna melaporkan latihan, sehingga setiap latihan masuk ke penyimpanan memori. Aturan 2 memaksa satu pembacaan suggest_next_session sebelum rekomendasi apa pun, sehingga setiap rekomendasi berdasar pada apa yang diketahui Supermemory. 

Lewati aturan itu, dan agen menjawab dari data pelatihannya, yang menggagalkan tujuan adanya lapisan memori.

Sekarang definisikan agen dan loop chat di file yang sama:

def build_agent() -> Agent:
	return Agent(
    	name="Trainer",
    	instructions=SYSTEM_PROMPT,
    	tools=[log_workout, suggest_next_session],
    	model="gpt-5",
	)
 
 
async def chat() -> None:
	agent = build_agent()
	session = SQLiteSession(session_id="trainer-cli")
 
	print("Trainer ready. Type a message, or 'exit' to quit.\n")
	while True:
    	try:
        	message = input("You: ").strip()
    	except (EOFError, KeyboardInterrupt):
        	print()
        	break
    	if not message:
        	continue
    	if message.lower() in {"exit", "quit"}:
        	break
 
    	result = await Runner.run(agent, message, session=session)
    	print(f"\nTrainer: {result.final_output}\n")
 
 
if __name__ == "__main__":
	asyncio.run(chat())

Ada dua baris pada blok itu yang patut disebut. tools=[log_workout, suggest_next_session] mendaftarkan dua alat berbasis memori. Dekorator @function_tool pada masing-masing (di tools.py) memberi tahu SDK bahwa mereka dapat dipanggil. Tanpa dekorator, agen tidak memiliki alat saat runtime, meskipun pemanggilan konstruktor berhasil.

SQLiteSession(session_id="trainer-cli") menyimpan riwayat giliran jangka pendek di dalam proses Python yang berjalan. Supermemory menyimpan fakta pengguna jangka panjang lintas proses. Mematikan proses Python menghapus sesi SQLite, tetapi data Supermemory tetap ada.

Penting: Jalankan main.py sebagai skrip, bukan di sel Jupyter, karena event loop Jupyter berbenturan dengan asyncio.run(). Klien sinkron Supermemory() bekerja di dalam fungsi alat async karena Agents SDK menjalankan alat di thread pool. Untuk info lebih lanjut tentang SDK itu sendiri, lihat tutorial OpenAI Agents SDK.

Menulis alat pencatatan latihan

log_workout adalah sisi tulis dari memori agen. Fungsinya menerima argumen terstruktur dari agen: nama latihan, set, repetisi, beban, dan catatan opsional. Fungsinya mengubah itu menjadi satu kalimat bahasa Inggris pendek dan menyerahkannya ke Supermemory melalui client.add(). Pipeline embed-and-extract berjalan di dalam Supermemory setelah itu dan tidak membutuhkan apa pun dari pelatih.

Buka tools.py dan mulai dengan impor serta satu klien bersama:

from agents import function_tool
from dotenv import load_dotenv
from supermemory import Supermemory
 
load_dotenv()
 
USER_ID = "demo_user"
 
client = Supermemory()

load_dotenv() berjalan saat impor sehingga SUPERMEMORY_API_KEY sudah ada di environment sebelum Supermemory() dibuat. Jika Anda membuat klien sebelum memuat env, Anda akan mendapatkan klien yang tidak terautentikasi. Panggilan pertama kemudian mengembalikan 401 yang membingungkan. Kedua fungsi alat dalam file ini berbagi satu klien itu dan satu konstanta USER_ID.

Tambahkan alat pencatatan di bawah klien:

@function_tool
def log_workout(
	exercise: str,
	sets: int,
	reps: int,
	weight: float,
	notes: str = "",
) -> str:
	"""Log a completed workout to the user's memory.
 
	Args:
    	exercise: Name of the exercise.
    	sets: Number of sets performed.
    	reps: Number of reps per set.
    	weight: Weight in pounds. Pass 0 for bodyweight or cardio.
    	notes: Optional notes about the session.
	"""
	print(f"[log_workout] {exercise=} {sets=} {reps=} {weight=} {notes=}")
 
	content = f"Performed {exercise}: {sets} sets of {reps} reps at {weight} lbs."
	if notes:
    	content += f" Notes: {notes}"
 
	response = client.add(content=content, container_tag=USER_ID)
	print(f"[log_workout] -> id={response.id} status={response.status}")
	return f"Logged {exercise} ({sets}x{reps} @ {weight} lb)."

Docstring @function_tool adalah apa yang dilihat LLM saat memutuskan apakah akan memanggil alat. Blok Args: memetakan ke deskripsi per parameter. Keduanya adalah bagian dari kontrak agen dengan fungsi tersebut.

Alat ini mengirimkan kalimat biasa ke client.add(), bukan JSON. Ekstraktor profil Supermemory membaca bahasa natural dan menyimpulkan fakta darinya. Secara teknis JSON bisa saja, tetapi kualitas ekstraksi menurun karena model tidak memiliki narasi untuk diringkas. "Performed bench press: 4 sets of 5 reps at 185.0 lbs" memberi ekstraktor satu kalimat bersih untuk dikerjakan.

Dua panggilan print() menulis setiap pemanggilan alat ke terminal: pertama argumen yang diurai, lalu respons.

[log_workout] exercise='bench press' sets=4 reps=5 weight=185.0 notes=''
[log_workout] -> id=xY7AK3qLzBPx5Vd2HnRf1M status=queued

Nilai status="queued" cocok dengan apa yang dikembalikan skrip pemanasan sebelumnya. Log mentah disimpan, tetapi client.profile() tidak akan mengembalikannya sebagai hasil pencarian hingga pipeline selesai. Anda akan menambahkan langkah verifikasi nanti yang menunggu hal itu selesai.

Menulis alat saran latihan

suggest_next_session adalah sisi baca, dan di sinilah pemisahan statis-dinamis terasa manfaatnya. Satu panggilan client.profile(container_tag=USER_ID, q=focus) mengembalikan tiga tampilan tentang pengguna dalam satu perjalanan. 

Preferensi yang stabil kembali sebagai profile.static, aktivitas saat ini sebagai profile.dynamic, dan memori masa lalu yang paling cocok sebagai search_results.results. Tugas alat adalah meratakan ketiga tampilan itu menjadi satu blok konteks yang bisa dikutip agen.

Setelah beberapa latihan, alat menghasilkan output seperti ini:

Recent activity:
- Trains at home instead of a gym
- Performed deadlift: 3 sets of 5 reps at 225.0 lbs
- Performed 5k run in 26 minutes
- Reports no knee pain during bench press
- Performed bench press: 4 sets of 5 reps at 185.0 lbs
Closest matching past entries:
- Trains at home instead of a gym
- Performed deadlift: 3 sets of 5 reps at 225.0 lbs
- Performed bench press: 4 sets of 5 reps at 185.0 lbs
- Performed 5k run in 26 minutes
- Reports no knee pain during bench press

Agen membaca blok itu dan menulis rekomendasi yang berlandaskan pada riwayat pengguna yang sebenarnya. Tanpa profil Supermemory, Anda akan membangun konteks yang sama sendiri. Itu berarti pencarian semantik terpisah, penyimpan profil Anda sendiri, dan menggabungkan hasilnya. Satu panggilan client.profile() menggantikan ketiganya.

Tambahkan ini ke tools.py di bawah log_workout:

@function_tool
def suggest_next_session(focus: str) -> str:
	"""Fetch the user's training history and preferences for a given focus.
 
	Returns a context string the agent can use to recommend the next session.
	The agent is responsible for the actual recommendation. This tool only
	surfaces what Supermemory knows about the user.
 
	Args:
    	focus: What the user wants to train next (e.g. "upper body", "legs",
        	"cardio", "today"). Drives semantic search against past logs.
	"""
	print(f"[suggest_next_session] focus={focus!r}")
	profile = client.profile(container_tag=USER_ID, q=focus)
 
	static_facts = profile.profile.static
	dynamic_facts = profile.profile.dynamic
	matches = profile.search_results.results
 
	print(
    	f"[suggest_next_session] static={len(static_facts)} "
    	f"dynamic={len(dynamic_facts)} matches={len(matches)}"
	)
 
	sections = []
	if static_facts:
    	sections.append("Stable preferences and constraints:")
    	sections.extend(f"- {fact}" for fact in static_facts)
	if dynamic_facts:
    	sections.append("Recent activity:")
    	sections.extend(f"- {fact}" for fact in dynamic_facts)
	if matches:
    	sections.append("Closest matching past entries:")
    	for r in matches[:5]:
        	sections.append(f"- {r['memory']}")
 
	if not sections:
    	return (
        	"No prior training history found for this user. "
        	"Ask the user about their goals, equipment, and recent training."
    	)
	return "\n".join(sections)

client.profile(container_tag=USER_ID, q=focus) mengembalikan objek ProfileResponse. Setelah 5 log singkat, tiga field yang dibaca alat terlihat seperti ini:

profile.profile.static        	# [] (list[str])
profile.profile.dynamic       	# ["Performed bench press: 4 sets of 5 reps at 185.0 lbs", ...]
profile.search_results.results	# [{"memory": "...", "similarity": 0.631, ...}, ...] (list[dict])

Setiap hasil pencarian adalah dict Python, bukan objek Pydantic. Gunakan r["memory"] untuk teks dan r["similarity"] untuk skornya. Dict lengkap memiliki kunci berikut:

• id

• memory

• rootMemoryId

• metadata

• updatedAt

• version

• similarity

• filepath

• documents

Snippet r.memory or r.chunk dari halaman integrasi OpenAI Agents SDK milik Supermemory menimbulkan AttributeError pada supermemory==3.37.0. Gunakan akses dengan bracket.

static kosong di sini, itulah alasan alat bercabang pada if static_facts:. Cabang dynamic dan search_results melakukan pekerjaan nyata untuk selusin log pertama.

Supermemory juga menerapkan ambang kemiripan default. Fakta yang Anda sebutkan sekali mungkin tidak kembali untuk setiap kueri. Kelima log di atas semuanya kembali untuk q="today", tetapi string kueri yang lebih spesifik bisa mengembalikan lebih sedikit. Guard if matches: menangani itu tanpa gagal.

Menjalankan sesi 1: mencatat latihan

Mulai sesi 1 dan catat beberapa latihan untuk mengisi Supermemory dengan sesuatu yang dapat dibaca kembali nanti. Jalankan skrip:

uv run python main.py

Catat bench press, lalu lari 5k, lalu deadlift, plus satu pernyataan preferensi: "Saya hanya latihan di rumah, tidak ke gym." Agen memanggil log_workout sekali per latihan, dan baris print() alat membuat setiap panggilan terlihat di terminal.

Contoh output. Ucapan agen Anda mungkin berbeda karena model non-deterministik.

Tiga baris status=queued adalah momen saat Supermemory mengambil alih. Masing-masing sesuai dengan dokumen yang bergerak melalui pipeline embed-and-extract di sisi Supermemory. Untuk log teks pendek seperti ini, dokumen menjadi bisa dicari melalui client.profile() dalam ~12 detik.

Tidak ada apa pun dalam kode pelatih yang menunggu itu. Agen lanjut berjalan, dan Supermemory menyelesaikan pekerjaan di latar belakang.

Setiap log memicu tepat satu panggilan log_workout, dan agen berhenti. Tidak ada rekomendasi proaktif, tidak ada panggilan alat tambahan, tidak ada saran lanjutan. Aturan pertama di system prompt yang melakukan itu. Tanpa aturan itu, agen akan menyarankan sesi berikutnya setelah setiap log, menggandakan panggilan alat.

Ketik exit untuk menutup sesi 1. Proses Python berakhir, dan SQLiteSession ikut hilang. Log latihan dan pernyataan preferensi kini hidup di Supermemory di bawah container_tag="demo_user", terpisah dari skrip yang menulisnya.

Memverifikasi recall dan menjalankan sesi 2

Sebelum sesi 2, konfirmasikan bahwa fakta dari sesi 1 dapat diquery. Buka REPL Python baru atau simpan ini sebagai skrip pendek:

from dotenv import load_dotenv
from supermemory import Supermemory
 
load_dotenv()
client = Supermemory()
 
prof = client.profile(container_tag="demo_user", q="training")
print(f"static  ({len(prof.profile.static)}): {prof.profile.static}")
print(f"dynamic ({len(prof.profile.dynamic)}):")
for fact in prof.profile.dynamic:
	print(f"  - {fact}")
print(f"matches ({len(prof.search_results.results)}):")
for r in prof.search_results.results[:5]:
	print(f"  - {r['memory']} (similarity={r['similarity']:.3f})")

Output nyata yang ditangkap di antara dua sesi:

static  (0): []
dynamic (5):
  - Trains at home instead of a gym
  - Performed deadlift: 3 sets of 5 reps at 225.0 lbs
  - Performed 5k run in 26 minutes
  - Reports no knee pain during bench press
  - Performed bench press: 4 sets of 5 reps at 185.0 lbs
matches (5):
  - Trains at home instead of a gym (similarity=0.682)
  - Performed deadlift: 3 sets of 5 reps at 225.0 lbs (similarity=0.643)
  - Performed bench press: 4 sets of 5 reps at 185.0 lbs (similarity=0.631)
  - Performed 5k run in 26 minutes (similarity=0.585)
  - Reports no knee pain during bench press (similarity=0.585)

Lihat apa yang dihasilkan ekstraktor Supermemory. Pengguna sekali berkata, "Saya hanya latihan di rumah, tidak ke gym." Ekstraktor mengubahnya menjadi fakta dinamis "Trains at home instead of a gym".

Log bench press menyertakan field catatan tentang tidak ada nyeri lutut. Ekstraktor membagi satu log itu menjadi dua fakta dinamis: satu untuk latihan, satu untuk ketiadaan rasa sakit.

Empat log menjadi lima fakta dinamis ternormalisasi plus lima potongan memori yang cocok dengan skor kemiripan antara 0,585 dan 0,682. Tidak ada pembagian, normalisasi, atau pencocokan itu yang berjalan di kode pelatih. Jika dynamic kosong bagi Anda, tunggu 10 detik lagi dan jalankan ulang potongan kode. Terkadang antrean pemrosesan memuncak.

Sekarang mulai sesi 2 di proses yang benar-benar baru:

uv run python main.py

Ini adalah interpreter Python baru. Tidak ada memori bersama dengan sesi 1. Tidak ada cache hangat. Apa pun yang diingat agen berasal dari Supermemory.

Kirim satu pesan: "Apa yang harus saya lakukan untuk latihan hari ini?"

Contoh output. Penyimpanan memori sama, proses Python baru.

Agen memanggil suggest_next_session("today"). Alat mencetak static=0 dynamic=5 matches=5. Run yang ditangkap merespons dengan sesi tubuh bagian bawah di rumah (squat, lunge, step-up).

Rekomendasi sejalan dengan log sebelumnya karena profil Supermemory memberi tahu agen apa saja log itu. Bench, deadlift, dan lari 5k adalah tubuh atas atau kardio, dan pengguna hanya berlatih di rumah. Keduanya kembali dari panggilan client.profile() yang sama. Run Anda akan merangkai kalimat secara berbeda karena model non-deterministik, tetapi jalur recall-nya sama.

Langkah Berikutnya untuk Agen Supermemory Anda

Demonya untuk satu pengguna, dua alat, dan CLI. Versi nyata dari pelatih berkembang ke tiga arah bernuansa Supermemory sebelum menyentuh loop agen.

Beri ruang lingkup memori per pengguna nyata. Konstanta USER_ID = "demo_user" berfungsi untuk satu orang. Aplikasi produksi menghitung tag dari ID pengguna yang terautentikasi, seperti container_tag="user_sarah" atau container_tag=customer_id. Memori antar pengguna tetap terpisah karena setiap pembacaan mengirimkan tag kembali. Satu perubahan di tools.py, tidak ada kode lain yang berubah.

Tambahkan lebih banyak alat berbasis memori. Minggu deload, pelacakan PR, dan pengingat mobilitas mingguan. Masing-masing adalah fungsi @function_tool lain yang memanggil client.add() untuk tulis dan client.profile() untuk baca terhadap container_tag yang sama. Bentuk alatnya tetap sama. Hanya apa yang dicatat agen dan dimintanya yang berubah.

Tangani kegagalan Supermemory. Bungkus client.add() dan client.profile() dalam try/except supermemory.APIError agar kegagalan sementara dari Supermemory tidak membuat agen crash. Tetapkan timeout per permintaan jika agen Anda berjalan di lingkungan yang terbatas.

Sisi loop agen bersifat independen dari Supermemory dan dapat berubah nanti. Letakkan CLI di depan Telegram, Discord, atau Slack, sehingga pengguna mengirim teks latihan dan bot memanggil Runner.run(). Atau tukar kerangka. Supermemory memiliki integrasi LangChain jika tumpukan Anda sudah menggunakan agen LangChain, dan kode memori tidak berubah.

Pemisahan statis-dinamis juga cocok untuk domain lain. 

• Agen dukungan pelanggan: statis = isu yang diketahui dan preferensi akun, dinamis = tiket terbuka dan kontak terbaru. 
• Agen pengodean: statis = bahasa dan framework yang disukai, dinamis = tugas saat ini dan file yang baru-baru ini disentuh. 

Pemisahan ini berlaku kapan pun pengguna adalah sumber kebenaran.

Kesimpulan

Anda baru saja membangun pelatih Python dengan dua alat dan memori persisten lintas proses. client.add() menulis latihan. client.profile() membaca kembali pengguna sebagai fakta statis, fakta dinamis, dan kecocokan semantik dalam satu panggilan, semuanya dibatasi oleh container_tag. Supermemory menangani chunking, embedding, pencarian, dan ekstraksi profil yang tidak perlu ditulis oleh demo.

Padukan dengan RAG, dan agen yang sama menjawab pertanyaan tentang pengguna dan produk. LLM Agents Explained membahas pola agen yang lebih luas, dan jalur Associate AI Engineer for Developers membahas lebih jauh tentang agen berbasis memori.