Ga naar inhoud

Automatische vertaling

Dit artikel is automatisch vertaald vanuit de oorspronkelijke Engelse versie.

AI-agentgeheugen: schema-gestuurde getypeerde staat voor langlopende systemen

Agents falen zelden omdat ze alles vergeten. Ze falen juist omdat ze zich een oude informatie herinneren en deze als actuele staat beschouwen.

Stel je voor dat er een langlopende assistent is die een gebruiker genaamd Mira bedient. In een bepaald gesprek zegt Mira dat de deadline voor haar paspoort op 15 juli ligt. Later corrigeert ze dit naar 30 juni. Een vectorzoekopdracht kan de oude notitie vinden. Op zichzelf weet deze echter niet welke deadline actueel is. Dat is het verschil tussen herinnering en geheugen.

Kort samengevat: Beschouw de duurzame geheugenopslag van agents als een getypeerde toepassingsstate. Haal potentiële gegevens uit het geheugen via een grens voor gestructureerde uitvoer, sla de records op met rekening houding van tenant-specifieke reikwijdten, geldigheidsperioden, vervanging, herkomst en schema-versiebeheer, en haal vervolgens het meest actuele deel op tijdens het lezen. Vectorsearch kan in het systeem blijven; het moet echter niet de bron zijn voor wijzbare feiten.

Het contract moet concrete vragen beantwoorden:

  • Wat is op dit moment waar?
  • Wat was er op 2 juni waar?
  • Wie heeft dat gezegd?
  • Aan welke huurder behoort het?
  • Welk oudere feit is door dit feit vervangen?
  • Kan ik het verwijderen of laten verlopen?

Daar begint Schema-Guided Agent Memory (SGAM).

Wat SGAM betekent

De naam moet eerst kort worden gezuiverd voordat de architectuur logisch wordt.

Schema-Guided Dialogue (SGD) is het taakgerichte dialoogdataset van Google uit 2019. Het schema beschrijft service-API’s, intenties en slots zodat een dialoogmodel de staat van diensten die het nog niet eerder heeft gezien, kan bijhouden. Een nuttig voorbeeld, maar op een andere laag.

Schema-Guided Memory (SGM) is de onderzoeksterm die door Mei et al. wordt gebruikt in According to Me: Long-Term Personalized Referential Memory QA. In het artikel wordt free-text Descriptive Memory (DM) vergeleken met geheugenitems met vaste schema’s van type sleutel-waarde. De broninformatie blijft hetzelfde; alleen de representatie verandert.

Schema-Guided Agent Memory (SGAM) is het ingenieurspatroon dat in dit artikel wordt genoemd: gebruik schema’s om schrijven, updaten, ophalen en verwijderen van duurzame agentgeheugendata te sturen. Het schema is geen simpel, mooier notatieformaat. Het vormt het contract voor de staat.

ATM-Bench maakt deze motivatie concreet. Het maakt gebruik van ongeveer vier jaar aan persoonlijke geheugendata uit e-mails, afbeeldingen en video’s, en stelt vervolgens vragen die persoonlijke referenties, locatiekennis, meerdere bewijsstukken en tijdsgebonden updates vereisen. Huidige geheugensystemen presteren slecht bij dit complexe vraagstuk, terwijl SGM een verbetering bood ten opzichte van DM, omdat velden als tijd, bron, locatie, entiteiten en tags beschikbaar zijn voor zowel de opvraagger als de antwoordgever in gestructureerde vorm in plaats van als proza.

Daarom is de volgende vergelijking SGAM versus SGR. Schema-gestuurd redeneren is geen toevallige omweg; het vormt juist de benodigde ‘write gate’ die SGAM doorgaans nodig heeft.

SGR is de write gate

Schema-gestuurd redeneren (SGR) en Schema-gestuurd agentengeheugen (SGAM) lossen verschillende aspecten op van hetzelfde productieprobleem.

