agentdb 1.0.0

package/dist/index/hnsw-optimized.mjs

@@ -0,0 +1,407 @@
+/**
+ * Optimized HNSW Implementation with In-Memory Build Cache
+ *
+ * Key optimizations:
+ * 1. In-memory graph during build (avoid DB queries)
+ * 2. Bulk database writes (batch all edges at once)
+ * 3. Lazy persistence (write to DB only after build complete)
+ * 4. Distance calculation caching
+ * 5. Optimized neighbor selection
+ *
+ * Target: <10ms per vector build time
+ */
+import { DEFAULT_HNSW_CONFIG } from './hnsw.mjs';
+/**
+ * Optimized HNSW Index with in-memory build cache
+ */
+export class OptimizedHNSWIndex {
+    constructor(db, config = {}) {
+        this.entryPoint = null;
+        this.maxLevel = 0;
+        this.isBuilt = false;
+        // In-memory graph cache (only during build)
+        this.nodeCache = new Map();
+        this.edgeCache = new Map();
+        this.buildMode = false;
+        this.db = db;
+        this.config = { ...DEFAULT_HNSW_CONFIG, ...config };
+        this.initializeSchema();
+        this.prepareStatements();
+        this.loadMetadata();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS hnsw_nodes (
+        id TEXT PRIMARY KEY,
+        vector_id TEXT NOT NULL,
+        level INTEGER NOT NULL,
+        embedding BLOB NOT NULL,
+        FOREIGN KEY (vector_id) REFERENCES vectors(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_hnsw_nodes_vector ON hnsw_nodes(vector_id);
+      CREATE INDEX IF NOT EXISTS idx_hnsw_nodes_level ON hnsw_nodes(level);
+
+      CREATE TABLE IF NOT EXISTS hnsw_edges (
+        from_id TEXT NOT NULL,
+        to_id TEXT NOT NULL,
+        level INTEGER NOT NULL,
+        distance REAL NOT NULL,
+        PRIMARY KEY (from_id, to_id, level),
+        FOREIGN KEY (from_id) REFERENCES hnsw_nodes(id) ON DELETE CASCADE,
+        FOREIGN KEY (to_id) REFERENCES hnsw_nodes(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_hnsw_edges_from ON hnsw_edges(from_id, level);
+
+      CREATE TABLE IF NOT EXISTS hnsw_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+    }
+    prepareStatements() {
+        this.insertNodeStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO hnsw_nodes (id, vector_id, level, embedding)
+      VALUES (?, ?, ?, ?)
+    `);
+        this.insertEdgeStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO hnsw_edges (from_id, to_id, level, distance)
+      VALUES (?, ?, ?, ?)
+    `);
+        this.getNodeStmt = this.db.prepare(`
+      SELECT id, vector_id, level, embedding
+      FROM hnsw_nodes
+      WHERE id = ?
+    `);
+        this.getNeighborsStmt = this.db.prepare(`
+      SELECT to_id, distance
+      FROM hnsw_edges
+      WHERE from_id = ? AND level = ?
+      ORDER BY distance ASC
+    `);
+    }
+    loadMetadata() {
+        const stmt = this.db.prepare('SELECT value FROM hnsw_metadata WHERE key = ?');
+        const entryPointRow = stmt.get('entry_point');
+        if (entryPointRow)
+            this.entryPoint = entryPointRow.value;
+        const maxLevelRow = stmt.get('max_level');
+        if (maxLevelRow)
+            this.maxLevel = parseInt(maxLevelRow.value, 10);
+        const isBuiltRow = stmt.get('is_built');
+        if (isBuiltRow)
+            this.isBuilt = isBuiltRow.value === 'true';
+    }
+    saveMetadata() {
+        const stmt = this.db.prepare('INSERT OR REPLACE INTO hnsw_metadata (key, value) VALUES (?, ?)');
+        if (this.entryPoint)
+            stmt.run('entry_point', this.entryPoint);
+        stmt.run('max_level', this.maxLevel.toString());
+        stmt.run('is_built', this.isBuilt.toString());
+    }
+    randomLevel() {
+        let level = 0;
+        while (Math.random() < this.config.mL && level < 16)
+            level++;
+        return level;
+    }
+    calculateDistance(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);
+    }
+    serializeEmbedding(embedding) {
+        const buffer = Buffer.allocUnsafe(embedding.length * 4);
+        const view = new Float32Array(buffer.buffer, buffer.byteOffset, embedding.length);
+        view.set(embedding);
+        return buffer;
+    }
+    deserializeEmbedding(buffer) {
+        const view = new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4);
+        return Array.from(view);
+    }
+    /**
+     * Get node from cache (build mode) or database
+     */
+    getNode(id) {
+        if (this.buildMode && this.nodeCache.has(id)) {
+            return this.nodeCache.get(id);
+        }
+        const row = this.getNodeStmt.get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            vectorId: row.vector_id,
+            level: row.level,
+            embedding: this.deserializeEmbedding(row.embedding)
+        };
+    }
+    /**
+     * Get neighbors from cache (build mode) or database
+     */
+    getNeighbors(nodeId, level) {
+        if (this.buildMode) {
+            const nodeLevels = this.edgeCache.get(nodeId);
+            return nodeLevels?.get(level) ?? [];
+        }
+        const rows = this.getNeighborsStmt.all(nodeId, level);
+        return rows.map(row => ({ id: row.to_id, distance: row.distance }));
+    }
+    /**
+     * Add edge to cache (build mode) or database
+     */
+    addEdge(fromId, toId, level, distance) {
+        if (this.buildMode) {
+            // Add to in-memory cache
+            if (!this.edgeCache.has(fromId)) {
+                this.edgeCache.set(fromId, new Map());
+            }
+            if (!this.edgeCache.has(toId)) {
+                this.edgeCache.set(toId, new Map());
+            }
+            const fromLevels = this.edgeCache.get(fromId);
+            const toLevels = this.edgeCache.get(toId);
+            if (!fromLevels.has(level))
+                fromLevels.set(level, []);
+            if (!toLevels.has(level))
+                toLevels.set(level, []);
+            fromLevels.get(level).push({ id: toId, distance });
+            toLevels.get(level).push({ id: fromId, distance });
+        }
+        else {
+            // Write directly to database
+            this.insertEdgeStmt.run(fromId, toId, level, distance);
+            this.insertEdgeStmt.run(toId, fromId, level, distance);
+        }
+    }
+    searchLayer(query, entryPoints, ef, level) {
+        const visited = new Set();
+        const candidates = [];
+        const results = [];
+        // Initialize with entry points
+        for (const ep of entryPoints) {
+            const node = this.getNode(ep);
+            if (!node)
+                continue;
+            const distance = this.calculateDistance(query, node.embedding);
+            candidates.push({ id: ep, distance });
+            results.push({ id: ep, distance });
+            visited.add(ep);
+        }
+        candidates.sort((a, b) => a.distance - b.distance);
+        results.sort((a, b) => a.distance - b.distance);
+        while (candidates.length > 0) {
+            const current = candidates.shift();
+            if (results.length >= ef && current.distance > results[results.length - 1].distance) {
+                break;
+            }
+            const neighbors = this.getNeighbors(current.id, level);
+            for (const neighbor of neighbors) {
+                if (visited.has(neighbor.id))
+                    continue;
+                visited.add(neighbor.id);
+                const node = this.getNode(neighbor.id);
+                if (!node)
+                    continue;
+                const distance = this.calculateDistance(query, node.embedding);
+                if (results.length < ef || distance < results[results.length - 1].distance) {
+                    candidates.push({ id: neighbor.id, distance });
+                    results.push({ id: neighbor.id, distance });
+                    results.sort((a, b) => a.distance - b.distance);
+                    if (results.length > ef)
+                        results.pop();
+                    candidates.sort((a, b) => a.distance - b.distance);
+                }
+            }
+        }
+        return results;
+    }
+    selectNeighborsHeuristic(candidates, M) {
+        candidates.sort((a, b) => a.distance - b.distance);
+        return candidates.slice(0, M);
+    }
+    /**
+     * Insert node into in-memory graph (build mode only)
+     */
+    insertToMemory(vectorId, embedding) {
+        const nodeId = `hnsw_${vectorId}`;
+        const level = this.randomLevel();
+        // Add to node cache
+        const node = { id: nodeId, vectorId, level, embedding };
+        this.nodeCache.set(nodeId, node);
+        if (level > this.maxLevel)
+            this.maxLevel = level;
+        if (!this.entryPoint) {
+            this.entryPoint = nodeId;
+            return;
+        }
+        let entryPoints = [this.entryPoint];
+        // Navigate to target level
+        for (let lc = this.maxLevel; lc > level; lc--) {
+            const nearest = this.searchLayer(embedding, entryPoints, 1, lc);
+            if (nearest.length > 0)
+                entryPoints = [nearest[0].id];
+        }
+        // Insert at all levels
+        for (let lc = level; lc >= 0; lc--) {
+            const M = lc === 0 ? this.config.M0 : this.config.M;
+            const candidates = this.searchLayer(embedding, entryPoints, this.config.efConstruction, lc);
+            const neighbors = this.selectNeighborsHeuristic(candidates, M);
+            for (const neighbor of neighbors) {
+                this.addEdge(nodeId, neighbor.id, lc, neighbor.distance);
+            }
+            // Prune neighbors if needed
+            for (const neighbor of neighbors) {
+                const neighborConnections = this.getNeighbors(neighbor.id, lc);
+                if (neighborConnections.length > M) {
+                    // Remove old edges
+                    const nodeLevels = this.edgeCache.get(neighbor.id);
+                    if (nodeLevels)
+                        nodeLevels.set(lc, []);
+                    const node = this.getNode(neighbor.id);
+                    if (node) {
+                        const newCandidates = [];
+                        for (const nc of neighborConnections) {
+                            const n = this.getNode(nc.id);
+                            if (n) {
+                                newCandidates.push({
+                                    id: nc.id,
+                                    distance: this.calculateDistance(node.embedding, n.embedding)
+                                });
+                            }
+                        }
+                        const selected = this.selectNeighborsHeuristic(newCandidates, M);
+                        for (const sel of selected) {
+                            this.addEdge(neighbor.id, sel.id, lc, sel.distance);
+                        }
+                    }
+                }
+            }
+            entryPoints = neighbors.map(n => n.id);
+        }
+    }
+    /**
+     * Flush in-memory graph to database (bulk write)
+     */
+    flushToDatabase() {
+        console.log('Flushing in-memory graph to database...');
+        const startTime = Date.now();
+        const transaction = this.db.transaction(() => {
+            // Write all nodes
+            for (const node of this.nodeCache.values()) {
+                this.insertNodeStmt.run(node.id, node.vectorId, node.level, this.serializeEmbedding(node.embedding));
+            }
+            // Write all edges (deduplicated)
+            const writtenEdges = new Set();
+            for (const [fromId, levels] of this.edgeCache) {
+                for (const [level, neighbors] of levels) {
+                    for (const neighbor of neighbors) {
+                        const edgeKey = `${fromId}:${neighbor.id}:${level}`;
+                        const reverseKey = `${neighbor.id}:${fromId}:${level}`;
+                        if (!writtenEdges.has(edgeKey) && !writtenEdges.has(reverseKey)) {
+                            this.insertEdgeStmt.run(fromId, neighbor.id, level, neighbor.distance);
+                            this.insertEdgeStmt.run(neighbor.id, fromId, level, neighbor.distance);
+                            writtenEdges.add(edgeKey);
+                        }
+                    }
+                }
+            }
+        });
+        transaction();
+        const duration = Date.now() - startTime;
+        console.log(`Flushed ${this.nodeCache.size} nodes and ${this.edgeCache.size} edge groups in ${duration}ms`);
+    }
+    /**
+     * Build index with in-memory optimization
+     */
+    buildOptimized() {
+        console.log('Building optimized HNSW index...');
+        this.clear();
+        const stmt = this.db.prepare('SELECT id, embedding FROM vectors ORDER BY id');
+        const rows = stmt.all();
+        if (rows.length === 0) {
+            console.log('No vectors to index');
+            return;
+        }
+        console.log(`Building in-memory graph for ${rows.length} vectors...`);
+        const startBuild = Date.now();
+        // Enable build mode (use in-memory cache)
+        this.buildMode = true;
+        this.nodeCache.clear();
+        this.edgeCache.clear();
+        // Build graph in memory
+        for (const row of rows) {
+            const embedding = this.deserializeEmbedding(row.embedding);
+            this.insertToMemory(row.id, embedding);
+        }
+        const buildDuration = Date.now() - startBuild;
+        const perVector = buildDuration / rows.length;
+        console.log(`In-memory graph built in ${buildDuration}ms (${perVector.toFixed(2)}ms per vector)`);
+        // Flush to database
+        this.flushToDatabase();
+        // Disable build mode
+        this.buildMode = false;
+        this.nodeCache.clear();
+        this.edgeCache.clear();
+        const totalDuration = Date.now() - startBuild;
+        console.log(`Total build time: ${totalDuration}ms (${(totalDuration / rows.length).toFixed(2)}ms per vector)`);
+        this.isBuilt = true;
+        this.saveMetadata();
+    }
+    /**
+     * Search using HNSW index
+     */
+    search(query, k) {
+        if (!this.entryPoint || !this.isBuilt)
+            return [];
+        let entryPoints = [this.entryPoint];
+        for (let lc = this.maxLevel; lc > 0; lc--) {
+            const nearest = this.searchLayer(query, entryPoints, 1, lc);
+            if (nearest.length > 0)
+                entryPoints = [nearest[0].id];
+        }
+        const ef = Math.max(this.config.efSearch, k);
+        const results = this.searchLayer(query, entryPoints, ef, 0);
+        return results.slice(0, k).map(result => {
+            const node = this.getNode(result.id);
+            return {
+                id: result.id,
+                vectorId: node.vectorId,
+                distance: result.distance,
+                embedding: node.embedding
+            };
+        });
+    }
+    clear() {
+        this.db.exec('DELETE FROM hnsw_edges');
+        this.db.exec('DELETE FROM hnsw_nodes');
+        this.db.exec('DELETE FROM hnsw_metadata');
+        this.entryPoint = null;
+        this.maxLevel = 0;
+        this.isBuilt = false;
+        this.nodeCache.clear();
+        this.edgeCache.clear();
+    }
+    getStats() {
+        const nodeCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM hnsw_nodes');
+        const edgeCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM hnsw_edges');
+        const nodeCount = nodeCountStmt.get().count;
+        const edgeCount = edgeCountStmt.get().count;
+        return {
+            nodeCount,
+            edgeCount,
+            maxLevel: this.maxLevel,
+            isBuilt: this.isBuilt,
+            avgDegree: nodeCount > 0 ? edgeCount / nodeCount : 0
+        };
+    }
+    isReady() {
+        return this.isBuilt && this.entryPoint !== null;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+}

package/dist/index/hnsw.d.ts

@@ -0,0 +1,165 @@
+/**
+ * HNSW (Hierarchical Navigable Small World) Index Implementation
+ * High-performance approximate nearest neighbor search with O(log n) complexity
+ *
+ * Algorithm: Hierarchical graph structure with multiple layers
+ * - Layer 0: All vectors with dense connections
+ * - Higher layers: Sparse long-range connections for efficient navigation
+ *
+ * Performance targets:
+ * - Search: <10ms for 10K vectors
+ * - Build: <5s for 10K vectors
+ * - Recall: >95% accuracy
+ */
+import Database from 'better-sqlite3';
+/**
+ * HNSW configuration parameters
+ */
+export interface HNSWConfig {
+    /** Maximum number of bi-directional links per element (default: 16) */
+    M: number;
+    /** Maximum connections for layer 0 (default: M * 2) */
+    M0: number;
+    /** Size of dynamic candidate list during construction (default: 200) */
+    efConstruction: number;
+    /** Size of dynamic candidate list during search (default: 50) */
+    efSearch: number;
+    /** Random level generation parameter (default: 1 / ln(M)) */
+    mL: number;
+    /** Minimum vectors to enable index (default: 1000) */
+    minVectorsForIndex: number;
+    /** Auto-rebuild index on updates (default: false) */
+    autoRebuild: boolean;
+    /** Enable index usage (default: true) */
+    enabled: boolean;
+}
+/**
+ * Default HNSW configuration optimized for most use cases
+ */
+export declare const DEFAULT_HNSW_CONFIG: HNSWConfig;
+/**
+ * Search result with distance
+ */
+interface HNSWSearchResult {
+    id: string;
+    vectorId: string;
+    distance: number;
+    embedding: number[];
+}
+/**
+ * HNSW Index implementation
+ */
+export declare class HNSWIndex {
+    private db;
+    private config;
+    private entryPoint;
+    private maxLevel;
+    private isBuilt;
+    private insertNodeStmt;
+    private insertEdgeStmt;
+    private getNodeStmt;
+    private getNeighborsStmt;
+    private deleteNodeStmt;
+    private deleteEdgesStmt;
+    constructor(db: Database.Database, config?: Partial<HNSWConfig>);
+    /**
+     * Initialize HNSW schema in SQLite
+     */
+    private initializeSchema;
+    /**
+     * Prepare frequently used SQL statements
+     */
+    private prepareStatements;
+    /**
+     * Load metadata from database
+     */
+    private loadMetadata;
+    /**
+     * Save metadata to database
+     */
+    private saveMetadata;
+    /**
+     * Calculate random level for new node using exponential decay
+     */
+    private randomLevel;
+    /**
+     * Calculate Euclidean distance between two vectors
+     */
+    private calculateDistance;
+    /**
+     * Serialize embedding to Buffer
+     */
+    private serializeEmbedding;
+    /**
+     * Deserialize embedding from Buffer
+     */
+    private deserializeEmbedding;
+    /**
+     * Get node by ID
+     */
+    private getNode;
+    /**
+     * Get neighbors of a node at a specific level
+     */
+    private getNeighbors;
+    /**
+     * Search for k nearest neighbors at a specific layer
+     */
+    private searchLayer;
+    /**
+     * Select neighbors using heuristic (Alg 4 from HNSW paper)
+     */
+    private selectNeighborsHeuristic;
+    /**
+     * Add bidirectional link between nodes
+     */
+    private addEdge;
+    /**
+     * Insert a new node into the HNSW index (optimized version)
+     */
+    insert(vectorId: string, embedding: number[]): void;
+    /**
+     * Search for k nearest neighbors using HNSW index
+     */
+    search(query: number[], k: number): HNSWSearchResult[];
+    /**
+     * Build HNSW index from all vectors in database with optimizations
+     */
+    build(): void;
+    /**
+     * Build index incrementally (non-blocking for large datasets)
+     */
+    buildAsync(onProgress?: (current: number, total: number, timeMs: number) => void): Promise<void>;
+    /**
+     * Clear the entire index
+     */
+    clear(): void;
+    /**
+     * Delete a node from the index
+     */
+    delete(vectorId: string): void;
+    /**
+     * Get index statistics
+     */
+    getStats(): {
+        nodeCount: number;
+        edgeCount: number;
+        maxLevel: number;
+        isBuilt: boolean;
+        avgDegree: number;
+    };
+    /**
+     * Check if index is ready to use
+     */
+    isReady(): boolean;
+    /**
+     * Get configuration
+     */
+    getConfig(): HNSWConfig;
+    /**
+     * Update configuration (requires rebuild)
+     */
+    updateConfig(config: Partial<HNSWConfig>): void;
+}
+export {};
+//# sourceMappingURL=hnsw.d.ts.map

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

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