agentdb 1.6.0 → 2.0.0-alpha.1

package/dist/browser/browser/AdvancedFeatures.js

@@ -0,0 +1,427 @@
+/**
+ * Advanced Features for AgentDB Browser
+ *
+ * Includes:
+ * - GNN (Graph Neural Networks) - Graph attention and message passing
+ * - MMR (Maximal Marginal Relevance) - Diversity ranking
+ * - SVD (Singular Value Decomposition) - Tensor compression
+ * - Batch operations and utilities
+ */
+/**
+ * Graph Neural Network with attention mechanism
+ */
+export class GraphNeuralNetwork {
+    constructor(config = {}) {
+        this.nodes = new Map();
+        this.edges = [];
+        this.attentionWeights = new Map();
+        this.config = {
+            hiddenDim: config.hiddenDim || 64,
+            numHeads: config.numHeads || 4,
+            dropout: config.dropout || 0.1,
+            learningRate: config.learningRate || 0.01,
+            attentionType: config.attentionType || 'gat'
+        };
+    }
+    /**
+     * Add node to graph
+     */
+    addNode(id, features) {
+        this.nodes.set(id, {
+            id,
+            features,
+            neighbors: []
+        });
+    }
+    /**
+     * Add edge to graph
+     */
+    addEdge(from, to, weight = 1.0) {
+        this.edges.push({ from, to, weight });
+        // Update neighbor lists
+        const fromNode = this.nodes.get(from);
+        const toNode = this.nodes.get(to);
+        if (fromNode && !fromNode.neighbors.includes(to)) {
+            fromNode.neighbors.push(to);
+        }
+        if (toNode && !toNode.neighbors.includes(from)) {
+            toNode.neighbors.push(from);
+        }
+    }
+    /**
+     * Graph Attention Network (GAT) message passing
+     */
+    graphAttention(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            throw new Error(`Node ${nodeId} not found`);
+        const neighbors = node.neighbors;
+        if (neighbors.length === 0) {
+            return node.features;
+        }
+        // Multi-head attention
+        const headDim = Math.floor(this.config.hiddenDim / this.config.numHeads);
+        const aggregated = new Float32Array(this.config.hiddenDim);
+        for (let h = 0; h < this.config.numHeads; h++) {
+            let attentionSum = 0;
+            const headOutput = new Float32Array(headDim);
+            // Compute attention scores for each neighbor
+            for (const neighborId of neighbors) {
+                const neighbor = this.nodes.get(neighborId);
+                // Attention score: similarity between node and neighbor
+                const score = this.computeAttentionScore(node.features, neighbor.features, h);
+                attentionSum += score;
+                // Aggregate neighbor features weighted by attention
+                for (let i = 0; i < headDim && i < neighbor.features.length; i++) {
+                    headOutput[i] += score * neighbor.features[i];
+                }
+            }
+            // Normalize by attention sum
+            if (attentionSum > 0) {
+                for (let i = 0; i < headDim; i++) {
+                    headOutput[i] /= attentionSum;
+                }
+            }
+            // Concatenate head outputs
+            const offset = h * headDim;
+            for (let i = 0; i < headDim; i++) {
+                aggregated[offset + i] = headOutput[i];
+            }
+        }
+        // Apply non-linearity (LeakyReLU)
+        for (let i = 0; i < aggregated.length; i++) {
+            aggregated[i] = aggregated[i] > 0 ? aggregated[i] : 0.01 * aggregated[i];
+        }
+        return aggregated;
+    }
+    /**
+     * Compute attention score between two nodes
+     */
+    computeAttentionScore(features1, features2, head) {
+        // Simple dot-product attention
+        let score = 0;
+        const len = Math.min(features1.length, features2.length);
+        for (let i = 0; i < len; i++) {
+            score += features1[i] * features2[i];
+        }
+        // Apply softmax-like normalization
+        return Math.exp(score / Math.sqrt(len));
+    }
+    /**
+     * Message passing for all nodes
+     */
+    messagePass() {
+        const newFeatures = new Map();
+        for (const [nodeId] of this.nodes) {
+            newFeatures.set(nodeId, this.graphAttention(nodeId));
+        }
+        return newFeatures;
+    }
+    /**
+     * Update node features after message passing
+     */
+    update(newFeatures) {
+        for (const [nodeId, features] of newFeatures) {
+            const node = this.nodes.get(nodeId);
+            if (node) {
+                node.features = features;
+            }
+        }
+    }
+    /**
+     * Compute graph embeddings for query enhancement
+     */
+    computeGraphEmbedding(nodeId, hops = 2) {
+        const features = new Map();
+        features.set(nodeId, this.nodes.get(nodeId).features);
+        // Multi-hop message passing
+        for (let h = 0; h < hops; h++) {
+            const newFeatures = this.messagePass();
+            this.update(newFeatures);
+        }
+        return this.nodes.get(nodeId).features;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            numNodes: this.nodes.size,
+            numEdges: this.edges.length,
+            avgDegree: this.edges.length / Math.max(this.nodes.size, 1),
+            config: this.config
+        };
+    }
+}
+/**
+ * Maximal Marginal Relevance for diversity ranking
+ */
+export class MaximalMarginalRelevance {
+    constructor(config = {}) {
+        this.config = {
+            lambda: config.lambda || 0.7,
+            metric: config.metric || 'cosine'
+        };
+    }
+    /**
+     * Rerank results for diversity
+     * @param query Query vector
+     * @param candidates Candidate vectors with scores
+     * @param k Number of results to return
+     * @returns Reranked indices
+     */
+    rerank(query, candidates, k) {
+        if (candidates.length === 0)
+            return [];
+        const selected = [];
+        const remaining = new Set(candidates.map((_, i) => i));
+        // Select first result (highest relevance)
+        let bestIdx = 0;
+        let bestScore = -Infinity;
+        for (let i = 0; i < candidates.length; i++) {
+            if (candidates[i].score > bestScore) {
+                bestScore = candidates[i].score;
+                bestIdx = i;
+            }
+        }
+        selected.push(candidates[bestIdx].id);
+        remaining.delete(bestIdx);
+        // Iteratively select remaining results
+        while (selected.length < k && remaining.size > 0) {
+            let bestMMR = -Infinity;
+            let bestCandidate = -1;
+            for (const idx of remaining) {
+                const candidate = candidates[idx];
+                // Relevance to query
+                const relevance = this.similarity(query, candidate.vector);
+                // Maximum similarity to already selected
+                let maxSimilarity = -Infinity;
+                for (const selectedId of selected) {
+                    const selectedCandidate = candidates.find(c => c.id === selectedId);
+                    const sim = this.similarity(candidate.vector, selectedCandidate.vector);
+                    maxSimilarity = Math.max(maxSimilarity, sim);
+                }
+                // MMR score
+                const mmr = this.config.lambda * relevance -
+                    (1 - this.config.lambda) * maxSimilarity;
+                if (mmr > bestMMR) {
+                    bestMMR = mmr;
+                    bestCandidate = idx;
+                }
+            }
+            if (bestCandidate !== -1) {
+                selected.push(candidates[bestCandidate].id);
+                remaining.delete(bestCandidate);
+            }
+            else {
+                break;
+            }
+        }
+        return selected;
+    }
+    /**
+     * Similarity computation
+     */
+    similarity(a, b) {
+        if (this.config.metric === 'cosine') {
+            return this.cosineSimilarity(a, b);
+        }
+        else {
+            // Euclidean distance converted to similarity
+            const dist = this.euclideanDistance(a, b);
+            return 1 / (1 + dist);
+        }
+    }
+    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);
+    }
+    /**
+     * Set lambda (relevance vs diversity trade-off)
+     */
+    setLambda(lambda) {
+        this.config.lambda = Math.max(0, Math.min(1, lambda));
+    }
+}
+// ============================================================================
+// SVD (Singular Value Decomposition) for Tensor Compression
+// ============================================================================
+/**
+ * Simple SVD implementation for dimension reduction
+ */
+export class TensorCompression {
+    /**
+     * Reduce dimensionality using truncated SVD
+     * @param vectors Array of vectors to compress
+     * @param targetDim Target dimension
+     * @returns Compressed vectors
+     */
+    static compress(vectors, targetDim) {
+        if (vectors.length === 0)
+            return [];
+        const originalDim = vectors[0].length;
+        if (targetDim >= originalDim)
+            return vectors;
+        // Create matrix (vectors as rows)
+        const matrix = vectors.map(v => Array.from(v));
+        // Center the data (subtract mean)
+        const mean = this.computeMean(matrix);
+        const centered = matrix.map(row => row.map((val, i) => val - mean[i]));
+        // Compute covariance matrix
+        const cov = this.computeCovariance(centered);
+        // Compute top k eigenvectors using power iteration
+        const eigenvectors = this.powerIteration(cov, targetDim);
+        // Project vectors onto eigenvectors
+        const compressed = centered.map(row => {
+            const projected = new Float32Array(targetDim);
+            for (let i = 0; i < targetDim; i++) {
+                let sum = 0;
+                for (let j = 0; j < originalDim; j++) {
+                    sum += row[j] * eigenvectors[i][j];
+                }
+                projected[i] = sum;
+            }
+            return projected;
+        });
+        return compressed;
+    }
+    /**
+     * Compute mean vector
+     */
+    static computeMean(matrix) {
+        const n = matrix.length;
+        const dim = matrix[0].length;
+        const mean = new Array(dim).fill(0);
+        for (const row of matrix) {
+            for (let i = 0; i < dim; i++) {
+                mean[i] += row[i];
+            }
+        }
+        return mean.map(v => v / n);
+    }
+    /**
+     * Compute covariance matrix
+     */
+    static computeCovariance(matrix) {
+        const n = matrix.length;
+        const dim = matrix[0].length;
+        const cov = Array.from({ length: dim }, () => new Array(dim).fill(0));
+        for (let i = 0; i < dim; i++) {
+            for (let j = 0; j <= i; j++) {
+                let sum = 0;
+                for (const row of matrix) {
+                    sum += row[i] * row[j];
+                }
+                cov[i][j] = cov[j][i] = sum / n;
+            }
+        }
+        return cov;
+    }
+    /**
+     * Power iteration for computing top eigenvectors
+     */
+    static powerIteration(matrix, k, iterations = 100) {
+        const dim = matrix.length;
+        const eigenvectors = [];
+        for (let i = 0; i < k; i++) {
+            // Random initialization
+            let v = new Array(dim).fill(0).map(() => Math.random() - 0.5);
+            // Power iteration
+            for (let iter = 0; iter < iterations; iter++) {
+                // Multiply by matrix
+                const newV = new Array(dim).fill(0);
+                for (let r = 0; r < dim; r++) {
+                    for (let c = 0; c < dim; c++) {
+                        newV[r] += matrix[r][c] * v[c];
+                    }
+                }
+                // Orthogonalize against previous eigenvectors
+                for (const prev of eigenvectors) {
+                    let dot = 0;
+                    for (let j = 0; j < dim; j++) {
+                        dot += newV[j] * prev[j];
+                    }
+                    for (let j = 0; j < dim; j++) {
+                        newV[j] -= dot * prev[j];
+                    }
+                }
+                // Normalize
+                let norm = 0;
+                for (const val of newV) {
+                    norm += val * val;
+                }
+                norm = Math.sqrt(norm);
+                if (norm < 1e-10)
+                    break;
+                v = newV.map(val => val / norm);
+            }
+            eigenvectors.push(v);
+        }
+        return eigenvectors;
+    }
+}
+// ============================================================================
+// Batch Operations
+// ============================================================================
+/**
+ * Efficient batch processing utilities
+ */
+export class BatchProcessor {
+    /**
+     * Batch cosine similarity computation
+     */
+    static batchCosineSimilarity(query, vectors) {
+        const similarities = new Float32Array(vectors.length);
+        // Precompute query norm
+        let queryNorm = 0;
+        for (let i = 0; i < query.length; i++) {
+            queryNorm += query[i] * query[i];
+        }
+        queryNorm = Math.sqrt(queryNorm);
+        // Compute similarities
+        for (let v = 0; v < vectors.length; v++) {
+            const vector = vectors[v];
+            let dotProduct = 0;
+            let vectorNorm = 0;
+            for (let i = 0; i < query.length; i++) {
+                dotProduct += query[i] * vector[i];
+                vectorNorm += vector[i] * vector[i];
+            }
+            vectorNorm = Math.sqrt(vectorNorm);
+            similarities[v] = dotProduct / (queryNorm * vectorNorm);
+        }
+        return similarities;
+    }
+    /**
+     * Batch vector normalization
+     */
+    static batchNormalize(vectors) {
+        return vectors.map(v => {
+            let norm = 0;
+            for (let i = 0; i < v.length; i++) {
+                norm += v[i] * v[i];
+            }
+            norm = Math.sqrt(norm);
+            const normalized = new Float32Array(v.length);
+            for (let i = 0; i < v.length; i++) {
+                normalized[i] = v[i] / norm;
+            }
+            return normalized;
+        });
+    }
+}

