agentdb 1.4.4 → 1.4.5

package/src/benchmarks/wasm-vector-benchmark.ts

@@ -0,0 +1,250 @@
+/**
+ * WASM Vector Operations Benchmark
+ *
+ * Measures actual performance improvements of WASM-accelerated vector operations
+ * compared to pure JavaScript implementations.
+ *
+ * Run with: npx tsx src/benchmarks/wasm-vector-benchmark.ts
+ */
+
+import { WASMVectorSearch } from '../controllers/WASMVectorSearch.js';
+
+interface BenchmarkResult {
+  name: string;
+  operations: number;
+  duration: number;
+  opsPerSecond: number;
+  avgLatency: number;
+}
+
+class VectorBenchmark {
+  private dimensions: number;
+  private vectorCount: number;
+
+  constructor(dimensions: number = 384, vectorCount: number = 1000) {
+    this.dimensions = dimensions;
+    this.vectorCount = vectorCount;
+  }
+
+  /**
+   * Generate random normalized vector
+   */
+  private generateRandomVector(): Float32Array {
+    const vector = new Float32Array(this.dimensions);
+    let norm = 0;
+
+    for (let i = 0; i < this.dimensions; i++) {
+      vector[i] = Math.random() * 2 - 1;
+      norm += vector[i] * vector[i];
+    }
+
+    norm = Math.sqrt(norm);
+    for (let i = 0; i < this.dimensions; i++) {
+      vector[i] /= norm;
+    }
+
+    return vector;
+  }
+
+  /**
+   * Pure JavaScript cosine similarity (baseline)
+   */
+  private cosineSimilarityJS(a: Float32Array, b: Float32Array): number {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dotProduct / denom;
+  }
+
+  /**
+   * Benchmark cosine similarity (pure JS)
+   */
+  async benchmarkJSSimilarity(iterations: number = 10000): Promise<BenchmarkResult> {
+    const vectorA = this.generateRandomVector();
+    const vectorB = this.generateRandomVector();
+
+    const start = performance.now();
+
+    for (let i = 0; i < iterations; i++) {
+      this.cosineSimilarityJS(vectorA, vectorB);
+    }
+
+    const duration = performance.now() - start;
+
+    return {
+      name: 'Cosine Similarity (Pure JS)',
+      operations: iterations,
+      duration,
+      opsPerSecond: (iterations / duration) * 1000,
+      avgLatency: duration / iterations,
+    };
+  }
+
+  /**
+   * Benchmark cosine similarity (WASM-accelerated)
+   */
+  async benchmarkWASMSimilarity(iterations: number = 10000): Promise<BenchmarkResult> {
+    const mockDb = {
+      prepare: () => ({ all: () => [], get: () => null, run: () => ({}) }),
+      exec: () => {},
+    };
+
+    const wasmSearch = new WASMVectorSearch(mockDb, { enableWASM: true });
+    const vectorA = this.generateRandomVector();
+    const vectorB = this.generateRandomVector();
+
+    const start = performance.now();
+
+    for (let i = 0; i < iterations; i++) {
+      wasmSearch.cosineSimilarity(vectorA, vectorB);
+    }
+
+    const duration = performance.now() - start;
+
+    return {
+      name: 'Cosine Similarity (WASM-Optimized)',
+      operations: iterations,
+      duration,
+      opsPerSecond: (iterations / duration) * 1000,
+      avgLatency: duration / iterations,
+    };
+  }
+
+  /**
+   * Benchmark batch similarity operations
+   */
+  async benchmarkBatchSimilarity(): Promise<BenchmarkResult> {
+    const mockDb = {
+      prepare: () => ({ all: () => [], get: () => null, run: () => ({}) }),
+      exec: () => {},
+    };
+
+    const wasmSearch = new WASMVectorSearch(mockDb, { enableWASM: true });
+    const query = this.generateRandomVector();
+    const vectors: Float32Array[] = [];
+
+    for (let i = 0; i < this.vectorCount; i++) {
+      vectors.push(this.generateRandomVector());
+    }
+
+    const start = performance.now();
+    wasmSearch.batchSimilarity(query, vectors);
+    const duration = performance.now() - start;
+
+    return {
+      name: 'Batch Similarity Search',
+      operations: this.vectorCount,
+      duration,
+      opsPerSecond: (this.vectorCount / duration) * 1000,
+      avgLatency: duration / this.vectorCount,
+    };
+  }
+
+  /**
+   * Benchmark k-NN search
+   */
+  async benchmarkKNNSearch(k: number = 10): Promise<BenchmarkResult> {
+    const mockDb = {
+      prepare: () => ({ all: () => [], get: () => null, run: () => ({}) }),
+      exec: () => {},
+    };
+
+    const wasmSearch = new WASMVectorSearch(mockDb, { enableWASM: true });
+    const query = this.generateRandomVector();
+    const vectors: Float32Array[] = [];
+    const ids: number[] = [];
+
+    for (let i = 0; i < this.vectorCount; i++) {
+      vectors.push(this.generateRandomVector());
+      ids.push(i);
+    }
+
+    // Build index
+    wasmSearch.buildIndex(vectors, ids);
+
+    const start = performance.now();
+    wasmSearch.searchIndex(query, k);
+    const duration = performance.now() - start;
+
+    return {
+      name: `k-NN Search (k=${k}, n=${this.vectorCount})`,
+      operations: 1,
+      duration,
+      opsPerSecond: (1 / duration) * 1000,
+      avgLatency: duration,
+    };
+  }
+
+  /**
+   * Run all benchmarks
+   */
+  async runAll(): Promise<void> {
+    console.log('='.repeat(80));
+    console.log('WASM Vector Operations Benchmark');
+    console.log('='.repeat(80));
+    console.log(`Configuration: ${this.dimensions}D vectors, ${this.vectorCount} dataset size\n`);
+
+    const results: BenchmarkResult[] = [];
+
+    // Cosine similarity benchmarks
+    console.log('Running similarity benchmarks...');
+    const jsResult = await this.benchmarkJSSimilarity();
+    results.push(jsResult);
+
+    const wasmResult = await this.benchmarkWASMSimilarity();
+    results.push(wasmResult);
+
+    const speedup = wasmResult.opsPerSecond / jsResult.opsPerSecond;
+    console.log(`  Speedup: ${speedup.toFixed(2)}x\n`);
+
+    // Batch similarity
+    console.log('Running batch similarity benchmark...');
+    const batchResult = await this.benchmarkBatchSimilarity();
+    results.push(batchResult);
+
+    // k-NN search
+    console.log('Running k-NN search benchmark...');
+    const knnResult = await this.benchmarkKNNSearch();
+    results.push(knnResult);
+
+    // Print results table
+    console.log('\n' + '='.repeat(80));
+    console.log('Results:');
+    console.log('='.repeat(80));
+    console.log(
+      'Benchmark'.padEnd(40) +
+      'Operations'.padStart(12) +
+      'Duration (ms)'.padStart(15) +
+      'Ops/sec'.padStart(15)
+    );
+    console.log('-'.repeat(80));
+
+    results.forEach(result => {
+      console.log(
+        result.name.padEnd(40) +
+        result.operations.toLocaleString().padStart(12) +
+        result.duration.toFixed(2).padStart(15) +
+        result.opsPerSecond.toLocaleString(undefined, { maximumFractionDigits: 0 }).padStart(15)
+      );
+    });
+
+    console.log('='.repeat(80));
+    console.log('\nKey Findings:');
+    console.log(`- WASM provides ${speedup.toFixed(2)}x speedup for cosine similarity`);
+    console.log(`- Batch processing: ${batchResult.opsPerSecond.toFixed(0)} vectors/sec`);
+    console.log(`- k-NN search latency: ${knnResult.avgLatency.toFixed(2)}ms`);
+    console.log('='.repeat(80));
+  }
+}
+
+// Run benchmarks
+const benchmark = new VectorBenchmark(384, 1000);
+benchmark.runAll().catch(console.error);

