agentdb 2.0.0-alpha.2 → 2.0.0-alpha.2.1

package/dist/browser/browser/ProductQuantization.js

@@ -1,348 +0,0 @@
-/**
- * Product Quantization for Browser
- *
- * Compresses high-dimensional vectors using product quantization.
- * Achieves 4-32x memory reduction with minimal accuracy loss.
- *
- * Features:
- * - PQ8: 8 subvectors, 256 centroids each (4x compression)
- * - PQ16: 16 subvectors, 256 centroids each (8x compression)
- * - Asymmetric distance computation (ADC)
- * - K-means clustering for codebook training
- *
- * Performance:
- * - Memory: Float32 (4 bytes) → uint8 (1 byte) per subvector
- * - Speed: ~1.5x slower search vs uncompressed
- * - Accuracy: 95-99% recall@10
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export class ProductQuantization {
-    constructor(config) {
-        this.codebook = null;
-        this.trained = false;
-        this.config = {
-            dimension: config.dimension,
-            numSubvectors: config.numSubvectors,
-            numCentroids: config.numCentroids,
-            maxIterations: config.maxIterations || 50,
-            convergenceThreshold: config.convergenceThreshold || 1e-4
-        };
-        // Validate config
-        if (this.config.dimension % this.config.numSubvectors !== 0) {
-            throw new Error(`Dimension ${this.config.dimension} must be divisible by numSubvectors ${this.config.numSubvectors}`);
-        }
-    }
-    /**
-     * Train codebook using k-means on training vectors
-     */
-    train(vectors) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (vectors.length === 0) {
-                throw new Error('Training requires at least one vector');
-            }
-            const subvectorDim = this.config.dimension / this.config.numSubvectors;
-            const centroids = [];
-            console.log(`[PQ] Training ${this.config.numSubvectors} subvectors with ${this.config.numCentroids} centroids each...`);
-            // Train each subvector independently
-            for (let s = 0; s < this.config.numSubvectors; s++) {
-                const startDim = s * subvectorDim;
-                const endDim = startDim + subvectorDim;
-                // Extract subvectors
-                const subvectors = vectors.map(v => v.slice(startDim, endDim));
-                // Run k-means
-                const subCentroids = yield this.kMeans(subvectors, this.config.numCentroids);
-                centroids.push(...subCentroids);
-                if ((s + 1) % 4 === 0 || s === this.config.numSubvectors - 1) {
-                    console.log(`[PQ] Trained ${s + 1}/${this.config.numSubvectors} subvectors`);
-                }
-            }
-            this.codebook = {
-                subvectorDim,
-                numSubvectors: this.config.numSubvectors,
-                numCentroids: this.config.numCentroids,
-                centroids
-            };
-            this.trained = true;
-            console.log('[PQ] Training complete');
-        });
-    }
-    /**
-     * K-means clustering for centroids
-     */
-    kMeans(vectors, k) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dim = vectors[0].length;
-            const n = vectors.length;
-            // Initialize centroids with k-means++
-            const centroids = this.kMeansPlusPlus(vectors, k);
-            const assignments = new Uint32Array(n);
-            let prevInertia = Infinity;
-            for (let iter = 0; iter < this.config.maxIterations; iter++) {
-                // Assign vectors to nearest centroid
-                let inertia = 0;
-                for (let i = 0; i < n; i++) {
-                    let minDist = Infinity;
-                    let minIdx = 0;
-                    for (let j = 0; j < k; j++) {
-                        const dist = this.squaredDistance(vectors[i], centroids[j]);
-                        if (dist < minDist) {
-                            minDist = dist;
-                            minIdx = j;
-                        }
-                    }
-                    assignments[i] = minIdx;
-                    inertia += minDist;
-                }
-                // Check convergence
-                if (Math.abs(prevInertia - inertia) < this.config.convergenceThreshold) {
-                    break;
-                }
-                prevInertia = inertia;
-                // Update centroids
-                const counts = new Uint32Array(k);
-                const sums = Array.from({ length: k }, () => new Float32Array(dim));
-                for (let i = 0; i < n; i++) {
-                    const cluster = assignments[i];
-                    counts[cluster]++;
-                    for (let d = 0; d < dim; d++) {
-                        sums[cluster][d] += vectors[i][d];
-                    }
-                }
-                for (let j = 0; j < k; j++) {
-                    if (counts[j] > 0) {
-                        for (let d = 0; d < dim; d++) {
-                            centroids[j][d] = sums[j][d] / counts[j];
-                        }
-                    }
-                }
-            }
-            return centroids;
-        });
-    }
-    /**
-     * K-means++ initialization for better centroid selection
-     */
-    kMeansPlusPlus(vectors, k) {
-        const n = vectors.length;
-        const dim = vectors[0].length;
-        const centroids = [];
-        // Choose first centroid randomly
-        const firstIdx = Math.floor(Math.random() * n);
-        centroids.push(new Float32Array(vectors[firstIdx]));
-        // Choose remaining centroids
-        for (let i = 1; i < k; i++) {
-            const distances = new Float32Array(n);
-            let sumDistances = 0;
-            // Calculate distances to nearest centroid
-            for (let j = 0; j < n; j++) {
-                let minDist = Infinity;
-                for (const centroid of centroids) {
-                    const dist = this.squaredDistance(vectors[j], centroid);
-                    minDist = Math.min(minDist, dist);
-                }
-                distances[j] = minDist;
-                sumDistances += minDist;
-            }
-            // Choose next centroid with probability proportional to distance²
-            let r = Math.random() * sumDistances;
-            for (let j = 0; j < n; j++) {
-                r -= distances[j];
-                if (r <= 0) {
-                    centroids.push(new Float32Array(vectors[j]));
-                    break;
-                }
-            }
-        }
-        return centroids;
-    }
-    /**
-     * Compress a vector using trained codebook
-     */
-    compress(vector) {
-        if (!this.trained || !this.codebook) {
-            throw new Error('Codebook must be trained before compression');
-        }
-        const codes = new Uint8Array(this.config.numSubvectors);
-        const subvectorDim = this.codebook.subvectorDim;
-        // Compute norm for later reconstruction
-        let norm = 0;
-        for (let i = 0; i < vector.length; i++) {
-            norm += vector[i] * vector[i];
-        }
-        norm = Math.sqrt(norm);
-        // Encode each subvector
-        for (let s = 0; s < this.config.numSubvectors; s++) {
-            const startDim = s * subvectorDim;
-            const subvector = vector.slice(startDim, startDim + subvectorDim);
-            // Find nearest centroid
-            let minDist = Infinity;
-            let minIdx = 0;
-            const centroidOffset = s * this.config.numCentroids;
-            for (let c = 0; c < this.config.numCentroids; c++) {
-                const centroid = this.codebook.centroids[centroidOffset + c];
-                const dist = this.squaredDistance(subvector, centroid);
-                if (dist < minDist) {
-                    minDist = dist;
-                    minIdx = c;
-                }
-            }
-            codes[s] = minIdx;
-        }
-        return { codes, norm };
-    }
-    /**
-     * Decompress a vector (approximate reconstruction)
-     */
-    decompress(compressed) {
-        if (!this.codebook) {
-            throw new Error('Codebook not available');
-        }
-        const vector = new Float32Array(this.config.dimension);
-        const subvectorDim = this.codebook.subvectorDim;
-        for (let s = 0; s < this.config.numSubvectors; s++) {
-            const code = compressed.codes[s];
-            const centroidOffset = s * this.config.numCentroids;
-            const centroid = this.codebook.centroids[centroidOffset + code];
-            const startDim = s * subvectorDim;
-            for (let d = 0; d < subvectorDim; d++) {
-                vector[startDim + d] = centroid[d];
-            }
-        }
-        return vector;
-    }
-    /**
-     * Asymmetric Distance Computation (ADC)
-     * Computes distance from query vector to compressed vector
-     */
-    asymmetricDistance(query, compressed) {
-        if (!this.codebook) {
-            throw new Error('Codebook not available');
-        }
-        let distance = 0;
-        const subvectorDim = this.codebook.subvectorDim;
-        for (let s = 0; s < this.config.numSubvectors; s++) {
-            const code = compressed.codes[s];
-            const centroidOffset = s * this.config.numCentroids;
-            const centroid = this.codebook.centroids[centroidOffset + code];
-            const startDim = s * subvectorDim;
-            const querySubvector = query.slice(startDim, startDim + subvectorDim);
-            distance += this.squaredDistance(querySubvector, centroid);
-        }
-        return Math.sqrt(distance);
-    }
-    /**
-     * Batch compression for multiple vectors
-     */
-    batchCompress(vectors) {
-        return vectors.map(v => this.compress(v));
-    }
-    /**
-     * Get memory savings
-     */
-    getCompressionRatio() {
-        // Original: dimension * 4 bytes (Float32)
-        // Compressed: numSubvectors * 1 byte (Uint8) + 4 bytes (norm)
-        const originalBytes = this.config.dimension * 4;
-        const compressedBytes = this.config.numSubvectors + 4;
-        return originalBytes / compressedBytes;
-    }
-    /**
-     * Export codebook for persistence
-     */
-    exportCodebook() {
-        if (!this.codebook) {
-            throw new Error('No codebook to export');
-        }
-        return JSON.stringify({
-            config: this.config,
-            codebook: {
-                subvectorDim: this.codebook.subvectorDim,
-                numSubvectors: this.codebook.numSubvectors,
-                numCentroids: this.codebook.numCentroids,
-                centroids: this.codebook.centroids.map(c => Array.from(c))
-            }
-        });
-    }
-    /**
-     * Import codebook
-     */
-    importCodebook(json) {
-        const data = JSON.parse(json);
-        this.config = data.config;
-        this.codebook = {
-            subvectorDim: data.codebook.subvectorDim,
-            numSubvectors: data.codebook.numSubvectors,
-            numCentroids: data.codebook.numCentroids,
-            centroids: data.codebook.centroids.map((c) => new Float32Array(c))
-        };
-        this.trained = true;
-    }
-    /**
-     * Utility: Squared Euclidean distance
-     */
-    squaredDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            const diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return sum;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        const compressionRatio = this.getCompressionRatio();
-        const memoryPerVector = this.config.numSubvectors + 4; // codes + norm
-        const codebookSize = this.codebook
-            ? this.config.numSubvectors * this.config.numCentroids * (this.config.dimension / this.config.numSubvectors) * 4
-            : 0;
-        return {
-            trained: this.trained,
-            compressionRatio,
-            memoryPerVector,
-            codebookSize
-        };
-    }
-}
-/**
- * Helper function to create PQ8 (8 subvectors, 4x compression)
- */
-export function createPQ8(dimension) {
-    return new ProductQuantization({
-        dimension,
-        numSubvectors: 8,
-        numCentroids: 256,
-        maxIterations: 50
-    });
-}
-/**
- * Helper function to create PQ16 (16 subvectors, 8x compression)
- */
-export function createPQ16(dimension) {
-    return new ProductQuantization({
-        dimension,
-        numSubvectors: 16,
-        numCentroids: 256,
-        maxIterations: 50
-    });
-}
-/**
- * Helper function to create PQ32 (32 subvectors, 16x compression)
- */
-export function createPQ32(dimension) {
-    return new ProductQuantization({
-        dimension,
-        numSubvectors: 32,
-        numCentroids: 256,
-        maxIterations: 50
-    });
-}

