@memvid/sdk 2.0.143 → 2.0.145

package/dist/index.d.ts

@@ -300,7 +300,7 @@ export declare function create(filename: string, kind?: Kind, apiKeyOrOptions?:
 export declare function open(filename: string, kind?: Kind, apiKeyOrOptions?: ApiKey | UseOptions, options?: UseOptions): Promise<Memvid>;
 export declare function verifyMemvid(path: string, options?: UseVerifyOptions): Promise<unknown>;
 export declare function doctorMemvid(path: string, options?: UseDoctorOptions): Promise<unknown>;
-export type { AddMemoryCardsResult, Kind, ApiKey, Memvid, MemoryCard, MemoryCardInput, MemoriesResult, MemoriesStats, LockOptions, UseOptions, UnlockOptions, FindInput, VecSearchInput, AskInput, TimelineInput, PutInput, PutManyInput, PutManyOptions, MemvidErrorCode, MemvidErrorDetails, HeatmapEntry, HeatmapResponse, SessionSummary, SessionReplayResult, SessionActionResult, StatsResult, FindHit, FindResult, VecSearchResult, AskResult, AskStats, AskUsage, AskSource, TimelineEntry, } from "./types";
+export type { AddMemoryCardsResult, Kind, ApiKey, Memvid, MemoryCard, MemoryCardInput, MemoriesResult, MemoriesStats, LockOptions, UseOptions, UnlockOptions, FindInput, VecSearchInput, AskInput, TimelineInput, PutInput, PutManyInput, PutManyOptions, MemvidErrorCode, MemvidErrorDetails, HeatmapEntry, HeatmapResponse, SessionSummary, SessionReplayResult, SessionActionResult, StatsResult, FindHit, FindResult, VecSearchResult, AskResult, AskStats, AskUsage, AskSource, Grounding, FollowUp, TimelineEntry, } from "./types";
 export { MemvidError, CapacityExceededError, TicketInvalidError, TicketReplayError, LexIndexDisabledError, TimeIndexMissingError, VerificationFailedError, LockedError, ApiKeyRequiredError, FileNotFoundError, MemoryAlreadyBoundError, FrameNotFoundError, VecIndexDisabledError, CorruptFileError, VecDimensionMismatchError, EmbeddingFailedError, EncryptionError, QuotaExceededError, getErrorSuggestion, } from "./error";
 export { EmbeddingProvider, OpenAIEmbeddings, OpenAIEmbeddingsConfig, CohereEmbeddings, CohereEmbeddingsConfig, VoyageEmbeddings, VoyageEmbeddingsConfig, NvidiaEmbeddings, NvidiaEmbeddingsConfig, GeminiEmbeddings, GeminiEmbeddingsConfig, MistralEmbeddings, MistralEmbeddingsConfig, getEmbedder, MODEL_DIMENSIONS, LOCAL_EMBEDDING_MODELS, LocalEmbeddingModel, } from "./embeddings";
 export { flush as flushAnalytics, isTelemetryEnabled } from "./analytics";

package/dist/index.js

@@ -492,6 +492,11 @@ function loadNativeAddon() {
         const pkgParts = platformInfo.pkg.split("/");
         const scope = pkgParts[0]; // "@memvid"
         const pkgName = pkgParts[1]; // "sdk-win32-x64-msvc"
+        const debug = process.env.MEMVID_DEBUG === "1";
+        if (debug) {
+            console.log("[memvid] __dirname:", __dirname);
+            console.log("[memvid] Looking for platform package:", platformInfo.pkg);
+        }
         // Try to find the platform package in various locations
         const possiblePaths = [
             // Sibling in same scope (most common for scoped packages)
@@ -509,9 +514,16 @@ function loadNativeAddon() {
             // Yarn PnP / berry
             path.join(__dirname, "..", "..", ".yarn", "cache", `${scope.replace("@", "")}-${pkgName}`, platformInfo.binary),
         ];
+        if (debug) {
+            console.log("[memvid] Checking paths:");
+            possiblePaths.forEach((p, i) => console.log(`  [${i}] ${p}`));
+        }
         for (const binaryPath of possiblePaths) {
             try {
                 fs.statSync(binaryPath);
+                if (debug) {
+                    console.log("[memvid] Found binary at:", binaryPath);
+                }
                 // Set LD_LIBRARY_PATH/DYLD_LIBRARY_PATH for Tika library
                 const binaryDir = path.dirname(binaryPath);
                 if (platform === "linux") {
@@ -526,7 +538,10 @@ function loadNativeAddon() {
                 }
                 return require(binaryPath);
             }
-            catch {
+            catch (err) {
+                if (debug) {
+                    console.log(`[memvid] Path not found: ${binaryPath}`);
+                }
                 // Try next path
             }
         }
@@ -1279,10 +1294,129 @@ class MemvidImpl {
                     }
                 }
             }
+            // Calculate grounding score
+            this.verifyGrounding(response);
             // Build follow-up suggestions if confidence is low
             return this.buildFollowUp(response);
         });
     }
