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