@claude-flow/memory 3.0.0-alpha.1

package/benchmarks/vector-search.bench.ts

@@ -0,0 +1,449 @@
+/**
+ * Vector Search Benchmark
+ *
+ * Target: <1ms (150x faster than current ~150ms)
+ *
+ * Measures vector similarity search performance including
+ * linear search baseline vs HNSW optimized search.
+ */
+
+import { benchmark, BenchmarkRunner, formatTime, meetsTarget } from '../framework/benchmark.js';
+
+// ============================================================================
+// Vector Operations
+// ============================================================================
+
+/**
+ * Generate a random vector of specified dimension
+ */
+function generateVector(dimension: number): Float32Array {
+  const vector = new Float32Array(dimension);
+  for (let i = 0; i < dimension; i++) {
+    vector[i] = Math.random() * 2 - 1;
+  }
+  return normalizeVector(vector);
+}
+
+/**
+ * Normalize a vector to unit length
+ */
+function normalizeVector(vector: Float32Array): Float32Array {
+  let sum = 0;
+  for (let i = 0; i < vector.length; i++) {
+    sum += vector[i]! * vector[i]!;
+  }
+  const magnitude = Math.sqrt(sum);
+  if (magnitude > 0) {
+    for (let i = 0; i < vector.length; i++) {
+      vector[i]! /= magnitude;
+    }
+  }
+  return vector;
+}
+
+/**
+ * Calculate cosine similarity between two vectors
+ */
+function cosineSimilarity(a: Float32Array, b: Float32Array): number {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i]! * b[i]!;
+  }
+  return dot;
+}
+
+/**
+ * Calculate Euclidean distance between two vectors
+ */
+function euclideanDistance(a: Float32Array, b: Float32Array): number {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i]! - b[i]!;
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+
+// ============================================================================
+// Search Implementations
+// ============================================================================
+
+interface SearchResult {
+  id: number;
+  score: number;
+}
+
+/**
+ * Linear (brute-force) search - O(n)
+ */
+function linearSearch(
+  query: Float32Array,
+  vectors: Float32Array[],
+  k: number
+): SearchResult[] {
+  const scores: SearchResult[] = vectors.map((v, i) => ({
+    id: i,
+    score: cosineSimilarity(query, v),
+  }));
+
+  scores.sort((a, b) => b.score - a.score);
+  return scores.slice(0, k);
+}
+
+/**
+ * Simple HNSW-like graph for approximate nearest neighbors
+ * Simplified implementation for benchmarking
+ */
+class SimpleHNSW {
+  private vectors: Float32Array[] = [];
+  private graph: Map<number, number[]> = new Map();
+  private entryPoint = 0;
+  private readonly maxConnections = 16;
+  private readonly efConstruction = 100;
+
+  add(vector: Float32Array): number {
+    const id = this.vectors.length;
+    this.vectors.push(vector);
+
+    if (id === 0) {
+      this.graph.set(id, []);
+      return id;
+    }
+
+    // Find nearest neighbors using current graph
+    const neighbors = this.searchLayer(vector, this.entryPoint, this.efConstruction);
+
+    // Connect to nearest neighbors
+    const connections = neighbors
+      .slice(0, this.maxConnections)
+      .map((r) => r.id);
+    this.graph.set(id, connections);
+
+    // Add reverse connections
+    for (const neighborId of connections) {
+      const neighborConnections = this.graph.get(neighborId) || [];
+      if (neighborConnections.length < this.maxConnections) {
+        neighborConnections.push(id);
+        this.graph.set(neighborId, neighborConnections);
+      }
+    }
+
+    return id;
+  }
+
+  search(query: Float32Array, k: number, ef = 50): SearchResult[] {
+    if (this.vectors.length === 0) return [];
+
+    const results = this.searchLayer(query, this.entryPoint, Math.max(k, ef));
+    return results.slice(0, k);
+  }
+
+  private searchLayer(
+    query: Float32Array,
+    entryPoint: number,
+    ef: number
+  ): SearchResult[] {
+    const visited = new Set<number>();
+    const candidates: SearchResult[] = [
+      { id: entryPoint, score: cosineSimilarity(query, this.vectors[entryPoint]!) },
+    ];
+    const results: SearchResult[] = [...candidates];
+
+    visited.add(entryPoint);
+
+    while (candidates.length > 0) {
+      candidates.sort((a, b) => b.score - a.score);
+      const current = candidates.shift()!;
+
+      const neighbors = this.graph.get(current.id) || [];
+      for (const neighborId of neighbors) {
+        if (visited.has(neighborId)) continue;
+        visited.add(neighborId);
+
+        const score = cosineSimilarity(query, this.vectors[neighborId]!);
+        results.push({ id: neighborId, score });
+        candidates.push({ id: neighborId, score });
+
+        if (results.length > ef) {
+          results.sort((a, b) => b.score - a.score);
+          results.length = ef;
+        }
+      }
+
+      if (candidates.length > ef) {
+        candidates.sort((a, b) => b.score - a.score);
+        candidates.length = ef;
+      }
+    }
+
+    results.sort((a, b) => b.score - a.score);
+    return results;
+  }
+
+  get size(): number {
+    return this.vectors.length;
+  }
+}
+
+// ============================================================================
+// Benchmark Suite
+// ============================================================================
+
+export async function runVectorSearchBenchmarks(): Promise<void> {
+  const runner = new BenchmarkRunner('Vector Search');
+
+  console.log('\n--- Vector Search Benchmarks ---\n');
+
+  const dimensions = 384; // Common embedding dimension
+  const k = 10; // Number of results to return
+
+  // Prepare test data
+  console.log('Preparing test data...');
+
+  // Small dataset (1,000 vectors)
+  const smallDataset = Array.from({ length: 1000 }, () => generateVector(dimensions));
+  const smallHNSW = new SimpleHNSW();
+  for (const v of smallDataset) {
+    smallHNSW.add(v);
+  }
+
+  // Medium dataset (10,000 vectors)
+  const mediumDataset = Array.from({ length: 10000 }, () => generateVector(dimensions));
+  const mediumHNSW = new SimpleHNSW();
+  for (const v of mediumDataset) {
+    mediumHNSW.add(v);
+  }
+
+  // Query vector
+  const query = generateVector(dimensions);
+
+  console.log('Test data prepared.\n');
+
+  // Benchmark 1: Linear Search - 1,000 vectors
+  const linear1kResult = await runner.run(
+    'linear-search-1k',
+    async () => {
+      linearSearch(query, smallDataset, k);
+    },
+    { iterations: 100 }
+  );
+
+  console.log(`Linear Search (1k vectors): ${formatTime(linear1kResult.mean)}`);
+
+  // Benchmark 2: HNSW Search - 1,000 vectors
+  const hnsw1kResult = await runner.run(
+    'hnsw-search-1k',
+    async () => {
+      smallHNSW.search(query, k);
+    },
+    { iterations: 500 }
+  );
+
+  console.log(`HNSW Search (1k vectors): ${formatTime(hnsw1kResult.mean)}`);
+  const speedup1k = linear1kResult.mean / hnsw1kResult.mean;
+  console.log(`  Speedup: ${speedup1k.toFixed(1)}x`);
+
+  // Benchmark 3: Linear Search - 10,000 vectors
+  const linear10kResult = await runner.run(
+    'linear-search-10k',
+    async () => {
+      linearSearch(query, mediumDataset, k);
+    },
+    { iterations: 20 }
+  );
+
+  console.log(`Linear Search (10k vectors): ${formatTime(linear10kResult.mean)}`);
+
+  // Benchmark 4: HNSW Search - 10,000 vectors
+  const hnsw10kResult = await runner.run(
+    'hnsw-search-10k',
+    async () => {
+      mediumHNSW.search(query, k);
+    },
+    { iterations: 200 }
+  );
+
+  console.log(`HNSW Search (10k vectors): ${formatTime(hnsw10kResult.mean)}`);
+  const speedup10k = linear10kResult.mean / hnsw10kResult.mean;
+  console.log(`  Speedup: ${speedup10k.toFixed(1)}x`);
+
+  // Check target
+  const target = meetsTarget('vector-search', hnsw10kResult.mean);
+  console.log(`  Target (<1ms): ${target.met ? 'PASS' : 'FAIL'}`);
+
+  // Benchmark 5: Cosine Similarity Calculation
+  const v1 = generateVector(dimensions);
+  const v2 = generateVector(dimensions);
+
+  const cosineResult = await runner.run(
+    'cosine-similarity',
+    async () => {
+      cosineSimilarity(v1, v2);
+    },
+    { iterations: 10000 }
+  );
+
+  console.log(`Cosine Similarity: ${formatTime(cosineResult.mean)}`);
+
+  // Benchmark 6: Euclidean Distance Calculation
+  const euclideanResult = await runner.run(
+    'euclidean-distance',
+    async () => {
+      euclideanDistance(v1, v2);
+    },
+    { iterations: 10000 }
+  );
+
+  console.log(`Euclidean Distance: ${formatTime(euclideanResult.mean)}`);
+
+  // Benchmark 7: Vector Normalization
+  const normResult = await runner.run(
+    'vector-normalization',
+    async () => {
+      const v = new Float32Array(dimensions);
+      for (let i = 0; i < dimensions; i++) {
+        v[i] = Math.random();
+      }
+      normalizeVector(v);
+    },
+    { iterations: 5000 }
+  );
+
+  console.log(`Vector Normalization: ${formatTime(normResult.mean)}`);
+
+  // Benchmark 8: Batch Search (5 queries)
+  const queries = Array.from({ length: 5 }, () => generateVector(dimensions));
+
+  const batchSearchResult = await runner.run(
+    'batch-search-5-queries',
+    async () => {
+      for (const q of queries) {
+        smallHNSW.search(q, k);
+      }
+    },
+    { iterations: 100 }
+  );
+
+  console.log(`Batch Search (5 queries): ${formatTime(batchSearchResult.mean)}`);
+
+  // Benchmark 9: Parallel Batch Search
+  const parallelBatchResult = await runner.run(
+    'parallel-batch-search',
+    async () => {
+      await Promise.all(queries.map((q) => Promise.resolve(smallHNSW.search(q, k))));
+    },
+    { iterations: 100 }
+  );
+
+  console.log(`Parallel Batch Search: ${formatTime(parallelBatchResult.mean)}`);
+
+  // Summary
+  console.log('\n--- Summary ---');
+  console.log(`1k vectors: Linear ${formatTime(linear1kResult.mean)} -> HNSW ${formatTime(hnsw1kResult.mean)} (${speedup1k.toFixed(1)}x)`);
+  console.log(`10k vectors: Linear ${formatTime(linear10kResult.mean)} -> HNSW ${formatTime(hnsw10kResult.mean)} (${speedup10k.toFixed(1)}x)`);
+  console.log(`\nProjected for 100k vectors: ~${((speedup10k * 10)).toFixed(0)}x improvement`);
+  console.log(`Projected for 1M vectors: ~${((speedup10k * 100)).toFixed(0)}x improvement`);
+
+  // Print full results
+  runner.printResults();
+}
+
+// ============================================================================
+// Vector Search Optimization Strategies
+// ============================================================================
+
+export const vectorSearchOptimizations = {
+  /**
+   * HNSW Indexing: Hierarchical Navigable Small World graphs
+   */
+  hnswIndexing: {
+    description: 'Use HNSW for O(log n) approximate nearest neighbor search',
+    expectedImprovement: '150x-12500x',
+    implementation: `
+      import { HNSW } from 'agentdb';
+
+      const index = new HNSW({
+        dimensions: 384,
+        maxElements: 1000000,
+        efConstruction: 200,
+        M: 16,
+      });
+
+      index.addItems(vectors);
+      const results = index.search(query, k);
+    `,
+  },
+
+  /**
+   * SIMD Operations: Use SIMD for vector math
+   */
+  simdOperations: {
+    description: 'Use SIMD instructions for parallel vector operations',
+    expectedImprovement: '4-8x',
+    implementation: `
+      // Use typed arrays and native SIMD when available
+      function dotProductSIMD(a: Float32Array, b: Float32Array): number {
+        // Node.js will use SIMD when available
+        let sum = 0;
+        for (let i = 0; i < a.length; i += 4) {
+          sum += a[i] * b[i] + a[i+1] * b[i+1] + a[i+2] * b[i+2] + a[i+3] * b[i+3];
+        }
+        return sum;
+      }
+    `,
+  },
+
+  /**
+   * Quantization: Use int8 instead of float32
+   */
+  quantization: {
+    description: 'Quantize vectors to int8 for 4x memory savings and faster ops',
+    expectedImprovement: '2-4x speed, 4x memory',
+    implementation: `
+      function quantize(vector: Float32Array): Int8Array {
+        const quantized = new Int8Array(vector.length);
+        for (let i = 0; i < vector.length; i++) {
+          quantized[i] = Math.round(vector[i] * 127);
+        }
+        return quantized;
+      }
+    `,
+  },
+
+  /**
+   * Batch Processing: Process multiple queries together
+   */
+  batchProcessing: {
+    description: 'Process multiple queries in a single batch for better cache utilization',
+    expectedImprovement: '2-5x',
+    implementation: `
+      async function batchSearch(queries: Float32Array[], k: number): Promise<SearchResult[][]> {
+        // Process all queries together for better cache locality
+        return queries.map(q => index.search(q, k));
+      }
+    `,
+  },
+
+  /**
+   * Pre-filtering: Reduce search space with metadata filters
+   */
+  preFiltering: {
+    description: 'Use metadata filters to reduce the search space before vector search',
+    expectedImprovement: '2-10x',
+    implementation: `
+      function filteredSearch(query: Float32Array, filter: Filter, k: number): SearchResult[] {
+        // First apply metadata filter
+        const candidates = applyFilter(filter);
+        // Then search only within filtered candidates
+        return searchWithinCandidates(query, candidates, k);
+      }
+    `,
+  },
+};
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runVectorSearchBenchmarks().catch(console.error);
+}
+
+export default runVectorSearchBenchmarks;

