ReasoningBank with AgentDB

AgentDB 中的 ReasoningBank

此技能的功能

使用 AgentDB 的高性能后端提供 ReasoningBank 自适应学习模式（速度提升 150 倍至 12,500 倍）。帮助 Agent 从经验中学习、评判结果、提炼记忆，并随时间推移改进决策，同时保持 100% 向后兼容性。

性能：模式检索速度提升 150 倍，批量操作速度提升 500 倍，记忆访问时间低于 1 毫秒。

前提条件

• Node.js 18+
• AgentDB v1.0.7+（通过 agentic-flow）
• 了解强化学习概念（可选）

---

使用 CLI 快速入门

初始化 ReasoningBank 数据库

# 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

从旧版 ReasoningBank 迁移

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

# Verify migration
npx agentdb@latest stats ./.agentdb$reasoningbank.db

---

使用 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);

---

ReasoningBank 核心概念

1. 轨迹跟踪

跟踪 Agent 的执行路径和结果：

// 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. 结果判定

判断某条轨迹是否成功：

// 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. 记忆提炼

将相似经验整合为模式：

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

---

与推理 Agent 集成

AgentDB 提供 4 个可增强 ReasoningBank 的推理模块：

1. PatternMatcher

查找相似的成功模式：

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

根据多条记忆生成丰富的上下文：

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

自动整合并精简记忆：

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

按质量和相关性筛选：

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

---

旧版 API 兼容性

AgentDB 与旧版 ReasoningBank 保持 100% 向后兼容：

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

---

性能特点

• 模式搜索：速度提升 150 倍（100µs，相比 15ms）
• 记忆检索：低于 1ms（使用缓存时）
• 批量插入：速度提升 500 倍（插入 100 个模式需 2ms，相比 1s）
• 轨迹判定：低于 5ms（包括检索和分析）
• 记忆提炼：低于 50ms（整合 100 个模式）

---

高级模式

分层记忆

按抽象级别组织记忆：

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

多领域学习

跨领域迁移学习：

// 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 操作

数据库管理

# 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

迁移

# 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

---

故障排除

问题：迁移失败

# Check source database exists
ls -la .swarm$memory.db

# Run with verbose logging
DEBUG=agentdb:* npx agentdb@latest migrate --source .swarm$memory.db

问题：置信度较低

// Enable context synthesis for better quality
const result = await rb.retrieveWithReasoning(embedding, {
  synthesizeContext: true,
  useMMR: true,
  k: 10,
});

问题：记忆增长过快

// Enable automatic optimization
const result = await rb.retrieveWithReasoning(embedding, {
  optimizeMemory: true,  // Consolidates similar patterns
});

// Or manually optimize
await rb.optimize();

---

了解更多

• AgentDB 集成：node_modules$agentic-flow/docs/AGENTDB_INTEGRATION.md
• GitHub：https:/$github.com$ruvnet$agentic-flow$tree$main$packages$agentdb
• MCP 集成：npx agentdb@latest mcp
• 网站：https:/$agentdb.ruv.io

---

类别：机器学习 / 强化学习 难度：中级 预计耗时：20-30 分钟