package/dist/browser/browser/index.d.ts

@@ -1,223 +0,0 @@
-/**
- * AgentDB Browser Advanced Features
- *
- * Unified export for all browser-compatible advanced features.
- *
- * Features:
- * - Product Quantization (PQ8/PQ16/PQ32) - 4-32x memory compression
- * - HNSW Indexing - 10-20x faster approximate search
- * - Graph Neural Networks - Graph attention and message passing
- * - MMR Diversity - Maximal marginal relevance ranking
- * - Tensor Compression - SVD dimension reduction
- * - Batch Operations - Optimized vector processing
- *
- * Bundle Size: ~35 KB minified (~12 KB gzipped)
- */
-export { ProductQuantization, createPQ8, createPQ16, createPQ32, type PQConfig, type PQCodebook, type CompressedVector } from './ProductQuantization';
-export { HNSWIndex, createHNSW, createFastHNSW, createAccurateHNSW, type HNSWConfig, type HNSWNode, type SearchResult } from './HNSWIndex';
-export { GraphNeuralNetwork, MaximalMarginalRelevance, TensorCompression, BatchProcessor, type GNNNode, type GNNEdge, type GNNConfig, type MMRConfig } from './AdvancedFeatures';
-/**
- * Detect available browser features
- */
-export declare function detectFeatures(): {
-    indexedDB: boolean;
-    broadcastChannel: boolean;
-    webWorkers: boolean;
-    wasmSIMD: Promise<boolean>;
-    sharedArrayBuffer: boolean;
-};
-/**
- * Recommended configuration for small datasets (<1K vectors)
- */
-export declare const SMALL_DATASET_CONFIG: {
-    pq: {
-        enabled: boolean;
-    };
-    hnsw: {
-        enabled: boolean;
-    };
-    gnn: {
-        enabled: boolean;
-        numHeads: number;
-    };
-    mmr: {
-        enabled: boolean;
-        lambda: number;
-    };
-    svd: {
-        enabled: boolean;
-    };
-};
-/**
- * Recommended configuration for medium datasets (1K-10K vectors)
- */
-export declare const MEDIUM_DATASET_CONFIG: {
-    pq: {
-        enabled: boolean;
-        subvectors: number;
-    };
-    hnsw: {
-        enabled: boolean;
-        M: number;
-    };
-    gnn: {
-        enabled: boolean;
-        numHeads: number;
-    };
-    mmr: {
-        enabled: boolean;
-        lambda: number;
-    };
-    svd: {
-        enabled: boolean;
-    };
-};
-/**
- * Recommended configuration for large datasets (10K-100K vectors)
- */
-export declare const LARGE_DATASET_CONFIG: {
-    pq: {
-        enabled: boolean;
-        subvectors: number;
-    };
-    hnsw: {
-        enabled: boolean;
-        M: number;
-    };
-    gnn: {
-        enabled: boolean;
-        numHeads: number;
-    };
-    mmr: {
-        enabled: boolean;
-        lambda: number;
-    };
-    svd: {
-        enabled: boolean;
-        targetDim: number;
-    };
-};
-/**
- * Memory-optimized configuration (minimal memory usage)
- */
-export declare const MEMORY_OPTIMIZED_CONFIG: {
-    pq: {
-        enabled: boolean;
-        subvectors: number;
-    };
-    hnsw: {
-        enabled: boolean;
-        M: number;
-    };
-    gnn: {
-        enabled: boolean;
-    };
-    mmr: {
-        enabled: boolean;
-    };
-    svd: {
-        enabled: boolean;
-        targetDim: number;
-    };
-};
-/**
- * Speed-optimized configuration (fastest search)
- */
-export declare const SPEED_OPTIMIZED_CONFIG: {
-    pq: {
-        enabled: boolean;
-    };
-    hnsw: {
-        enabled: boolean;
-        M: number;
-        efSearch: number;
-    };
-    gnn: {
-        enabled: boolean;
-    };
-    mmr: {
-        enabled: boolean;
-    };
-    svd: {
-        enabled: boolean;
-    };
-};
-/**
- * Quality-optimized configuration (best result quality)
- */
-export declare const QUALITY_OPTIMIZED_CONFIG: {
-    pq: {
-        enabled: boolean;
-    };
-    hnsw: {
-        enabled: boolean;
-        M: number;
-        efConstruction: number;
-    };
-    gnn: {
-        enabled: boolean;
-        numHeads: number;
-    };
-    mmr: {
-        enabled: boolean;
-        lambda: number;
-    };
-    svd: {
-        enabled: boolean;
-    };
-};
-export declare const VERSION: {
-    major: number;
-    minor: number;
-    patch: number;
-    prerelease: string;
-    features: string;
-    full: string;
-};
-/**
- * Estimate memory usage for configuration
- */
-export declare function estimateMemoryUsage(numVectors: number, dimension: number, config: any): {
-    vectors: number;
-    index: number;
-    total: number;
-    totalMB: number;
-};
-/**
- * Recommend configuration based on dataset size
- */
-export declare function recommendConfig(numVectors: number, dimension: number): {
-    name: string;
-    config: {
-        pq: {
-            enabled: boolean;
-        };
-        hnsw: {
-            enabled: boolean;
-        };
-        gnn: {
-            enabled: boolean;
-            numHeads: number;
-        };
-        mmr: {
-            enabled: boolean;
-            lambda: number;
-        };
-        svd: {
-            enabled: boolean;
-        };
-    };
-    reason: string;
-};
-/**
- * Benchmark search performance
- */
-export declare function benchmarkSearch(searchFn: (query: Float32Array, k: number) => any[], numQueries?: number, k?: number, dimension?: number): Promise<{
-    avgTimeMs: number;
-    minTimeMs: number;
-    maxTimeMs: number;
-    p50Ms: number;
-    p95Ms: number;
-    p99Ms: number;
-}>;
-//# sourceMappingURL=index.d.ts.map

package/dist/browser/browser/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,EACL,mBAAmB,EACnB,SAAS,EACT,UAAU,EACV,UAAU,EACV,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EACL,SAAS,EACT,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AAMrB,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,oBAAoB,CAAC;AAM5B;;GAEG;AACH,wBAAgB,cAAc;;;;;;EAQ7B;AA0BD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;CAMhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;CAMjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;CAMhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;CAMnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;CAMlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;CAMpC,CAAC;AAMF,eAAO,MAAM,OAAO;;;;;;;CAOnB,CAAC;AAMF;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,GACV;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CA+BA;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;EAoBpE;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,KAAK,GAAG,EAAE,EACnD,UAAU,GAAE,MAAY,EACxB,CAAC,GAAE,MAAW,EACd,SAAS,GAAE,MAAY,GACtB,OAAO,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,CA0BD"}