AI Agent Geheugen Bouwen met Mem0 in Python: Persistent Context voor Slimmere Agents

Waarom AI-Agents Geheugen Nodig Hebben

Stel je voor: je vertelt je AI-chatbot dat je vegetariër bent. De volgende dag raadt hij doodleuk een biefstukrecept aan. Frustrerend? Zeker. Maar het is geen bug — het is simpelweg hoe LLMs werken. Standaard zijn large language models stateless: elke interactie begint met een schone lei, zonder enige herinnering aan wat je eerder hebt besproken.

En dat is best een groot probleem als je serieuze AI-agents wilt bouwen.

In 2026 is geheugen dé eigenschap die eenvoudige taalmodellen transformeert tot werkelijk autonome, adaptieve agents. Volgens het State of AI Agents-rapport heeft inmiddels 57% van de organisaties agents in productie, maar blijft kwaliteit de grootste uitdaging. Persistent geheugen — het vermogen om context te behouden over sessies heen — is daarbij vaak de ontbrekende schakel.

In deze handleiding bouwen we stap voor stap een AI-agent met langetermijngeheugen met behulp van Mem0, de populairste open-source geheugenlaag voor AI-applicaties. Je leert hoe je herinneringen opslaat, doorzoekt, en integreert met zowel OpenAI als Anthropic Claude. Eerlijk gezegd was ik verrast hoe snel je hiermee aan de slag kunt — dus laten we erin duiken.

Wat is Mem0 en Hoe Werkt Het?

Mem0 (uitgesproken als "mem-zero") is een universele geheugenlaag voor AI-agents en -applicaties. Het lost het statelessness-probleem van LLMs op door een intelligente laag toe te voegen die informatie opslaat, bijwerkt en ophaalt over sessies heen.

Onder de motorkap combineert Mem0 vectorzoekopdrachten met optionele grafiekrelaties. Wanneer je een gesprek aan het geheugen toevoegt, extraheert Mem0 automatisch de relevante informatie. Je hoeft dus niet handmatig te taggen wat onthouden moet worden — dat is best prettig.

Prestaties op de LOCOMO-Benchmark

• +26% nauwkeuriger dan OpenAI's ingebouwde geheugenfunctie
• 91% snellere responstijden (1,44s vs. 17,12s p95-latentie)
• 90% minder tokenverbruik vergeleken met full-context benaderingen

Die laatste twee cijfers zijn behoorlijk indrukwekkend als je bedenkt wat dat betekent voor je API-kosten.

Drie Soorten Agent-Geheugen

Mem0 ondersteunt drie geheugenscopes die inmiddels standaard zijn geworden in de industrie:

1. Episodisch geheugen — specifieke herinneringen aan eerdere interacties ("Vorige week vroeg je naar Python-cursussen")
2. Semantisch geheugen — feiten en voorkeuren ("Deze gebruiker is vegetariër en allergisch voor noten")
3. Procedureel geheugen — aangeleerde gedragingen en regels ("Antwoord altijd in het Nederlands")

Je kunt ze het best vergelijken met hoe menselijk geheugen werkt: je herinnert je specifieke gebeurtenissen, je kent feiten over de wereld, en je hebt aangeleerde vaardigheden. Mem0 bootst dat na voor je AI-agent.

Installatie en Eerste Configuratie

Vereisten

• Python 3.10 of hoger
• Een API-key van OpenAI of Anthropic (voor het LLM en embedding-model)
• Optioneel: een Neo4j-database voor graph memory

Mem0 Installeren

pip install mem0ai

De nieuwste versie (1.0.9 op moment van schrijven) vereist standaard een OpenAI API-key voor het embedding-model. Je kunt echter ook alternatieve providers configureren — daar komen we later op terug.

Omgevingsvariabelen Instellen

export OPENAI_API_KEY="jouw-openai-api-key"
# Optioneel, als je Claude als LLM wilt gebruiken:
export ANTHROPIC_API_KEY="jouw-anthropic-api-key"

Basisgebruik: Herinneringen Toevoegen en Doorzoeken

Oké, laten we beginnen met het eenvoudigste gebruik — het opslaan en ophalen van herinneringen in de open-source modus:

from mem0 import Memory

# Initialiseer het geheugen (gebruikt standaard een in-memory vectorstore)
m = Memory()

# Voeg herinneringen toe
m.add(
    "Ik houd van sciencefictionfilms en werk als data engineer bij een fintech-startup.",
    user_id="jan"
)

m.add(
    "Mijn favoriete programmeertaal is Python en ik gebruik VS Code als editor.",
    user_id="jan"
)