+    verifyGrounding(response) {
+        const answer = response.answer || "";
+        const context = response.context || "";
+        // Empty answer = no hallucination
+        if (!answer) {
+            response.grounding = {
+                score: 1.0,
+                label: "HIGH",
+                sentence_count: 0,
+                grounded_sentences: 0,
+                has_warning: false,
+                warning_reason: undefined,
+            };
+            return;
+        }
+        // No context = potential hallucination
+        if (!context) {
+            response.grounding = {
+                score: 0.0,
+                label: "LOW",
+                sentence_count: 1,
+                grounded_sentences: 0,
+                has_warning: true,
+                warning_reason: "No context provided - answer may be hallucinated",
+            };
+            return;
+        }
+        // Normalize context for comparison
+        const contextLower = context.toLowerCase();
+        const contextWords = new Set(contextLower.split(/[^a-zA-Z0-9]+/).filter(w => w.length > 2));
+        // Split answer into sentences
+        const sentences = answer
+            .split(/[.!?]/)
+            .map(s => s.trim())
+            .filter(s => s.length > 10);
+        if (sentences.length === 0) {
+            response.grounding = {
+                score: 0.5,
+                label: "MEDIUM",
+                sentence_count: 0,
+                grounded_sentences: 0,
+                has_warning: false,
+                warning_reason: undefined,
+            };
+            return;
+        }
+        const sentenceScores = [];
+        let groundedCount = 0;
+        for (const sentence of sentences) {
+            const sentenceLower = sentence.toLowerCase();
+            const sentenceWords = new Set(sentenceLower.split(/[^a-zA-Z0-9]+/).filter(w => w.length > 2));
+            if (sentenceWords.size === 0) {
+                sentenceScores.push(0.5);
+                continue;
+            }
+            // Calculate word overlap
+            let overlap = 0;
+            for (const word of sentenceWords) {
+                if (contextWords.has(word))
+                    overlap++;
+            }
+            const score = overlap / Math.max(sentenceWords.size, 1);
+            // Add phrase bonus for exact matches
+            let phraseBonus = 0;
+            if (contextLower.includes(sentenceLower)) {
+                phraseBonus = 0.3;
+            }
+            else {
+                // Check for significant substring matches
+                const words = sentenceLower.split(/\s+/);
+                if (words.length >= 3) {
+                    const phrase = words.slice(0, 3).join(" ");
+                    if (contextLower.includes(phrase)) {
+                        phraseBonus = 0.15;
+                    }
+                }
+            }
+            const finalScore = Math.min(score + phraseBonus, 1.0);
+            sentenceScores.push(finalScore);
+            if (finalScore >= 0.3) {
+                groundedCount++;
+            }
+        }
+        const overallScore = sentenceScores.length > 0
+            ? sentenceScores.reduce((a, b) => a + b, 0) / sentenceScores.length
+            : 0.5;
+        // Determine warning
+        let hasWarning = false;
+        let warningReason;
+        if (overallScore < 0.2) {
+            hasWarning = true;
+            warningReason = "Answer appears to be poorly grounded in context";
+        }
+        else if (overallScore < 0.4 && groundedCount < Math.floor(sentences.length / 2)) {
+            hasWarning = true;
+            warningReason = "Some statements may not be supported by context";
+        }
+        // Determine label
+        let label;
+        if (overallScore >= 0.7) {
+            label = "HIGH";
+        }
+        else if (overallScore >= 0.4) {
+            label = "MEDIUM";
+        }
+        else {
+            label = "LOW";
+        }
+        response.grounding = {
+            score: overallScore,
+            label,
+            sentence_count: sentences.length,
+            grounded_sentences: groundedCount,
+            has_warning: hasWarning,
+            warning_reason: warningReason,
+        };
+    }
     async buildFollowUp(response) {
         const hits = response.hits || [];
         // Check if retrieval has no results
@@ -1296,10 +1430,10 @@ class MemvidImpl {
                 veryLowRetrieval = true;
             }
         }
