Geheugen in AI-agents implementeren

Waarom geheugen cruciaal is voor agents

Een agent zonder geheugen begint elke taak opnieuw. Hij weet niet wat hij eerder heeft gedaan, welke fouten hij maakte of wat de gebruiker prefereerde. Geheugen maakt het verschil tussen een agent die telkens opnieuw instructies nodig heeft en een die leert en verbetert.

De indeling in vier typen geheugen, in-context, episodisch, semantisch en procedureel, sluit aan op het CoALA-raamwerk (Cognitive Architectures for Language Agents) en is in 2026 de gangbare standaard. Elk type heeft andere eigenschappen:

In-context geheugen

In-context geheugen is de message-history in het contextvenster. Eenvoudig maar beperkt door de grootte van het venster:

class InContextMemory {
  private messages: Message[] = [];
  private readonly maxTokens: number;

  constructor(maxTokens = 50000) {
    this.maxTokens = maxTokens;
  }

  add(message: Message): void {
    this.messages.push(message);
    this.pruneIfNeeded();
  }

  private pruneIfNeeded(): void {
    while (estimateTokens(this.messages) > this.maxTokens) {
      const firstUserMsg = this.messages.findIndex(m => m.role !== "system");
      if (firstUserMsg === -1) break;
      this.messages.splice(firstUserMsg, 2);
    }
  }

  getMessages(): Message[] {
    return this.messages;
  }
}

Episodisch geheugen met vectoropslag

Episodisch geheugen slaat specifieke ervaringen op (tool-aanroepen, resultaten, fouten) en haalt ze op als ze relevant zijn:

import { ChromaClient, Collection } from "chromadb";

class EpisodicMemory {
  private collection: Collection;
  private embedder: EmbeddingFunction;

  async storeEpisode(episode: {
    description: string;
    outcome: string;
    tools_used: string[];
    success: boolean;
  }): Promise<void> {
    const id = `ep-${Date.now()}-${Math.random().toString(36).slice(2)}`;
    await this.collection.add({
      ids: [id],
      documents: [episode.description],
      metadatas: [{
        outcome: episode.outcome,
        tools_used: episode.tools_used.join(","),
        success: String(episode.success),
        timestamp: new Date().toISOString(),
      }],
    });
  }

  async recallSimilar(query: string, limit = 3): Promise<Episode[]> {
    const results = await this.collection.query({
      queryTexts: [query],
      nResults: limit,
      where: { success: "true" },
    });
    return results.documents[0]?.map((doc, i) => ({
      description: doc ?? "",
      metadata: results.metadatas[0]?.[i] ?? {},
    })) ?? [];
  }
}

Semantisch geheugen

Semantisch geheugen bevat feiten over entiteiten (gebruikers, producten, projecten):

class SemanticMemory {
  private store = new Map<string, Record<string, unknown>>();

  upsert(entityId: string, facts: Record<string, unknown>): void {
    const existing = this.store.get(entityId) ?? {};
    this.store.set(entityId, { ...existing, ...facts, updated_at: new Date().toISOString() });
  }

  get(entityId: string): Record<string, unknown> | undefined {
    return this.store.get(entityId);
  }

  toContextString(entityId: string): string {
    const facts = this.get(entityId);
    if (!facts) return "";
    return `Bekende informatie over ${entityId}:
${Object.entries(facts)
      .filter(([k]) => k !== "updated_at")
      .map(([k, v]) => `- ${k}: ${v}`)
      .join("
")}`;
  }
}

Procedureel geheugen

Procedureel geheugen slaat geleerde gedragsregels op in de system prompt:

class ProceduralMemory {
  private rules: string[] = [];

  addRule(rule: string): void {
    if (!this.rules.includes(rule)) {
      this.rules.push(rule);
    }
  }

  toSystemPromptSection(): string {
    if (this.rules.length === 0) return "";
    return `
Geleerde gedragsregels:
${this.rules.map(r => `- ${r}`).join("
")}`;
  }
}

Vul procedureel geheugen aan na succesvolle en mislukte taken:

async function learnFromOutcome(task: string, success: boolean, details: string) {
  if (!success) {
    const rule = await llm.complete(`
      Taak: ${task}
      Fout: ${details}
      Formuleer een korte gedragsregel (max 1 zin) om deze fout in de toekomst te vermijden:
    `);
    proceduralMemory.addRule(rule);
  }
}

Alles samenbrengen

async function agentWithMemory(userMessage: string, userId: string): Promise<string> {
  const userFacts = semanticMemory.toContextString(userId);
  const similarEpisodes = await episodicMemory.recallSimilar(userMessage);
  const learnedRules = proceduralMemory.toSystemPromptSection();

  const systemPrompt = BASE_SYSTEM_PROMPT + learnedRules;
  const contextPrefix = [
    userFacts,
    similarEpisodes.length > 0
      ? `Relevante eerdere ervaringen:
${similarEpisodes.map(e => `- ${e.description}: ${e.metadata.outcome}`).join("
")}`
      : "",
  ].filter(Boolean).join("

");

  inContextMemory.add({ role: "user", content: contextPrefix + "

" + userMessage });

  const result = await reactAgent(userMessage, tools, systemPrompt, inContextMemory.getMessages());

  await episodicMemory.storeEpisode({
    description: userMessage,
    outcome: result,
    tools_used: extractUsedTools(result),
    success: true,
  });

  return result;
}

Zelf bouwen of een framework gebruiken

De voorbeelden hierboven laten zien wat er onder de motorkap gebeurt. In productie hoef je dit niet altijd zelf te schrijven. In 2026 bestaan er volwassen geheugenlagen die episodisch en semantisch geheugen, samenvatting en vergeten al voor je regelen, zoals Mem0, Zep en de geheugenmodules in LangChain en LlamaIndex. Bouw het zelf als je volledige controle wilt over opslag en privacy, en pak een framework als je snel wilt itereren.