ReasoningBank with AgentDB

What This Skill Does

Provides ReasoningBank adaptive learning patterns using AgentDB's high-performance backend (150x-12,500x faster). Enables agents to learn from experiences, judge outcomes, distill memories, and improve decision-making over time with 100% backward compatibility.

Performance: 150x faster pattern retrieval, 500x faster batch operations, <1ms memory access.

Prerequisites

• Node.js 18+

• AgentDB v1.0.7+ (via agentic-flow)

• Understanding of reinforcement learning concepts (optional)

Quick Start with CLI

Initialize ReasoningBank Database

# Initialize AgentDB for ReasoningBank

npx agentdb@latest init ./.agentdb$reasoningbank.db --dimension 1536

# Start MCP server for Claude Code integration

npx agentdb@latest mcp

claude mcp add agentdb npx agentdb@latest mcp

Migrate from Legacy ReasoningBank

# Automatic migration with validation

npx agentdb@latest migrate --source .swarm$memory.db

# Verify migration

npx agentdb@latest stats ./.agentdb$reasoningbank.db

Quick Start with API

import { createAgentDBAdapter, computeEmbedding } from 'agentic-flow$reasoningbank';

// Initialize ReasoningBank with AgentDB

const rb = await createAgentDBAdapter({

  dbPath: '.agentdb$reasoningbank.db',

  enableLearning: true,      // Enable learning plugins

  enableReasoning: true,      // Enable reasoning agents

  cacheSize: 1000,            // 1000 pattern cache

});

// Store successful experience

const query = "How to optimize database queries?";

const embedding = await computeEmbedding(query);

await rb.insertPattern({

  id: '',

  type: 'experience',

  domain: 'database-optimization',

  pattern_data: JSON.stringify({

    embedding,

    pattern: {

      query,

      approach: 'indexing + query optimization',

      outcome: 'success',

      metrics: { latency_reduction: 0.85 }

    }

  }),

  confidence: 0.95,

  usage_count: 1,

  success_count: 1,

  created_at: Date.now(),

  last_used: Date.now(),

});

// Retrieve similar experiences with reasoning

const result = await rb.retrieveWithReasoning(embedding, {

  domain: 'database-optimization',

  k: 5,

  useMMR: true,              // Diverse results

  synthesizeContext: true,    // Rich context synthesis

});

console.log('Memories:', result.memories);

console.log('Context:', result.context);

console.log('Patterns:', result.patterns);

Core ReasoningBank Concepts

1. Trajectory Tracking

Track agent execution paths and outcomes:

// Record trajectory (sequence of actions)

const trajectory = {

  task: 'optimize-api-endpoint',

  steps: [

    { action: 'analyze-bottleneck', result: 'found N+1 query' },

    { action: 'add-eager-loading', result: 'reduced queries' },

    { action: 'add-caching', result: 'improved latency' }

  ],

  outcome: 'success',

  metrics: { latency_before: 2500, latency_after: 150 }

};

const embedding = await computeEmbedding(JSON.stringify(trajectory));

await rb.insertPattern({

  id: '',

  type: 'trajectory',

  domain: 'api-optimization',

  pattern_data: JSON.stringify({ embedding, pattern: trajectory }),

  confidence: 0.9,

  usage_count: 1,

  success_count: 1,

  created_at: Date.now(),

  last_used: Date.now(),

});

2. Verdict Judgment

Judge whether a trajectory was successful:

// Retrieve similar past trajectories

const similar = await rb.retrieveWithReasoning(queryEmbedding, {

  domain: 'api-optimization',

  k: 10,

});

// Judge based on similarity to successful patterns

const verdict = similar.memories.filter(m =>

  m.pattern.outcome === 'success' &&

  m.similarity > 0.8

).length > 5 ? 'likely_success' : 'needs_review';

console.log('Verdict:', verdict);

console.log('Confidence:', similar.memories[0]?.similarity || 0);

3. Memory Distillation

Consolidate similar experiences into patterns:

// Get all experiences in domain

const experiences = await rb.retrieveWithReasoning(embedding, {

  domain: 'api-optimization',

  k: 100,

  optimizeMemory: true,  // Automatic consolidation

});

// Distill into high-level pattern

const distilledPattern = {

  domain: 'api-optimization',

  pattern: 'For N+1 queries: add eager loading, then cache',

  success_rate: 0.92,

  sample_size: experiences.memories.length,

  confidence: 0.95

};

await rb.insertPattern({

  id: '',

  type: 'distilled-pattern',

  domain: 'api-optimization',

  pattern_data: JSON.stringify({

    embedding: await computeEmbedding(JSON.stringify(distilledPattern)),

    pattern: distilledPattern

  }),

  confidence: 0.95,

  usage_count: 0,

  success_count: 0,

  created_at: Date.now(),

  last_used: Date.now(),

});

Integration with Reasoning Agents

AgentDB provides 4 reasoning modules that enhance ReasoningBank:

1. PatternMatcher

Find similar successful patterns:

const result = await rb.retrieveWithReasoning(queryEmbedding, {

  domain: 'problem-solving',

  k: 10,

  useMMR: true,  // Maximal Marginal Relevance for diversity

});

// PatternMatcher returns diverse, relevant memories

result.memories.forEach(mem => {

  console.log(`Pattern: ${mem.pattern.approach}`);

  console.log(`Similarity: ${mem.similarity}`);

  console.log(`Success Rate: ${mem.success_count / mem.usage_count}`);

});

