cozo-memory 1.0.0

package/dist/benchmark.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const perf_hooks_1 = require("perf_hooks");
+const BENCHMARK_DB_PATH = path_1.default.join(process.cwd(), "benchmark_db");
+async function runBenchmark() {
+    console.log("🚀 Starting Performance Benchmark...");
+    // Cleanup
+    if (fs_1.default.existsSync(BENCHMARK_DB_PATH + ".db")) {
+        fs_1.default.unlinkSync(BENCHMARK_DB_PATH + ".db");
+    }
+    // Measure Memory Baseline
+    const memStart = process.memoryUsage();
+    // Initialize Server
+    console.log("• Initializing Server & Loading Embedding Model...");
+    const initStart = perf_hooks_1.performance.now();
+    const server = new index_1.MemoryServer(BENCHMARK_DB_PATH);
+    // Force embedding model load
+    await server.embeddingService.embed("warmup");
+    const initEnd = perf_hooks_1.performance.now();
+    console.log(`  -> Init Time: ${(initEnd - initStart).toFixed(2)}ms`);
+    const memAfterInit = process.memoryUsage();
+    console.log(`  -> Memory Increase (Init): ${((memAfterInit.rss - memStart.rss) / 1024 / 1024).toFixed(2)} MB RSS`);
+    // Data Generation
+    const NUM_ENTITIES = 50;
+    const NUM_OBSERVATIONS = 200;
+    const NUM_RELATIONS = 100;
+    console.log(`\n• Generating Data (${NUM_ENTITIES} Entities, ${NUM_OBSERVATIONS} Observations, ${NUM_RELATIONS} Relations)...`);
+    const dataStart = perf_hooks_1.performance.now();
+    // Entities
+    const entities = [];
+    for (let i = 0; i < NUM_ENTITIES; i++) {
+        entities.push(await server.createEntity({
+            name: `Entity_${i}`,
+            type: i % 2 === 0 ? "Person" : "Project",
+            metadata: { index: i }
+        }));
+    }
+    // Observations
+    for (let i = 0; i < NUM_OBSERVATIONS; i++) {
+        const entity = entities[i % NUM_ENTITIES];
+        // @ts-ignore
+        await server.addObservation({
+            // @ts-ignore
+            entity_id: entity.id,
+            text: `This is observation number ${i} for entity ${ // @ts-ignore
+            entity.name}. It contains some random keywords like apple, banana, and cherry.`
+        });
+    }
+    // Relations
+    for (let i = 0; i < NUM_RELATIONS; i++) {
+        const from = entities[i % NUM_ENTITIES];
+        const to = entities[(i + 1) % NUM_ENTITIES];
+        // @ts-ignore
+        await server.createRelation({
+            // @ts-ignore
+            from_id: from.id,
+            // @ts-ignore
+            to_id: to.id,
+            relation_type: "related_to",
+            strength: 0.5
+        });
+    }
+    const dataEnd = perf_hooks_1.performance.now();
+    console.log(`  -> Data Ingestion Time: ${(dataEnd - dataStart).toFixed(2)}ms`);
+    console.log(`  -> Avg Time per Operation: ${((dataEnd - dataStart) / (NUM_ENTITIES + NUM_OBSERVATIONS + NUM_RELATIONS)).toFixed(2)}ms`);
+    const memAfterData = process.memoryUsage();
+    console.log(`  -> Memory Increase (Data): ${((memAfterData.rss - memAfterInit.rss) / 1024 / 1024).toFixed(2)} MB RSS`);
+    // Query Benchmark
+    console.log("\n• Running Queries (Hybrid Search)...");
+    const queries = [
+        "observation number 10",
+        "apple banana",
+        "Entity_0",
+        "Project related"
+    ];
+    const times = [];
+    for (const q of queries) {
+        const t0 = perf_hooks_1.performance.now();
+        await server.hybridSearch.search({
+            query: q,
+            limit: 10,
+            includeEntities: true,
+            includeObservations: true
+        });
+        const t1 = perf_hooks_1.performance.now();
+        times.push(t1 - t0);
+        process.stdout.write(".");
+    }
+    console.log("");
+    const avgQueryTime = times.reduce((a, b) => a + b, 0) / times.length;
+    const minQueryTime = Math.min(...times);
+    const maxQueryTime = Math.max(...times);
+    console.log(`  -> Avg Query Time: ${avgQueryTime.toFixed(2)}ms`);
+    console.log(`  -> Min Query Time: ${minQueryTime.toFixed(2)}ms`);
+    console.log(`  -> Max Query Time: ${maxQueryTime.toFixed(2)}ms`);
+    // RRF Overhead Estimation (Approximation)
+    // We perform a raw vector search (fastest component) and compare with hybrid search
+    // This is a rough proxy because hybrid search does 5 parallel searches + RRF
+    console.log("\n• Estimating RRF/Combination Overhead...");
+    const tVecStart = perf_hooks_1.performance.now();
+    // Access private method via any cast or just simulate a similar query
+    // Since we can't easily access private methods, we will rely on the fact that
+    // Hybrid Search = Promise.all([Vector, Keyword, Graph]) + RRF
+    // We'll run a search with ONLY vector enabled (by setting weights of others to 0? No, they still run)
+    // We will try to run a pure DB query to simulate vector search time
+    const vectorOnlyStart = perf_hooks_1.performance.now();
+    const qEmb = await server.embeddingService.embed("apple");
+    await server.db.run(`
+    ?[id, score] := ~entity:semantic { id | query: vec($qEmb), k: 10, ef: 20 }, score = 1.0
+  `, { qEmb });
+    const vectorOnlyEnd = perf_hooks_1.performance.now();
+    const vectorTime = vectorOnlyEnd - vectorOnlyStart;
+    console.log(`  -> Raw Vector Search Time: ${vectorTime.toFixed(2)}ms`);
+    console.log(`  -> Overhead (Hybrid Logic + RRF): ${(avgQueryTime - vectorTime).toFixed(2)}ms`);
+    // Graph Benchmark
+    console.log("\n• Running Graph Benchmarks (Graph-RAG & Graph-Walking)...");
+    // Graph-RAG
+    const ragStart = perf_hooks_1.performance.now();
+    // @ts-ignore
+    await server.hybridSearch.graphRag({
+        query: "Entity_0",
+        limit: 20,
+        graphConstraints: {
+            maxDepth: 2
+        }
+    });
+    const ragEnd = perf_hooks_1.performance.now();
+    console.log(`  -> Graph-RAG (2-Hop) Time: ${(ragEnd - ragStart).toFixed(2)}ms`);
+    // Graph-Walking
+    const walkStart = perf_hooks_1.performance.now();
+    // @ts-ignore
+    const startEntityId = entities[0].id;
+    // @ts-ignore
+    await server.graph_walking({
+        query: "related concepts",
+        start_entity_id: startEntityId,
+        max_depth: 3,
+        limit: 10
+    });
+    const walkEnd = perf_hooks_1.performance.now();
+    console.log(`  -> Graph-Walking (Recursive) Time: ${(walkEnd - walkStart).toFixed(2)}ms`);
+    // Final Memory
+    const memFinal = process.memoryUsage();
+    console.log("\n• Final Memory Stats:");
+    console.log(`  -> RSS: ${(memFinal.rss / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`  -> Heap Used: ${(memFinal.heapUsed / 1024 / 1024).toFixed(2)} MB`);
+    // Cleanup
+    // @ts-ignore
+    server.db.close();
+    if (fs_1.default.existsSync(BENCHMARK_DB_PATH + ".db")) {
+        fs_1.default.unlinkSync(BENCHMARK_DB_PATH + ".db");
+    }
+}
+runBenchmark().catch(console.error);

package/dist/clear-cache.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const path_1 = __importDefault(require("path"));
+async function main() {
+    const dbPath = path_1.default.resolve(__dirname, "..", "memory_db.cozo.db");
+    console.log("DB Path:", dbPath);
+    try {
+        const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+        const keys = await db.run("?[hash] := *search_cache{query_hash: hash}");
+        console.log(`Found ${keys.rows.length} cache entries.`);
+        if (keys.rows.length > 0) {
+            await db.run("?[hash] <- $hashes :delete search_cache {query_hash: hash}", {
+                hashes: keys.rows
+            });
+            console.log("Cache cleared.");
+        }
+        else {
+            console.log("Cache is already empty.");
+        }
+    }
+    catch (e) {
+        console.error("Error:", e.message);
+    }
+}
+main();

package/dist/db-service.js

@@ -0,0 +1,228 @@
+"use strict";
+// Simple in-memory database simulation for CozoDB
+// This will be replaced with actual CozoDB integration
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = void 0;
+class DatabaseService {
+    entities = new Map();
+    observations = new Map();
+    relationships = new Map();
+    snapshots = new Map();
+    dbPath;
+    engine;
+    constructor(dbPath = 'memory_db.cozo.db', engine = 'sqlite') {
+        this.dbPath = dbPath;
+        this.engine = engine;
+    }
+    async initialize() {
+        console.error('[DatabaseService] Connected to ' + this.engine + ' at ' + this.dbPath);
+        console.error('[DatabaseService] Database schema initialized');
+    }
+    async runQuery(query, params = {}) {
+        console.error('[DatabaseService] Query:', query);
+        return { rows: [] };
+    }
+    async exportRelations() {
+        const result = {
+            entity: [],
+            observation: [],
+            relationship: [],
+        };
+        for (const entity of this.entities.values()) {
+            result.entity.push([entity.id, entity.name, entity.type, entity.embedding, entity.name_embedding, entity.metadata, entity.created_at]);
+        }
+        for (const obs of this.observations.values()) {
+            result.observation.push([obs.id, obs.entity_id, obs.text, obs.embedding, obs.metadata, obs.created_at]);
+        }
+        for (const rels of this.relationships.values()) {
+            for (const rel of rels) {
+                result.relationship.push([rel.from_id, rel.to_id, rel.relation_type, rel.strength, rel.metadata, rel.created_at]);
+            }
+        }
+        return result;
+    }
+    async backup(path) {
+        console.error('[DatabaseService] Backup to:', path);
+    }
+    async restore(path) {
+        console.error('[DatabaseService] Restore from:', path);
+    }
+    async close() {
+        console.error('[DatabaseService] Database closed');
+    }
+    async createEntity(entity) {
+        const dbEntity = {
+            id: entity.id,
+            name: entity.name,
+            type: entity.type,
+            embedding: entity.embedding,
+            name_embedding: entity.name_embedding,
+            metadata: entity.metadata,
+            created_at: entity.created_at,
+        };
+        this.entities.set(entity.id, dbEntity);
+    }
+    async getEntity(id, asOf) {
+        const entity = this.entities.get(id);
+        if (!entity)
+            return null;
+        return {
+            id: entity.id,
+            name: entity.name,
+            type: entity.type,
+            embedding: entity.embedding,
+            name_embedding: entity.name_embedding,
+            metadata: entity.metadata,
+            created_at: entity.created_at,
+        };
+    }
+    async updateEntity(id, updates) {
+        const entity = this.entities.get(id);
+        if (!entity)
+            return;
+        if (updates.name !== undefined)
+            entity.name = updates.name;
+        if (updates.type !== undefined)
+            entity.type = updates.type;
+        if (updates.metadata !== undefined)
+            entity.metadata = { ...entity.metadata, ...updates.metadata };
+        if (updates.embedding !== undefined)
+            entity.embedding = updates.embedding;
+        if (updates.name_embedding !== undefined)
+            entity.name_embedding = updates.name_embedding;
+    }
+    async deleteEntity(id) {
+        this.entities.delete(id);
+        for (const [obsId, obs] of this.observations.entries()) {
+            if (obs.entity_id === id) {
+                this.observations.delete(obsId);
+            }
+        }
+        this.relationships.delete(id);
+    }
+    async addObservation(obs) {
+        const dbObs = {
+            id: obs.id,
+            entity_id: obs.entity_id,
+            text: obs.text,
+            embedding: obs.embedding,
+            metadata: obs.metadata,
+            created_at: obs.created_at,
+        };
+        this.observations.set(obs.id, dbObs);
+    }
+    async getObservationsForEntity(entityId) {
+        const result = [];
+        for (const obs of this.observations.values()) {
+            if (obs.entity_id === entityId) {
+                result.push({
+                    id: obs.id,
+                    entity_id: obs.entity_id,
+                    text: obs.text,
+                    embedding: obs.embedding,
+                    metadata: obs.metadata,
+                    created_at: obs.created_at,
+                });
+            }
+        }
+        return result;
+    }
+    async createRelation(rel) {
+        const dbRel = {
+            from_id: rel.from_id,
+            to_id: rel.to_id,
+            relation_type: rel.relation_type,
+            strength: rel.strength,
+            metadata: rel.metadata,
+            created_at: rel.created_at,
+        };
+        const existing = this.relationships.get(rel.from_id) || [];
+        existing.push(dbRel);
+        this.relationships.set(rel.from_id, existing);
+    }
+    async getRelations(fromId, toId) {
+        const result = [];
+        for (const rels of this.relationships.values()) {
+            for (const rel of rels) {
+                if (fromId && rel.from_id !== fromId)
+                    continue;
+                if (toId && rel.to_id !== toId)
+                    continue;
+                result.push({
+                    from_id: rel.from_id,
+                    to_id: rel.to_id,
+                    relation_type: rel.relation_type,
+                    strength: rel.strength,
+                    metadata: rel.metadata,
+                    created_at: rel.created_at,
+                });
+            }
+        }
+        return result;
+    }
+    async vectorSearchEntity(embedding, limit = 10) {
+        const results = [];
+        for (const entity of this.entities.values()) {
+            const similarity = this.cosineSimilarity(embedding, entity.embedding);
+            results.push([entity.id, entity.name, entity.type, entity.metadata, similarity]);
+        }
+        results.sort((a, b) => b[4] - a[4]);
+        return results.slice(0, limit);
+    }
+    async vectorSearchObservation(embedding, limit = 10) {
+        const results = [];
+        for (const obs of this.observations.values()) {
+            const similarity = this.cosineSimilarity(embedding, obs.embedding);
+            results.push([obs.id, obs.entity_id, obs.text, obs.metadata, similarity]);
+        }
+        results.sort((a, b) => b[4] - a[4]);
+        return results.slice(0, limit);
+    }
+    async fullTextSearchEntity(searchText, limit = 10) {
+        const query = searchText.toLowerCase();
+        const results = [];
+        for (const entity of this.entities.values()) {
+            if (entity.name.toLowerCase().includes(query)) {
+                results.push([entity.id, entity.name, entity.type, entity.metadata, 1]);
+            }
+        }
+        return results.slice(0, limit);
+    }
+    async fullTextSearchObservation(searchText, limit = 10) {
+        const query = searchText.toLowerCase();
+        const results = [];
+        for (const obs of this.observations.values()) {
+            if (obs.text.toLowerCase().includes(query)) {
+                results.push([obs.id, obs.entity_id, obs.text, obs.metadata, 1]);
+            }
+        }
+        return results.slice(0, limit);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        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];
+        }
+        if (normA === 0 || normB === 0)
+            return 0;
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    async getStats() {
+        let relCount = 0;
+        for (const rels of this.relationships.values()) {
+            relCount += rels.length;
+        }
+        return {
+            entities: this.entities.size,
+            observations: this.observations.size,
+            relationships: relCount,
+        };
+    }
+}
+exports.DatabaseService = DatabaseService;

package/dist/download-model.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const transformers_1 = require("@xenova/transformers");
+const path = __importStar(require("path"));
+// Configure cache path
+const CACHE_DIR = path.resolve('./.cache');
+transformers_1.env.cacheDir = CACHE_DIR;
+const MODEL_ID = "Xenova/bge-m3";
+async function downloadModel() {
+    console.log(`Downloading FP32 model for ${MODEL_ID}...`);
+    // quantized: false forces FP32 model download
+    await transformers_1.AutoModel.from_pretrained(MODEL_ID, { quantized: false });
+    console.log("Download completed.");
+}
+downloadModel();