Long-term Memory

Implement persistent, intelligent memory with semantic search and automatic consolidation

Long-term memory in AG-Kit enables agents to remember information across conversations and sessions. It provides persistent storage with semantic search, automatic memory extraction, and intelligent consolidation capabilities.

Overview

Long-term memory stores:

• Persistent facts - Information that should be remembered indefinitely
• User preferences - Personal settings and choices
• Historical context - Past interactions and decisions
• Domain knowledge - Learned information and insights
• Relationships - Connections between concepts and entities

Unlike short-term memory (conversation history), long-term memory focuses on extracting and storing meaningful information that transcends individual conversations.

Memory Implementations

AG-Kit provides multiple long-term memory implementations:

Mem0LongTermMemory

Official Mem0 SDK integration with advanced AI-powered memory management.

Features:

• Automatic memory extraction from conversations
• Semantic search with vector embeddings
• Graph-based memory relationships
• Intelligent memory consolidation
• Deduplication and merging
• Memory decay and reinforcement
• Multi-user and multi-agent support

Use Cases:

• Production AI applications
• Personalized user experiences
• Knowledge management systems
• Multi-session conversations

TDAILongTermMemory

TDAI cloud-based long-term memory with enterprise features.

Features:

• Cloud-based persistent storage
• Semantic search capabilities
• Strategy-based memory organization
• Scalable infrastructure
• Enterprise-grade reliability

Use Cases:

• Enterprise deployments
• Large-scale applications
• Distributed systems

Quick Start

Using Mem0LongTermMemory

Python

from agkit.agents import Mem0LongTermMemory

# Initialize Mem0 memory
memory = Mem0LongTermMemory(
    api_key=os.getenv('MEM0_API_KEY'),
    user_id='user-123',
    agent_id='assistant-v1',
    app_id='my-app'
)

# Test connection
await memory.ping()

# Extract and record memories from conversation
messages = [
    {'role': 'user', 'content': 'My name is Alice and I love pizza'},
    {'role': 'assistant', 'content': 'Nice to meet you, Alice! I\'ll remember that you love pizza.'}
]

extracted_memories = await memory.extract_and_record(messages, {
    'user_id': 'user-123'
})

print('Extracted memories:', extracted_memories)

Manual Memory Recording

Python

# Record a specific memory manually
await memory.record({
    'id': memory.generate_memory_id(),
    'strategy': 'preferences',
    'role': 'user',
    'content': 'User prefers dark mode interface',
    'metadata': {
        'category': 'ui_preferences',
        'confidence': 0.95,
        'source': 'explicit_statement'
    },
    'created_at': datetime.now()
})

# Record multiple memories in batch
await memory.record_batch([
    {
        'id': memory.generate_memory_id(),
        'strategy': 'facts',
        'content': 'User works as a software engineer',
        'metadata': {'category': 'professional'},
        'created_at': datetime.now()
    },
    {
        'id': memory.generate_memory_id(),
        'strategy': 'preferences',
        'content': 'User prefers TypeScript over JavaScript',
        'metadata': {'category': 'technical'},
        'created_at': datetime.now()
    }
])

Core Operations

Recording Memories

Store new memories in long-term storage.

Python

# Record single memory
await memory.record({
    'id': 'mem-001',
    'strategy': 'facts',
    'role': 'user',
    'content': 'User birthday is March 15th',
    'metadata': {
        'type': 'personal_info',
        'verified': True
    },
    'created_at': datetime.now()
})

# Record batch of memories
memories = [
    {
        'id': 'mem-002',
        'strategy': 'preferences',
        'content': 'User likes morning meetings',
        'metadata': {},
        'created_at': datetime.now()
    },
    {
        'id': 'mem-003',
        'strategy': 'facts',
        'content': 'User lives in San Francisco',
        'metadata': {},
        'created_at': datetime.now()
    }
]

await memory.record_batch(memories)

Retrieving Memories

Query memories with various filters and search options.

Python

# Retrieve all memories
all_memories = await memory.retrieve({})

# Retrieve with limit
recent_memories = await memory.retrieve(limit=10)

# Retrieve by strategy
preferences = await memory.retrieve(
    strategy='preferences',
    limit=20
)

# Retrieve with pagination
page1 = await memory.retrieve(limit=10, offset=0)
page2 = await memory.retrieve(limit=10, offset=10)

# Retrieve with custom filters
verified_memories = await memory.retrieve(
    filters={'verified': True},
    limit=50
)

Semantic Search

Find memories using natural language queries with semantic understanding.

Python

# Search for memories about user preferences
results = await memory.semantic_search('What does the user like?',
    limit=5,
    threshold=0.7  # Minimum similarity score
)

