Supermemory-handledning: Lägg till bestående minne i AI-agenter

Vad är Supermemory?

Supermemory kan bäst beskrivas som ett AI-minnes-API för agenter.  När du ger Supermemory strängar om din användare returnerar det senare en kompakt bild av vem den användaren är och vad hen nyligen har gjort. Inbäddning, indexering och hämtning körs alla inne i Supermemory, så din agentkod förblir liten.

Benchmarken LongMemEval testar hur väl ett minnessystem besvarar frågor över en lång konversationshistorik. Supermemory minns 81,6% av de korrekta fakta. Zep, näst bästa system, får 71,2%, ett gap på 10 punkter som motsvarar ungefär 1 extra rätt svar per 10 användarfrågor. Det öppna källkods-repot har 22k+ GitHub-stjärnor, ytterligare en signal om verklig användning.

Minne vs RAG

De flesta läsare som söker ett agentminnesverktyg har använt RAG tidigare. Det hjälper att placera Supermemory bredvid det. RAG och minne löser olika problem och lever ofta i samma agent.

Ett RAG-system pekar på en dokumentkorpus som utvecklaren förbereder en gång. Produktmanualer, supportartiklar, interna dokument. Korpusen laddas vid driftsättning, frågas vid körning och ändras sällan. Agenten använder den för att besvara frågor som produkten själv kan svara på.

Ett minnessystem pekar på användaren. Supermemory skriver användarspecifika fakta medan agenten pratar med den användaren, och lagret växer med varje konversation. Agenten använder det för att besvara frågor som bara användaren kan svara på, som preferenser, historik och senaste aktivitet.

I en riktig produkt körs de två sida vid sida. RAG över en företagskunskapsbas svarar på ”vad är vår återbetalningspolicy?”. Supermemory över användaren svarar på ”Vad var mitt bänkpresslyft förra veckan?” Samma agent, två datalager, två jobb.

Användarprofiler: statiska och dynamiska fakta

Supermemorys huvudidé är användarprofilen. Varje logg sorteras i två hinkar: statiska fakta som sällan ändras och dynamiska fakta om aktuell aktivitet. Återkommande mönster lyfts upp till statiskt. Senaste aktivitet stannar i det dynamiska.

När agenten läser profilen returnerar ett anrop båda hinkarna plus matchande minnesbitar.

Uppdelningen spelar roll eftersom statiska och dynamiska fakta besvarar olika frågor om samma användare:

Läs rad ett. Den statiska sidan säger hur användaren tränar: hemma, med utrustningen de äger. Det ändras inte vecka till vecka. Den dynamiska sidan säger vad de jobbar på just nu: överkropp, den här cykeln.

En träningsförslagare behöver båda. Den statiska sidan utesluter övningar som kräver gym, den dynamiska sidan väljer dagens pass.

Bakom profilen gör Supermemory fyra jobb som du annars skulle bygga själv. Det lagrar råa minnen, bäddar in varje bit, kör likhetssökning vid läsning och extraherar profilfakta från loggat innehåll. Inget av de fyra syns i din kod.

Varje minne taggas med en sträng som utvecklaren väljer. Varje läsning skickar tillbaka samma sträng för att begränsa vad som kommer ut. Tränaren hårdkodar en tagg eftersom en användare räcker för att visa vad profilen gör. Riktiga appar beräknar taggen från den autentiserade användaren, som deras JWT.

Ställ in din Supermemory-miljö

Tränaren behöver två API-nycklar (Supermemory och OpenAI) och ett Python-projekt med tre beroenden. Ett snabbt rundrese-skript visar att båda nycklarna fungerar innan någon agentkod rör dem.

Hämta dina API-nycklar

Supermemorys API-nyckel finns på console.supermemory.ai, INTE app.supermemory.ai. Subdomänen app är konsumentprodukten för minne (för att spara anteckningar, bläddra i ditt utrymme). Den har ingen sida för API-nycklar. Hoppa över den och gå direkt till konsolen.

På console.supermemory.ai:

