AgentDB Advanced Features

AgentDB の高度な機能

このスキルでできること

分散システム、複数データベースの連携、カスタム距離メトリクス、ハイブリッド検索（ベクトル＋メタデータ）、QUIC 同期、本番環境へのデプロイパターンなど、AgentDB の高度な機能を網羅しています。サブミリ秒のノード間通信と高度な検索機能を備えた、洗練された AI システムを構築できます。

パフォーマンス：1 ミリ秒未満の QUIC 同期、フィルター対応のハイブリッド検索、カスタム距離メトリクス。

前提条件

• Node.js 18+
• AgentDB v1.0.7+（agentic-flow 経由）
• 分散システムの理解（QUIC 同期の場合）
• ベクトル検索の基礎知識

---

QUIC 同期

QUIC 同期とは？

QUIC（Quick UDP Internet Connections）は、自動再試行、多重化、暗号化に対応し、ネットワーク境界を越えて AgentDB インスタンス間をサブミリ秒のレイテンシで同期できます。

メリット：

• ノード間のレイテンシが 1 ミリ秒未満
• 多重化ストリーム（複数の処理を同時に実行）
• 暗号化を標準搭載（TLS 1.3）
• 自動再試行と復旧
• イベントベースのブロードキャスト

QUIC 同期を有効にする

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

// Initialize with QUIC synchronization
const adapter = await createAgentDBAdapter({
  dbPath: '.agentdb$distributed.db',
  enableQUICSync: true,
  syncPort: 4433,
  syncPeers: [
    '192.168.1.10:4433',
    '192.168.1.11:4433',
    '192.168.1.12:4433',
  ],
});

// Patterns automatically sync across all peers
await adapter.insertPattern({
  // ... pattern data
});

// Available on all peers within ~1ms

QUIC の設定

const adapter = await createAgentDBAdapter({
  enableQUICSync: true,
  syncPort: 4433,              // QUIC server port
  syncPeers: ['host1:4433'],   // Peer addresses
  syncInterval: 1000,          // Sync interval (ms)
  syncBatchSize: 100,          // Patterns per batch
  maxRetries: 3,               // Retry failed syncs
  compression: true,           // Enable compression
});

マルチノードのデプロイ

# Node 1 (192.168.1.10)
AGENTDB_QUIC_SYNC=true \
AGENTDB_QUIC_PORT=4433 \
AGENTDB_QUIC_PEERS=192.168.1.11:4433,192.168.1.12:4433 \
node server.js

# Node 2 (192.168.1.11)
AGENTDB_QUIC_SYNC=true \
AGENTDB_QUIC_PORT=4433 \
AGENTDB_QUIC_PEERS=192.168.1.10:4433,192.168.1.12:4433 \
node server.js

# Node 3 (192.168.1.12)
AGENTDB_QUIC_SYNC=true \
AGENTDB_QUIC_PORT=4433 \
AGENTDB_QUIC_PEERS=192.168.1.10:4433,192.168.1.11:4433 \
node server.js

---

距離メトリクス

コサイン類似度（デフォルト）

正規化されたベクトルや意味的類似性に最適です。

# CLI
npx agentdb@latest query .$vectors.db "[0.1,0.2,...]" -m cosine

# API
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  metric: 'cosine',
  k: 10,
});

ユースケース：

• テキスト埋め込み（BERT、GPT など）
• セマンティック検索
• ドキュメントの類似性
• ほとんどの汎用アプリケーション

数式：cos(θ) = (A · B) / (||A|| × ||B||) 範囲：[-1, 1]（1 = 同一、-1 = 正反対）

ユークリッド距離（L2）

空間データや幾何学的類似性に最適です。

# CLI
npx agentdb@latest query .$vectors.db "[0.1,0.2,...]" -m euclidean

# API
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  metric: 'euclidean',
  k: 10,
});

ユースケース：

• 画像埋め込み
• 空間データ
• コンピュータービジョン
• ベクトルの大きさが重要な場合

数式：d = √(Σ(ai - bi)²) 範囲：[0, ∞]（0 = 同一、∞ = 非常に異なる）

内積

事前に正規化されたベクトルや高速な計算に最適です。

# CLI
npx agentdb@latest query .$vectors.db "[0.1,0.2,...]" -m dot

# API
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  metric: 'dot',
  k: 10,
});

ユースケース：

• 事前に正規化された埋め込み
• 高速な類似度計算
• ベクトルがすでに単位長の場合

数式：dot = Σ(ai × bi) 範囲：[-∞, ∞]（値が大きいほど類似度が高い）