Ik heb SGR gebruikt als herhaaldelijk terugkerend bouwblok in dit blog. De oorspronkelijke... vLLM en XGrammar artikel de werking van het mechanisme. In latere artikelen werd dit toegepast op gestructureerde beoordelaars, planners en routers, en Reproducibele RAG-rubrieken. In al die gevallen heeft SGR de aanroep beperkt zodat het antwoord voldoende geldig was voor verwerking door code.

SGAM maakt gebruik van diezelfde principes, maar wijzigt de levensduur van het resultaat. Het uitvoerresultaat is niet langer enkel een oordeel, route of plan voor de huidige aanvraag. Het wordt een mogelijke schrijfwijze in het geheugen die invloed kan hebben op toekomstige sessies en toolaanroepen. Daarom zijn de overeenkomsten en verschillen belangrijk.

SGR beperkt één modelaanroep. Het dwingt het model om voor de huidige inferentiestap een geldig object te genereren, meestal met behulp van Pydantic, JSON Schema, door de provider geleverde gestructureerde uitvoerformaten, of een geleide decoderingssnelkader zoals XGrammar.

SGAM bepaalt wat er gebeurt nadat dat object bestaat. Moet het worden opgeslagen? Vervangt het een oudere waarheid? Welke huurder kan het zien? Is het actueel of historisch? Welk bronepisode ondersteunt het?

Dimensie SGR SGAM
Reikwijdte Eén inferentiestap of toolaanroep Levenscyclus van duurzame geheugen
Vormgeving Pydantic of JSON Schema voor de aanroep Getypte records, schema’s en relaties
Handhaving Gestructureerde uitvoer of beperkingen bij het decoderen Validatie, databasebeperkingen, conflicterulen
Levensduur Wordt meestal weggegooid na het genereren van het antwoord Blijft bestaan tussen sessies en wordt uitgevoerd
Foutmodus Ongeldige of semantisch zwakke extractie Verouderde, vervuilde, niet-gescopeerde of niet-naar-te-volgen toestand

Het patroon is:

structured extraction on write -> typed memory at rest -> scoped retrieval on read

SGR zorgt ervoor dat de extractie betrouwbaar genoeg is om in het geheugen opgeslagen te worden. SGAM zorgt er vervolgens voor dat het geheugen veilig genoeg is om later opnieuw gebruikt te kunnen worden.

from datetime import datetime
from pydantic import BaseModel, Field


class MemoryDelta(BaseModel):
    tenant_id: str = Field(description="Isolation boundary, e.g. acme")
    subject: str = Field(description="Normalized entity ID, e.g. mira")
    attribute: str = Field(description="Property being updated")
    value: str = Field(description="New value")
    valid_from: datetime
    source_episode_id: str

Dat object is niet het geheugensysteem. Het vormt de grens tussen chaotische gesprekken en het geheugenregister.

De twee stromen

De workflow kent twee afzonderlijke stromen. Het mengen van deze stromen zorgt er namelijk voor dat diagrammen onoverzichtelijk worden.

De ingestuurde stroom vormt het schrijfpad:

  1. Vang een ruwe gebeurtenis op uit berichten, resultaten van tools of bedrijfsgebeurtenissen.
  2. Haal gedefinieerde kandidaten uit de gestructureerde uitvoer.
  3. Valideer het schema en wees ongeldige invoeren af.
  4. Verzoen conflicten, sluit verouderde feiten af en bewaar de herkomstgegevens.
  5. Zet het record op in de SGAM-opslag.

De verzoekstroom vormt het leespad:

  1. Begin met de vraag van de gebruiker.
  2. Bepaal of de vraag hulp nodig heeft bij het huidige staatstoestand of bij de staat op een specifiek tijdstip.
  3. Filter op basis van tenant, geheugentype, onderwerp, attribuut en geldigheidsperiode.
  4. Voeg vector- of grafexpansie alleen toe als een exacte staatsonderzoek niet voldoende is.
  5. Stel samen de kleinste mogelijke context samen voor het model.

Architectuur voor agentengeheugen gestuurd door schema’s

Lees die diagram van links naar rechts in twee banen. De bovenste baan schrijft geheugeninformatie op. De onderste baan leest geheugeninformatie op. Het geheugen wordt gedeeld, maar de verantwoordelijkheden niet.