# Doorzoek het geheugen
resultaten = m.search("Wat doet Jan voor werk?", user_id="jan")
for r in resultaten["results"]:
    print(f"Herinnering: {r['memory']}")
    print(f"Score: {r['score']:.2f}")
    print("---")

Wat hier opvalt: Mem0 extraheert automatisch de kernfeiten uit je tekst en slaat ze op als afzonderlijke herinneringen. Je gooit er een lap tekst in, en het pikt er zelf de relevante stukjes uit. De search()-methode vindt vervolgens semantisch relevante herinneringen op basis van je zoekopdracht.

Een Chatbot met Geheugen Bouwen

Nu wordt het pas echt interessant. We bouwen een volledige chatbot die herinneringen bewaart en gebruikt bij elke interactie. Dit patroon is de basis voor vrijwel elke geheugen-ondersteunde AI-agent:

from openai import OpenAI
from mem0 import Memory

openai_client = OpenAI()
memory = Memory()

def chat_met_geheugen(bericht: str, user_id: str = "standaard_gebruiker") -> str:
    """Chatfunctie die herinneringen ophaalt en opslaat."""

    # Stap 1: Haal relevante herinneringen op
    relevante_herinneringen = memory.search(
        query=bericht,
        user_id=user_id,
        limit=5
    )
    herinneringen_tekst = "\n".join(
        f"- {entry['memory']}"
        for entry in relevante_herinneringen["results"]
    )

    # Stap 2: Bouw het systeemprompt met context
    systeem_prompt = f"""Je bent een behulpzame AI-assistent met geheugen.
Gebruik de volgende herinneringen over de gebruiker om je antwoord te personaliseren:

{herinneringen_tekst}

Als er geen relevante herinneringen zijn, antwoord dan gewoon op de vraag."""

    # Stap 3: Genereer een antwoord
    response = openai_client.chat.completions.create(
        model="gpt-4.1-nano",
        messages=[
            {"role": "system", "content": systeem_prompt},
            {"role": "user", "content": bericht}
        ]
    )
    antwoord = response.choices[0].message.content

    # Stap 4: Sla het gesprek op als herinnering
    memory.add(
        [
            {"role": "user", "content": bericht},
            {"role": "assistant", "content": antwoord}
        ],
        user_id=user_id
    )

    return antwoord

# Gebruik
print(chat_met_geheugen("Ik ben vegetariër en allergisch voor noten.", user_id="maria"))
print(chat_met_geheugen("Wat kan ik vanavond eten?", user_id="maria"))

Bij die tweede aanroep haalt de chatbot automatisch Maria's dieetvoorkeuren op en houdt daar rekening mee. Geen biefstukken of notenrecepten meer — precies wat je wilt.

Mem0 Configureren met Anthropic Claude

Standaard gebruikt Mem0 OpenAI als LLM-backend, maar je kunt makkelijk overschakelen naar Claude van Anthropic. Persoonlijk vind ik Claude's output vaak wat natuurlijker klinken, en als je al een Anthropic API-key hebt is dit een logische keuze:

import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "jouw-openai-key"      # nog steeds nodig voor embeddings
os.environ["ANTHROPIC_API_KEY"] = "jouw-anthropic-key"

config = {
    "llm": {
        "provider": "anthropic",
        "config": {
            "model": "claude-sonnet-4-20250514",
            "temperature": 0.1,
            "max_tokens": 2000,
        }
    }
}

m = Memory.from_config(config)

# Voeg herinneringen toe
berichten = [
    {"role": "user", "content": "Ik werk als ML-engineer en gebruik dagelijks PyTorch."},
    {"role": "assistant", "content": "Goed om te weten! Ik onthoud dat je een ML-engineer bent die met PyTorch werkt."}
]
m.add(berichten, user_id="pieter", metadata={"categorie": "profiel"})

# Zoek herinneringen
resultaten = m.search("Wat is Pieters specialisatie?", user_id="pieter")
for r in resultaten["results"]:
    print(r["memory"])

Eén ding om op te letten: je hebt nog steeds een OpenAI API-key nodig voor het standaard embedding-model (text-embedding-3-small). Dat is een beetje vervelend als je volledig van OpenAI af wilt, maar je kunt ook een alternatief embedding-model configureren — zie de productieconfiguratie hieronder.

Graph Memory: Relaties Vastleggen met Neo4j

Naast vectorgebaseerde opslag biedt Mem0 graph memory — een kennisgraaf die entiteiten en hun relaties expliciet vastlegt. Het verschil? Vectoropslag is goed voor semantische gelijkenis ("vind vergelijkbare herinneringen"), maar graph memory legt structurele relaties vast zoals "Alice werkt bij Google" of "Bob beheert het Engineering-team".

Voor complexere agent-scenario's is dat onmisbaar.

Neo4j Instellen

