ReasoningBank with AgentDB：AI智能体自适应学习与推理数据库优化方案

ReasoningBank with AgentDB by agenticsorg/hackathon-tv5

22 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/agenticsorg/hackathon-tv5 --skill 'ReasoningBank with AgentDB'

AI/机器学习数据库性能优化

🇨🇳中文介绍

基于 AgentDB 的 ReasoningBank

功能概述

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

性能：模式检索快 150 倍，批量操作快 500 倍，内存访问时间 <1ms。

先决条件

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

CLI 快速开始

初始化 ReasoningBank 数据库

# 为 ReasoningBank 初始化 AgentDB
npx agentdb@latest init ./.agentdb/reasoningbank.db --dimension 1536

# 启动 MCP 服务器以集成 Claude Code
npx agentdb@latest mcp
claude mcp add agentdb npx agentdb@latest mcp

从旧版 ReasoningBank 迁移

# 带验证的自动迁移
npx agentdb@latest migrate --source .swarm/memory.db

# 验证迁移
npx agentdb@latest stats ./.agentdb/reasoningbank.db

API 快速开始

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

// 使用 AgentDB 初始化 ReasoningBank
const rb = await createAgentDBAdapter({
  dbPath: '.agentdb/reasoningbank.db',
  enableLearning: true,      // 启用学习插件
  enableReasoning: true,      // 启用推理智能体
  cacheSize: 1000,            // 1000 个模式缓存
});

// 存储成功经验
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(),
});

// 通过推理检索相似经验
const result = await rb.retrieveWithReasoning(embedding, {
  domain: 'database-optimization',
  k: 5,
  useMMR: true,              // 多样化结果
  synthesizeContext: true,    // 丰富的上下文合成
});

console.log('Memories:', result.memories);
console.log('Context:', result.context);
console.log('Patterns:', result.patterns);

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

ReasoningBank 核心概念

追踪智能体执行路径和结果：

// 记录轨迹（一系列动作）
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(),
});

判断轨迹是否成功：

// 检索相似的过往轨迹
const similar = await rb.retrieveWithReasoning(queryEmbedding, {
  domain: 'api-optimization',
  k: 10,
});

// 基于与成功模式的相似性进行判断
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);

将相似经验整合为模式：

// 获取领域内的所有经验
const experiences = await rb.retrieveWithReasoning(embedding, {
  domain: 'api-optimization',
  k: 100,
  optimizeMemory: true,  // 自动整合
});

// 提炼为高级模式
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(),
});

与推理智能体集成

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

查找相似的成功模式：

const result = await rb.retrieveWithReasoning(queryEmbedding, {
  domain: 'problem-solving',
  k: 10,
  useMMR: true,  // 使用最大边际相关性以获得多样性
});

// PatternMatcher 返回多样化、相关的记忆
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,  // 启用上下文合成
  k: 5,
});

// ContextSynthesizer 创建连贯的叙述
console.log('Synthesized Context:', result.context);
// "基于 5 个相似的优化案例，最有效的方法涉及性能分析、识别瓶颈并应用针对性改进。成功率：87%"

自动整合和修剪：

const result = await rb.retrieveWithReasoning(queryEmbedding, {
  domain: 'testing',
  optimizeMemory: true,  // 启用自动优化
});

// MemoryOptimizer 整合相似模式并修剪低质量模式
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,  // 仅限高置信度经验
});

// ExperienceCurator 仅返回高质量经验
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';

// 旧版 API 无需更改即可工作（自动使用 AgentDB 后端）
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 个模式）

按抽象级别组织记忆：

// 低层级：具体实现
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,
  // ...
});

// 中层级：跨相似案例的模式
await rb.insertPattern({
  type: 'pattern',
  domain: 'debugging',
  pattern_data: JSON.stringify({
    embedding,
    pattern: { category: 'null-pointer', approach: 'defensive-checks' }
  }),
  confidence: 0.85,
  // ...
});

// 高层级：通用原则
await rb.insertPattern({
  type: 'principle',
  domain: 'software-engineering',
  pattern_data: JSON.stringify({
    embedding,
    pattern: { principle: 'fail-fast with clear errors' }
  }),
  confidence: 0.95,
  // ...
});

跨领域迁移学习：

// 从后端优化中学习
const backendExperience = await rb.retrieveWithReasoning(embedding, {
  domain: 'backend-optimization',
  k: 10,
});

// 应用于前端优化
const transferredKnowledge = backendExperience.memories.map(mem => ({
  ...mem,
  domain: 'frontend-optimization',
  adapted: true,
}));

# 导出轨迹和模式
npx agentdb@latest export ./.agentdb/reasoningbank.db ./backup.json

# 导入经验
npx agentdb@latest import ./experiences.json

# 获取统计信息
npx agentdb@latest stats ./.agentdb/reasoningbank.db
# 显示：总模式数、领域数、置信度分布

# 从旧版 ReasoningBank 迁移
npx agentdb@latest migrate --source .swarm/memory.db --target .agentdb/reasoningbank.db

# 验证迁移
npx agentdb@latest stats .agentdb/reasoningbank.db

问题：迁移失败

# 检查源数据库是否存在
ls -la .swarm/memory.db

# 使用详细日志运行
DEBUG=agentdb:* npx agentdb@latest migrate --source .swarm/memory.db

问题：置信度分数低

// 启用上下文合成以提高质量
const result = await rb.retrieveWithReasoning(embedding, {
  synthesizeContext: true,
  useMMR: true,
  k: 10,
});

问题：内存增长过大

// 启用自动优化
const result = await rb.retrieveWithReasoning(embedding, {
  optimizeMemory: true,  // 整合相似模式
});

// 或手动优化
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 分钟

🇺🇸English

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

Weekly Installs

Repository

agenticsorg/hac…thon-tv5

GitHub Stars

First Seen

Jan 1, 1970

Security Audits

Gen Agent Trust HubPass SocketPass SnykWarn

超能力技能使用指南：AI助手技能调用优先级与工作流程详解

37,500 周安装

ReasoningBank with AgentDB：AI智能体自适应学习与推理数据库优化方案

🇨🇳中文介绍

基于 AgentDB 的 ReasoningBank

功能概述

先决条件

CLI 快速开始

初始化 ReasoningBank 数据库

从旧版 ReasoningBank 迁移

API 快速开始

相关 Skills

ReasoningBank 核心概念

1. 轨迹追踪

2. 结果判定

3. 记忆提炼

与推理智能体集成

1. PatternMatcher

2. ContextSynthesizer

3. MemoryOptimizer

4. ExperienceCurator

旧版 API 兼容性

性能特征

高级模式

分层记忆

跨领域学习

CLI 操作

数据库管理

迁移

故障排除

问题：迁移失败

问题：置信度分数低

问题：内存增长过大

了解更多

🇺🇸English

ReasoningBank with AgentDB

What This Skill Does

Prerequisites

Quick Start with CLI

Initialize ReasoningBank Database

Migrate from Legacy ReasoningBank

Quick Start with API

Core ReasoningBank Concepts

1. Trajectory Tracking

2. Verdict Judgment

3. Memory Distillation

Integration with Reasoning Agents

1. PatternMatcher

2. ContextSynthesizer

3. MemoryOptimizer

4. ExperienceCurator

Legacy API Compatibility

Performance Characteristics

Advanced Patterns

Hierarchical Memory

Multi-Domain Learning

CLI Operations

Database Management

Migration

Troubleshooting

Issue: Migration fails

Issue: Low confidence scores

Issue: Memory growing too large

Learn More

最新 Skills