Wat hoort bij een geheugenschema

Een minimale SGAM-record heeft meer nodig dan text.

tenant_id
memory_id
subject
attribute
value
memory_type
schema_version
valid_from
valid_to
supersedes_memory_id
source_episode_id
confidence
retention_policy

Die vorm maakt gewone operaties expliciet. Een nieuwe vervaldatum voor een paspoort kan de vorige vervaldatum activeren zonder de geschiedenis te verwijderen. Een query kan om de huidige staat of de staat op een bepaald tijdstip vragen. Een antwoord kan verwijzen naar het desbetreffende bronmoment. Een migratie kan bepalen welke schema-versie een record heeft gegenereerd. Een verwijderingsproces kan vaststellen welke indexsen gereinigd moeten worden.

Hier onderscheiden SGAM en RAG zich van elkaar. RAG haalt documenten op, terwijl SGAM de staat bijhoudt.

SGAM is geen anti-vector methode. Vektoren zijn nuttig voor fuzzy recall, clustering en expansie. Maar de huidige waarde van mira.passport_deadline Het moet afkomstig zijn van een gescopeerd geheugenrecord, en niet van zomaar het eerste beschikbare stukje gegevens.

Een voorbeeld van een verouderde waarheid

De kleinste bruikbare SGAM-demo is een boekhoudsysteem voor dat Mira-exempel met twee episodes.

e1: Mira prefers concise answers. Her passport deadline is 2026-07-15.
e2: Mira corrected the deadline. It is now 2026-06-30.

Een tekstgeheugenzoekopdracht kan resultaten teruggeven e1 omdat het de juiste woorden bevat. Een getypte opslag moet worden geretourneerd e2 voor de huidige staat en behouden e1 voor een historische query.

Het gedrag aan de schrijvende kant is minimaal:

def close_previous_fact(db: sqlite3.Connection, fact: MemoryFact) -> int | None:
    row = db.execute(
        """
        select fact_id
        from memory_facts
        where tenant_id = ?
          and subject = ?
          and attribute = ?
          and valid_to is null
        order by valid_from desc
        limit 1
        """,
        (fact.tenant_id, fact.subject, fact.attribute),
    ).fetchone()
    if not row:
        return None

    db.execute(
        "update memory_facts set valid_to = ? where fact_id = ?",
        (fact.valid_from, row["fact_id"]),
    )
    return int(row["fact_id"])

Het verwachte gedrag is precies het punt.

Naive text memory:
  returned episode: e1 -> passport deadline is 2026-07-15

SGAM current state:
  mira.passport_deadline = 2026-06-30
  valid_from=2026-06-03T10:00:00Z, source=e2

SGAM point-in-time state:
  on 2026-06-02, mira.passport_deadline = 2026-07-15

In productie moet deze transactie worden gecombineerd met gestructureerde extractie op de write-path. Hierdoor wordt de verouderde staat in de database afgesloten. Het model hoeft dan niet meer te raden welke oude notitie nog van toepassing is.

Tooling-map

Op het gebied van agent-memory-markten is er nog geen consensus over één specifieke benaming voor dit patroon. De verschillende componenten worden aangeduid als geheugenopslag, contextgrafieken, profielen, langetermijnopslag, graph RAG en stateful agents.

Tool of framework Hoofdopslaglaag Tijdsbeheer Schema-mechanisme Praktische niche
Zep / Graphiti Neo4j, FalkorDB, Neptune en ondersteuning voor de legendarische Kuzu Hoog Pydantic-entiteit en randtypen, temporele randen, herkomst Tijdsgrafische geheugens
LangGraph / LangMem LangGraph-opslag, opslag met Postgres als basis Medium JSON slaat op plus het extraheren van Pydantic-profielen of collecties Agent-apps die al zijn gebouwd op LangGraph
Mem0 Gemanageerde stack met Valkey / Redis / vector-backend in OSS-omgevingen Middelgroot Geheugentypen, aangepaste categorieën, extractieprompten Gebruikers-, agent- en sessiememory als dienst
Letta / MemGPT Agent-toestand en geheugenblokken ondersteund door een database Laag Editbare gemarkeerde geheugenblokken Statevolle agents met contextbeheer in OS-stijl
Cognee Graph-, vector- en relationele backends Medium Ontologie-georiënteerde extractie en validatie Onthouding van het enterprise-kennisgrafiek
LlamaIndex-eigenschapsgraaf Property graphopslag en vectoropslag Laag tot gemiddeld SchemaLLMPathExtractor met toegestane entiteiten en relaties Grafextractie uit documenten en tracegegevens

