AgentDB Learning Plugins

AgentDB 学习插件

此技能的作用

通过 AgentDB 的插件系统使用 9 种强化学习算法。创建、训练和部署学习插件，让自主 Agent 能够通过经验不断改进。包括离线 RL（Decision Transformer）、基于价值的学习（Q-Learning）、策略梯度（Actor-Critic）和高级技术。

性能：借助 WASM 加速的神经推理，模型训练速度可提升 10 到 100 倍。

前置条件

• Node.js 18+
• AgentDB v1.0.7+（通过 agentic-flow）
• 具备强化学习的基础知识（建议）

---

使用 CLI 快速入门

创建学习插件

# Interactive wizard
npx agentdb@latest create-plugin

# Use specific template
npx agentdb@latest create-plugin -t decision-transformer -n my-agent

# Preview without creating
npx agentdb@latest create-plugin -t q-learning --dry-run

# Custom output directory
npx agentdb@latest create-plugin -t actor-critic -o .$plugins

列出可用模板

# Show all plugin templates
npx agentdb@latest list-templates

# Available templates:
# - decision-transformer (sequence modeling RL - recommended)
# - q-learning (value-based learning)
# - sarsa (on-policy TD learning)
# - actor-critic (policy gradient with baseline)
# - curiosity-driven (exploration-based)

管理插件

# List installed plugins
npx agentdb@latest list-plugins

# Get plugin information
npx agentdb@latest plugin-info my-agent

# Shows: algorithm, configuration, training status

---

使用 API 快速入门

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

// Initialize with learning enabled
const adapter = await createAgentDBAdapter({
  dbPath: '.agentdb$learning.db',
  enableLearning: true,       // Enable learning plugins
  enableReasoning: true,
  cacheSize: 1000,
});

// Store training experience
await adapter.insertPattern({
  id: '',
  type: 'experience',
  domain: 'game-playing',
  pattern_data: JSON.stringify({
    embedding: await computeEmbedding('state-action-reward'),
    pattern: {
      state: [0.1, 0.2, 0.3],
      action: 2,
      reward: 1.0,
      next_state: [0.15, 0.25, 0.35],
      done: false
    }
  }),
  confidence: 0.9,
  usage_count: 1,
  success_count: 1,
  created_at: Date.now(),
  last_used: Date.now(),
});

// Train learning model
const metrics = await adapter.train({
  epochs: 50,
  batchSize: 32,
});

console.log('Training Loss:', metrics.loss);
console.log('Duration:', metrics.duration, 'ms');

---

可用的学习算法（共 9 种）

1. Decision Transformer（推荐）

类型：离线强化学习 最适用于：从已记录的经验中学习、模仿学习 优势：无需在线交互，训练稳定

npx agentdb@latest create-plugin -t decision-transformer -n dt-agent

使用场景：

• 从历史数据中学习
• 根据专家演示进行模仿学习
• 无需与环境交互的安全学习
• 序列建模任务

配置：

{
  "algorithm": "decision-transformer",
  "model_size": "base",
  "context_length": 20,
  "embed_dim": 128,
  "n_heads": 8,
  "n_layers": 6
}

2. Q-Learning

类型：基于价值的 RL（离策略） 最适用于：离散动作空间、样本效率 优势：经过验证、简单，适用于小到中型问题

npx agentdb@latest create-plugin -t q-learning -n q-agent

使用场景：

• 网格世界、棋盘游戏
• 导航任务
• 资源分配
• 离散决策

配置：

{
  "algorithm": "q-learning",
  "learning_rate": 0.001,
  "gamma": 0.99,
  "epsilon": 0.1,
  "epsilon_decay": 0.995
}

3. SARSA

类型：基于价值的 RL（同策略） 最适用于：安全探索、风险敏感型任务 优势：比 Q-Learning 更保守，更适合安全场景

npx agentdb@latest create-plugin -t sarsa -n sarsa-agent

使用场景：

• 安全关键型应用
• 风险敏感型决策
• 探索式在线学习

配置：

{
  "algorithm": "sarsa",
  "learning_rate": 0.001,
  "gamma": 0.99,
  "epsilon": 0.1
}

4. Actor-Critic

类型：带价值基线的策略梯度 最适用于：连续动作、降低方差 优势：稳定，适用于连续和离散动作

npx agentdb@latest create-plugin -t actor-critic -n ac-agent

使用场景：

• 连续控制（机器人、仿真）
• 复杂动作空间
• 多 Agent 协调

配置：

{
  "algorithm": "actor-critic",
  "actor_lr": 0.001,
  "critic_lr": 0.002,
  "gamma": 0.99,
  "entropy_coef": 0.01
}

5. 主动学习

类型：基于查询的学习 最适用于：标签高效学习、人机协同 优势：最大限度降低标注成本，重点关注不确定样本

使用场景：

• 整合人工反馈
• 标签高效训练
• 不确定性采样
• 降低标注成本

6. 对抗训练

类型：鲁棒性增强 最适用于：安全性、抵御扰动 优势：提升模型鲁棒性、防御对抗攻击

使用场景：

• 安全应用
• 鲁棒决策
• 对抗防御
• 安全测试

7. 课程学习

类型：渐进式难度训练 最适用于：复杂任务、更快收敛 优势：学习稳定，处理困难任务时收敛更快

使用场景：

• 复杂的多阶段任务
• 困难的探索问题
• 技能组合
• 迁移学习

