agentdb-memory-patterns

# Start MCP server (integrates with Claude Code)
npx agentdb@latest mcp
 
# Add to Claude Code (one-time setup)
claude mcp add agentdb npx agentdb@latest mcp

# Interactive plugin wizard
npx agentdb@latest create-plugin
 
# Use template directly
npx agentdb@latest 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)

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
});

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
    });
  }
}

// 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'
});

// 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);

// Organize memory in hierarchy
await memory.organize({
  immediate: recentMessages,    // Last 10 messages
  shortTerm: sessionContext,    // Current session
  longTerm: importantFacts,     // Persistent facts
  semantic: embeddedKnowledge   // Vector search
});

// Periodically consolidate memories
await memory.consolidate({
  strategy: 'importance',       // Keep important memories
  maxSize: 10000,              // Size limit
  minScore: 0.5                // Relevance threshold
});

# Query with vector embedding
npx agentdb@latest query ./agents.db "[0.1,0.2,0.3,...]"
 
# Top-k results
npx agentdb@latest query ./agents.db "[0.1,0.2,0.3]" -k 10
 
# With similarity threshold
npx agentdb@latest query ./agents.db "0.1 0.2 0.3" -t 0.75
 
# JSON output
npx agentdb@latest query ./agents.db "[...]" -f json

# Export vectors to file
npx agentdb@latest export ./agents.db ./backup.json
 
# Import vectors from file
npx agentdb@latest import ./backup.json
 
# Get database statistics
npx agentdb@latest stats ./agents.db

# Run performance benchmarks
npx agentdb@latest 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)

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.train({
  epochs: 50,
  batchSize: 32,
});
 
// Get optimal strategy with reasoning
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'task-planning',
  synthesizeContext: true,
  optimizeMemory: true,
});

# List available plugins
npx agentdb@latest list-plugins
 
# List plugin templates
npx agentdb@latest list-templates
 
# Get plugin info
npx agentdb@latest plugin-info <name>

# Check database size
npx agentdb@latest stats ./agents.db
 
# Enable quantization
# Use 'binary' (32x smaller) or 'scalar' (4x smaller)

# Enable HNSW indexing and caching
# Results: <100µs search time

# Automatic migration with validation
npx agentdb@latest migrate --source .swarm/memory.db