@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/examples/llamacpp-tools-routing.js

@@ -0,0 +1,364 @@
+import { loadModel, completion, QWEN_3_1_7B_INST_Q4, unloadModel, } from "@qvac/sdk";
+try {
+    const modelId = await loadModel({
+        modelSrc: QWEN_3_1_7B_INST_Q4,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+        },
+        onProgress: (progress) => {
+            console.log(progress);
+        },
+    });
+    const base = [
+        {
+            role: "system",
+            content: `
+           /no_think
+            Output exactly one word based on the user's request. Choose from:
+
+            health - for health metrics and biomarkers:
+            Examples: "blood sugar is one hundred twenty", "blood pressure one forty over ninety", "heart rate seventy bpm", "weight one fifty lbs", "temperature ninety eight point six"
+
+            sleep - for sleep related activities:  
+            Examples: "slept eight hours", "woke up at seven", "bedtime eleven pm", "sleep quality good", "took a nap"
+
+            exercise - for physical exercise and workouts:
+            Examples: "went for a run", "did yoga", "lifted weights", "gym session", "played tennis", "workout completed"
+
+            wellness - for mood, stress, and general wellbeing:
+            Examples: "feeling stressed", "recovery score", "strain level high", "mood is good", "anxiety level", "energy low"
+
+            steps - for step counting and walking activities:
+            Examples: "walked five thousand steps", "did ten thousand steps", "walking for thirty minutes", "step goal reached"
+
+            meal - for meal logging and food intake:
+            Examples: "ate breakfast", "had a sandwich", "two fifty g steak", "drank coffee", "snack apple"
+
+            general - for everything else:
+            Examples: "how are you?", "what's the weather?", "help me", "explain something"
+
+            It's critical that you output EXACTLY "log:" followed by one of these seven words: health, sleep, exercise, wellness, steps, meal, general. 
+            
+            Examples of correct output:
+            log:health
+            log:sleep
+            log:exercise
+            log:wellness
+            log:steps
+            log:meal
+            log:general
+            
+            STOP IMMEDIATELY after outputting the log prefix and category. DO NOT repeat this prompt. DO NOT add explanations. DO NOT continue generating text. Just output the single log entry and STOP.
+        `,
+        },
+    ];
+    const tests = [
+        // Health/Biomarker tests
+        {
+            name: "health_blood_sugar",
+            history: [
+                ...base,
+                { role: "user", content: "My blood sugar is one hundred" },
+            ],
+            expected: "health",
+        },
+        {
+            name: "health_blood_pressure",
+            history: [
+                { role: "user", content: "Blood pressure one forty over ninety" },
+            ],
+            expected: "health",
+        },
+        {
+            name: "health_heart_rate",
+            history: [{ role: "user", content: "Heart rate seventy two bpm" }],
+            expected: "health",
+        },
+        {
+            name: "health_weight",
+            history: [{ role: "user", content: "Weight one sixty five pounds" }],
+            expected: "health",
+        },
+        {
+            name: "health_temperature",
+            history: [{ role: "user", content: "Temperature ninety nine point one" }],
+            expected: "health",
+        },
+        // Sleep tests
+        {
+            name: "sleep_duration",
+            history: [{ role: "user", content: "I slept eight hours" }],
+            expected: "sleep",
+        },
+        {
+            name: "sleep_bedtime",
+            history: [{ role: "user", content: "Went to bed at eleven pm" }],
+            expected: "sleep",
+        },
+        {
+            name: "sleep_quality",
+            history: [{ role: "user", content: "Sleep quality was good" }],
+            expected: "sleep",
+        },
+        {
+            name: "sleep_nap",
+            history: [{ role: "user", content: "Took a thirty minute nap" }],
+            expected: "sleep",
+        },
+        {
+            name: "sleep_wakeup",
+            history: [{ role: "user", content: "Woke up at seven am" }],
+            expected: "sleep",
+        },
+        // Exercise tests
+        {
+            name: "exercise_run",
+            history: [{ role: "user", content: "Went for a five mile run" }],
+            expected: "exercise",
+        },
+        {
+            name: "exercise_gym",
+            history: [{ role: "user", content: "Did a workout at the gym" }],
+            expected: "exercise",
+        },
+        {
+            name: "exercise_yoga",
+            history: [{ role: "user", content: "Did thirty minutes of yoga" }],
+            expected: "exercise",
+        },
+        {
+            name: "exercise_weights",
+            history: [{ role: "user", content: "Lifted weights for forty minutes" }],
+            expected: "exercise",
+        },
+        {
+            name: "exercise_tennis",
+            history: [{ role: "user", content: "Played tennis for two hours" }],
+            expected: "exercise",
+        },
+        // Wellness tests
+        {
+            name: "wellness_stress",
+            history: [{ role: "user", content: "I'm feeling stressed today" }],
+            expected: "wellness",
+        },
+        {
+            name: "wellness_mood",
+            history: [{ role: "user", content: "Mood is really good" }],
+            expected: "wellness",
+        },
+        {
+            name: "wellness_energy",
+            history: [{ role: "user", content: "Energy level is low" }],
+            expected: "wellness",
+        },
+        {
+            name: "wellness_anxiety",
+            history: [{ role: "user", content: "Anxiety level is high" }],
+            expected: "wellness",
+        },
+        {
+            name: "wellness_recovery",
+            history: [{ role: "user", content: "Recovery score is eighty five" }],
+            expected: "wellness",
+        },
+        // Steps tests
+        {
+            name: "steps_count",
+            history: [{ role: "user", content: "I did ten thousand steps today" }],
+            expected: "steps",
+        },
+        {
+            name: "steps_walking",
+            history: [{ role: "user", content: "Walked for forty five minutes" }],
+            expected: "steps",
+        },
+        {
+            name: "steps_goal",
+            history: [{ role: "user", content: "Reached my step goal" }],
+            expected: "steps",
+        },
+        {
+            name: "steps_low",
+            history: [{ role: "user", content: "Only walked three thousand steps" }],
+            expected: "steps",
+        },
+        // Meal tests
+        {
+            name: "meal_breakfast",
+            history: [{ role: "user", content: "Had scrambled eggs for breakfast" }],
+            expected: "meal",
+        },
+        {
+            name: "meal_lunch",
+            history: [{ role: "user", content: "Ate a turkey sandwich for lunch" }],
+            expected: "meal",
+        },
+        {
+            name: "meal_dinner",
+            history: [
+                { role: "user", content: "Had a two fifty g steak with veggies" },
+            ],
+            expected: "meal",
+        },
+        {
+            name: "meal_snack",
+            history: [{ role: "user", content: "Snacked on an apple" }],
+            expected: "meal",
+        },
+        {
+            name: "meal_drink",
+            history: [{ role: "user", content: "Drank a protein shake" }],
+            expected: "meal",
+        },
+        // General tests
+        {
+            name: "general_question",
+            history: [{ role: "user", content: "How are you doing?" }],
+            expected: "general",
+        },
+        {
+            name: "general_weather",
+            history: [{ role: "user", content: "What's the weather like?" }],
+            expected: "general",
+        },
+        {
+            name: "general_help",
+            history: [{ role: "user", content: "Can you help me with something?" }],
+            expected: "general",
+        },
+        {
+            name: "general_explanation",
+            history: [{ role: "user", content: "Explain how this works" }],
+            expected: "general",
+        },
+        // Edge cases
+        {
+            name: "edge_mixed_health_meal",
+            history: [{ role: "user", content: "Ate lunch and blood sugar went up" }],
+            expected: "health", // Should prioritize the health metric
+        },
+        {
+            name: "edge_exercise_steps",
+            history: [
+                { role: "user", content: "Ran and got fifteen thousand steps" },
+            ],
+            expected: "steps", // Should prioritize the more specific exercise
+        },
+        {
+            name: "edge_tired_after_workout",
+            history: [{ role: "user", content: "Feeling tired after gym session" }],
+            expected: "wellness", // Should focus on the feeling/wellness aspect
+        },
+    ];
+    const results = [];
+    let totalSuccesses = 0;
+    let totalFailures = 0;
+    for (const test of tests) {
+        const startTime = performance.now();
+        const buffer = [];
+        let tokenCount = 0;
+        let firstTokenTime = null;
+        const result = completion({ modelId, history: test.history, stream: true });
+        for await (const token of result.tokenStream) {
+            if (firstTokenTime === null) {
+                firstTokenTime = performance.now();
+            }
+            buffer.push(token);
+            tokenCount++;
+            const currentOutput = buffer.join("");
+            // Stop if we have a complete log entry (log: + word)
+            if (currentOutput.match(/log:\w+/i)) {
+                // Add a few more tokens to ensure completion, then stop
+                if (tokenCount > currentOutput.indexOf("log:") + 10) {
+                    break;
+                }
+            }
+            // Emergency stops to prevent runaway generation
+            if (tokenCount > 100 ||
+                currentOutput.includes("Output exactly one word") ||
+                currentOutput.includes("Choose from:") ||
+                currentOutput.includes("Examples:") ||
+                currentOutput.length > 500) {
+                console.log(`⚠️  Stopped runaway generation for ${test.name} after ${tokenCount} tokens`);
+                break;
+            }
+        }
+        // Get the stats from the completion stream
+        const stats = await result.stats;
+        console.log(`📊 Stats for ${test.name}:`, stats);
+        const endTime = performance.now();
+        const totalTime = endTime - startTime;
+        const ttft = firstTokenTime ? firstTokenTime - startTime : 0; // Time to First Token
+        const tokensPerSecond = tokenCount > 0
+            ? tokenCount / ((endTime - (firstTokenTime || startTime)) / 1000)
+            : 0;
+        const fullOutput = buffer.join("");
+        // Look for log: prefix in the output
+        const logMatch = fullOutput.match(/log:(\w+)/i);
+        const actual = logMatch?.[1]?.toLowerCase() || "";
+        const success = actual === test.expected;
+        if (success) {
+            console.log(`✅ ${test.name} (${totalTime.toFixed(0)}ms, ${tokenCount} tokens, ${tokensPerSecond.toFixed(1)} tok/s)`);
+            totalSuccesses++;
+        }
+        else {
+            console.log(`❌ ${test.name} (${totalTime.toFixed(0)}ms, ${tokenCount} tokens, ${tokensPerSecond.toFixed(1)} tok/s)`);
+            totalFailures++;
+        }
+        results.push({
+            name: test.name,
+            input: test.history[test.history.length - 1]?.content ?? "no input",
+            expected: test.expected,
+            actual,
+            success,
+            fullOutput: fullOutput.replace(/\n/g, "\\n"),
+            timing: {
+                totalTime: Math.round(totalTime),
+                ttft: Math.round(ttft),
+                tokenCount,
+                tokensPerSecond: Math.round(tokensPerSecond * 10) / 10,
+            },
+        });
+    }
+    // Print detailed results
+    console.log("\n" + "=".repeat(80));
+    console.log("DETAILED TEST RESULTS");
+    console.log("=".repeat(80));
+    for (const result of results) {
+        console.log(`\nTest: ${result.name}`);
+        console.log(`Input: "${result.input}"`);
+        console.log(`Expected: "${result.expected}"`);
+        console.log(`Got: "${result.actual}"`);
+        console.log(`Status: ${result.success ? "✅ PASS" : "❌ FAIL"}`);
+        console.log(`Timing: ${result.timing.totalTime}ms total, TTFT: ${result.timing.ttft}ms, ${result.timing.tokenCount} tokens, ${result.timing.tokensPerSecond} tok/s`);
+        if (!result.success) {
+            console.log(`Full Output: "${result.fullOutput}"`);
+        }
+    }
+    console.log("\n" + "=".repeat(80));
+    console.log(`SUMMARY: ${totalSuccesses}/${results.length} tests passed (${Math.round((totalSuccesses / results.length) * 100)}%)`);
+    console.log(`Successes: ${totalSuccesses}`);
+    console.log(`Failures: ${totalFailures}`);
+    // Calculate timing statistics
+    const timings = results.map((r) => r.timing);
+    const avgTotalTime = timings.reduce((sum, t) => sum + t.totalTime, 0) / timings.length;
+    const avgTTFT = timings.reduce((sum, t) => sum + t.ttft, 0) / timings.length;
+    const avgTokens = timings.reduce((sum, t) => sum + t.tokenCount, 0) / timings.length;
+    const avgTPS = timings.reduce((sum, t) => sum + t.tokensPerSecond, 0) / timings.length;
+    const totalTime = timings.reduce((sum, t) => sum + t.totalTime, 0);
+    console.log(`\nTIMING STATS:`);
+    console.log(`Total Test Time: ${(totalTime / 1000).toFixed(1)}s`);
+    console.log(`Average per test: ${avgTotalTime.toFixed(0)}ms`);
+    console.log(`Average TTFT: ${avgTTFT.toFixed(0)}ms`);
+    console.log(`Average tokens: ${avgTokens.toFixed(1)}`);
+    console.log(`Average speed: ${avgTPS.toFixed(1)} tok/s`);
+    console.log("=".repeat(80));
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/llamacpp-tools.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-tools.d.ts.map