package/dist/browser/browser/HNSWIndex.d.ts

@@ -0,0 +1,117 @@
+/**
+ * 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
+ */
+export interface HNSWConfig {
+    dimension: number;
+    M: number;
+    efConstruction: number;
+    efSearch: number;
+    ml: number;
+    maxLayers: number;
+    distanceFunction?: 'cosine' | 'euclidean' | 'manhattan';
+}
+export interface HNSWNode {
+    id: number;
+    vector: Float32Array;
+    level: number;
+    connections: Map<number, number[]>;
+}
+export interface SearchResult {
+    id: number;
+    distance: number;
+    vector: Float32Array;
+}
+export declare class HNSWIndex {
+    private config;
+    private nodes;
+    private entryPoint;
+    private currentId;
+    private ml;
+    constructor(config?: Partial<HNSWConfig>);
+    /**
+     * Add vector to index
+     */
+    add(vector: Float32Array, id?: number): number;
+    /**
+     * Search for k nearest neighbors
+     */
+    search(query: Float32Array, k: number, ef?: number): SearchResult[];
+    /**
+     * Search at specific layer
+     */
+    private searchLayer;
+    /**
+     * Select best neighbors using heuristic
+     */
+    private selectNeighbors;
+    /**
+     * Connect two nodes at layer
+     */
+    private connect;
+    /**
+     * Random level assignment
+     */
+    private randomLevel;
+    /**
+     * Distance function
+     */
+    private distance;
+    private cosineSimilarity;
+    private euclideanDistance;
+    private manhattanDistance;
+    /**
+     * Get index statistics
+     */
+    getStats(): {
+        numNodes: number;
+        numLayers: number;
+        avgConnections: number;
+        entryPointLevel: number;
+        memoryBytes: number;
+    };
+    /**
+     * Export index for persistence
+     */
+    export(): string;
+    /**
+     * Import index from JSON
+     */
+    import(json: string): void;
+    /**
+     * Clear index
+     */
+    clear(): void;
+    /**
+     * Get number of nodes
+     */
+    size(): number;
+}
+/**
+ * Helper function to create HNSW index with default settings
+ */
+export declare function createHNSW(dimension: number): HNSWIndex;
+/**
+ * Helper function to create fast HNSW (lower quality, faster build)
+ */
+export declare function createFastHNSW(dimension: number): HNSWIndex;
+/**
+ * Helper function to create accurate HNSW (higher quality, slower build)
+ */
+export declare function createAccurateHNSW(dimension: number): HNSWIndex;
+//# sourceMappingURL=HNSWIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HNSWIndex.d.ts","sourceRoot":"","sources":["../../../src/browser/HNSWIndex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC;CACzD;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;CACtB;AA0DD,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,EAAE,CAAS;gBAEP,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAc5C;;OAEG;IACH,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAsE9C;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE;IA0BnE;;OAEG;IACH,OAAO,CAAC,WAAW;IA4CnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAcvB;;OAEG;IACH,OAAO,CAAC,OAAO;IAQf;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAahB,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,iBAAiB;IAQzB;;OAEG;IACH,QAAQ,IAAI;QACV,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;QACxB,WAAW,EAAE,MAAM,CAAC;KACrB;IAqCD;;OAEG;IACH,MAAM,IAAI,MAAM;IAgBhB;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAmB1B;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,IAAI,IAAI,MAAM;CAGf;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAOvD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAO3D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAO/D"}