Other skills
AgentDB Memory Patterns
Implement persistent memory patterns for AI agents using AgentDB. Includes session memory, long-term storage, pattern learning, and context management. Use when building stateful agents, chat systems, or intelligent assistants.
proffesor-for-testing · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add proffesor-for-testing/agentic-qe --skill AgentDB Memory PatternsAbout this skill
name: "AgentDB Memory Patterns" description: "Implement persistent memory patterns for AI agents using AgentDB. Includes session memory, long-term storage, pattern learning, and context management. Use when building stateful agents, chat systems, or intelligent assistants."
AgentDB Memory Patterns
What This Skill Does
Provides memory management patterns for AI agents using AgentDB's persistent storage and ReasoningBank integration. Enables agents to remember conversations, learn from interactions, and maintain context across sessions.
Performance: 150x-12,500x faster than traditional solutions with 100% backward compatibility.
Prerequisites
- Node.js 18+
- AgentDB v1.0.7+ (via agentic-flow or standalone)
- Understanding of agent architectures
Quick Start with CLI
Initialize AgentDB
# Initialize vector database
npx agentdb@3.3.0 init ./agents.db
# Or with custom dimensions
npx agentdb@3.3.0 init ./agents.db --dimension 768
# Use preset configurations
npx agentdb@3.3.0 init ./agents.db --preset large
# In-memory database for testing
npx agentdb@3.3.0 init ./memory.db --in-memory
Start MCP Server for Claude Code
# Start MCP server (integrates with Claude Code)
npx agentdb@3.3.0 mcp
# Add to Claude Code (one-time setup)
claude mcp add agentdb npx agentdb@3.3.0 mcp
Create Learning Plugin
# Interactive plugin wizard
npx agentdb@3.3.0 create-plugin
# Use template directly
npx agentdb@3.3.0 create-plugin -t decision-transformer -n my-agent
# Available templates:
# - decision-transformer (sequence modeling RL)
# - q-learning (value-based learning)
# - sarsa (on-policy TD learning)
# - actor-critic (policy gradient)
# - curiosity-driven (exploration-based)
Quick Start with API
import { createAgentDBAdapter } from 'agentic-flow/reasoningbank';
// Initialize with default configuration
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/reasoningbank.db',
enableLearning: true, // Enable learning plugins
enableReasoning: true, // Enable reasoning agents
quantizationType: 'scalar', // binary | scalar | product | none
cacheSize: 1000, // In-memory cache
});
// Store interaction memory
const patternId = await adapter.insertPattern({
id: '',
type: 'pattern',
domain: 'conversation',
pattern_data: JSON.stringify({
embedding: await computeEmbedding('What is the capital of France?'),
pattern: {
user: 'What is the capital of France?',
assistant: 'The capital of France is Paris.',
timestamp: Date.now()
}
}),
confidence: 0.95,
usage_count: 1,
success_count: 1,
created_at: Date.now(),
last_used: Date.now(),
});
// Retrieve context with reasoning
const context = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'conversation',
k: 10,
useMMR: true, // Maximal Marginal Relevance
synthesizeContext: true, // Generate rich context
});
Memory Patterns
1. Session Memory
class SessionMemory {
async storeMessage(role: string, content: string) {
return await db.storeMemory({
sessionId: this.sessionId,
role,
content,
timestamp: Date.now()
});
}
async getSessionHistory(limit = 20) {
return await db.query({
filters: { sessionId: this.sessionId },
orderBy: 'timestamp',
limit
});
}
}
2. Long-Term Memory
// Store important facts
await db.storeFact({
category: 'user_preference',
key: 'language',
value: 'English',
confidence: 1.0,
source: 'explicit'
});
// Retrieve facts
const prefs = await db.getFacts({
category: 'user_preference'
});
3. Pattern Learning
// Learn from successful interactions
await db.storePattern({
trigger: 'user_asks_time',
response: 'provide_formatted_time',
success: true,
context: { timezone: 'UTC' }
});
// Apply learned patterns
const pattern = await db.matchPattern(currentContext);
Advanced Patterns
Hierarchical Memory
// Organize memory in hierarchy
await memory.organize({
immediate: recentMessages, // Last 10 messages
shortTerm: sessionContext, // Current session
longTerm: importantFacts, // Persistent facts
semantic: embeddedKnowledge // Vector search
});
Memory Consolidation
// Periodically consolidate memories
await memory.consolidate({
strategy: 'importance', // Keep important memories
maxSize: 10000, // Size limit
minScore: 0.5 // Relevance threshold
});
CLI Operations
Query Database
# Query with vector embedding
npx agentdb@3.3.0 query ./agents.db "[0.1,0.2,0.3,...]"
# Top-k results
npx agentdb@3.3.0 query ./agents.db "[0.1,0.2,0.3]" -k 10
# With similarity threshold
npx agentdb@3.3.0 query ./agents.db "0.1 0.2 0.3" -t 0.75
# JSON output
npx agentdb@3.3.0 query ./agents.db "[...]" -f json
Import/Export Data
# Export vectors to file
npx agentdb@3.3.0 export ./agents.db ./backup.json
# Import vectors from file
npx agentdb@3.3.0 import ./backup.json
# Get database statistics
npx agentdb@3.3.0 stats ./agents.db
Performance Benchmarks
# Run performance benchmarks
npx agentdb@3.3.0 benchmark
# Results show:
# - Pattern Search: 150x faster (100µs vs 15ms)
# - Batch Insert: 500x faster (2ms vs 1s)
# - Large-scale Query: 12,500x faster (8ms vs 100s)
Integration with ReasoningBank
import { createAgentDBAdapter, migrateToAgentDB } from 'agentic-flow/reasoningbank';
// Migrate from legacy ReasoningBank
const result = await migrateToAgentDB(
'.swarm/memory.db', // Source (legacy)
'.agentdb/reasoningbank.db' // Destination (AgentDB)
);
console.log(`✅ Migrated ${result.patternsMigrated} patterns`);
// Train learning model
const adapter = await createAgentDBAdapter({
enableLearning: true,
});
await adapter.t
Read the complete source ↗