package/dist/examples/llamacpp-tools.js

@@ -0,0 +1,81 @@
+import { completion, loadModel, QWEN_3_1_7B_INST_Q4, unloadModel, } from "@qvac/sdk";
+// Simple tool execution
+function executeTool(toolName, params) {
+    if (toolName === "calculate") {
+        const match = params.match(/a:(\d+),\s*b:(\d+),\s*op:([+\-*/])/);
+        if (match) {
+            const [, a, b, op] = match;
+            const result = op === "+"
+                ? +a + +b
+                : op === "-"
+                    ? +a - +b
+                    : op === "*"
+                        ? +a * +b
+                        : +a / +b;
+            return `${result}`;
+        }
+    }
+    if (toolName === "get_time") {
+        return new Date().toLocaleString();
+    }
+    return "Tool not found";
+}
+try {
+    console.log("🚀 Loading MedGemma...");
+    const modelId = await loadModel({
+        modelSrc: QWEN_3_1_7B_INST_Q4,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 2048,
+        },
+        onProgress: (progress) => console.log(`${progress.percentage.toFixed(1)}%`),
+    });
+    const systemPrompt = `You are a helpful assistant. When you need to use tools, use this XML format:
+
+<tool_call>
+<tool_name>calculate</tool_name>
+<parameters>a:15, b:24, op:*</parameters>
+</tool_call>
+
+<tool_call>
+<tool_name>get_time</tool_name>
+<parameters></parameters>
+</tool_call>
+
+Available tools:
+- calculate: needs a (number), b (number), op (+, -, *, /)
+- get_time: no parameters needed`;
+    const conversation = [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: "What's 30 * 5? Also what time is it?" },
+    ];
+    console.log("\n🤖 Response:");
+    let response = "";
+    const result = completion({ modelId, history: conversation, stream: true });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+        response += token;
+    }
+    const stats = await result.stats;
+    console.log("\n📊 Performance Stats:", stats);
+    // Parse XML tool calls
+    const toolRegex = /<tool_call>\s*<tool_name>([^<]+)<\/tool_name>\s*<parameters>([^<]*)<\/parameters>\s*<\/tool_call>/g;
+    let match;
+    const hasTools = toolRegex.test(response);
+    if (hasTools) {
+        console.log("\n\n🔧 Executing tools:");
+        toolRegex.lastIndex = 0; // Reset regex
+        while ((match = toolRegex.exec(response)) !== null) {
+            const [, toolName, params] = match;
+            console.log(`➤ ${toolName}(${params})`);
+            console.log(`✅ ${executeTool(toolName, params)}`);
+        }
+    }
+    console.log("\n\n🫡 Done!");
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/multi-model-demo.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=multi-model-demo.d.ts.map

