AgentDB Memory Patterns

AgentDB 记忆模式

此技能的作用

提供 AI Agent 使用 AgentDB 持久化存储和 ReasoningBank 集成的记忆管理模式。使 Agent 能够记住对话、从交互中学习，并在不同会话间保持上下文。

性能：比传统解决方案快 150 到 12,500 倍，同时保持 100% 向后兼容性。

前提条件

• Node.js 18+
• AgentDB v1.0.7+（通过 agentic-flow 或独立安装）
• 了解 Agent 架构

使用 CLI 快速入门

初始化 AgentDB

# Initialize vector database
npx agentdb@latest init ./agents.db

# Or with custom dimensions
npx agentdb@latest init ./agents.db --dimension 768

# Use preset configurations
npx agentdb@latest init ./agents.db --preset large

# In-memory database for testing
npx agentdb@latest init ./memory.db --in-memory

为 Claude Code 启动 MCP 服务

# Start MCP server (integrates with Claude Code)
npx agentdb@latest mcp

# Add to Claude Code (one-time setup)
claude mcp add agentdb npx agentdb@latest mcp

创建学习插件

# Interactive plugin wizard
npx agentdb@latest create-plugin

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

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

使用 API 快速入门

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

// Initialize with default configuration
const adapter = await createAgentDBAdapter({
  dbPath: '.agentdb/reasoningbank.db',
  enableLearning: true,      // Enable learning plugins
  enableReasoning: true,      // Enable reasoning agents
  quantizationType: 'scalar', // binary | scalar | product | none
  cacheSize: 1000,            // In-memory cache
});

// Store interaction memory
const patternId = await adapter.insertPattern({
  id: '',
  type: 'pattern',
  domain: 'conversation',
  pattern_data: JSON.stringify({
    embedding: await computeEmbedding('What is the capital of France?'),
    pattern: {
      user: 'What is the capital of France?',
      assistant: 'The capital of France is Paris.',
      timestamp: Date.now()
    }
  }),
  confidence: 0.95,
  usage_count: 1,
  success_count: 1,
  created_at: Date.now(),
  last_used: Date.now(),
});

// Retrieve context with reasoning
const context = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'conversation',
  k: 10,
  useMMR: true,              // Maximal Marginal Relevance
  synthesizeContext: true,    // Generate rich context
});

记忆模式

1. 会话记忆

class SessionMemory {
  async storeMessage(role: string, content: string) {
    return await db.storeMemory({
      sessionId: this.sessionId,
      role,
      content,
      timestamp: Date.now()
    });
  }

  async getSessionHistory(limit = 20) {
    return await db.query({
      filters: { sessionId: this.sessionId },
      orderBy: 'timestamp',
      limit
    });
  }
}

2. 长期记忆

// Store important facts
await db.storeFact({
  category: 'user_preference',
  key: 'language',
  value: 'English',
  confidence: 1.0,
  source: 'explicit'
});

// Retrieve facts
const prefs = await db.getFacts({
  category: 'user_preference'
});

3. 模式学习

// Learn from successful interactions
await db.storePattern({
  trigger: 'user_asks_time',
  response: 'provide_formatted_time',
  success: true,
  context: { timezone: 'UTC' }
});

// Apply learned patterns
const pattern = await db.matchPattern(currentContext);

高级模式

分层记忆

// Organize memory in hierarchy
await memory.organize({
  immediate: recentMessages,    // Last 10 messages
  shortTerm: sessionContext,    // Current session
  longTerm: importantFacts,     // Persistent facts
  semantic: embeddedKnowledge   // Vector search
});

记忆整合

// Periodically consolidate memories
await memory.consolidate({
  strategy: 'importance',       // Keep important memories
  maxSize: 10000,              // Size limit
  minScore: 0.5                // Relevance threshold
});

CLI 操作

查询数据库

# Query with vector embedding
npx agentdb@latest query ./agents.db "[0.1,0.2,0.3,...]"

# Top-k results
npx agentdb@latest query ./agents.db "[0.1,0.2,0.3]" -k 10

# With similarity threshold
npx agentdb@latest query ./agents.db "0.1 0.2 0.3" -t 0.75

# JSON output
npx agentdb@latest query ./agents.db "[...]" -f json

导入/导出数据

# Export vectors to file
npx agentdb@latest export ./agents.db ./backup.json

# Import vectors from file
npx agentdb@latest import ./backup.json

# Get database statistics
npx agentdb@latest stats ./agents.db

性能基准测试

# Run performance benchmarks
npx agentdb@latest benchmark

# Results show:
# - Pattern Search: 150x faster (100µs vs 15ms)
# - Batch Insert: 500x faster (2ms vs 1s)
# - Large-scale Query: 12,500x faster (8ms vs 100s)

与 ReasoningBank 集成

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

// Migrate from legacy ReasoningBank
const result = await migrateToAgentDB(
  '.swarm/memory.db',           // Source (legacy)
  '.agentdb/reasoningbank.db'   // Destination (AgentDB)
);

console.log(`✅ Migrated ${result.patternsMigrated} patterns`);

// Train learning model
const adapter = await createAgentDBAdapter({
  enableLearning: true,
});

await adapter.train({
  epochs: 50,
  batchSize: 32,
});

// Get optimal strategy with reasoning
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'task-planning',
  synthesizeContext: true,
  optimizeMemory: true,
});

学习插件

可用算法（共 9 种）

1. Decision Transformer - 序列建模强化学习（推荐）
2. Q-Learning - 基于价值的学习
3. SARSA - 同策略 TD 学习
4. Actor-Critic - 带基线的策略梯度
5. Active Learning - 查询选择
6. Adversarial Training - 鲁棒性
7. Curriculum Learning - 渐进式难度
8. Federated Learning - 分布式学习
9. Multi-task Learning - 迁移学习

列出和管理插件

# List available plugins
npx agentdb@latest list-plugins

# List plugin templates
npx agentdb@latest list-templates

# Get plugin info
npx agentdb@latest plugin-info <name>

推理 Agent（4 个模块）

1. PatternMatcher - 使用 HNSW 索引查找相似模式
2. ContextSynthesizer - 从多个来源生成丰富的上下文
3. MemoryOptimizer - 整合相似模式，清除低质量模式
4. ExperienceCurator - 基于质量筛选经验

最佳实践

1. 启用量化：使用标量/二进制量化，将内存占用减少 4 到 32 倍
2. 使用缓存：缓存 1,000 个模式，实现低于 1 ms 的检索速度
3. 批量操作：速度比单条插入快 500 倍
4. 定期训练：使用新经验更新学习模型
5. 启用推理：自动合成和优化上下文
6. 监控指标：使用 stats 命令跟踪性能

故障排除

问题：内存占用增长过大

# Check database size
npx agentdb@latest stats ./agents.db

# Enable quantization
# Use 'binary' (32x smaller) or 'scalar' (4x smaller)

问题：搜索性能缓慢

# Enable HNSW indexing and caching
# Results: <100µs search time

问题：从旧版 ReasoningBank 迁移

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

性能特征

• 向量搜索：<100µs（HNSW 索引）
• 模式检索：<1ms（使用缓存时）
• 批量插入：插入 100 个模式需 2 ms
• 内存效率：量化后减少 4 到 32 倍
• 向后兼容性：与 ReasoningBank API 100% 兼容

了解更多

• GitHub：https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
• 文档：node_modules/agentic-flow/docs/AGENTDB_INTEGRATION.md
• MCP 集成：在 Claude Code 中使用 npx agentdb@latest mcp
• 网站：https://agentdb.ruv.io