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

package/dist/browser/browser/HNSWIndex.js

@@ -1,402 +0,0 @@
-/**
- * HNSW (Hierarchical Navigable Small World) Index for Browser
- *
- * JavaScript implementation of HNSW algorithm for fast approximate nearest neighbor search.
- * Achieves O(log n) search complexity vs O(n) for linear scan.
- *
- * Features:
- * - Multi-layer graph structure
- * - Probabilistic layer assignment
- * - Greedy search algorithm
- * - Dynamic insertion
- * - Configurable M (connections per node)
- * - Configurable efConstruction and efSearch
- *
- * Performance:
- * - 10-20x faster than linear scan (vs 150x for native HNSW)
- * - Memory: ~16 bytes per edge + vector storage
- * - Suitable for datasets up to 100K vectors in browser
- */
-class MinHeap {
-    constructor() {
-        this.items = [];
-    }
-    push(item, priority) {
-        this.items.push({ item, priority });
-        this.bubbleUp(this.items.length - 1);
-    }
-    pop() {
-        if (this.items.length === 0)
-            return undefined;
-        const result = this.items[0].item;
-        const last = this.items.pop();
-        if (this.items.length > 0) {
-            this.items[0] = last;
-            this.bubbleDown(0);
-        }
-        return result;
-    }
-    peek() {
-        var _a;
-        return (_a = this.items[0]) === null || _a === void 0 ? void 0 : _a.item;
-    }
-    size() {
-        return this.items.length;
-    }
-    bubbleUp(index) {
-        while (index > 0) {
-            const parentIndex = Math.floor((index - 1) / 2);
-            if (this.items[index].priority >= this.items[parentIndex].priority)
-                break;
-            [this.items[index], this.items[parentIndex]] = [this.items[parentIndex], this.items[index]];
-            index = parentIndex;
-        }
-    }
-    bubbleDown(index) {
-        while (true) {
-            const leftChild = 2 * index + 1;
-            const rightChild = 2 * index + 2;
-            let smallest = index;
-            if (leftChild < this.items.length && this.items[leftChild].priority < this.items[smallest].priority) {
-                smallest = leftChild;
-            }
-            if (rightChild < this.items.length && this.items[rightChild].priority < this.items[smallest].priority) {
-                smallest = rightChild;
-            }
-            if (smallest === index)
-                break;
-            [this.items[index], this.items[smallest]] = [this.items[smallest], this.items[index]];
-            index = smallest;
-        }
-    }
-}
-export class HNSWIndex {
-    constructor(config = {}) {
-        this.nodes = new Map();
-        this.entryPoint = null;
-        this.currentId = 0;
-        this.config = {
-            dimension: config.dimension || 384,
-            M: config.M || 16,
-            efConstruction: config.efConstruction || 200,
-            efSearch: config.efSearch || 50,
-            ml: config.ml || 1 / Math.log(2),
-            maxLayers: config.maxLayers || 16,
-            distanceFunction: config.distanceFunction || 'cosine'
-        };
-        this.ml = this.config.ml;
-    }
-    /**
-     * Add vector to index
-     */
-    add(vector, id) {
-        const nodeId = id !== undefined ? id : this.currentId++;
-        const level = this.randomLevel();
-        const node = {
-            id: nodeId,
-            vector,
-            level,
-            connections: new Map()
-        };
-        // Initialize connections for each layer
-        for (let l = 0; l <= level; l++) {
-            node.connections.set(l, []);
-        }
-        if (this.entryPoint === null) {
-            // First node
-            this.entryPoint = nodeId;
-            this.nodes.set(nodeId, node);
-            return nodeId;
-        }
-        // Find nearest neighbors at each layer
-        const ep = this.entryPoint;
-        let nearest = ep;
-        // Search from top layer to target layer + 1
-        for (let lc = this.nodes.get(ep).level; lc > level; lc--) {
-            nearest = this.searchLayer(vector, nearest, 1, lc)[0];
-        }
-        // Insert node at layers 0 to level
-        for (let lc = Math.min(level, this.nodes.get(ep).level); lc >= 0; lc--) {
-            const candidates = this.searchLayer(vector, nearest, this.config.efConstruction, lc);
-            // Select M neighbors
-            const M = lc === 0 ? this.config.M * 2 : this.config.M;
-            const neighbors = this.selectNeighbors(vector, candidates, M);
-            // Add bidirectional connections
-            for (const neighbor of neighbors) {
-                this.connect(nodeId, neighbor, lc);
-                this.connect(neighbor, nodeId, lc);
-                // Prune connections if necessary
-                const neighborNode = this.nodes.get(neighbor);
-                const neighborConnections = neighborNode.connections.get(lc);
-                if (neighborConnections.length > M) {
-                    const newNeighbors = this.selectNeighbors(neighborNode.vector, neighborConnections, M);
-                    neighborNode.connections.set(lc, newNeighbors);
-                }
-            }
-            nearest = candidates[0];
-        }
-        // Update entry point if necessary
-        if (level > this.nodes.get(this.entryPoint).level) {
-            this.entryPoint = nodeId;
-        }
-        this.nodes.set(nodeId, node);
-        return nodeId;
-    }
-    /**
-     * Search for k nearest neighbors
-     */
-    search(query, k, ef) {
-        if (this.entryPoint === null)
-            return [];
-        ef = ef || Math.max(this.config.efSearch, k);
-        let ep = this.entryPoint;
-        let nearest = ep;
-        // Search from top to layer 1
-        for (let lc = this.nodes.get(ep).level; lc > 0; lc--) {
-            nearest = this.searchLayer(query, nearest, 1, lc)[0];
-        }
-        // Search at layer 0
-        const candidates = this.searchLayer(query, nearest, ef, 0);
-        // Convert to SearchResult and return top k
-        return candidates
-            .slice(0, k)
-            .map(id => ({
-            id,
-            distance: this.distance(query, this.nodes.get(id).vector),
-            vector: this.nodes.get(id).vector
-        }));
-    }
-    /**
-     * Search at specific layer
-     */
-    searchLayer(query, ep, ef, layer) {
-        const visited = new Set();
-        const candidates = new MinHeap();
-        const w = new MinHeap();
-        const dist = this.distance(query, this.nodes.get(ep).vector);
-        candidates.push(ep, dist);
-        w.push(ep, -dist); // Max heap (negate for min heap)
-        visited.add(ep);
-        while (candidates.size() > 0) {
-            const c = candidates.pop();
-            const fDist = -w.peek(); // Furthest point distance
-            const cDist = this.distance(query, this.nodes.get(c).vector);
-            if (cDist > fDist)
-                break;
-            const neighbors = this.nodes.get(c).connections.get(layer) || [];
-            for (const e of neighbors) {
-                if (visited.has(e))
-                    continue;
-                visited.add(e);
-                const eDist = this.distance(query, this.nodes.get(e).vector);
-                const fDist = -w.peek();
-                if (eDist < fDist || w.size() < ef) {
-                    candidates.push(e, eDist);
-                    w.push(e, -eDist);
-                    if (w.size() > ef) {
-                        w.pop();
-                    }
-                }
-            }
-        }
-        // Return ef nearest neighbors
-        const result = [];
-        while (w.size() > 0) {
-            result.unshift(w.pop());
-        }
-        return result;
-    }
-    /**
-     * Select best neighbors using heuristic
-     */
-    selectNeighbors(base, candidates, M) {
-        if (candidates.length <= M)
-            return candidates;
-        // Sort by distance
-        const sorted = candidates
-            .map(id => ({
-            id,
-            distance: this.distance(base, this.nodes.get(id).vector)
-        }))
-            .sort((a, b) => a.distance - b.distance);
-        return sorted.slice(0, M).map(x => x.id);
-    }
-    /**
-     * Connect two nodes at layer
-     */
-    connect(from, to, layer) {
-        const node = this.nodes.get(from);
-        const connections = node.connections.get(layer);
-        if (!connections.includes(to)) {
-            connections.push(to);
-        }
-    }
-    /**
-     * Random level assignment
-     */
-    randomLevel() {
-        let level = 0;
-        while (Math.random() < this.ml && level < this.config.maxLayers - 1) {
-            level++;
-        }
-        return level;
-    }
-    /**
-     * Distance function
-     */
-    distance(a, b) {
-        switch (this.config.distanceFunction) {
-            case 'cosine':
-                return 1 - this.cosineSimilarity(a, b);
-            case 'euclidean':
-                return this.euclideanDistance(a, b);
-            case 'manhattan':
-                return this.manhattanDistance(a, b);
-            default:
-                return 1 - this.cosineSimilarity(a, b);
-        }
-    }
-    cosineSimilarity(a, b) {
-        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];
-        }
-        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-    }
-    euclideanDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            const diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return Math.sqrt(sum);
-    }
-    manhattanDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            sum += Math.abs(a[i] - b[i]);
-        }
-        return sum;
-    }
-    /**
-     * Get index statistics
-     */
-    getStats() {
-        if (this.nodes.size === 0) {
-            return {
-                numNodes: 0,
-                numLayers: 0,
-                avgConnections: 0,
-                entryPointLevel: 0,
-                memoryBytes: 0
-            };
-        }
-        const maxLevel = Math.max(...Array.from(this.nodes.values()).map(n => n.level));
-        let totalConnections = 0;
-        for (const node of this.nodes.values()) {
-            for (const connections of node.connections.values()) {
-                totalConnections += connections.length;
-            }
-        }
-        const avgConnections = totalConnections / this.nodes.size;
-        // Estimate memory: vector + connections + metadata
-        const vectorBytes = this.config.dimension * 4; // Float32Array
-        const connectionBytes = avgConnections * 4; // number array
-        const metadataBytes = 100; // rough estimate for node object
-        const memoryBytes = this.nodes.size * (vectorBytes + connectionBytes + metadataBytes);
-        return {
-            numNodes: this.nodes.size,
-            numLayers: maxLevel + 1,
-            avgConnections,
-            entryPointLevel: this.entryPoint ? this.nodes.get(this.entryPoint).level : 0,
-            memoryBytes
-        };
-    }
-    /**
-     * Export index for persistence
-     */
-    export() {
-        const data = {
-            config: this.config,
-            entryPoint: this.entryPoint,
-            currentId: this.currentId,
-            nodes: Array.from(this.nodes.entries()).map(([id, node]) => ({
-                id,
-                vector: Array.from(node.vector),
-                level: node.level,
-                connections: Array.from(node.connections.entries())
-            }))
-        };
-        return JSON.stringify(data);
-    }
-    /**
-     * Import index from JSON
-     */
-    import(json) {
-        const data = JSON.parse(json);
-        this.config = data.config;
-        this.entryPoint = data.entryPoint;
-        this.currentId = data.currentId;
-        this.nodes.clear();
-        for (const nodeData of data.nodes) {
-            const node = {
-                id: nodeData.id,
-                vector: new Float32Array(nodeData.vector),
-                level: nodeData.level,
-                connections: new Map(nodeData.connections)
-            };
-            this.nodes.set(nodeData.id, node);
-        }
-    }
-    /**
-     * Clear index
-     */
-    clear() {
-        this.nodes.clear();
-        this.entryPoint = null;
-        this.currentId = 0;
-    }
-    /**
-     * Get number of nodes
-     */
-    size() {
-        return this.nodes.size;
-    }
-}
-/**
- * Helper function to create HNSW index with default settings
- */
-export function createHNSW(dimension) {
-    return new HNSWIndex({
-        dimension,
-        M: 16,
-        efConstruction: 200,
-        efSearch: 50
-    });
-}
-/**
- * Helper function to create fast HNSW (lower quality, faster build)
- */
-export function createFastHNSW(dimension) {
-    return new HNSWIndex({
-        dimension,
-        M: 8,
-        efConstruction: 100,
-        efSearch: 30
-    });
-}
-/**
- * Helper function to create accurate HNSW (higher quality, slower build)
- */
-export function createAccurateHNSW(dimension) {
-    return new HNSWIndex({
-        dimension,
-        M: 32,
-        efConstruction: 400,
-        efSearch: 100
-    });
-}