2. ContextSynthesizer

Generate rich context from multiple memories:

const result = await rb.retrieveWithReasoning(queryEmbedding, {

  domain: 'code-optimization',

  synthesizeContext: true,  // Enable context synthesis

  k: 5,

});

// ContextSynthesizer creates coherent narrative

console.log('Synthesized Context:', result.context);

// "Based on 5 similar optimizations, the most effective approach

//  involves profiling, identifying bottlenecks, and applying targeted

//  improvements. Success rate: 87%"

3. MemoryOptimizer

Automatically consolidate and prune:

const result = await rb.retrieveWithReasoning(queryEmbedding, {

  domain: 'testing',

  optimizeMemory: true,  // Enable automatic optimization

});

// MemoryOptimizer consolidates similar patterns and prunes low-quality

console.log('Optimizations:', result.optimizations);

// { consolidated: 15, pruned: 3, improved_quality: 0.12 }

4. ExperienceCurator

Filter by quality and relevance:

const result = await rb.retrieveWithReasoning(queryEmbedding, {

  domain: 'debugging',

  k: 20,

  minConfidence: 0.8,  // Only high-confidence experiences

});

// ExperienceCurator returns only quality experiences

result.memories.forEach(mem => {

  console.log(`Confidence: ${mem.confidence}`);

  console.log(`Success Rate: ${mem.success_count / mem.usage_count}`);

});

Legacy API Compatibility

AgentDB maintains 100% backward compatibility with legacy ReasoningBank:

import {

  retrieveMemories,

  judgeTrajectory,

  distillMemories

} from 'agentic-flow$reasoningbank';

// Legacy API works unchanged (uses AgentDB backend automatically)

const memories = await retrieveMemories(query, {

  domain: 'code-generation',

  agent: 'coder'

});

const verdict = await judgeTrajectory(trajectory, query);

const newMemories = await distillMemories(

  trajectory,

  verdict,

  query,

  { domain: 'code-generation' }

);

Performance Characteristics

• Pattern Search: 150x faster (100µs vs 15ms)

• Memory Retrieval: <1ms (with cache)

• Batch Insert: 500x faster (2ms vs 1s for 100 patterns)

• Trajectory Judgment: <5ms (including retrieval + analysis)

• Memory Distillation: <50ms (consolidate 100 patterns)

Advanced Patterns

Hierarchical Memory

Organize memories by abstraction level:

// Low-level: Specific implementation

await rb.insertPattern({

  type: 'concrete',

  domain: 'debugging$null-pointer',

  pattern_data: JSON.stringify({

    embedding,

    pattern: { bug: 'NPE in UserService.getUser()', fix: 'Add null check' }

  }),

  confidence: 0.9,

  // ...

});

// Mid-level: Pattern across similar cases

await rb.insertPattern({

  type: 'pattern',

  domain: 'debugging',

  pattern_data: JSON.stringify({

    embedding,

    pattern: { category: 'null-pointer', approach: 'defensive-checks' }

  }),

  confidence: 0.85,

  // ...

});

// High-level: General principle

await rb.insertPattern({

  type: 'principle',

  domain: 'software-engineering',

  pattern_data: JSON.stringify({

    embedding,

    pattern: { principle: 'fail-fast with clear errors' }

  }),

  confidence: 0.95,

  // ...

});

Multi-Domain Learning

Transfer learning across domains:

// Learn from backend optimization

const backendExperience = await rb.retrieveWithReasoning(embedding, {

  domain: 'backend-optimization',

  k: 10,

});

// Apply to frontend optimization

const transferredKnowledge = backendExperience.memories.map(mem => ({

  ...mem,

  domain: 'frontend-optimization',

  adapted: true,

}));

CLI Operations

Database Management

# Export trajectories and patterns

npx agentdb@latest export ./.agentdb$reasoningbank.db .$backup.json

# Import experiences

npx agentdb@latest import .$experiences.json

# Get statistics

npx agentdb@latest stats ./.agentdb$reasoningbank.db

# Shows: total patterns, domains, confidence distribution

Migration

# Migrate from legacy ReasoningBank

npx agentdb@latest migrate --source .swarm$memory.db --target .agentdb$reasoningbank.db

# Validate migration

npx agentdb@latest stats .agentdb$reasoningbank.db

Troubleshooting

Issue: Migration fails

# Check source database exists

ls -la .swarm$memory.db

# Run with verbose logging

DEBUG=agentdb:* npx agentdb@latest migrate --source .swarm$memory.db

Issue: Low confidence scores

// Enable context synthesis for better quality

const result = await rb.retrieveWithReasoning(embedding, {

  synthesizeContext: true,

  useMMR: true,

  k: 10,

});

Issue: Memory growing too large

// Enable automatic optimization

const result = await rb.retrieveWithReasoning(embedding, {

  optimizeMemory: true,  // Consolidates similar patterns

});

// Or manually optimize

await rb.optimize();

Learn More

• AgentDB Integration: node_modules$agentic-flow/docs/AGENTDB_INTEGRATION.md

• GitHub: https:/$github.com$ruvnet$agentic-flow$tree$main$packages$agentdb

• MCP Integration: npx agentdb@latest mcp

• Website: https:/$agentdb.ruv.io

Category: Machine Learning / Reinforcement Learning

Difficulty: Intermediate

Estimated Time: 20-30 minutes