Graphiti vormt de meest transparante open-source referentie wanneer je geheugen van relationele en temporele aard is. Het houdt bij hoe feiten veranderen, bewaart de oorsprong van gegevens en ondersteunt hybride zoekmethoden. LangGraph is een goede applicatielayer omdat het controlepunten voor afzonderlijke threads scheidt van de opslagstructuren tussen threads. Mem0 is handig wanneer je gemanageerde geheugenoperaties wilt in plaats van zelf alle opslaginfrastructuur te beheren. Letta ligt dichter bij editabele contextblokken dan SGAM op veldniveau, maar het stateful-agent model blijft relevant.

Begin niet met de meest geavanceerde grafische weergave, tenzij de domeinbehoeften dit vereisen. Voor veel teams is een relationele tabel met JSON-inhoud, validiteitskolommen, tenant-indexen en een vector-sidecar voldoende voor de eerste versie.

Implementatieplaybook

De eerste beslissing met betrekking tot de implementatie is niet “grafenopslag of vectorenopslag?”, maar eerder wat het product wel en niet mag onthouden.

Een supportagent kan zich het accountniveau, openstaande tickets en permanente contactvoorkeuren herinneren. Hij moet echter niet elke gefrustreerde opmerking automatisch in een profielsituatie omzetten. Een codingagent kan zich repository-conventies en onopgeloste taken herinneren. Hij moet geen privénotitie eeuwig bewaren alleen omdat die één keer is opgehaald.

Begin met de schrijfweg en beschouw geheugen als een kleine staatswijziging:

  1. Geef de typen van het geheugen, het onderwerp, het tenantbereik en de retentieklasse een naam.
  2. Haal kandidaatrecords eruit met gestructureerde uitvoer.
  3. Valideer de payload met Pydantic of de schema-laag die je stack al gebruikt.
  4. Los conflicten op voordat je iets invoegt, inclusief bepalen of het nieuwe record het oude vervangt.
  5. Bewaar een bronpointer naar het originele incident, het hulptergebnis, het bestand, het ticket of de bevestiging van de gebruiker die het record heeft gegenereerd.
  6. Schrijf de schemaversie samen met het record op, niet alleen in de applicatiecode.

Voor veel teams kan de eerste SGAM-opslag een relationele tabel zijn met een JSON-colom en enkele indexen. Je hoeft niet meteen te beginnen met een tijdelijk kennisnetwerk. Het netwerk wordt nuttig wanneer relaties belangrijk zijn: klant-tot-account, account-tot-beleid, taak-tot-artefact, gebruiker-tot-voorkeur, project-tot-beslissing.

Hot path en achtergrondschrijvingen

Onmiddellijke extrahering is zinvol wanneer de volgende actie afhankelijk is van het nieuwe geheugen. Als de gebruiker zegt “onthoud dat ik kort antwoord prefereer”, hoeft het systeem geen nachtelijke verwerking te doen voordat het zich anders gedraagt.

De meeste gesprekspunten zijn niet zo. De goedkopere standaardmethode is om het ruwe verslag snel op te stellen, metadata over de gebruiker/tentoonstelling/tool toe te voegen, en een achtergrondproces te laten wachten tot er later kandidaatherinneringen kunnen worden geëxtraheerd. Consolidatie gebaseerd op herhaling is een variant van deze aanpak: gesprekspunten met weinig relevante informatie worden opgeslagen en een feit wordt alleen gepresenteerd wanneer soortgelijke bewijzen zich herhalen of de gebruiker dit expliciet bevestigt. Het nadeel hiervan is een vertraging in de actualiteit van de informatie. Dit is acceptabel voor situaties waarin “de gebruiker vaak om CSV-exporten vraagt”, maar minder acceptabel voor gevallen waarin “de klant het leveradres heeft gewijzigd”.