Je kunt gratis een Neo4j Aura-instance aanmaken op neo4j.io. Kopieer de Bolt URI, gebruikersnaam en wachtwoord, en stel ze in als omgevingsvariabelen:

export NEO4J_URL="neo4j+s://jouw-instance.databases.neo4j.io"
export NEO4J_USERNAME="neo4j"
export NEO4J_PASSWORD="jouw-wachtwoord"

Graph Memory Configureren

import os
from mem0 import Memory

config = {
    "graph_store": {
        "provider": "neo4j",
        "config": {
            "url": os.environ["NEO4J_URL"],
            "username": os.environ["NEO4J_USERNAME"],
            "password": os.environ["NEO4J_PASSWORD"],
            "database": "neo4j",
        }
    }
}

memory = Memory.from_config(config)

# Voeg gesprek met relaties toe
gesprek = [
    {"role": "user", "content": "Lisa is projectmanager bij TechCorp en werkt samen met Tom aan het AI-project."},
    {"role": "assistant", "content": "Begrepen! Ik onthoud dat Lisa projectmanager is bij TechCorp en samenwerkt met Tom."},
]

memory.add(gesprek, user_id="demo-user")

# Zoek met reranking
resultaten = memory.search(
    "Met wie werkt Lisa samen?",
    user_id="demo-user",
    limit=3,
    rerank=True,
)
for r in resultaten["results"]:
    print(r["memory"])

Graph memory draait gelijktijdig met vectoroperaties via een ThreadPoolExecutor, dus de latentie-impact is minimaal. De kennisgraaf is vooral waardevol voor complexe multi-agent systemen waar agents relaties tussen entiteiten moeten begrijpen — denk aan klantenservicebots die moeten weten welke collega waar verantwoordelijk voor is.

Productieconfiguratie met Qdrant

Voor productieomgevingen wil je absoluut een persistente vectordatabase gebruiken in plaats van de standaard in-memory opslag. Qdrant is hier een populaire (en naar mijn ervaring betrouwbare) keuze vanwege de snelheid en schaalbaarheid:

from mem0 import Memory

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
            "collection_name": "ai_agent_geheugen",
        }
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-large",
            "embedding_dims": 1536,
        }
    },
    "llm": {
        "provider": "anthropic",
        "config": {
            "model": "claude-sonnet-4-20250514",
            "temperature": 0.1,
        }
    }
}

m = Memory.from_config(config)

# Voeg herinneringen toe met metadata
m.add(
    "De klant heeft voorkeur voor maandelijkse rapportages in PDF-formaat.",
    user_id="klant_042",
    metadata={"categorie": "voorkeur", "prioriteit": "hoog"}
)

# Zoek met filters
resultaten = m.search(
    "rapportagevoorkeuren",
    user_id="klant_042",
    limit=5
)
print(resultaten)

Start Qdrant lokaal met Docker:

docker run -p 6333:6333 qdrant/qdrant:latest

Deze configuratie combineert Qdrant voor schaalbare vectoropslag, OpenAI's text-embedding-3-large voor nauwkeurige embeddings, en Claude als LLM-backend. Dat is een solide productiestack voor enterprise-toepassingen.

Integratie met LangChain en LangGraph

Als je al met LangChain werkt, is de integratie met Mem0 gelukkig vrij eenvoudig. Hier is een voorbeeld:

from langchain_anthropic import ChatAnthropic
from mem0 import Memory

# Initialiseer componenten
llm = ChatAnthropic(model="claude-sonnet-4-20250514")
memory = Memory()

def agent_met_geheugen(vraag: str, user_id: str) -> str:
    """LangChain-agent met Mem0-geheugen."""

    # Haal relevante herinneringen op
    herinneringen = memory.search(query=vraag, user_id=user_id, limit=3)
    context = "\n".join(
        f"- {h['memory']}" for h in herinneringen["results"]
    )

    # Bouw prompt met geheugencontext
    prompt = f"""Bekende informatie over de gebruiker:
{context}

Vraag: {vraag}

Geef een behulpzaam antwoord dat rekening houdt met wat je weet over deze gebruiker."""

    # Genereer antwoord
    response = llm.invoke(prompt)
    antwoord = response.content

    # Sla interactie op
    memory.add(
        [
            {"role": "user", "content": vraag},
            {"role": "assistant", "content": antwoord}
        ],
        user_id=user_id
    )

    return antwoord

Mem0 integreert trouwens ook met CrewAI voor gedeelde geheugencontexten in multi-agent systemen, en met LangGraph voor state-graph agents met geheugenpersistentie. Ideaal als je al met een van deze frameworks werkt (zie onze eerdere handleidingen over LangGraph en CrewAI).

Best Practices voor AI Agent Geheugen

1. Scheid geheugenscopes