# Search within specific strategy
food_preferences = await memory.semantic_search('favorite foods',
    strategy='preferences',
    limit=10
)

# Search with custom filters
recent_facts = await memory.semantic_search('user information',
    strategy='facts',
    filters={'verified': True},
    limit=20
)

print(results)

Updating Memories

Modify existing memories with new information.

Python

# Update memory content
await memory.update('mem-001', {
    'content': 'User birthday is March 15th, 1990',
    'metadata': {
        'verified': True,
        'updated_reason': 'Added birth year'
    }
})

# Update only metadata
await memory.update('mem-002', {
    'metadata': {
        'confidence': 0.98,
        'last_confirmed': datetime.now().isoformat()
    }
})

# Change memory strategy
await memory.update('mem-003', {
    'strategy': 'important_facts'
})

Deleting Memories

Remove memories by ID or query conditions.

Python

# Delete by ID
await memory.delete('mem-001')

# Delete by query (all matching memories)
await memory.delete({
    'strategy': 'temporary',
    'filters': {'expired': True}
})

# Clear all memories with specific strategy
await memory.clear('temporary')

# Clear all memories (use with caution!)
await memory.clear()

Advanced Features

Automatic Memory Extraction ( Mem0 Only )

Mem0 automatically extracts meaningful information from conversations.

Python

# Extract memories from conversation
conversation = [
    {'role': 'user', 'content': 'I just moved to New York and started working at Google'},
    {'role': 'assistant', 'content': 'Congratulations on your new job and move!'},
    {'role': 'user', 'content': 'Thanks! I\'m excited but also nervous about the change'}
]

extracted_memories = await memory.extract_and_record(conversation, {
    'user_id': 'user-123',
    'metadata': {
        'conversation_id': 'conv-456',
        'extraction_date': datetime.now().isoformat()
    }
})

Related Memories

Find memories related to a specific memory using graph-based relationships.

Python

# Get memories related to a specific memory
related_memories = await memory.get_related_memories('mem-001', 3)
# Returns up to 3 related memories

Memory Consolidation ( Mem0 Only )

Automatically deduplicate, merge, and optimize stored memories.

Python

# Trigger memory consolidation
await memory.consolidate()

Integration with Agents

Long-term memory integrates with agents for persistent, cross-session knowledge.

Learn more: Complete Agent Integration Guide

Best Practices

1. Use Appropriate Strategies

Organize memories with meaningful strategies:

# Good: Clear strategy categorization
await memory.record({
    'strategy': 'preferences',
    'content': 'User prefers dark mode',
    # ...
})

# Bad: Generic or unclear strategy
await memory.record({
    'strategy': 'general',
    'content': 'User prefers dark mode',
    # ...
})

2. Add Rich Metadata

Include contextual information in metadata:

# Good: Rich metadata
await memory.record({
    'content': 'User completed Python course',
    'metadata': {
        'category': 'education',
        'skill_level': 'intermediate',
        'completion_date': '2024-01-15',
        'verified': True,
        'source': 'certificate'
    },
    # ...
})

# Bad: Minimal metadata
await memory.record({
    'content': 'User completed Python course',
    'metadata': {},
    # ...
})

3. Use Semantic Search

Take advantage of semantic search for better retrieval:

# Good: Natural language queries
results = await memory.semantic_search('What are the user\'s hobbies?')

# Less optimal: Exact keyword matching
results = await memory.retrieve(filters={'keyword': 'hobby'})

Performance Considerations

Mem0LongTermMemory

• Automatic Optimization: Mem0 handles deduplication and consolidation
• Semantic Search: Fast vector-based similarity search
• Scalability: Handles millions of memories efficiently
• Network Latency: Requires API calls to Mem0 service
• Caching: Consider caching frequently accessed memories

Query Optimization

# Efficient: Use limits and filters
memories = await memory.retrieve(
    strategy='preferences',
    limit=10,
    filters={'category': 'food'}
)

# Inefficient: Retrieve all and filter in code
all_memories = await memory.retrieve()
filtered = [m for m in all_memories if m.strategy == 'preferences']

Comparison: Short-term vs Long-term Memory

Aspect	Short-term Memory	Long-term Memory
Purpose	Conversation history	Persistent knowledge
Scope	Single session	Cross-session
Storage	Recent messages	Extracted facts
Retrieval	Chronological	Semantic search
Lifespan	Session duration	Indefinite
Size	Limited by tokens	Unlimited
Use Case	Context window	Personalization

Next Steps

Short-term Memory

Learn about conversation history management

Session Management

Manage multi-user sessions and context

Agent Integration

Complete guide to memory-agent integration

API Reference

Detailed API documentation