De leesweg moet eenvoudiger zijn dan de schrijfweg. Eerst antwoorden op “welke staat mag ik gebruiken?”, daarna vragen of vage zoekmethoden nuttige context kunnen toevoegen.

  1. Filteren op basis van gebruiker, type herinnering en geldigheidsperiode.
  2. Eerst het exacte, gestructureerde verslag ophalen, daarna semantisch verwante opties.
  3. Vector- of grafexpansie gebruiken voor ondersteunend bewijs, gerelateerde entiteiten en voorbeelden, maar niet als bron voor actuele feiten.
  4. Het kleinste mogelijke contextpakket samenstellen dat voldoende is om de vraag te beantwoorden.

Behandel schema-migraties als onderdeel van het productwerk. Wanneer een herinneringsrecord verandert, verandert ook het gedrag van het agentschap: wat het kan herinneren, wat het kan citeren, wat het kan verwijderen, en welke oude feiten nog als actueel gelden. Houd migratiescripts, backfills, dubbele leesmogelijkheden en verwijderingsregels in hetzelfde releaseplan als de productwijzigingen.

Waar SGAM zijn waarde bewijst

SGAM is geschikt wanneer herinneringen een staat hebben en in de tijd veranderen:

  • Gebruikersvoorkeuren die kunnen worden bijgewerkt of ingetrokken;
  • Klant- of accountgegevens met vereisten voor auditlogboeken;
  • Taakstatus voor langlopende assistenten;
  • Projectgeheugen van coderingsagenten;
  • Gedeeld staat voor meerdere agenten;
  • Compliancemerkmeningen waar de herkomst belangrijk is;
  • Tijdsgerelateerde vragen zoals “Wat geloofden we vóór de migratie?”

Het is overdreven wanneer het geheugen tijdelijk is, bedoeld is voor verkenning, of gemakkelijk opnieuw kan worden berekend. Als de agent slechts enkele opeenvolgende acties nodig heeft, zijn een checkpoint en een beknopt berichtgeschiedenis voldoende. Voor statische documentcontrole kan RAG al voldoende zijn. Als uw schema elke dag verandert omdat het domein nog niet duidelijk is, zal SGAM u juist vertragen.

Evaluatiecontrolelijst

Evalueer het geheugensysteem niet alleen op basis van het eindantwoord. Een geheugensysteem kan beleefd antwoorden, zelfs wanneer het een verkeerde waarheid heeft opgeschreven, een verouderde informatie heeft opgehaald, of onderweg een grens tussen gebruikers heeft overschreden.

De structuur komt overeen met de evaluatiestructuur in mijn Artikel over de evaluatie van RAG: Meet de pipelinefase waarin de fout kan optreden, en niet alleen de gegenereerde tekst aan het einde. Dit overlapt ook met de trace-discipline. het artikel over de evaluatie van agents: Een geheugenfout is vaak al zichtbaar in het uitvoeringsverleden voordat deze zich vertoont in het antwoord.

Voor SGAM is de meest zuivere test het herhalen van het proces. Voer een vaste reeks episodes in bij de geheugenopslagmodule, controleer het register na elke relevante zet, en stel vervolgens vragen over de huidige staat en het tijdstip tegenover de daaruit voortvloeiende opslag.