package/dist/browser/browser/ProductQuantization.d.ts

@@ -1,107 +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
- */
-export interface PQConfig {
-    dimension: number;
-    numSubvectors: number;
-    numCentroids: number;
-    maxIterations?: number;
-    convergenceThreshold?: number;
-}
-export interface PQCodebook {
-    subvectorDim: number;
-    numSubvectors: number;
-    numCentroids: number;
-    centroids: Float32Array[];
-}
-export interface CompressedVector {
-    codes: Uint8Array;
-    norm: number;
-}
-export declare class ProductQuantization {
-    private config;
-    private codebook;
-    private trained;
-    constructor(config: PQConfig);
-    /**
-     * Train codebook using k-means on training vectors
-     */
-    train(vectors: Float32Array[]): Promise<void>;
-    /**
-     * K-means clustering for centroids
-     */
-    private kMeans;
-    /**
-     * K-means++ initialization for better centroid selection
-     */
-    private kMeansPlusPlus;
-    /**
-     * Compress a vector using trained codebook
-     */
-    compress(vector: Float32Array): CompressedVector;
-    /**
-     * Decompress a vector (approximate reconstruction)
-     */
-    decompress(compressed: CompressedVector): Float32Array;
-    /**
-     * Asymmetric Distance Computation (ADC)
-     * Computes distance from query vector to compressed vector
-     */
-    asymmetricDistance(query: Float32Array, compressed: CompressedVector): number;
-    /**
-     * Batch compression for multiple vectors
-     */
-    batchCompress(vectors: Float32Array[]): CompressedVector[];
-    /**
-     * Get memory savings
-     */
-    getCompressionRatio(): number;
-    /**
-     * Export codebook for persistence
-     */
-    exportCodebook(): string;
-    /**
-     * Import codebook
-     */
-    importCodebook(json: string): void;
-    /**
-     * Utility: Squared Euclidean distance
-     */
-    private squaredDistance;
-    /**
-     * Get statistics
-     */
-    getStats(): {
-        trained: boolean;
-        compressionRatio: number;
-        memoryPerVector: number;
-        codebookSize: number;
-    };
-}
-/**
- * Helper function to create PQ8 (8 subvectors, 4x compression)
- */
-export declare function createPQ8(dimension: number): ProductQuantization;
-/**
- * Helper function to create PQ16 (16 subvectors, 8x compression)
- */
-export declare function createPQ16(dimension: number): ProductQuantization;
-/**
- * Helper function to create PQ32 (32 subvectors, 16x compression)
- */
-export declare function createPQ32(dimension: number): ProductQuantization;
-//# sourceMappingURL=ProductQuantization.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ProductQuantization.d.ts","sourceRoot":"","sources":["../../../src/browser/ProductQuantization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,YAAY,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE,QAAQ;IAe5B;;OAEG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCnD;;OAEG;YACW,MAAM;IA0DpB;;OAEG;IACH,OAAO,CAAC,cAAc;IAuCtB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB;IAwChD;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,gBAAgB,GAAG,YAAY;IAsBtD;;;OAGG;IACH,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,gBAAgB,GAAG,MAAM;IAsB7E;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,gBAAgB,EAAE;IAI1D;;OAEG;IACH,mBAAmB,IAAI,MAAM;IAQ7B;;OAEG;IACH,cAAc,IAAI,MAAM;IAgBxB;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAYlC;;OAEG;IACH,OAAO,CAAC,eAAe;IASvB;;OAEG;IACH,QAAQ,IAAI;QACV,OAAO,EAAE,OAAO,CAAC;QACjB,gBAAgB,EAAE,MAAM,CAAC;QACzB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;KACtB;CAcF;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,CAOhE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,CAOjE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,CAOjE"}