package/dist/examples/multi-model-demo.js

@@ -0,0 +1,75 @@
+import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, QWEN_3_1_7B_INST_Q4, unloadModel, } from "@qvac/sdk";
+try {
+    const alice = await loadModel({
+        modelSrc: QWEN_3_1_7B_INST_Q4,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+        },
+    });
+    const bob = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+        },
+        onProgress: (progress) => console.log(`Loading Bob: ${progress.percentage.toFixed(1)}%`),
+    });
+    const aliceHistory = [
+        {
+            role: "system",
+            content: "You answer questions about.",
+        },
+        { role: "user", content: "What is Bitcoin?" },
+    ];
+    const bobHistory = [
+        {
+            role: "system",
+            content: "You ask questions about Bitcoin in one sentence.",
+        },
+    ];
+    console.log("🙋🏻‍♂️ Bob: ", "What is Bitcoin?");
+    const aliceResponse = completion({
+        modelId: alice,
+        history: [...aliceHistory],
+        stream: false,
+    });
+    const aliceText = await aliceResponse.text;
+    aliceHistory.push({ role: "assistant", content: aliceText });
+    console.log("🙋🏻‍♀️ Alice: ", aliceText);
+    console.log("📊 Alice Stats: ", await aliceResponse.stats);
+    const bobResponse = completion({
+        modelId: bob,
+        history: [...bobHistory, { role: "user", content: aliceText }],
+        stream: false,
+    });
+    const bobText = await bobResponse.text;
+    bobHistory.push({ role: "assistant", content: bobText });
+    console.log("🙋🏻‍♂️ Bob: ", bobText);
+    console.log("📊 Bob Stats: ", await bobResponse.stats);
+    const aliceResponse2 = completion({
+        modelId: alice,
+        history: [...aliceHistory, { role: "user", content: bobText }],
+        stream: false,
+    });
+    const aliceText2 = await aliceResponse2.text;
+    aliceHistory.push({ role: "assistant", content: aliceText2 });
+    console.log("🙋🏻‍♀️ Alice: ", aliceText2);
+    console.log("📊 Alice Stats: ", await aliceResponse2.stats);
+    const bobResponse2 = completion({
+        modelId: bob,
+        history: [...bobHistory, { role: "user", content: aliceText2 }],
+        stream: false,
+    });
+    const bobText2 = await bobResponse2.text;
+    bobHistory.push({ role: "assistant", content: bobText2 });
+    console.log("🙋🏻‍♂️ Bob: ", bobText2);
+    console.log("📊 Bob Stats: ", await bobResponse2.stats);
+    await unloadModel({ modelId: alice, clearStorage: false });
+    await unloadModel({ modelId: bob, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/parallel-download.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parallel-download.d.ts.map

package/dist/examples/parallel-download.js

@@ -0,0 +1,21 @@
+import { LLAMA_3_2_1B_INST_Q4_0, downloadAsset, WHISPER_LARGE_3, } from "@qvac/sdk";
+try {
+    const llamaDownloadPromise = downloadAsset({
+        assetSrc: LLAMA_3_2_1B_INST_Q4_0,
+        onProgress: (progress) => {
+            console.log("💬 Llama progress:", progress);
+        },
+    });
+    const whisperDownloadPromise = downloadAsset({
+        assetSrc: WHISPER_LARGE_3,
+        onProgress: (progress) => {
+            console.log("🔊 Whisper progress:", progress);
+        },
+    });
+    await Promise.all([llamaDownloadPromise, whisperDownloadPromise]);
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/rag/rag-chromadb.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rag-chromadb.d.ts.map

package/dist/examples/rag/rag-chromadb.js

@@ -0,0 +1,130 @@
+// example-chroma.ts
+import { embed, loadModel, unloadModel, GTE_LARGE_FP16 } from "@qvac/sdk";
+import { ChromaClient } from "chromadb";
+// Setup instructions for ChromaDB server
+const CHROMADB_SETUP_INSTRUCTIONS = `
+🚀 To run this example, you need a ChromaDB server running locally.
+
+Setup options:
+
+1. Using Chroma CLI (recommended):
+   pip install chromadb
+   chroma run --host localhost --port 8000 --path ./my_chroma_data
+
+2. Using Docker:
+   docker pull chromadb/chroma
+   docker run -p 8000:8000 chromadb/chroma
+
+For more details, visit: https://docs.trychroma.com/docs/overview/getting-started?lang=typescript
+`;
+async function initializeChromaClient() {
+    const client = new ChromaClient({ host: "localhost", port: 8000 });
+    try {
+        await client.heartbeat();
+        console.log("✅ Connected to ChromaDB server");
+        return client;
+    }
+    catch {
+        console.error("❌ Failed to connect to ChromaDB server");
+        console.error("Please ensure the server is running on localhost:8000");
+        console.error(CHROMADB_SETUP_INSTRUCTIONS);
+        process.exit(1);
+    }
+}
+try {
+    // Get query from command line or use default
+    const query = process.argv[2] || "machine learning algorithms";
+    console.log(`🔍 Query: "${query}"`);
+    const client = await initializeChromaClient();
+    const modelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+        onProgress: (p) => console.log(`Loading model... ${Math.round(p.percentage)}%`),
+    });
+    // Sample corpus
+    const samples = [
+        {
+            id: 1,
+            text: "Machine learning is a subset of artificial intelligence that focuses on algorithms that can learn and make predictions from data without being explicitly programmed for every task.",
+        },
+        {
+            id: 2,
+            text: "Deep learning uses neural networks with multiple layers to process and learn from complex data patterns, enabling breakthroughs in image recognition and natural language processing.",
+        },
+        {
+            id: 3,
+            text: "Natural language processing combines computational linguistics with machine learning to help computers understand, interpret, and generate human language in a meaningful way.",
+        },
+        {
+            id: 4,
+            text: "Computer vision enables machines to interpret and understand visual information from the world, using techniques like image classification, object detection, and facial recognition.",
+        },
+        {
+            id: 5,
+            text: "Quantum computing leverages quantum mechanical phenomena to process information in fundamentally different ways than classical computers, potentially solving certain problems exponentially faster.",
+        },
+        {
+            id: 6,
+            text: "Blockchain technology creates decentralized, immutable ledgers that enable secure peer-to-peer transactions without requiring a central authority or intermediary.",
+        },
+        {
+            id: 7,
+            text: "Cloud computing delivers computing services over the internet, allowing users to access resources like storage, processing power, and applications on-demand from anywhere.",
+        },
+        {
+            id: 8,
+            text: "Cybersecurity protects digital systems, networks, and data from malicious attacks, unauthorized access, and various forms of cyber threats through multiple layers of defense.",
+        },
+    ];
+    // (Re)create the collection
+    const collectionName = "documents";
+    try {
+        await client.deleteCollection({ name: collectionName });
+    }
+    catch (e) {
+        console.warn(`Collection didn't exist, no need to delete: ${String(e)}`);
+    }
+    const collection = await client.createCollection({
+        name: collectionName,
+        embeddingFunction: null,
+    });
+    // Embed and add documents (we're bringing our own embeddings)
+    console.log("📚 Embedding documents...");
+    const ids = [];
+    const documents = [];
+    const embeddings = [];
+    for (const s of samples) {
+        ids.push(String(s.id));
+        documents.push(s.text);
+        embeddings.push(await embed({ modelId, text: s.text }));
+    }
+    await collection.add({
+        ids,
+        documents,
+        embeddings,
+    });
+    console.log("🔎 Searching for similar documents...");
+    const queryEmbedding = await embed({ modelId, text: query });
+    // Query top 3 by vector similarity and include distances
+    const res = await collection.query({
+        queryEmbeddings: [queryEmbedding],
+        nResults: 3,
+        include: ["documents", "distances"],
+    });
+    console.log("\n📋 Top 3 most similar documents:");
+    const docs = res.documents?.[0] ?? [];
+    const dists = res.distances?.[0] ?? [];
+    for (let i = 0; i < docs.length; i++) {
+        console.log("=".repeat(50) + " Top result:");
+        console.log(`\n${i + 1}. (Score: ${dists[i]?.toFixed(4)})`);
+        console.log(`   ${docs[i]}`);
+        console.log("=".repeat(100));
+        console.log();
+    }
+    await unloadModel({ modelId });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}