cozo-memory 1.0.0

package/dist/api_bridge.js

@@ -0,0 +1,266 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const index_js_1 = require("./index.js");
+const uuid_1 = require("uuid");
+const app = (0, express_1.default)();
+const port = process.env.PORT || 3001;
+app.use((0, cors_1.default)());
+app.use(express_1.default.json());
+const memoryServer = new index_js_1.MemoryServer();
+// --- Entities ---
+app.get("/api/entities", async (req, res) => {
+    try {
+        const result = await memoryServer.db.run('?[id, name, type, metadata, ts] := *entity{id, name, type, metadata, created_at, @ "NOW"}, ts = to_int(created_at)');
+        res.json(result.rows.map((r) => ({
+            id: r[0],
+            name: r[1],
+            type: r[2],
+            metadata: r[3],
+            created_at: r[4]
+        })));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.post("/api/entities", async (req, res) => {
+    const { name, type, metadata } = req.body;
+    if (!name || !type)
+        return res.status(400).json({ error: "Name and type are required" });
+    try {
+        // We use the same logic as in create_entity tool
+        const id = (0, uuid_1.v4)();
+        const embedding = await memoryServer.embeddingService.embed(name + " " + type);
+        await memoryServer.db.run(`
+        ?[id, created_at, name, type, embedding, metadata] <- [
+          [$id, "ASSERT", $name, $type, [${embedding.join(",")}], $metadata]
+        ] :put entity {id, created_at => name, type, embedding, metadata}
+      `, { id, name, type, metadata: metadata || {} });
+        res.status(201).json({ id, name, type, metadata, status: "Entity created" });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get("/api/entities/:id", async (req, res) => {
+    const { id } = req.params;
+    try {
+        // Logic from get_entity_details
+        const entityRes = await memoryServer.db.run('?[id, name, type, metadata, ts] := *entity{id, name, type, metadata, created_at, @ "NOW"}, id = $id, ts = to_int(created_at)', { id });
+        if (entityRes.rows.length === 0)
+            return res.status(404).json({ error: "Entity not found" });
+        const obsRes = await memoryServer.db.run('?[id, text, metadata, ts] := *observation{id, entity_id, text, metadata, created_at, @ "NOW"}, entity_id = $id, ts = to_int(created_at)', { id });
+        const relRes = await memoryServer.db.run(`
+      ?[target_id, type, strength, metadata, direction] := *relationship{from_id, to_id, relation_type: type, strength, metadata, @ "NOW"}, from_id = $id, target_id = to_id, direction = 'outgoing'
+      ?[target_id, type, strength, metadata, direction] := *relationship{from_id, to_id, relation_type: type, strength, metadata, @ "NOW"}, to_id = $id, target_id = from_id, direction = 'incoming'
+    `, { id });
+        res.json({
+            entity: {
+                id: entityRes.rows[0][0],
+                name: entityRes.rows[0][1],
+                type: entityRes.rows[0][2],
+                metadata: entityRes.rows[0][3],
+                created_at: entityRes.rows[0][4]
+            },
+            observations: obsRes.rows.map((r) => ({ id: r[0], text: r[1], metadata: r[2], created_at: r[3] })),
+            relations: relRes.rows.map((r) => ({ target_id: r[0], type: r[1], strength: r[2], metadata: r[3], direction: r[4] }))
+        });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.delete("/api/entities/:id", async (req, res) => {
+    const { id } = req.params;
+    try {
+        // Fixed logic from delete_entity
+        await memoryServer.db.run(`
+      { ?[id, created_at] := *observation{id, entity_id, created_at}, entity_id = $target_id :rm observation {id, created_at} }
+      { ?[from_id, to_id, relation_type, created_at] := *relationship{from_id, to_id, relation_type, created_at}, from_id = $target_id :rm relationship {from_id, to_id, relation_type, created_at} }
+      { ?[from_id, to_id, relation_type, created_at] := *relationship{from_id, to_id, relation_type, created_at}, to_id = $target_id :rm relationship {from_id, to_id, relation_type, created_at} }
+      { ?[id, created_at] := *entity{id, created_at}, id = $target_id :rm entity {id, created_at} }
+    `, { target_id: id });
+        res.json({ status: "Entity and related data deleted" });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// --- Observations ---
+app.post("/api/observations", async (req, res) => {
+    const { entity_id, text, metadata } = req.body;
+    if (!entity_id || !text)
+        return res.status(400).json({ error: "Entity ID and text are required" });
+    try {
+        const id = (0, uuid_1.v4)();
+        const embedding = await memoryServer.embeddingService.embed(text);
+        await memoryServer.db.run(`
+        ?[id, created_at, entity_id, text, embedding, metadata] <- [
+          [$id, "ASSERT", $entity_id, $text, [${embedding.join(",")}], $metadata]
+        ] :put observation {id, created_at => entity_id, text, embedding, metadata}
+      `, { id, entity_id, text, metadata: metadata || {} });
+        res.status(201).json({ id, entity_id, text, metadata, status: "Observation added" });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// --- Search / Context ---
+app.get("/api/search", async (req, res) => {
+    const { query, limit = 10 } = req.query;
+    if (!query)
+        return res.status(400).json({ error: "Query is required" });
+    try {
+        const results = await memoryServer.hybridSearch.search({
+            query: query,
+            limit: Number(limit)
+        });
+        res.json(results);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get("/api/context", async (req, res) => {
+    const { query, context_window = 20 } = req.query;
+    if (!query)
+        return res.status(400).json({ error: "Query is required" });
+    try {
+        // Logic from get_context
+        const searchResults = await memoryServer.hybridSearch.search({
+            query: query,
+            limit: Number(context_window)
+        });
+        const entities = searchResults.filter(r => r.type === 'entity');
+        const observations = searchResults.filter(r => r.type === 'observation');
+        const graphContext = [];
+        for (const entity of entities) {
+            const connections = await memoryServer.db.run(`
+        ?[target_name, rel_type] := *relationship{from_id, to_id, relation_type: rel_type, @ "NOW"}, from_id = $id, *entity{id: to_id, name: target_name, @ "NOW"}
+        ?[target_name, rel_type] := *relationship{from_id, to_id, relation_type: rel_type, @ "NOW"}, to_id = $id, *entity{id: from_id, name: target_name, @ "NOW"}
+      `, { id: entity.id });
+            graphContext.push({ entity: entity.name, connections: connections.rows });
+        }
+        res.json({
+            search_results: searchResults,
+            graph_context: graphContext
+        });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get("/api/evolution/:id", async (req, res) => {
+    const { id } = req.params;
+    const { to_id, since, until } = req.query;
+    try {
+        const result = await memoryServer.getRelationEvolution({
+            from_id: id,
+            to_id: to_id,
+            since: since ? Number(since) : undefined,
+            until: until ? Number(until) : undefined
+        });
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// --- Health & Maintenance ---
+app.get("/api/health", async (req, res) => {
+    try {
+        const e = await memoryServer.db.run('?[count(id)] := *entity{id, @ "NOW"}');
+        const o = await memoryServer.db.run('?[count(id)] := *observation{id, @ "NOW"}');
+        const r = await memoryServer.db.run('?[count(f)] := *relationship{from_id: f, @ "NOW"}');
+        res.json({
+            entities: e.rows[0]?.[0] ?? 0,
+            observations: o.rows[0]?.[0] ?? 0,
+            relationships: r.rows[0]?.[0] ?? 0,
+            status: "healthy"
+        });
+    }
+    catch (error) {
+        console.error("Health endpoint error:", error);
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get("/api/communities", async (req, res) => {
+    try {
+        const query = `
+      edges[f, t, s] := *relationship{from_id: f, to_id: t, strength: s, @ "NOW"}
+      temp_communities[community_id, entity_id] <~ LabelPropagation(edges[f, t, s])
+      ?[entity_id, community_id] := temp_communities[community_id, entity_id]
+    `;
+        const result = await memoryServer.db.run(query);
+        const entitiesRes = await memoryServer.db.run('?[id, name, type] := *entity{id, name, type, @ "NOW"}');
+        const entityMap = new Map();
+        entitiesRes.rows.forEach((r) => entityMap.set(r[0], { name: r[1], type: r[2] }));
+        const communities = {};
+        result.rows.forEach((r) => {
+            const communityId = String(r[1]);
+            const entityId = r[0];
+            const info = entityMap.get(entityId) || { name: "Unknown", type: "Unknown" };
+            if (!communities[communityId])
+                communities[communityId] = [];
+            communities[communityId].push({ id: entityId, name: info.name, type: info.type });
+        });
+        res.json({ community_count: Object.keys(communities).length, communities });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// --- Snapshots ---
+app.get("/api/snapshots", async (req, res) => {
+    try {
+        const result = await memoryServer.db.run("?[id, e, o, r, meta, created_at] := *memory_snapshot{snapshot_id: id, entity_count: e, observation_count: o, relation_count: r, metadata: meta, created_at}");
+        res.json(result.rows.map((r) => ({
+            snapshot_id: r[0],
+            entity_count: r[1],
+            observation_count: r[2],
+            relation_count: r[3],
+            metadata: r[4],
+            created_at: r[5]
+        })));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.post("/api/snapshots", async (req, res) => {
+    const { metadata } = req.body;
+    try {
+        const [entityResult, obsResult, relResult] = await Promise.all([
+            memoryServer.db.run('?[id] := *entity{id, @ "NOW"}'),
+            memoryServer.db.run('?[id] := *observation{id, @ "NOW"}'),
+            memoryServer.db.run('?[from_id, to_id] := *relationship{from_id, to_id, @ "NOW"}')
+        ]);
+        const counts = {
+            entities: entityResult.rows.length,
+            observations: obsResult.rows.length,
+            relations: relResult.rows.length
+        };
+        const snapshot_id = (0, uuid_1.v4)();
+        const now = Date.now();
+        await memoryServer.db.run("?[snapshot_id, entity_count, observation_count, relation_count, metadata, created_at] <- [[$id, $e, $o, $r, $meta, $now]]:put memory_snapshot {snapshot_id => entity_count, observation_count, relation_count, metadata, created_at}", {
+            id: snapshot_id,
+            e: counts.entities,
+            o: counts.observations,
+            r: counts.relations,
+            meta: metadata || {},
+            now
+        });
+        res.status(201).json({ snapshot_id, ...counts, status: "Snapshot created" });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.listen(port, () => {
+    console.log(`API Bridge listening at http://localhost:${port}`);
+});

package/dist/benchmark-gpu-cpu.js

@@ -0,0 +1,188 @@
+"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 ort = require('onnxruntime-node');
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Configure cache path
+const CACHE_DIR = path.resolve('./.cache');
+transformers_1.env.cacheDir = CACHE_DIR;
+const MODEL_ID = "Xenova/bge-m3";
+const EMBEDDING_DIM = 1024;
+const QUANTIZED = false;
+const MODEL_FILE = QUANTIZED ? "model_quantized.onnx" : "model.onnx";
+const BATCH_SIZE = 10;
+const NUM_TEXTS = 200;
+const texts = Array.from({ length: NUM_TEXTS }, (_, i) => `This is a complex test sentence number ${i} for the performance comparison of CPU and GPU embeddings. The longer the text, the more apparent the advantage of parallel processing on the graphics card should be, especially with transformer models like BGE-M3. We are testing the DirectML integration on Windows with an RTX 2080 here.`);
+async function runBenchmark() {
+    console.log("==========================================");
+    console.log(`Starting Benchmark: CPU vs GPU (DirectML) [FP32 Mode]`);
+    console.log(`Batch Size: ${BATCH_SIZE}, Total Texts: ${NUM_TEXTS}`);
+    // 1. Prepare Model Path
+    const modelPath = path.join(CACHE_DIR, 'Xenova', 'bge-m3', 'onnx', MODEL_FILE);
+    if (!fs.existsSync(modelPath)) {
+        console.error(`Model not found at: ${modelPath}`);
+        return;
+    }
+    console.log(`Model path: ${modelPath}`);
+    // 2. Load Tokenizer
+    console.log("Loading Tokenizer...");
+    const tokenizer = await transformers_1.AutoTokenizer.from_pretrained(MODEL_ID);
+    // 3. Define Helper for Inference
+    async function runInference(session, label, useInt32 = false) {
+        console.log(`Starting ${label} inference (Int32 Inputs: ${useInt32})...`);
+        const start = performance.now();
+        for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+            const batchTexts = texts.slice(i, i + BATCH_SIZE);
+            const model_inputs = await tokenizer(batchTexts, { padding: true, truncation: true });
+            const feeds = {};
+            for (const [key, value] of Object.entries(model_inputs)) {
+                if (key === 'input_ids' || key === 'attention_mask' || key === 'token_type_ids') {
+                    // @ts-ignore
+                    let data = value.data || value.cpuData;
+                    // @ts-ignore
+                    const dims = value.dims; // [batch_size, seq_len]
+                    // Convert to Int32 if requested (for DirectML optimization)
+                    // Note: The model input MUST support int32 in ONNX, otherwise this will fail.
+                    // Most transformer models use int64 for input_ids. 
+                    // If we change type here, we rely on ORT to cast or the model to accept it.
+                    // DirectML often prefers Int32 for indices.
+                    let type = 'int64';
+                    if (useInt32) {
+                        data = Int32Array.from(data);
+                        type = 'int32';
+                    }
+                    else {
+                        // Ensure BigInt64Array
+                        if (!(data instanceof BigInt64Array)) {
+                            data = BigInt64Array.from(data);
+                        }
+                    }
+                    try {
+                        feeds[key] = new ort.Tensor(type, data, dims);
+                    }
+                    catch (err) {
+                        console.error(`Error creating tensor for ${key}:`, err.message);
+                        throw err;
+                    }
+                }
+            }
+            // Run Inference
+            await session.run(feeds);
+            process.stdout.write(".");
+        }
+        const end = performance.now();
+        const duration = (end - start) / 1000;
+        console.log(`\n${label} Time: ${duration.toFixed(2)}s`);
+        const speed = texts.length / duration;
+        console.log(`${label} Speed: ${speed.toFixed(2)} Embeddings/s`);
+        return speed;
+    }
+    // --- Phase 1: CPU Benchmark ---
+    console.log("\n--- Phase 1: CPU Benchmark ---");
+    let speedCpu = 0;
+    try {
+        const sessionCpu = await ort.InferenceSession.create(modelPath, {
+            executionProviders: ['cpu']
+        });
+        console.log("CPU Session created.");
+        // CPU usually handles Int64 fine
+        speedCpu = await runInference(sessionCpu, "CPU", false);
+    }
+    catch (e) {
+        console.error("CPU Benchmark failed:", e.message);
+    }
+    // --- Phase 2: GPU Benchmark ---
+    console.log("\n--- Phase 2: GPU (DirectML) Benchmark ---");
+    try {
+        const sessionOptions = {
+            executionProviders: ['dml', 'cpu'],
+            enableCpuMemArena: false // Sometimes helps with DML memory management
+        };
+        const startGpuLoad = performance.now();
+        const sessionGpu = await ort.InferenceSession.create(modelPath, sessionOptions);
+        const endGpuLoad = performance.now();
+        console.log(`GPU Session created in ${((endGpuLoad - startGpuLoad) / 1000).toFixed(2)}s`);
+        // Warmup
+        {
+            const text = ["Warmup"];
+            const model_inputs = await tokenizer(text, { padding: true, truncation: true });
+            const feeds = {};
+            for (const [key, value] of Object.entries(model_inputs)) {
+                if (key === 'input_ids' || key === 'attention_mask' || key === 'token_type_ids') {
+                    // @ts-ignore
+                    let data = value.data || value.cpuData;
+                    // @ts-ignore
+                    const dims = value.dims;
+                    if (!(data instanceof BigInt64Array))
+                        data = BigInt64Array.from(data);
+                    feeds[key] = new ort.Tensor('int64', data, dims);
+                }
+            }
+            await sessionGpu.run(feeds);
+        }
+        // Try with Int64 first (standard)
+        let speedGpu = await runInference(sessionGpu, "GPU (Int64)", false);
+        // Compare
+        if (speedCpu > 0) {
+            const speedup = speedGpu / speedCpu;
+            console.log("\n==========================================");
+            console.log(`Result: GPU is ${speedup.toFixed(2)}x faster than CPU.`);
+            console.log("==========================================");
+        }
+        // Optional: Try Int32 if result is bad?
+        // Usually ONNX models are strict about input types. 
+        // If the model expects Int64, passing Int32 might fail with "Type mismatch".
+        // We can try catching it.
+        /*
+        try {
+            console.log("\nAttempting GPU with Int32 Inputs (experimental)...");
+            const speedGpu32 = await runInference(sessionGpu, "GPU (Int32)", true);
+             if (speedCpu > 0) {
+                const speedup = speedGpu32 / speedCpu;
+                console.log(`Result (Int32): GPU is ${speedup.toFixed(2)}x faster than CPU.`);
+            }
+        } catch(e) {
+            console.log("Int32 inference not supported by model (expected).");
+        }
+        */
+    }
+    catch (e) {
+        console.error("GPU Benchmark failed:", e.message);
+        console.error(e.stack);
+    }
+}
+runBenchmark();

package/dist/benchmark-heavy.js

@@ -0,0 +1,230 @@
+"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 ort = __importStar(require("onnxruntime-node"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Configure cache path
+const CACHE_DIR = path.resolve('./.cache');
+transformers_1.env.cacheDir = CACHE_DIR;
+const EMBEDDING_DIM = 1024; // bge-m3
+const MODEL_ID = "Xenova/bge-m3";
+const QUANTIZED = false;
+const MODEL_FILE = QUANTIZED ? "model_quantized.onnx" : "model.onnx";
+// Massive Load Configuration
+const BATCH_SIZE = 10; // Process 10 items concurrently
+const NUM_TEXTS = 50;
+const TEXT_LENGTH_MULTIPLIER = 5; // 5x longer texts
+const baseText = `This is a very long complex test sentence for the extended performance comparison of CPU and GPU embeddings. We want to maximize the graphics card (RTX 2080) utilization to make the activity visible in the Task Manager. DirectML should show what it can do here. `;
+const longText = baseText.repeat(TEXT_LENGTH_MULTIPLIER);
+const texts = Array.from({ length: NUM_TEXTS }, (_, i) => `[${i}] ${longText}`);
+async function runBenchmark() {
+    console.log("==========================================");
+    console.log(`Starting HEAVY Benchmark: CPU vs GPU (DirectML) [FP32 Mode]`);
+    console.log(`Batch Size: ${BATCH_SIZE}, Total Texts: ${NUM_TEXTS}`);
+    console.log(`Text Length: ~${longText.length} chars`);
+    console.log("==========================================");
+    // 1. Prepare Model Path
+    const modelPath = path.join(CACHE_DIR, 'Xenova', 'bge-m3', 'onnx', MODEL_FILE);
+    if (!fs.existsSync(modelPath)) {
+        console.error(`Model not found at: ${modelPath}`);
+        return;
+    }
+    console.log(`Model path: ${modelPath}`);
+    // 2. Load Tokenizer
+    console.log("Loading Tokenizer...");
+    const tokenizer = await transformers_1.AutoTokenizer.from_pretrained(MODEL_ID);
+    // 3. Define Helper for Inference
+    async function runInference(session, label) {
+        console.log(`Starting ${label} inference...`);
+        const start = performance.now();
+        let processed = 0;
+        for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+            const batchTexts = texts.slice(i, i + BATCH_SIZE);
+            const model_inputs = await tokenizer(batchTexts, { padding: true, truncation: true, maxLength: 512 });
+            const feeds = {};
+            for (const [key, value] of Object.entries(model_inputs)) {
+                if (key === 'input_ids' || key === 'attention_mask' || key === 'token_type_ids') {
+                    // @ts-ignore
+                    let data = value.data || value.cpuData;
+                    // @ts-ignore
+                    const dims = value.dims; // [batch_size, seq_len]
+                    // Ensure BigInt64Array
+                    if (!(data instanceof BigInt64Array)) {
+                        data = BigInt64Array.from(data);
+                    }
+                    try {
+                        feeds[key] = new ort.Tensor('int64', data, dims);
+                    }
+                    catch (err) {
+                        console.error(`Error creating tensor for ${key}:`, err.message);
+                        throw err;
+                    }
+                }
+            }
+            // Run Inference
+            await session.run(feeds);
+            processed += batchTexts.length;
+            if (processed % (BATCH_SIZE * 5) === 0) {
+                process.stdout.write(`\r${label}: ${processed}/${NUM_TEXTS} Embeddings...`);
+            }
+        }
+        const end = performance.now();
+        const duration = (end - start) / 1000;
+        console.log(`\n${label} Time: ${duration.toFixed(2)}s`);
+        const speed = texts.length / duration;
+        console.log(`${label} Speed: ${speed.toFixed(2)} Embeddings/s`);
+        return speed;
+    }
+    // --- Phase 1: GPU Benchmark (Priority) ---
+    console.log("\n--- Phase 1: GPU (DirectML) Benchmark ---");
+    let speedGpu = 0;
+    try {
+        const sessionOptions = {
+            executionProviders: [
+                {
+                    name: 'dml',
+                    device_id: 0,
+                },
+                'cpu'
+            ],
+            graphOptimizationLevel: 'all',
+            enableCpuMemArena: false
+        };
+        console.log("Creating GPU Session (This might take a moment)...");
+        const startGpuLoad = performance.now();
+        const sessionGpu = await ort.InferenceSession.create(modelPath, sessionOptions);
+        const endGpuLoad = performance.now();
+        console.log(`GPU Session created in ${((endGpuLoad - startGpuLoad) / 1000).toFixed(2)}s`);
+        // @ts-ignore
+        console.log(`Providers: ${sessionGpu.getProviders ? sessionGpu.getProviders() : 'Unknown'}`);
+        // Warmup
+        console.log("GPU Warmup...");
+        {
+            const text = ["Warmup sentence to wake up the GPU."];
+            const model_inputs = await tokenizer(text, { padding: true, truncation: true });
+            const feeds = {};
+            for (const [key, value] of Object.entries(model_inputs)) {
+                if (key === 'input_ids' || key === 'attention_mask' || key === 'token_type_ids') {
+                    // @ts-ignore
+                    let data = value.data || value.cpuData;
+                    // @ts-ignore
+                    const dims = value.dims;
+                    if (!(data instanceof BigInt64Array))
+                        data = BigInt64Array.from(data);
+                    feeds[key] = new ort.Tensor('int64', data, dims);
+                }
+            }
+            await sessionGpu.run(feeds);
+        }
+        console.log("PLEASE WATCH TASK MANAGER GPU TAB NOW!");
+        await new Promise(resolve => setTimeout(resolve, 2000)); // Give user time to switch
+        speedGpu = await runInference(sessionGpu, "GPU");
+    }
+    catch (e) {
+        console.error("GPU Benchmark failed:", e.message);
+        console.error(e.stack);
+    }
+    // --- Phase 2: CPU Benchmark (Comparison) ---
+    // Only run if GPU succeeded to compare, or if user wants to see baseline
+    console.log("\n--- Phase 2: CPU Benchmark ---");
+    let speedCpu = 0;
+    try {
+        const sessionCpu = await ort.InferenceSession.create(modelPath, {
+            executionProviders: ['cpu'],
+            graphOptimizationLevel: 'all'
+        });
+        console.log("CPU Session created.");
+        // Limit CPU run to avoid waiting too long if it's very slow
+        // We'll run a subset for CPU
+        const cpuTextsOriginal = texts;
+        // Use fewer texts for CPU to save time, then extrapolate
+        // 200 texts is enough for a reliable CPU speed measure
+        const CPU_SUBSET_SIZE = 200;
+        console.log(`(Using only ${CPU_SUBSET_SIZE} texts for CPU Benchmark to save time...)`);
+        // Mock the texts array temporarily or adjust the function
+        // Actually, let's just slice the array in the function call? 
+        // No, the function uses the global 'texts'. I should have made it an argument.
+        // I'll just change the global 'texts' variable? No it's const.
+        // I'll create a new runner function or just accept it runs on full set?
+        // 2000 texts on CPU might take forever if it's 5/s -> 400s = 6 mins. Too long.
+        // I'll define a new runInferenceForCpu that takes texts
+        async function runInferenceSubset(session, label, subset) {
+            console.log(`Starting ${label} inference (Subset: ${subset.length})...`);
+            const start = performance.now();
+            let processed = 0;
+            for (let i = 0; i < subset.length; i += BATCH_SIZE) {
+                const batchTexts = subset.slice(i, i + BATCH_SIZE);
+                const model_inputs = await tokenizer(batchTexts, { padding: true, truncation: true, maxLength: 512 });
+                const feeds = {};
+                for (const [key, value] of Object.entries(model_inputs)) {
+                    if (key === 'input_ids' || key === 'attention_mask' || key === 'token_type_ids') {
+                        // @ts-ignore
+                        let data = value.data || value.cpuData;
+                        // @ts-ignore
+                        const dims = value.dims;
+                        if (!(data instanceof BigInt64Array))
+                            data = BigInt64Array.from(data);
+                        feeds[key] = new ort.Tensor('int64', data, dims);
+                    }
+                }
+                await session.run(feeds);
+                processed += batchTexts.length;
+                process.stdout.write(`.`);
+            }
+            const end = performance.now();
+            const duration = (end - start) / 1000;
+            console.log(`\n${label} Time: ${duration.toFixed(2)}s`);
+            const speed = subset.length / duration;
+            console.log(`${label} Speed: ${speed.toFixed(2)} Embeddings/s`);
+            return speed;
+        }
+        speedCpu = await runInferenceSubset(sessionCpu, "CPU", texts.slice(0, CPU_SUBSET_SIZE));
+    }
+    catch (e) {
+        console.error("CPU Benchmark failed:", e.message);
+    }
+    // Final Result
+    if (speedGpu > 0 && speedCpu > 0) {
+        const speedup = speedGpu / speedCpu;
+        console.log("\n==========================================");
+        console.log(`Result: GPU is ${speedup.toFixed(2)}x faster than CPU.`);
+        console.log(`GPU Throughput: ${speedGpu.toFixed(2)} emb/s`);
+        console.log(`CPU Throughput: ${speedCpu.toFixed(2)} emb/s`);
+        console.log("==========================================");
+    }
+}
+runBenchmark();