カスタム距離メトリクス

// Implement custom distance function
function customDistance(vec1: number[], vec2: number[]): number {
  // Weighted Euclidean distance
  const weights = [1.0, 2.0, 1.5, ...];
  let sum = 0;
  for (let i = 0; i < vec1.length; i++) {
    sum += weights[i] * Math.pow(vec1[i] - vec2[i], 2);
  }
  return Math.sqrt(sum);
}

// Use in search (requires custom implementation)

---

ハイブリッド検索（ベクトル＋メタデータ）

基本的なハイブリッド検索

ベクトル類似度とメタデータフィルタリングを組み合わせます。

// Store documents with metadata
await adapter.insertPattern({
  id: '',
  type: 'document',
  domain: 'research-papers',
  pattern_data: JSON.stringify({
    embedding: documentEmbedding,
    text: documentText,
    metadata: {
      author: 'Jane Smith',
      year: 2025,
      category: 'machine-learning',
      citations: 150,
    }
  }),
  confidence: 1.0,
  usage_count: 0,
  success_count: 0,
  created_at: Date.now(),
  last_used: Date.now(),
});

// Hybrid search: vector similarity + metadata filters
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'research-papers',
  k: 20,
  filters: {
    year: { $gte: 2023 },          // Published 2023 or later
    category: 'machine-learning',   // ML papers only
    citations: { $gte: 50 },       // Highly cited
  },
});

高度なフィルタリング

// Complex metadata queries
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'products',
  k: 50,
  filters: {
    price: { $gte: 10, $lte: 100 },      // Price range
    category: { $in: ['electronics', 'gadgets'] },  // Multiple categories
    rating: { $gte: 4.0 },                // High rated
    inStock: true,                        // Available
    tags: { $contains: 'wireless' },      // Has tag
  },
});

重み付けハイブリッド検索

ベクトルのスコアとメタデータのスコアを組み合わせます。

const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'content',
  k: 20,
  hybridWeights: {
    vectorSimilarity: 0.7,  // 70% weight on semantic similarity
    metadataScore: 0.3,     // 30% weight on metadata match
  },
  filters: {
    category: 'technology',
    recency: { $gte: Date.now() - 30 * 24 * 3600000 },  // Last 30 days
  },
});

---

複数データベースの管理

複数のデータベース

// Separate databases for different domains
const knowledgeDB = await createAgentDBAdapter({
  dbPath: '.agentdb$knowledge.db',
});

const conversationDB = await createAgentDBAdapter({
  dbPath: '.agentdb$conversations.db',
});

const codeDB = await createAgentDBAdapter({
  dbPath: '.agentdb$code.db',
});

// Use appropriate database for each task
await knowledgeDB.insertPattern({ /* knowledge */ });
await conversationDB.insertPattern({ /* conversation */ });
await codeDB.insertPattern({ /* code */ });

データベースのシャーディング

// Shard by domain for horizontal scaling
const shards = {
  'domain-a': await createAgentDBAdapter({ dbPath: '.agentdb$shard-a.db' }),
  'domain-b': await createAgentDBAdapter({ dbPath: '.agentdb$shard-b.db' }),
  'domain-c': await createAgentDBAdapter({ dbPath: '.agentdb$shard-c.db' }),
};

// Route queries to appropriate shard
function getDBForDomain(domain: string) {
  const shardKey = domain.split('-')[0];  // Extract shard key
  return shards[shardKey] || shards['domain-a'];
}

// Insert to correct shard
const db = getDBForDomain('domain-a-task');
await db.insertPattern({ /* ... */ });

---

MMR（最大限界関連性）

結果の重複を避け、多様な結果を取得します。

// Without MMR: Similar results may be redundant
const standardResults = await adapter.retrieveWithReasoning(queryEmbedding, {
  k: 10,
  useMMR: false,
});

// With MMR: Diverse, non-redundant results
const diverseResults = await adapter.retrieveWithReasoning(queryEmbedding, {
  k: 10,
  useMMR: true,
  mmrLambda: 0.5,  // Balance relevance (0) vs diversity (1)
});

MMR パラメーター：

• mmrLambda = 0：関連性を最大化（重複する可能性があります）
• mmrLambda = 0.5：バランス重視（デフォルト）
• mmrLambda = 1：多様性を最大化（関連性が低くなる可能性があります）

ユースケース：

• 検索結果の多様化
• レコメンデーションシステム
• エコーチェンバーの回避
• 探索的検索

---

コンテキストの統合

複数のメモリから豊富なコンテキストを生成します。