-        // Check grounding if available (from model inference)
-        const grounding = response.grounding || {};
-        const hasGroundingWarning = grounding.has_warning || false;
-        const lowGrounding = grounding.score !== undefined && grounding.score < 0.3;
+        // Check grounding if available
+        const grounding = response.grounding;
+        const hasGroundingWarning = grounding?.has_warning || false;
+        const lowGrounding = grounding?.score !== undefined && grounding.score < 0.3;
         // Detect "Not enough information" type answers (primary trigger)
         const answer = (response.answer || "").toLowerCase();
         const noInfoPhrases = [

package/dist/types.d.ts

@@ -507,6 +507,21 @@ export interface FollowUp {
     available_topics: string[];
     suggestions: string[];
 }
+/** Grounding information for answer quality assessment */
+export interface Grounding {
+    /** Overall grounding score (0-1) */
+    score: number;
+    /** Grounding quality label (LOW, MEDIUM, HIGH) */
+    label?: string;
+    /** Number of sentences in the answer */
+    sentence_count?: number;
+    /** Number of sentences grounded in context */
+    grounded_sentences?: number;
+    /** Whether there's a grounding warning */
+    has_warning: boolean;
+    /** Reason for the warning if any */
+    warning_reason?: string;
+}
 /** Response from ask() method */
 export interface AskResult {
     question: string;
@@ -521,6 +536,8 @@ export interface AskResult {
     stats: AskStats;
     usage: AskUsage;
     model?: string;
+    /** Grounding information for answer quality assessment */
+    grounding?: Grounding;
     /** Follow-up suggestions when confidence is low */
     follow_up?: FollowUp;
 }
@@ -548,6 +565,10 @@ export interface Memvid {
     vecSearch(query: string, queryEmbedding: number[], opts?: VecSearchInput): Promise<VecSearchResult>;
     /** Ask a question and get an AI-generated answer based on memory contents. */
     ask(question: string, opts?: AskInput): Promise<AskResult>;
+    /** Store a correction/ground truth statement with retrieval priority boost. */
+    correct(statement: string, options?: CorrectOptions): Promise<string>;
+    /** Batch store multiple corrections with retrieval priority boost. */
+    correctMany(corrections: CorrectManyInput[]): Promise<string[]>;
     /** Get chronological list of frames. */
     timeline(opts?: TimelineInput): Promise<TimelineEntry[]>;
     /** Get memory statistics including capacity, frame count, and index status. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memvid/sdk",
-  "version": "2.0.143",
+  "version": "2.0.145",
   "description": "Single-file AI memory system for Node.js. Store, search, and query documents with built-in RAG.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -41,10 +41,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@memvid/sdk-darwin-arm64": "2.0.143",
-    "@memvid/sdk-darwin-x64": "2.0.143",
-    "@memvid/sdk-linux-x64-gnu": "2.0.143",
-    "@memvid/sdk-win32-x64-msvc": "2.0.143"
+    "@memvid/sdk-darwin-arm64": "2.0.145",
+    "@memvid/sdk-darwin-x64": "2.0.145",
+    "@memvid/sdk-linux-x64-gnu": "2.0.145",
+    "@memvid/sdk-win32-x64-msvc": "2.0.145"
   },
   "peerDependencies": {
     "@langchain/core": ">=0.3.0",