8. 联邦学习

类型：分布式学习 最适用于：隐私保护、分布式数据 优势：保护隐私、可扩展

使用场景：

• 多 Agent 系统
• 敏感隐私数据
• 分布式训练
• 协同学习

9. 多任务学习

类型：迁移学习 最适用于：相关任务、知识共享 优势：新任务学习更快、泛化能力更强

使用场景：

• 任务族
• 迁移学习
• 领域自适应
• 元学习

---

训练工作流

1. 收集经验

// Store experiences during agent execution
for (let i = 0; i < numEpisodes; i++) {
  const episode = runEpisode();

  for (const step of episode.steps) {
    await adapter.insertPattern({
      id: '',
      type: 'experience',
      domain: 'task-domain',
      pattern_data: JSON.stringify({
        embedding: await computeEmbedding(JSON.stringify(step)),
        pattern: {
          state: step.state,
          action: step.action,
          reward: step.reward,
          next_state: step.next_state,
          done: step.done
        }
      }),
      confidence: step.reward > 0 ? 0.9 : 0.5,
      usage_count: 1,
      success_count: step.reward > 0 ? 1 : 0,
      created_at: Date.now(),
      last_used: Date.now(),
    });
  }
}

2. 训练模型

// Train on collected experiences
const trainingMetrics = await adapter.train({
  epochs: 100,
  batchSize: 64,
  learningRate: 0.001,
  validationSplit: 0.2,
});

console.log('Training Metrics:', trainingMetrics);
// {
//   loss: 0.023,
//   valLoss: 0.028,
//   duration: 1523,
//   epochs: 100
// }

3. 评估性能

// Retrieve similar successful experiences
const testQuery = await computeEmbedding(JSON.stringify(testState));
const result = await adapter.retrieveWithReasoning(testQuery, {
  domain: 'task-domain',
  k: 10,
  synthesizeContext: true,
});

// Evaluate action quality
const suggestedAction = result.memories[0].pattern.action;
const confidence = result.memories[0].similarity;

console.log('Suggested Action:', suggestedAction);
console.log('Confidence:', confidence);

---

高级训练技术

经验回放

// Store experiences in buffer
const replayBuffer = [];

// Sample random batch for training
const batch = sampleRandomBatch(replayBuffer, batchSize: 32);

// Train on batch
await adapter.train({
  data: batch,
  epochs: 1,
  batchSize: 32,
});

优先经验回放

// Store experiences with priority (TD error)
await adapter.insertPattern({
  // ... standard fields
  confidence: tdError,  // Use TD error as confidence$priority
  // ...
});

// Retrieve high-priority experiences
const highPriority = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'task-domain',
  k: 32,
  minConfidence: 0.7,  // Only high TD-error experiences
});

多 Agent 训练

// Collect experiences from multiple agents
for (const agent of agents) {
  const experience = await agent.step();

  await adapter.insertPattern({
    // ... store experience with agent ID
    domain: `multi-agent/${agent.id}`,
  });
}

// Train shared model
await adapter.train({
  epochs: 50,
  batchSize: 64,
});

---

性能优化

批量训练

// Collect batch of experiences
const experiences = collectBatch(size: 1000);

// Batch insert (500x faster)
for (const exp of experiences) {
  await adapter.insertPattern({ /* ... */ });
}

// Train on batch
await adapter.train({
  epochs: 10,
  batchSize: 128,  // Larger batch for efficiency
});

增量学习

// Train incrementally as new data arrives
setInterval(async () => {
  const newExperiences = getNewExperiences();

  if (newExperiences.length > 100) {
    await adapter.train({
      epochs: 5,
      batchSize: 32,
    });
  }
}, 60000);  // Every minute

---

与推理 Agent 集成

将学习与推理结合起来，以提升性能：

// Train learning model
await adapter.train({ epochs: 50, batchSize: 32 });

// Use reasoning agents for inference
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'decision-making',
  k: 10,
  useMMR: true,              // Diverse experiences
  synthesizeContext: true,    // Rich context
  optimizeMemory: true,       // Consolidate patterns
});

// Make decision based on learned experiences + reasoning
const decision = result.context.suggestedAction;
const confidence = result.memories[0].similarity;

---

CLI 操作

# Create plugin
npx agentdb@latest create-plugin -t decision-transformer -n my-plugin

# List plugins
npx agentdb@latest list-plugins

# Get plugin info
npx agentdb@latest plugin-info my-plugin

# List templates
npx agentdb@latest list-templates

---

故障排查

问题：训练未能收敛

// Reduce learning rate
await adapter.train({
  epochs: 100,
  batchSize: 32,
  learningRate: 0.0001,  // Lower learning rate
});

问题：过拟合

// Use validation split
await adapter.train({
  epochs: 50,
  batchSize: 64,
  validationSplit: 0.2,  // 20% validation
});

// Enable memory optimization
await adapter.retrieveWithReasoning(queryEmbedding, {
  optimizeMemory: true,  // Consolidate, reduce overfitting
});

问题：训练缓慢

# Enable quantization for faster inference
# Use binary quantization (32x faster)

---

了解更多

• 算法论文：查看 docs$algorithms/，了解详细论文
• GitHub：https:/$github.com$ruvnet$agentic-flow$tree$main$packages$agentdb
• MCP 集成：npx agentdb@latest mcp
• 网站：https:/$agentdb.ruv.io

---

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