Gebruik de drie Mem0-scopes — user_id, agent_id en run_id — om geheugen te isoleren. Gebruikersgeheugen bevat persoonlijke voorkeuren, agentgeheugen bevat systeemkennis, en sessiegeheugen bevat tijdelijke context. Houd deze strikt gescheiden, anders krijg je gegarandeerd verwarring.

2. Beheer geheugengroei

Mem0 biedt automatische filtering om geheugenopzwelling te voorkomen, inclusief decay-mechanismen die irrelevante informatie na verloop van tijd verwijderen. Monitor je geheugengebruik en stel limieten in. In productie is dit geen "nice to have" — het is essentieel.

3. Beveiliging en privacy

Dit punt wordt nog weleens onderschat: vectorembeddings kunnen onbedoeld gevoelige informatie onthullen. Behandel herinneringen als potentieel privédata. Versleutel vectoren in rust en in transit (AES-256, TLS) en implementeer rolgebaseerde toegangscontrole.

4. Test je geheugen

Bouw een evaluatieset van queries en verifieer dat de juiste herinneringen worden opgehaald. Meet recall en precision — het klinkt misschien overdreven, maar je wilt niet ontdekken in productie dat je agent de verkeerde herinneringen ophaalt.

5. Kies de juiste opslagstrategie

Gebruik vectoropslag voor semantisch zoeken, graph memory voor expliciete relaties, en samenvatting voor het comprimeren van lange gespreksgeschiedenissen. De beste resultaten krijg je door ze te combineren.

Platform vs. Self-Hosted: Welke Optie Kies Je?

Kenmerk	Mem0 Platform (Cloud)	Self-Hosted (Open Source)
Setup	Aanmelden en API-key pakken	Zelf vectordatabase en LLM configureren
Gratis tier	10.000 herinneringen, 1.000 ophaalbeurten/maand	Onbeperkt (eigen infra)
Controle	Beperkt	Volledig (eigen vectorDB, LLM, embedder)
Graph memory	Inbegrepen	Vereist Neo4j/Memgraph/FalkorDB
SDK	MemoryClient	Memory
Geschikt voor	Prototyping en kleine teams	Enterprise en dataprivacy

Beide opties gebruiken dezelfde Python SDK, dus overstappen is gelukkig vrij pijnloos. Begin met het platform om snel te prototypen, en migreer naar self-hosted zodra je meer controle nodig hebt.

Veelgestelde Vragen

Wat is het verschil tussen agent-geheugen en een grotere context window?

Een context window is het werkgeheugen van een LLM — het bepaalt hoeveel tokens het model in één keer kan verwerken. Zodra de sessie eindigt, is alles weg. Agent-geheugen daarentegen is persistent: het slaat informatie op in een externe database en haalt alleen relevante herinneringen op wanneer nodig. Dit is efficiënter (tot 90% minder tokens) en werkt over sessies heen, wat een context window simpelweg niet doet.

Kan ik Mem0 gebruiken zonder OpenAI?

Ja, absoluut. Je kunt een alternatief LLM configureren — Anthropic Claude, Ollama, Groq, en 16+ andere providers worden ondersteund. Voor embeddings kun je ook alternatieve modellen gebruiken, zoals HuggingFace-modellen of Cohere's embed-v4.0. Stel dit in via de config-dictionary bij Memory.from_config().

Hoe voorkom ik dat gevoelige gegevens in het geheugen terechtkomen?

Mem0 ondersteunt metadata-filtering waarmee je herinneringen kunt categoriseren en beheren. Implementeer een pre-processing stap die gevoelige data (BSN-nummers, creditcardgegevens) filtert vóórdat je ze aan het geheugen toevoegt. Combineer dit met versleuteling en toegangscontrole op databaseniveau — dat is echt het minimum.

Hoeveel herinneringen kan Mem0 opslaan per gebruiker?

Er is geen harde limiet in de open-source versie — het hangt volledig af van je vectordatabase-capaciteit. Qdrant, Pinecone en Weaviate schalen moeiteloos naar miljoenen vectoren. Het platform biedt een gratis tier van 10.000 herinneringen. In de praktijk zijn 100-500 goed onderhouden herinneringen per gebruiker ruim voldoende voor de meeste toepassingen.

Werkt Mem0 met multi-agent systemen zoals CrewAI?

Zeker. Mem0 integreert officieel met CrewAI, LangGraph, LangChain, Mastra en CAMEL AI. In multi-agent systemen kun je geheugen delen tussen agents via dezelfde user_id, of isoleren via aparte agent_id-scopes. Zo kunnen gespecialiseerde agents kennis uitwisselen terwijl ze hun eigen context behouden — precies wat je nodig hebt in een productieopstelling.