1. Logga in.

2. Klicka på API Keys i sidofältet.

3. Klicka på Create API Key.

4. Namnge den (tränardemon använder datacamp-tutorial).

5. Kopiera den resulterande nyckeln. Den börjar med sm_.

Du behöver också en OpenAI-nyckel för agentens LLM-anrop. Hämta en på platform.openai.com/api-keys om du inte redan har en.

Skapa en .env-fil i projektroten med båda nycklarna. Commita den inte.

SUPERMEMORY_API_KEY=sm_your_key_here
OPENAI_API_KEY=sk-your_key_here

Supermemorys gratistill nivå täcker denna handledning utan att du behöver ange betalningsinformation. Exakta gränser finns på prissidan.

Installera beroenden

Handledningen använder uv för projektsetup och körning. Om du inte har uv, installera det en gång med one-linern från astral.sh/uv.

Initiera projektet:

uv init supermemory-trainer
cd supermemory-trainer

Ta bort den autogenererade README.md som uv init lägger till. Den autogenererade hello.py skrivs över i nästa steg, så låt den vara tills vidare.

Lägg till tre beroenden:

• supermemory==3.37.0 är minnesklienten, låst till versionen som verifierats för denna handledning.

• openai-agents är OpenAI Agents SDK. Paketnamnet är med bindestreck, importvägen är agents.

• python-dotenv läser .env-filen du just skapade.

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

Resulterande pyproject.toml:

[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",
]

Verifiera din setup

Innan du skriver någon agentkod, se Supermemory göra sitt jobb en gång på en enda mening. Skriptet nedan skickar ett faktum till Supermemory, väntar på pipelinen och läser sedan ut profilen igen. Om detta körs rent fungerar nycklarna och SDK:n är nåbar. Utdata ger dig också en första titt på vad Supermemory gör med rå text.

Öppna hello.py i projektroten och ersätt den autogenererade kroppen med importerna och ett write-anrop:

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() läser in API-nyckeln från .env till miljön innan Supermemory() konstrueras. Klienten plockar upp SUPERMEMORY_API_KEY automatiskt. Värdet container_tag="demo_warmup" avgränsar detta enda faktum till en tillfällig användare.

Lägg nu till väntan och läsningen längst ner i samma fil:

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})")

Sömnen på 20 sekunder ger Supermemorys inbäddnings- och extraktionspipeline tid att bearbeta det nya minnet. Utan den returnerar läsningen ingenting, och skriptet ser trasigt ut när det inte är det.

Kör filen:

uv run python hello.py

Förväntad utdata:

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)

Tre detaljer är viktiga i denna utdata. client.add() returnerar omedelbart med status="queued", eftersom Supermemory bearbetar dokument asynkront. Den 20 sekunder långa väntan täcker inbäddnings- och extraktionspipelinen. När läsningen körs är den råa meningen en sökbar minnesbit.

Den intressanta raden är profile.dynamic. Indatat var meningen ”The user is learning Supermemory by building a personal trainer agent.” Utdata är det dynamiska faktumet 'Building a personal trainer agent to learn Supermemory.' Supermemory skrev om en mening i tredje person till ett faktum i första person om användaren. Det är profilextraktorn som gör sitt jobb.

profile.static är en tom lista. Statiska fakta konsolideras långsamt, efter att ett antal relaterade loggar har samlats, så en enda uppvärmningsskrivning ger inte ett sådant. Tränarens förslagsverktyg planerar för detta och behandlar static som en bonus snarare än en garanti.

Bygga en Supermemory-agent: Personlig träningstränare i Python

Tränaren kapslar in client.add() och client.profile() i två agentverktyg, så att läsningar och skrivningar sker automatiskt medan användaren chattar. Träningshistorik passar minne väl. Utrustning, skador och senaste lyft finns inte i LLM:ens träningsdata, och de ackumuleras pass för pass.

Projektstruktur och agenten