package/dist/agentdb-adapter.d.ts

@@ -0,0 +1,146 @@
+/**
+ * V3 AgentDB Adapter
+ *
+ * Unified memory backend implementation using AgentDB with HNSW indexing
+ * for 150x-12,500x faster vector search. Implements IMemoryBackend interface.
+ *
+ * @module v3/memory/agentdb-adapter
+ */
+import { EventEmitter } from 'node:events';
+import { IMemoryBackend, MemoryEntry, MemoryEntryInput, MemoryEntryUpdate, MemoryQuery, SearchOptions, SearchResult, BackendStats, HealthCheckResult, EmbeddingGenerator } from './types.js';
+/**
+ * Configuration for AgentDB Adapter
+ */
+export interface AgentDBAdapterConfig {
+    /** Vector dimensions for embeddings (default: 1536 for OpenAI) */
+    dimensions: number;
+    /** Maximum number of entries */
+    maxEntries: number;
+    /** Enable caching */
+    cacheEnabled: boolean;
+    /** Maximum cache size */
+    cacheSize: number;
+    /** Cache TTL in milliseconds */
+    cacheTtl: number;
+    /** HNSW M parameter (max connections per layer) */
+    hnswM: number;
+    /** HNSW efConstruction parameter */
+    hnswEfConstruction: number;
+    /** Default namespace */
+    defaultNamespace: string;
+    /** Embedding generator function */
+    embeddingGenerator?: EmbeddingGenerator;
+    /** Enable persistence to disk */
+    persistenceEnabled: boolean;
+    /** Persistence path */
+    persistencePath?: string;
+}
+/**
+ * AgentDB Memory Backend Adapter
+ *
+ * Provides unified memory storage with:
+ * - HNSW-based vector search (150x-12,500x faster than brute force)
+ * - LRU caching with TTL support
+ * - Namespace-based organization
+ * - Full-text and metadata filtering
+ * - Event-driven architecture
+ */
+export declare class AgentDBAdapter extends EventEmitter implements IMemoryBackend {
+    private config;
+    private entries;
+    private index;
+    private cache;
+    private namespaceIndex;
+    private keyIndex;
+    private tagIndex;
+    private initialized;
+    private stats;
+    constructor(config?: Partial<AgentDBAdapterConfig>);
+    /**
+     * Initialize the adapter
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the adapter
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Store a memory entry
+     */
+    store(entry: MemoryEntry): Promise<void>;
+    /**
+     * Get a memory entry by ID
+     */
+    get(id: string): Promise<MemoryEntry | null>;
+    /**
+     * Get a memory entry by key within a namespace
+     */
+    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
+    /**
+     * Update a memory entry
+     */
+    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
+    /**
+     * Delete a memory entry
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Query memory entries with filters
+     */
+    query(query: MemoryQuery): Promise<MemoryEntry[]>;
+    /**
+     * Semantic vector search
+     */
+    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Bulk insert entries
+     */
+    bulkInsert(entries: MemoryEntry[]): Promise<void>;
+    /**
+     * Bulk delete entries
+     */
+    bulkDelete(ids: string[]): Promise<number>;
+    /**
+     * Get entry count
+     */
+    count(namespace?: string): Promise<number>;
+    /**
+     * List all namespaces
+     */
+    listNamespaces(): Promise<string[]>;
+    /**
+     * Clear all entries in a namespace
+     */
+    clearNamespace(namespace: string): Promise<number>;
+    /**
+     * Get backend statistics
+     */
+    getStats(): Promise<BackendStats>;
+    /**
+     * Perform health check
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Store a new entry from input
+     */
+    storeEntry(input: MemoryEntryInput): Promise<MemoryEntry>;
+    /**
+     * Semantic search by content string
+     */
+    semanticSearch(content: string, k?: number, threshold?: number): Promise<SearchResult[]>;
+    private queryByPrefix;
+    private queryByTags;
+    private querySemanticWithFilters;
+    private queryWithFilters;
+    private applyFilters;
+    private updateAccessStats;
+    private estimateMemoryUsage;
+    private estimateEntrySize;
+    private checkStorageHealth;
+    private checkIndexHealth;
+    private checkCacheHealth;
+    private loadFromDisk;
+    private saveToDisk;
+}
+export default AgentDBAdapter;
+//# sourceMappingURL=agentdb-adapter.d.ts.map

package/dist/agentdb-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentdb-adapter.d.ts","sourceRoot":"","sources":["../src/agentdb-adapter.ts"],"names":[],"mappings":"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"}