const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  domain: 'problem-solving',
  k: 10,
  synthesizeContext: true,  // Enable context synthesis
});

// ContextSynthesizer creates coherent narrative
console.log('Synthesized Context:', result.context);
// "Based on 10 similar problem-solving attempts, the most effective
//  approach involves: 1) analyzing root cause, 2) brainstorming solutions,
//  3) evaluating trade-offs, 4) implementing incrementally. Success rate: 85%"

console.log('Patterns:', result.patterns);
// Extracted common patterns across memories

---

本番環境でのパターン

接続プーリング

// Singleton pattern for shared adapter
class AgentDBPool {
  private static instance: AgentDBAdapter;

  static async getInstance() {
    if (!this.instance) {
      this.instance = await createAgentDBAdapter({
        dbPath: '.agentdb$production.db',
        quantizationType: 'scalar',
        cacheSize: 2000,
      });
    }
    return this.instance;
  }
}

// Use in application
const db = await AgentDBPool.getInstance();
const results = await db.retrieveWithReasoning(queryEmbedding, { k: 10 });

エラー処理

async function safeRetrieve(queryEmbedding: number[], options: any) {
  try {
    const result = await adapter.retrieveWithReasoning(queryEmbedding, options);
    return result;
  } catch (error) {
    if (error.code === 'DIMENSION_MISMATCH') {
      console.error('Query embedding dimension mismatch');
      // Handle dimension error
    } else if (error.code === 'DATABASE_LOCKED') {
      // Retry with exponential backoff
      await new Promise(resolve => setTimeout(resolve, 100));
      return safeRetrieve(queryEmbedding, options);
    }
    throw error;
  }
}

モニタリングとログ記録

// Performance monitoring
const startTime = Date.now();
const result = await adapter.retrieveWithReasoning(queryEmbedding, { k: 10 });
const latency = Date.now() - startTime;

if (latency > 100) {
  console.warn('Slow query detected:', latency, 'ms');
}

// Log statistics
const stats = await adapter.getStats();
console.log('Database Stats:', {
  totalPatterns: stats.totalPatterns,
  dbSize: stats.dbSize,
  cacheHitRate: stats.cacheHitRate,
  avgSearchLatency: stats.avgSearchLatency,
});

---

CLI の高度な操作

データベースのインポート／エクスポート

# Export with compression
npx agentdb@latest export .$vectors.db .$backup.json.gz --compress

# Import from backup
npx agentdb@latest import .$backup.json.gz --decompress

# Merge databases
npx agentdb@latest merge .$db1.sqlite .$db2.sqlite .$merged.sqlite

データベースの最適化

# Vacuum database (reclaim space)
sqlite3 .agentdb$vectors.db "VACUUM;"

# Analyze for query optimization
sqlite3 .agentdb$vectors.db "ANALYZE;"

# Rebuild indices
npx agentdb@latest reindex .$vectors.db

---

環境変数

# AgentDB configuration
AGENTDB_PATH=.agentdb$reasoningbank.db
AGENTDB_ENABLED=true

# Performance tuning
AGENTDB_QUANTIZATION=binary     # binary|scalar|product|none
AGENTDB_CACHE_SIZE=2000
AGENTDB_HNSW_M=16
AGENTDB_HNSW_EF=100

# Learning plugins
AGENTDB_LEARNING=true

# Reasoning agents
AGENTDB_REASONING=true

# QUIC synchronization
AGENTDB_QUIC_SYNC=true
AGENTDB_QUIC_PORT=4433
AGENTDB_QUIC_PEERS=host1:4433,host2:4433

---

トラブルシューティング

問題：QUIC 同期が機能しない

# Check firewall allows UDP port 4433
# NOTE: Requires administrator privileges - for reference only
sudo ufw allow 4433/udp

# Verify peers are reachable
ping host1

# Check QUIC logs
DEBUG=agentdb:quic node server.js

問題：ハイブリッド検索で結果が返されない

// Relax filters
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  k: 100,  // Increase k
  filters: {
    // Remove or relax filters
  },
});

問題：メモリの統合が過剰に行われる

// Disable automatic optimization
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
  optimizeMemory: false,  // Disable auto-consolidation
  k: 10,
});

---

詳細情報

• QUIC プロトコル：docs$quic-synchronization.pdf
• ハイブリッド検索：docs$hybrid-search-guide.md
• GitHub：https:/$github.com$ruvnet$agentic-flow$tree$main$packages$agentdb
• ウェブサイト：https:/$agentdb.ruv.io

---

カテゴリ：高度な機能／分散システム 難易度：上級 所要時間の目安：45～60 分