Skip to main content

​
Mem0LongTermMemory

Advanced long-term memory implementation using Mem0 SDK with intelligent memory management, automatic extraction, and AI-powered consolidation.

​
Overview

Mem0LongTermMemory provides enterprise-grade long-term memory capabilities with:
  • Intelligent Extraction: Automatically identifies and extracts important information from conversations
  • Semantic Search: Advanced similarity-based retrieval using vector embeddings
  • Memory Consolidation: Automatic deduplication and relationship mapping
  • Multi-dimensional Organization: Strategy-based categorization and filtering
  • Real-time Updates: Dynamic memory updates with confidence scoring

​
Configuration

import { Mem0LongTermMemory } from '@ag-kit/agents/storage';

const longTermMemory = new Mem0LongTermMemory({
  apiKey: 'your-mem0-api-key',
  host: 'https://api.mem0.ai',           // Optional custom host
  organizationName: 'my-org',            // Optional organization
  projectName: 'my-project',             // Optional project
  userId: 'user-123',                    // Default user ID
  agentId: 'assistant-v1',               // Default agent ID
  appId: 'my-app'                        // Default app ID
});

​
Configuration Parameters

​
config
Mem0LongTermMemoryConfig
required
Mem0 configuration object

​
Core Interface Methods

Mem0LongTermMemory implements the standard long-term memory interface methods. For complete API documentation including record(), recordBatch(), retrieve(), delete(), update(), clear(), extractAndRecord(), semanticSearch(), and other advanced methods, see the Memory Service API Reference.

​
Usage Examples

​
Basic Memory Operations

// Record individual memory
await longTermMemory.record({
  id: 'mem-1',
  strategy: 'user_preferences',
  role: 'user',
  content: 'User prefers dark mode and minimal UI',
  metadata: {
    category: 'ui_preferences',
    confidence: 0.9,
    source: 'explicit_statement'
  },
  createdAt: new Date()
});

// Batch record multiple memories
const memories = [
  { id: 'mem-2', strategy: 'facts', content: 'User is a software engineer', metadata: {} },
  { id: 'mem-3', strategy: 'preferences', content: 'User likes TypeScript', metadata: {} }
];
await longTermMemory.recordBatch(memories);

​
Intelligent Extraction

// Automatic extraction from conversations
const messages = [
  { role: 'user', content: 'I work as a data scientist and love Python' },
  { role: 'assistant', content: 'That\'s great! Python is excellent for data science.' }
];

const extractedMemories = await longTermMemory.extractAndRecord(messages, {
  userId: 'user-123',
  sessionId: 'session-456',
  metadata: { conversation_type: 'onboarding' }
});

console.log('Extracted memories:', extractedMemories);

// Semantic search with filters
const searchResults = await longTermMemory.semanticSearch('programming languages', {
  threshold: 0.7,
  limit: 10,
  strategy: ['preferences', 'skills'],
  filters: { category: 'technical' }
});

// Complex queries
const queryResults = await longTermMemory.retrieve({
  strategy: ['user_preferences', 'facts'],
  limit: 20,
  filters: { confidence: { $gte: 0.8 } }
});

​
Memory Management

// Update existing memory
await longTermMemory.update('mem-1', {
  content: 'User strongly prefers dark mode and clean, minimal UI design',
  metadata: { confidence: 0.95, last_confirmed: new Date() }
});

// Get related memories using graph relationships
const relatedMemories = await longTermMemory.getRelatedMemories('mem-1', 3);

// Trigger memory consolidation
await longTermMemory.consolidate();

// Clear memories by strategy
await longTermMemory.clear('temporary');

​
Features

​
Automatic Memory Extraction

  • AI-powered analysis of conversation content
  • Intelligent identification of important information
  • Automatic categorization by strategy
  • Confidence scoring for extracted memories
  • Vector-based similarity matching
  • Multi-dimensional filtering
  • Relevance scoring
  • Strategy-based organization

​
Memory Consolidation

  • Automatic deduplication
  • Relationship mapping
  • Memory merging and updating
  • Confidence adjustment

​
Enterprise Features

  • Multi-tenant organization support
  • Project-based isolation
  • User and agent-specific memories
  • Real-time synchronization

​
Best Practices

  1. Use Descriptive Strategies: Organize memories with clear strategy names (user_preferences, technical_skills, project_context)
  2. Include Rich Metadata: Add context, confidence scores, and source information
  3. Regular Consolidation: Trigger consolidation periodically to maintain memory quality
  4. Threshold Tuning: Adjust similarity thresholds based on your use case requirements
  5. Batch Operations: Use batch recording for multiple memories to improve performance

​
Limitations

  • Requires Mem0 API key and internet connectivity
  • API rate limits apply based on your Mem0 plan
  • Memory extraction quality depends on conversation content quality
  • Vector search performance scales with memory database size