Laag De fout die u zoekt Metingen
Schrijf extractie De agent heeft een feit over het hoofd gezien, er eentje verzonnen, of een ongeldige vorm gegenereerd. Schema-gewaarborgde schrijfsnelheid, extractieprecisie/herinneringsratio, dekking van bronafleveringen
Conflictbeheer Een verouderde waarheid bleef actueel of een geldige oude waarheid werd overschreven. Correctheid van supersensitiviteit, duplicatieratio, correctheid van invalidatie van verouderde feiten
Isolatie en beleid Geheugenlek tussen gebruikers of het bleef bestaan na afloop van de toegestane tijdslimiet. Falen bij tenantisolatie, correctheid van verwijdering, naleving van retentievereisten
Leesopname Het juiste record bestaat wel, maar de lezer heeft het niet opgehaald. Accuraatheid in de huidige staat, accuraatheid op een specifiek tijdstip, recall@k voor geheugenrecords
Antwoordverankering Het antwoord maakte gebruik van geheugen zonder ondersteuning of verwees naar de verkeerde bron. Vraag ondersteuning aan met betrekking tot oorspronkelijke episodes, de nauwkeurigheid van citaten en de correctheid van het conflictoplossingsproces.
Operaties Het geheugenpad is te langzaam, te verouderd of te kostbaar. p95-schrijflatenste, vertraging door ouder wordende gegevens, leeslatenste, kosten per query

Benchmarks zoals LoCoMo, LongMemEval, en ATM-bench Stuur nuttige externe signalen. Ze vormen geen vervanging voor een domeintestsuite. Het geheugen is afhankelijk van de werklast: een coderingsassistent, een klantenservicebot en een compliance-copilot hebben verschillende schema’s, filters, retentieregels en fouttesten nodig.

Voorzorgsmaatregelen

SGAM is mijn label voor een patroon, niet voor een standaard. De industrie gebruikt al overlappende namen voor onderdelen uit dezelfde ontwerpruimte: Geheugen van LangGraph en LangMem Praat over kortetermijn- en langtermijnopslag, profielen, collecties, schrijfoperaties op de ‘hot-path’ en achtergrondgeheugenbeheerders. Zep Graphiti noemt de grafvormige versie een temporeel Context Graph. Letta het formuleert het systeem als stateful agents met behoudende geheugenblokken. Mem0 noemt zichzelf een gemanageerde geheugelaag. Microsoft Graph RAGLlamaIndex-propertygraphs en Cognee maken gebruik van de knowledge-graph-taal voor gerelateerde zoekopdrachten en ontologieproblemen.

Deze namen zijn niet onderling vervangbaar. Sommige systemen beheren gebruikersprofielen. Andere beheren episodes. Weer andere creëren een grafische context op basis van documenten. Nog andere geven agents de mogelijkheid om hun eigen geheugen te bewerken. SGAM is de striktere versie van dit concept: wanneer duurzaam geheugen de huidige toestand van een applicatie weergeeft, is er behoefte aan een schema, validiteit, herkomstinformatie, conflictbeheer, retentie en migratie.

Gestructureerd geheugen kan nog steeds onjuist zijn. Een schema maakt het gemakkelijker om foutieve invoeren te controleren; het maakt ze echter niet betrouwbaarder. U heeft nog steeds vertrouwen in de bronbronnen, bevestiging van de gebruiker voor gevoelige feiten, een conflictbeleid, mogelijkheden tot verwijdering en monitoring nodig.

Schema-migratie vereist werk. Zodra geheugen een toestandsweergave vormt, bent u verantwoordelijk voor versionering, terugvullen van oude gegevens, oude records en het verwijderingsgedrag. Dat is de prijs die u betaalt voor een betrouwbare weergave van de huidige toestand in plaats van een stapel plausibele notities.

Belangrijkste conclusies

  1. De context vormt een werkset. Duurzame agentengeheugen vereisen een aparte staatsovereenkomst.
  2. SGR en SGAM zijn complementair: eerst de schrijfoperatie valideren, daarna het getypeerde geheugenlevencyclus in rust behouden.
  3. Vectorrecall is nuttig, maar huidige feiten hebben behoefte aan scope, geldigheid, vervanging en herkomst.
  4. Begin met een eenvoudig relationeel of JSON-gestuurd geheugenboek voordat je overgaat op een graafstructuur.
  5. Beoordeel het geheugen op basis van correctheid bij schrijven, tijdsgebonden opvraging, gronding, isolatie van gebruikers en gedragspatronen bij verwijdering.

Referenties