Tränaren är så liten att hela projektet får plats i två Python-filer plus pyproject.toml som du redan har:

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 innehåller de två minnesstödda verktygen du skriver härnäst. log_workout skriver ett träningspass till Supermemory via client.add(). suggest_next_session läser användarens profil via client.profile(). main.py importerar båda och kopplar samman agenten.

Det mesta av main.py är OpenAI Agents SDK-boilerplate. En mening i systemprompten gör Supermemory-arbetet: varje faktum om användaren måste komma tillbaka via verktygsanrop. Agenten får veta att den inte har något eget minne. Den enda regeln är det som gör tränaren minnesstödd.

Öppna main.py och börja med importerna och systemprompten:

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.
"""

Båda reglerna i systemprompten leder modellen genom Supermemory. 

Regel 1 tvingar en log_workout-skrivning när användaren rapporterar ett pass, så att varje pass når minneslagret. Regel 2 tvingar en suggest_next_session-läsning innan någon rekommendation, så att varje rekommendation grundas i vad Supermemory vet. 

Hoppa över de reglerna och agenten svarar från sina träningsdata, vilket motverkar syftet med ett minneslager.

Definiera nu agenten och chat-loopen i samma fil:

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())

Två rader i det blocket är värda att nämna. tools=[log_workout, suggest_next_session] registrerar de två minnesstödda verktygen. Dekoratorn @function_tool på var och en (i tools.py) talar om för SDK:n att de är anropbara. Utan dekoratorn har agenten inga verktyg vid körning, även om konstruktionsanropet lyckas.

SQLiteSession(session_id="trainer-cli") håller kortsiktig turhistorik inne i den körande Python-processen. Supermemory håller långsiktiga användarfakta över processer. Att döda Python-processen tar bort SQLite-sessionen, men Supermemory-datan stannar kvar.

Viktigt: Kör main.py som ett skript, inte i en Jupyter-cell, eftersom Jupyters event loop krockar med asyncio.run(). Den synkrona Supermemory()-klienten fungerar inne i asynkrona verktygsfunktioner eftersom Agents SDK kör verktyg i en trådpool. För mer om själva SDK:n, se OpenAI Agents SDK-handledningen.

Skriva verktyget för att logga träningspass

log_workout är skrivsidan av agentens minne. Funktionen tar strukturerade argument från agenten: övningsnamn, set, reps, vikt och valfria anteckningar. Den gör om dem till en kort engelsk mening och lämnar över meningen till Supermemory via client.add(). Inbäddnings- och extraktionspipelinen körs inne i Supermemory efter det och behöver inget från tränaren.

Öppna tools.py och börja med importerna och en enda delad klient:

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

load_dotenv() körs vid import så att SUPERMEMORY_API_KEY finns i miljön innan Supermemory() konstrueras. Konstruera klienten innan du laddar miljön och du får en oautentiserad klient. Första anropet returnerar då en förvirrande 401. Båda verktygsfunktionerna i denna fil delar den enda klienten och den enda USER_ID-konstanten.

Lägg till loggningsverktyget under klienten:

@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)."

Docstringen för @function_tool är vad LLM:en ser när den avgör om verktyget ska anropas. Args:-blocket mappar till beskrivningar per parameter. Båda ingår i agentens kontrakt med funktionen.

Verktyget skickar en vanlig mening till client.add(), inte JSON. Supermemorys profilextraktor läser naturligt språk och härleder fakta från det. JSON fungerar tekniskt, men extraktionskvaliteten sjunker eftersom modellen saknar en berättelse att sammanfatta. ”Performed bench press: 4 sets of 5 reps at 185.0 lbs” ger extraktorn en ren mening att jobba med.

De två print()-anropen skriver varje verktygsanrop till terminalen: först de tolkade argumenten, sedan svaret.

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

Värdet status="queued" matchar vad uppvärmningsskriptet returnerade tidigare. Råloggen lagras, men client.profile() returnerar den inte som ett sökresultat förrän pipelinen är klar. Du lägger till ett verifieringssteg senare som väntar på att det ska landa.

Skriva verktyget för träningsförslag

suggest_next_session är lässidan, och det är här uppdelningen statiskt-och-dynamiskt lönar sig. Ett client.profile(container_tag=USER_ID, q=focus)-anrop returnerar tre vyer av användaren i en enda rundresa. 

Stabila preferenser kommer tillbaka som profile.static, aktuell aktivitet som profile.dynamic och de närmast matchande tidigare minnena som search_results.results. Verktygets jobb är att platta ut de tre vyerna till ett block av kontext som agenten kan citera.

Efter några pass producerar verktyget utdata som detta:

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

Agenten läser det blocket och skriver en rekommendation grundad i användarens faktiska historik. Utan Supermemorys profil skulle du bygga samma kontext själv. Det betyder en separat semantisk sökning, ett eget profillager och sammanslagning av resultaten. Det enskilda client.profile()-anropet ersätter alla tre.

Lägg till detta i tools.py under 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) returnerar ett ProfileResponse-objekt. Efter 5 korta loggar ser de tre fälten verktyget läser ut så här:

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])

Varje sökresultat är en Python-dict, inte ett Pydantic-objekt. Använd r["memory"] för texten och r["similarity"] för poängen. Hela dicten har följande nycklar:

• id

• memory

• rootMemoryId

• metadata

• updatedAt

• version

• similarity

• filepath

• documents

Snutten r.memory or r.chunk från Supermemorys sida om integration med OpenAI Agents SDK ger AttributeError mot supermemory==3.37.0. Använd hakparentesåtkomst.

static är tomt här, vilket är varför verktyget förgrenar på if static_facts:. Grenarna dynamic och search_results gör det riktiga jobbet för det första dussinet loggar.

Supermemory tillämpar också en standardtröskel för likhet. Ett faktum du nämnde en gång kanske inte kommer tillbaka för varje fråga. De 5 loggarna ovan returnerades alla för q="today", men en mer specifik frågesträng kan returnera färre. Vaktvillkoret if matches: hanterar det utan att fallera.

Köra session 1: logga träningspass

Starta session 1 och logga några pass för att fylla Supermemory med något att läsa tillbaka senare. Kör skriptet:

uv run python main.py

Logga bänkpress, sedan en 5 km-löpning, sedan marklyft, plus ett preferensuttalande: ”Jag tränar bara hemma, inget gym.” Agenten triggar log_workout en gång per pass, och verktygets print()-rader gör varje anrop synligt i terminalen.

Exempelutdata. Din agents exakta formulering kommer att skilja sig eftersom modellen är icke-deterministisk.

De tre status=queued-raderna är ögonblicket då Supermemory tar över. Var och en motsvarar ett dokument som rör sig genom inbäddnings- och extraktionspipelinen på Supermemorys sida. För korta textloggar som dessa blir dokumentet sökbart via client.profile() inom ~12 sekunder.

Inget i tränarens kod väntar på det. Agenten går vidare och Supermemory slutför arbetet i bakgrunden.

Varje logg triggar exakt ett log_workout-anrop, och agenten stannar. Inga proaktiva rekommendationer, inga extra verktygsanrop, inga uppföljningsförslag. Den första systempromtregeln gör det jobbet. Utan regeln skulle agenten föreslå ett nästa pass efter varje loggning och dubblera verktygsanropen.

Skriv exit för att stänga session 1. Python-processen avslutas, och SQLiteSession försvinner med den. Träningsloggarna och preferensuttalandet bor nu i Supermemory under container_tag="demo_user", separat från skriptet som skrev dem.

Verifiera återkallning och köra session 2

Före session 2, bekräfta att fakta från session 1 är sökbara. Öppna en ny Python-REPL eller spara detta som ett kort skript:

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})")

Verklig utdata fångad mellan de två sessionerna:

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)

Titta på vad Supermemorys extraktor producerade. Användaren sa, ”Jag tränar bara hemma, inget gym,” en gång. Extraktorn gjorde om det till det dynamiska faktumet "Trains at home instead of a gym".

Bänkpressloggen innehöll ett anteckningsfält om ingen knäsmärta. Extraktorn delade upp den enda loggen i två dynamiska fakta: ett för passet, ett för frånvaron av smärta.

Fyra loggar blev fem normaliserade dynamiska fakta plus fem matchande minnesbitar med likhetspoäng mellan 0,585 och 0,682. Ingen av den delningen, normaliseringen eller matchningen kördes i tränarens kod. Om dynamic är tom för dig, vänta ytterligare 10 sekunder och kör snutten igen. Bearbetningskön spetsar till ibland.

Starta nu session 2 i en helt ny process:

uv run python main.py

Detta är en ny Python-tolk. Inget delat minne med session 1. Ingen varm cache. Allt agenten minns kommer från Supermemory.

Skicka ett meddelande: ”Vad ska jag göra för mitt träningspass idag?”

Exempelutdata. Samma minneslager, ny Python-process.

Agenten anropar suggest_next_session("today"). Verktyget skriver ut static=0 dynamic=5 matches=5. Den fångade körningen svarade med ett underkroppspass hemma (knäböj, utfall, step-ups).

Rekommendationen stämde med tidigare loggar eftersom Supermemorys profil berättade för agenten vilka de var. Bänk, marklyft och en 5 km var överkropp eller kondition, och användaren tränade bara hemma. Båda fakta kom tillbaka från samma client.profile()-anrop. Din körning kommer att formulera saker annorlunda eftersom modellen är icke-deterministisk, men återkallningsvägen är densamma.

Nästa steg för din Supermemory-agent

Demon är en användare, två verktyg och en CLI. En riktig version av tränaren utökas i tre Supermemory-formade riktningar innan den rör agentloopen.

Avgränsa minne per riktig användare. Konstanten USER_ID = "demo_user" fungerar för en person. Produktionsappar beräknar taggen från den autentiserade användarens ID, som container_tag="user_sarah" eller container_tag=customer_id. Minnet mellan användare förblir separat eftersom varje läsning skickar tillbaka taggen. En ändring i tools.py, ingen annan kod rörs.

Lägg till fler minnesstödda verktyg. Deload-veckor, PR-spårning och veckovisa rörlighetsuppmaningar. Var och en är ytterligare en @function_tool-funktion som anropar client.add() för skrivningar och client.profile() för läsningar mot samma container_tag. Verktygets form är densamma. Bara vad agenten registrerar och frågar efter ändras.

Hantera Supermemory-fel. Kapsla in client.add() och client.profile() i try/except supermemory.APIError så att tillfälliga fel från Supermemory inte kraschar agenten. Sätt tidsgränser per anrop om din agent kör i en begränsad miljö.

Arbetet på agentloopsidan är oberoende av Supermemory och kan ändras senare. Fronta CLI:et med Telegram, Discord eller Slack, så att användaren sms:ar ett pass och boten anropar Runner.run(). Eller byt ramverk. Supermemory har en LangChain-integration om din stack redan ligger på LangChain-agenter, och minneskoden ändras inte.

Uppdelningen statiskt och dynamiskt passar också andra domäner. 

• Kundsupportagent: statiskt = kända problem och kontopreferenser, dynamiskt = öppna ärenden och senaste kontakter. 
• Kodningsagent: statiskt = föredragna språk och ramverk, dynamiskt = aktuell uppgift och nyligen berörda filer. 

Uppdelningen håller närhelst användaren är sanningskälla.

Slutsats

Du har just byggt en Python-tränare med två verktyg och bestående minne över processer. client.add() skriver träningspass. client.profile() läser tillbaka användaren som statiska fakta, dynamiska fakta och semantiska träffar i ett anrop, allt avgränsat av container_tag. Supermemory gör chunking, inbäddning, sökning och profilextraktion som demon aldrig behövde skriva.

Para ihop det med RAG, så svarar samma agent på frågor om användaren och produkten. LLM-agenter förklarade täcker bredare agentmönster, och utbildningsspåret Associate AI Engineer for Developers går djupare in i minnesstödda agenter.