package/src/cli/agentdb-cli.ts

@@ -45,7 +45,7 @@ const log = {
 };
 
 class AgentDBCLI {
-  private db?: any; // Database instance from createDatabase
+  public db?: any; // Database instance from createDatabase (public for init command)
   private causalGraph?: CausalMemoryGraph;
   private causalRecall?: CausalRecall;
   private explainableRecall?: ExplainableRecall;
@@ -749,10 +749,49 @@ async function handleInitCommand(args: string[]) {
     return;
   }
 
+  // Create parent directories if needed
+  const parentDir = path.dirname(dbPath);
+  if (parentDir !== '.' && !fs.existsSync(parentDir)) {
+    log.info(`Creating directory: ${parentDir}`);
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+
   // Create new database with schemas
   const cli = new AgentDBCLI();
   await cli.initialize(dbPath);
 
+  // CRITICAL: Save the database to disk
+  // sql.js keeps everything in memory until explicitly saved
+  if (cli.db && typeof cli.db.save === 'function') {
+    cli.db.save();
+  } else if (cli.db && typeof cli.db.close === 'function') {
+    // close() calls save() internally
+    cli.db.close();
+  }
+
+  // Verify database file was created
+  if (!fs.existsSync(dbPath)) {
+    log.error(`Failed to create database file at ${dbPath}`);
+    log.error('The database may be in memory only');
+    process.exit(1);
+  }
+
+  // Verify database has tables
+  try {
+    const db = await createDatabase(dbPath);
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+    db.close();
+
+    if (tables.length === 0) {
+      log.warning('Database file created but no tables found');
+      log.warning('Schemas may not have been loaded correctly');
+    } else {
+      log.success(`Database created with ${tables.length} tables`);
+    }
+  } catch (error) {
+    log.warning(`Could not verify database tables: ${(error as Error).message}`);
+  }
+
   log.success(`✅ AgentDB initialized successfully at ${dbPath}`);
   log.info('Database includes:');
   log.info('  - Core vector tables (episodes, embeddings)');

package/src/controllers/EmbeddingService.ts

@@ -29,10 +29,14 @@ export class EmbeddingService {
     if (this.config.provider === 'transformers') {
       // Use transformers.js for local embeddings
       try {
-        const { pipeline } = await import('@xenova/transformers' as any);
-        this.pipeline = await pipeline('feature-extraction', this.config.model);
+        const transformers = await import('@xenova/transformers');
+        this.pipeline = await transformers.pipeline('feature-extraction', this.config.model);
+        console.log(`✅ Transformers.js loaded: ${this.config.model}`);
       } catch (error) {
-        console.warn('Transformers.js not available, falling back to mock embeddings');
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`⚠️  Transformers.js initialization failed: ${errorMessage}`);
+        console.warn('   Falling back to mock embeddings for testing');
+        console.warn('   Install @xenova/transformers for real embeddings: npm install @xenova/transformers');
         this.pipeline = null;
       }
     }

package/src/controllers/EnhancedEmbeddingService.ts

@@ -0,0 +1,159 @@
+/**
+ * Enhanced EmbeddingService with WASM Acceleration
+ *
+ * Extends the base EmbeddingService with WASM-accelerated batch operations
+ * and improved performance for large-scale embedding generation.
+ */
+
+import { EmbeddingService, EmbeddingConfig } from './EmbeddingService.js';
+import { WASMVectorSearch } from './WASMVectorSearch.js';
+
+export interface EnhancedEmbeddingConfig extends EmbeddingConfig {
+  enableWASM?: boolean;
+  enableBatchProcessing?: boolean;
+  batchSize?: number;
+}
+
+export class EnhancedEmbeddingService extends EmbeddingService {
+  private wasmSearch: WASMVectorSearch | null = null;
+  private enhancedConfig: EnhancedEmbeddingConfig;
+
+  constructor(config: EnhancedEmbeddingConfig) {
+    super(config);
+    this.enhancedConfig = {
+      enableWASM: true,
+      enableBatchProcessing: true,
+      batchSize: 100,
+      ...config,
+    };
+
+    if (this.enhancedConfig.enableWASM) {
+      this.initializeWASM();
+    }
+  }
+
+  /**
+   * Initialize WASM acceleration
+   */
+  private initializeWASM(): void {
+    const mockDb = {
+      prepare: () => ({ all: () => [], get: () => null, run: () => ({}) }),
+      exec: () => {},
+    };
+
+    this.wasmSearch = new WASMVectorSearch(mockDb, {
+      enableWASM: true,
+      batchSize: this.enhancedConfig.batchSize || 100,
+    });
+  }
+
+  /**
+   * Enhanced batch embedding with parallel processing
+   */
+  async embedBatch(texts: string[]): Promise<Float32Array[]> {
+    if (!this.enhancedConfig.enableBatchProcessing || texts.length < 10) {
+      return super.embedBatch(texts);
+    }
+
+    const batchSize = this.enhancedConfig.batchSize || 100;
+    const batches: string[][] = [];
+
+    // Split into batches
+    for (let i = 0; i < texts.length; i += batchSize) {
+      batches.push(texts.slice(i, i + batchSize));
+    }
+
+    // Process batches in parallel
+    const results = await Promise.all(
+      batches.map(batch => super.embedBatch(batch))
+    );
+
+    // Flatten results
+    return results.flat();
+  }
+
+  /**
+   * Calculate similarity between two texts using WASM acceleration
+   */
+  async similarity(textA: string, textB: string): Promise<number> {
+    const [embeddingA, embeddingB] = await Promise.all([
+      this.embed(textA),
+      this.embed(textB),
+    ]);
+
+    if (this.wasmSearch) {
+      return this.wasmSearch.cosineSimilarity(embeddingA, embeddingB);
+    }
+
+    // Fallback to manual calculation
+    return this.cosineSimilarity(embeddingA, embeddingB);
+  }
+
+  /**
+   * Find most similar texts from a corpus
+   */
+  async findMostSimilar(
+    query: string,
+    corpus: string[],
+    k: number = 5
+  ): Promise<Array<{ text: string; similarity: number; index: number }>> {
+    const queryEmbedding = await this.embed(query);
+    const corpusEmbeddings = await this.embedBatch(corpus);
+
+    let similarities: number[];
+
+    if (this.wasmSearch) {
+      similarities = this.wasmSearch.batchSimilarity(queryEmbedding, corpusEmbeddings);
+    } else {
+      similarities = corpusEmbeddings.map(emb =>
+        this.cosineSimilarity(queryEmbedding, emb)
+      );
+    }
+
+    // Create results with indices
+    const results = corpus.map((text, index) => ({
+      text,
+      similarity: similarities[index],
+      index,
+    }));
+
+    // Sort by similarity and take top k
+    results.sort((a, b) => b.similarity - a.similarity);
+    return results.slice(0, k);
+  }
+
+  /**
+   * Get service statistics
+   */
+  getStats(): {
+    cacheSize: number;
+    wasmEnabled: boolean;
+    simdEnabled: boolean;
+  } {
+    const wasmStats = this.wasmSearch?.getStats();
+
+    return {
+      cacheSize: (this as any).cache.size,
+      wasmEnabled: wasmStats?.wasmAvailable ?? false,
+      simdEnabled: wasmStats?.simdAvailable ?? false,
+    };
+  }
+
+  /**
+   * Cosine similarity fallback
+   */
+  private cosineSimilarity(a: Float32Array, b: Float32Array): number {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dotProduct / denom;
+  }
+}