Conversation Memory

1---2name: conversation-memory3description: Persistent memory systems for LLM conversations including4  short-term, long-term, and entity-based memory5risk: unknown6source: vibeship-spawner-skills (Apache 2.0)7date_added: 2026-02-278---9 10# Conversation Memory11 12Persistent memory systems for LLM conversations including short-term, long-term, and entity-based memory13 14## Capabilities15 16- short-term-memory17- long-term-memory18- entity-memory19- memory-persistence20- memory-retrieval21- memory-consolidation22 23## Prerequisites24 25- Knowledge: LLM conversation patterns, Database basics, Key-value stores26- Skills_recommended: context-window-management, rag-implementation27 28## Scope29 30- Does_not_cover: Knowledge graph construction, Semantic search implementation, Database administration31- Boundaries: Focus is memory patterns for LLMs, Covers storage and retrieval strategies32 33## Ecosystem34 35### Primary_tools36 37- Mem0 - Memory layer for AI applications38- LangChain Memory - Memory utilities in LangChain39- Redis - In-memory data store for session memory40 41## Patterns42 43### Tiered Memory System44 45Different memory tiers for different purposes46 47**When to use**: Building any conversational AI48 49interface MemorySystem {50    // Buffer: Current conversation (in context)51    buffer: ConversationBuffer;52 53    // Short-term: Recent interactions (session)54    shortTerm: ShortTermMemory;55 56    // Long-term: Persistent across sessions57    longTerm: LongTermMemory;58 59    // Entity: Facts about people, places, things60    entity: EntityMemory;61}62 63class TieredMemory implements MemorySystem {64    async addMessage(message: Message): Promise<void> {65        // Always add to buffer66        this.buffer.add(message);67 68        // Extract entities69        const entities = await extractEntities(message);70        for (const entity of entities) {71            await this.entity.upsert(entity);72        }73 74        // Check for memorable content75        if (await isMemoryWorthy(message)) {76            await this.shortTerm.add({77                content: message.content,78                timestamp: Date.now(),79                importance: await scoreImportance(message)80            });81        }82    }83 84    async consolidate(): Promise<void> {85        // Move important short-term to long-term86        const memories = await this.shortTerm.getOld(24 * 60 * 60 * 1000);87        for (const memory of memories) {88            if (memory.importance > 0.7 || memory.referenced > 2) {89                await this.longTerm.add(memory);90            }91            await this.shortTerm.remove(memory.id);92        }93    }94 95    async buildContext(query: string): Promise<string> {96        const parts: string[] = [];97 98        // Relevant long-term memories99        const longTermRelevant = await this.longTerm.search(query, 3);100        if (longTermRelevant.length) {101            parts.push('## Relevant Memories\n' +102                longTermRelevant.map(m => `- ${m.content}`).join('\n'));103        }104 105        // Relevant entities106        const entities = await this.entity.getRelevant(query);107        if (entities.length) {108            parts.push('## Known Entities\n' +109                entities.map(e => `- ${e.name}: ${e.facts.join(', ')}`).join('\n'));110        }111 112        // Recent conversation113        const recent = this.buffer.getRecent(10);114        parts.push('## Recent Conversation\n' + formatMessages(recent));115 116        return parts.join('\n\n');117    }118}119 120### Entity Memory121 122Store and update facts about entities123 124**When to use**: Need to remember details about people, places, things125 126interface Entity {127    id: string;128    name: string;129    type: 'person' | 'place' | 'thing' | 'concept';130    facts: Fact[];131    lastMentioned: number;132    mentionCount: number;133}134 135interface Fact {136    content: string;137    confidence: number;138    source: string;  // Which message this came from139    timestamp: number;140}141 142class EntityMemory {143    async extractAndStore(message: Message): Promise<void> {144        // Use LLM to extract entities and facts145        const extraction = await llm.complete(`146            Extract entities and facts from this message.147            Return JSON: { "entities": [148                { "name": "...", "type": "...", "facts": ["..."] }149            ]}150 151            Message: "${message.content}"152        `);153 154        const { entities } = JSON.parse(extraction);155        for (const entity of entities) {156            await this.upsert(entity, message.id);157        }158    }159 160    async upsert(entity: ExtractedEntity, sourceId: string): Promise<void> {161        const existing = await this.store.get(entity.name.toLowerCase());162 163        if (existing) {164            // Merge facts, avoiding duplicates165            for (const fact of entity.facts) {166                if (!this.hasSimilarFact(existing.facts, fact)) {167                    existing.facts.push({168                        content: fact,169                        confidence: 0.9,170                        source: sourceId,171                        timestamp: Date.now()172                    });173                }174            }175            existing.lastMentioned = Date.now();176            existing.mentionCount++;177            await this.store.set(existing.id, existing);178        } else {179            // Create new entity180            await this.store.set(entity.name.toLowerCase(), {181                id: generateId(),182                name: entity.name,183                type: entity.type,184                facts: entity.facts.map(f => ({185                    content: f,186                    confidence: 0.9,187                    source: sourceId,188                    timestamp: Date.now()189                })),190                lastMentioned: Date.now(),191                mentionCount: 1192            });193        }194    }195}196 197### Memory-Aware Prompting198 199Include relevant memories in prompts200 201**When to use**: Making LLM calls with memory context202 203async function promptWithMemory(204    query: string,205    memory: MemorySystem,206    systemPrompt: string207): Promise<string> {208    // Retrieve relevant memories209    const relevantMemories = await memory.longTerm.search(query, 5);210    const entities = await memory.entity.getRelevant(query);211    const recentContext = memory.buffer.getRecent(5);212 213    // Build memory-augmented prompt214    const prompt = `215${systemPrompt}216 217## User Context218${entities.length ? `Known about user:\n${entities.map(e =>219    `- ${e.name}: ${e.facts.map(f => f.content).join('; ')}`220).join('\n')}` : ''}221 222${relevantMemories.length ? `Relevant past interactions:\n${relevantMemories.map(m =>223    `- [${formatDate(m.timestamp)}] ${m.content}`224).join('\n')}` : ''}225 226## Recent Conversation227${formatMessages(recentContext)}228 229## Current Query230${query}231    `.trim();232 233    const response = await llm.complete(prompt);234 235    // Extract any new memories from response236    await memory.addMessage({ role: 'assistant', content: response });237 238    return response;239}240 241## Sharp Edges242 243### Memory store grows unbounded, system slows244 245Severity: HIGH246 247Situation: System slows over time, costs increase248 249Symptoms:250- Slow memory retrieval251- High storage costs252- Increasing latency over time253 254Why this breaks:255Every message stored as memory.256No cleanup or consolidation.257Retrieval over millions of items.258 259Recommended fix:260 261// Implement memory lifecycle management262 263class ManagedMemory {264    // Limits265    private readonly SHORT_TERM_MAX = 100;266    private readonly LONG_TERM_MAX = 10000;267    private readonly CONSOLIDATION_INTERVAL = 24 * 60 * 60 * 1000;268 269    async add(memory: Memory): Promise<void> {270        // Score importance before storing271        const score = await this.scoreImportance(memory);272        if (score < 0.3) return;  // Don't store low-importance273 274        memory.importance = score;275        await this.shortTerm.add(memory);276 277        // Check limits278        await this.enforceShortTermLimit();279    }280 281    async enforceShortTermLimit(): Promise<void> {282        const count = await this.shortTerm.count();283        if (count > this.SHORT_TERM_MAX) {284            // Consolidate: move important to long-term, delete rest285            const memories = await this.shortTerm.getAll();286            memories.sort((a, b) => b.importance - a.importance);287 288            const toKeep = memories.slice(0, this.SHORT_TERM_MAX * 0.7);289            const toConsolidate = memories.slice(this.SHORT_TERM_MAX * 0.7);290 291            for (const m of toConsolidate) {292                if (m.importance > 0.7) {293                    await this.longTerm.add(m);294                }295                await this.shortTerm.remove(m.id);296            }297        }298    }299 300    async scoreImportance(memory: Memory): Promise<number> {301        const factors = {302            hasUserPreference: /prefer|like|don't like|hate|love/i.test(memory.content) ? 0.3 : 0,303            hasDecision: /decided|chose|will do|won't do/i.test(memory.content) ? 0.3 : 0,304            hasFactAboutUser: /my|I am|I have|I work/i.test(memory.content) ? 0.2 : 0,305            length: memory.content.length > 100 ? 0.1 : 0,306            userMessage: memory.role === 'user' ? 0.1 : 0,307        };308 309        return Object.values(factors).reduce((a, b) => a + b, 0);310    }311}312 313### Retrieved memories not relevant to current query314 315Severity: HIGH316 317Situation: Memories included in context but don't help318 319Symptoms:320- Memories in context seem random321- User asks about things already in memory322- Confusion from irrelevant context323 324Why this breaks:325Simple keyword matching.326No relevance scoring.327Including all retrieved memories.328 329Recommended fix:330 331// Intelligent memory retrieval332 333async function retrieveRelevant(334    query: string,335    memories: MemoryStore,336    maxResults: number = 5337): Promise<Memory[]> {338    // 1. Semantic search339    const candidates = await memories.semanticSearch(query, maxResults * 3);340 341    // 2. Score relevance with context342    const scored = await Promise.all(candidates.map(async (m) => {343        const relevanceScore = await llm.complete(`344            Rate 0-1 how relevant this memory is to the query.345            Query: "${query}"346            Memory: "${m.content}"347            Return just the number.348        `);349        return { ...m, relevance: parseFloat(relevanceScore) };350    }));351 352    // 3. Filter low relevance353    const relevant = scored.filter(m => m.relevance > 0.5);354 355    // 4. Sort and limit356    return relevant357        .sort((a, b) => b.relevance - a.relevance)358        .slice(0, maxResults);359}360 361### Memories from one user accessible to another362 363Severity: CRITICAL364 365Situation: User sees information from another user's sessions366 367Symptoms:368- User sees other user's information369- Privacy complaints370- Compliance violations371 372Why this breaks:373No user isolation in memory store.374Shared memory namespace.375Cross-user retrieval.376 377Recommended fix:378 379// Strict user isolation in memory380 381class IsolatedMemory {382    private getKey(userId: string, memoryId: string): string {383        // Namespace all keys by user384        return `user:${userId}:memory:${memoryId}`;385    }386 387    async add(userId: string, memory: Memory): Promise<void> {388        // Validate userId is authenticated389        if (!isValidUserId(userId)) {390            throw new Error('Invalid user ID');391        }392 393        const key = this.getKey(userId, memory.id);394        memory.userId = userId;  // Tag with user395        await this.store.set(key, memory);396    }397 398    async search(userId: string, query: string): Promise<Memory[]> {399        // CRITICAL: Filter by user in query400        return await this.store.search({401            query,402            filter: { userId: userId },  // Mandatory filter403            limit: 10404        });405    }406 407    async delete(userId: string, memoryId: string): Promise<void> {408        const memory = await this.get(userId, memoryId);409        // Verify ownership before delete410        if (memory.userId !== userId) {411            throw new Error('Access denied');412        }413        await this.store.delete(this.getKey(userId, memoryId));414    }415 416    // User data export (GDPR compliance)417    async exportUserData(userId: string): Promise<Memory[]> {418        return await this.store.getAll({ userId });419    }420 421    // User data deletion (GDPR compliance)422    async deleteUserData(userId: string): Promise<void> {423        const memories = await this.exportUserData(userId);424        for (const m of memories) {425            await this.store.delete(this.getKey(userId, m.id));426        }427    }428}429 430## Validation Checks431 432### No User Isolation in Memory433 434Severity: CRITICAL435 436Message: Memory operations without user isolation. Privacy vulnerability.437 438Fix action: Add userId to all memory operations, filter by user on retrieval439 440### No Importance Filtering441 442Severity: WARNING443 444Message: Storing memories without importance filtering. May cause memory explosion.445 446Fix action: Score importance before storing, filter low-importance content447 448### Memory Storage Without Retrieval449 450Severity: WARNING451 452Message: Storing memories but no retrieval logic. Memories won't be used.453 454Fix action: Implement memory retrieval and include in prompts455 456### No Memory Cleanup457 458Severity: INFO459 460Message: No memory cleanup mechanism. Storage will grow unbounded.461 462Fix action: Implement consolidation and cleanup based on age/importance463 464## Collaboration465 466### Delegation Triggers467 468- context window|token -> context-window-management (Need context optimization)469- rag|retrieval|vector -> rag-implementation (Need retrieval system)470- cache|caching -> prompt-caching (Need caching strategies)471 472### Complete Memory System473 474Skills: conversation-memory, context-window-management, rag-implementation475 476Workflow:477 478```4791. Design memory tiers4802. Implement storage and retrieval4813. Integrate with context management4824. Add consolidation and cleanup483```484 485## Related Skills486 487Works well with: `context-window-management`, `rag-implementation`, `prompt-caching`, `llm-npc-dialogue`488 489## When to Use490- User mentions or implies: conversation memory491- User mentions or implies: remember492- User mentions or implies: memory persistence493- User mentions or implies: long-term memory494- User mentions or implies: chat history495 496## Limitations497- Use this skill only when the task clearly matches the scope described above.498- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.499- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.