@squirrelnotes.app/mcp-embeddings 2.1.1-test.341 → 2.1.1-test.343

package/README.md

@@ -8,7 +8,8 @@ flat white with oat milk"*.
 It is the same server as [`@squirrelnotes.app/mcp`](https://www.npmjs.com/package/@squirrelnotes.app/mcp):
 the same tools, the same inputs and the same output shape. It is built from the
 same source and published from the same commit, at the same version. The
-only difference is the order `search_memory` returns. If you do not install it,
+only differences are the order `search_memory` returns, its `ranking` (`hybrid`) and each hit's
+`semanticScore`, which the base package sends as `null`. If you do not install it,
 nothing changes for you.
 
 ## What stays on your machine
@@ -96,8 +97,18 @@ The vector file can be deleted at any time; it is rebuilt when needed.
   ranks above one in only one.
 - A semantic match must reach a minimum similarity of 0.35. Below that, a
   memory is returned only if its words match.
-- `score` is on a 0–1 scale here, and unbounded BM25 in the base package. The
-  keys are the same in both.
+- `score` is on a 0–1 scale here, and unbounded BM25 in the base package. It
+  orders one response only: a memory found by one order alone scores about 0.5
+  whatever its relevance. The keys are the same in both.
+- To judge a hit, use the absolute scores: `semanticScore` (the cosine
+  similarity, reported for every hit, also those below 0.35 found by words) and
+  `lexicalScore` (the share of the query's content words, stopwords aside).
+  As a guide, from the recall gate's data (ADR-0444): below `semanticScore`
+  0.45 and `lexicalScore` 0.67 a hit is rarely the answer (about 1 in 20); at
+  `semanticScore` ≥ 0.45 about half are, and at `lexicalScore` ≥ 0.67 about
+  9 in 10. These were measured on the delivered (rounded) scores. `semanticScore` is a cosine, −1 to 1
+  (in practice about −0.1 to 0.9). `ranking` is `hybrid` when the semantic
+  order ran, `lexical` while the model loads or after it fails.
 - Words outside ASCII letters and digits never match lexically, in either
   package. Embeddings can find some of these memories (see *Recall*).
 - A query with no ASCII letters or digits always comes back with a `note`.

package/dist/cli.js

@@ -22613,8 +22613,15 @@ function intersectSets(a, b) {
 function searchableText(p) {
   return normalizeText([p.text, p.entity, ...p.tags].join(" "));
 }
+function hasSearchableText(query) {
+  return normalizeText(query).length > 0;
+}
 function queryTerms(query) {
-  return [...new Set(normalizeText(query).split(" ").filter(Boolean))];
+  const tokens = normalizeText(query).split(" ").filter(Boolean);
+  const isStop = (w, i) => STOPWORDS.has(w) || NT_STEMS.has(w) && tokens[i + 1] === "t";
+  const content = [...new Set(tokens.filter((w, i) => !isStop(w, i)))];
+  const words = [...new Set(tokens)];
+  return content.length > 0 ? content : words;
 }
 function recencyWeight(category, lastValidatedAt, now2) {
   const at = Date.parse(lastValidatedAt);
@@ -22700,7 +22707,7 @@ function termCoverage(text, p) {
   }
   return total / terms.length;
 }
-var DECAY_HALF_LIFE_DAYS, BM25_K1, BM25_B, PREFIX_WEIGHT, DAY_MS;
+var DECAY_HALF_LIFE_DAYS, BM25_K1, BM25_B, PREFIX_WEIGHT, DAY_MS, STOPWORDS, NT_STEMS;
 var init_memory_search = __esm({
   "../mcp/src/memory-search.ts"() {
     "use strict";
@@ -22714,6 +22721,158 @@ var init_memory_search = __esm({
     BM25_B = 0.75;
     PREFIX_WEIGHT = 0.5;
     DAY_MS = 864e5;
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "a",
+      "about",
+      "above",
+      "after",
+      "again",
+      "all",
+      "am",
+      "an",
+      "and",
+      "any",
+      "are",
+      "as",
+      "at",
+      "be",
+      "because",
+      "been",
+      "before",
+      "being",
+      "below",
+      "between",
+      "both",
+      "but",
+      "by",
+      "can",
+      "could",
+      "did",
+      "do",
+      "does",
+      "doing",
+      "during",
+      "each",
+      "few",
+      "for",
+      "from",
+      "further",
+      "had",
+      "has",
+      "have",
+      "having",
+      "he",
+      "her",
+      "here",
+      "hers",
+      "herself",
+      "him",
+      "himself",
+      "his",
+      "how",
+      "i",
+      "if",
+      "in",
+      "into",
+      "is",
+      "it",
+      "its",
+      "itself",
+      "just",
+      "me",
+      "more",
+      "most",
+      "my",
+      "myself",
+      "no",
+      "nor",
+      "not",
+      "of",
+      "off",
+      "on",
+      "once",
+      "only",
+      "or",
+      "other",
+      "our",
+      "ours",
+      "ourselves",
+      "out",
+      "over",
+      "own",
+      "same",
+      "she",
+      "should",
+      "so",
+      "some",
+      "such",
+      "than",
+      "that",
+      "the",
+      "their",
+      "theirs",
+      "them",
+      "themselves",
+      "then",
+      "there",
+      "these",
+      "they",
+      "this",
+      "those",
+      "through",
+      "to",
+      "too",
+      "under",
+      "until",
+      "up",
+      "very",
+      "was",
+      "we",
+      "were",
+      "what",
+      "when",
+      "where",
+      "which",
+      "while",
+      "who",
+      "whom",
+      "whose",
+      "why",
+      "will",
+      "with",
+      "would",
+      "you",
+      "your",
+      "yours",
+      "yourself",
+      "yourselves",
+      // What contractions leave once normalizeText turns the apostrophe into a
+      // space ("what's" → "what s", "doesn't" → "doesn t"). A one-letter term
+      // would prefix-match every word starting with that letter. "don", "won" and
+      // "haven" are also words or names, so they are not here: queryTerms drops
+      // them only before a "t" (NT_STEMS).
+      "s",
+      "t",
+      "d",
+      "ll",
+      "m",
+      "re",
+      "ve",
+      "aren",
+      "couldn",
+      "didn",
+      "doesn",
+      "hadn",
+      "hasn",
+      "isn",
+      "mustn",
+      "needn",
+      "shouldn",
+      "wasn",
+      "weren",
+      "wouldn"
+    ]);
+    NT_STEMS = /* @__PURE__ */ new Set(["don", "won", "haven"]);
   }
 });
 
@@ -22730,6 +22889,9 @@ function blendRanks(lexical, dense) {
   for (const [id, s] of scores) scores.set(id, s / max);
   return scores;
 }
+function aboveFloor(similarities, minSimilarity) {
+  return similarities.filter((m) => m.similarity >= minSimilarity);
+}
 var RRF_K;
 var init_memory_rank = __esm({
   "../mcp/src/memory-rank.ts"() {
@@ -22785,24 +22947,66 @@ async function listAllMemories(client, key) {
   return { memories, unverifiable };
 }
 async function rankForSearch(query, all, eligible, semantic, key, now2) {
+  const byId = new Map(eligible.map((m) => [m.id, m]));
+  const hit = (id, score, similarity2) => ({
+    id,
+    score,
+    lexicalScore: termCoverage(query, byId.get(id).payload),
+    semanticScore: similarity2 ? similarity2.get(id) ?? null : null
+  });
   const lexical = scoreMemories(query, eligible, now2);
-  if (!semantic) return { ranked: lexical, fused: false };
-  const matches = await semantic.rank(
+  const lexicalOnly = () => ({ ranked: lexical.map((x) => hit(x.id, x.score, null)), fused: false });
+  if (!semantic) return lexicalOnly();
+  const scored = await semantic.score(
     query,
     all.map((m) => ({ id: m.id, revision: m.revision, text: memoryEmbeddingText(m.payload) })),
     new Set(eligible.map((m) => m.id)),
     key
   );
-  if (!matches) return { ranked: lexical, fused: false };
-  const byId = new Map(eligible.map((m) => [m.id, m]));
+  if (!scored) return lexicalOnly();
+  const similarity = new Map(scored.similarities.map((m) => [m.id, m.similarity]));
   const decay = (id) => {
     const p = byId.get(id).payload;
     return recencyWeight(p.category, p.lastValidatedAt, now2);
   };
-  const dense = matches.map(({ id, similarity }) => ({ id, weighed: similarity * decay(id) })).sort((a, b) => b.weighed - a.weighed || (a.id < b.id ? -1 : 1)).map((x) => x.id);
-  const ranked = [...blendRanks(lexical.map((x) => x.id), dense)].map(([id, score]) => ({ id, score, updatedAt: byId.get(id).payload.updatedAt })).sort((a, b) => b.score - a.score || b.updatedAt.localeCompare(a.updatedAt) || (a.id < b.id ? -1 : 1)).map(({ id, score }) => ({ id, score }));
+  const dense = aboveFloor(scored.similarities, scored.minSimilarity).map(({ id, similarity: sim }) => ({ id, weighed: sim * decay(id) })).sort((a, b) => b.weighed - a.weighed || (a.id < b.id ? -1 : 1)).map((x) => x.id);
+  const ranked = [...blendRanks(lexical.map((x) => x.id), dense)].map(([id, score]) => ({ id, score, updatedAt: byId.get(id).payload.updatedAt })).sort((a, b) => b.score - a.score || b.updatedAt.localeCompare(a.updatedAt) || (a.id < b.id ? -1 : 1)).map(({ id, score }) => hit(id, score, similarity));
   return { ranked, fused: true };
 }
+function listByRecency(eligible) {
+  return [...eligible].sort(compareRecency);
+}
+function compareRecency(a, b) {
+  return b.payload.updatedAt.localeCompare(a.payload.updatedAt) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+function encodeListCursor(m) {
+  const position = { u: m.payload.updatedAt, i: m.id };
+  return Buffer.from(JSON.stringify(position)).toString("base64url");
+}
+function decodeListCursor(cursor) {
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const { u, i } = parsed;
+    return typeof u === "string" && typeof i === "string" && u.length <= 64 && i.length <= 64 ? { u, i } : null;
+  } catch {
+    return null;
+  }
+}
+function listPage(eligible, after, limit) {
+  const ordered = listByRecency(eligible);
+  const start = after === null ? ordered : ordered.filter((m) => compareRecency(m, { id: after.i, payload: { updatedAt: after.u } }) > 0);
+  const page = start.slice(0, limit);
+  const last = page[page.length - 1];
+  return { page, nextCursor: start.length > limit && last ? encodeListCursor(last) : null };
+}
+function hitScores(h) {
+  return {
+    score: round(h.score, 2),
+    lexicalScore: round(h.lexicalScore, 2),
+    semanticScore: h.semanticScore === null ? null : round(h.semanticScore, 3)
+  };
+}
 function view(m, score) {
   const p = m.payload;
   return {
@@ -22823,7 +23027,7 @@ function view(m, score) {
     reviewedAt: p.reviewedAt,
     flaggedAt: p.flaggedAt ?? null,
     updatedAt: p.updatedAt,
-    ...score !== void 0 ? { score: Math.round(score * 100) / 100 } : {}
+    ...typeof score === "number" ? { score: round(score, 2) } : score ?? {}
   };
 }
 function chunkNote(title, markdown, category) {
@@ -23060,33 +23264,45 @@ function registerMemoryTools(server, context, options = {}) {
   };
   server.tool(
     "search_memory",
-    `Search the user's long-term memories (short facts and preferences saved by agents or the user). Ranks active memories by their relevance to the query: matching words in the text, entity and tags, and, when the user has installed local embeddings, similar meaning. Word matching uses ASCII letters and digits only (as in the app's search): other letters, such as accented or non-Latin ones, are ignored by it, so without local embeddings a query or memory written only in them cannot be found. ${NEEDS_REVIEW_HELP} Superseded and invalidated memories are left out unless asked for.`,
+    SEARCH_MEMORY_DESCRIPTION,
     {
-      query: external_exports.string().min(1).max(500).describe("Words to look for"),
+      query: external_exports.string().max(500).optional().describe("Words to look for. Optional when category or entity is given: then the matching memories are listed, newest first"),
       category: external_exports.enum(MEMORY_CATEGORIES).optional().describe("Only this category"),
       entity: external_exports.string().max(MAX_ENTITY).optional().describe("Only memories about this entity (case-insensitive)"),
       includeSuperseded: external_exports.boolean().default(false),
       includeInvalidated: external_exports.boolean().default(false),
-      limit: external_exports.number().int().min(1).max(20).default(5)
+      limit: external_exports.number().int().min(1).max(20).default(5),
+      cursor: external_exports.string().max(200).optional().describe("A listing only (no query): the nextCursor of the previous page, to get the next one")
     },
-    async ({ query, category, entity, includeSuperseded, includeInvalidated, limit }) => {
+    async ({ query, category, entity, includeSuperseded, includeInvalidated, limit, cursor }) => {
+      const wantEntity = entity?.trim().toLowerCase() || void 0;
+      const wantQuery = query?.trim() ? query : void 0;
+      if (wantQuery === void 0 && !category && !wantEntity) return refuse("search_memory", NO_QUERY_OR_FILTER);
+      if (cursor !== void 0 && wantQuery !== void 0) return refuse("search_memory", CURSOR_WITH_QUERY);
+      const after = cursor === void 0 ? null : decodeListCursor(cursor);
+      if (cursor !== void 0 && after === null) return refuse("search_memory", BAD_CURSOR);
       try {
         const ctx = await unlock();
         const { client, key } = ctx;
         const { memories, unverifiable } = await loadAll(client, key);
-        const wantEntity = entity?.trim().toLowerCase();
         const eligible = memories.filter(
           ({ payload: p }) => p.state === "active" || p.state === "superseded" && includeSuperseded || p.state === "invalidated" && includeInvalidated
         ).filter(({ payload: p }) => !category || p.category === category).filter(({ payload: p }) => !wantEntity || p.entity.trim().toLowerCase() === wantEntity);
+        if (wantQuery === void 0) {
+          const { page, nextCursor } = listPage(eligible, after, limit);
+          const results2 = page.map((m) => view(m, NO_SCORES));
+          mcpLog(`memory: search_memory listed=${eligible.length} results=${results2.length} unverifiable=${unverifiable}`);
+          const ranking2 = "none";
+          return ok({ ranking: ranking2, results: results2, total: eligible.length, nextCursor, searched: memories.length, unverifiable });
+        }
         const byId = new Map(eligible.map((m) => [m.id, m]));
-        const { ranked, fused } = await rankForSearch(query, memories, eligible, options.semantic ?? null, key, Date.now());
-        const results = ranked.slice(0, limit).map((x) => view(byId.get(x.id), x.score));
+        const { ranked, fused } = await rankForSearch(wantQuery, memories, eligible, options.semantic ?? null, key, Date.now());
+        const results = ranked.slice(0, limit).map((x) => view(byId.get(x.id), hitScores(x)));
+        const ranking = fused ? "hybrid" : "lexical";
         mcpLog(`memory: search_memory searched=${memories.length} results=${results.length} unverifiable=${unverifiable}`);
-        if (queryTerms(query).length === 0) {
-          const note = fused ? MEANING_ONLY_NOTE : NO_SEARCHABLE_TERMS;
-          return ok({ results, searched: memories.length, unverifiable, note });
-        }
-        return ok({ results, searched: memories.length, unverifiable });
+        const body = { ranking, results, total: ranked.length, nextCursor: null, searched: memories.length, unverifiable };
+        if (!hasSearchableText(wantQuery)) return ok({ ...body, note: fused ? MEANING_ONLY_NOTE : NO_SEARCHABLE_TERMS });
+        return ok(body);
       } catch (err) {
         return fail("search_memory", err);
       }
@@ -23317,7 +23533,7 @@ async function supersedeLanded(client, key, newId, oldId) {
     return false;
   }
 }
-var MEMORY_CATEGORIES, MEMORY_STATES, VIAS, MAX_TEXT, MAX_ENTITY, MAX_REASON, MAX_TAGS, MAX_TAG, MAX_CLIENT_NAME, uuidArg, MAX_IMPORT, CREATED_REVISION, MAX_ENCRYPTED_PAYLOAD_LENGTH, NoteVerificationError, MemoryTooLongError, isStr, isStrOrNull, oneOf, NEAR_DUPLICATE_SCORE, NEAR_DUPLICATE_LIMIT, STORAGE_MESSAGES, KeyContextError, isRetryable, USER_DATA_TEXT, NEEDS_REVIEW_TEXT, PROFILE_TOKEN_BUDGET, CHARS_PER_TOKEN, PROFILE_URI, NO_SEARCHABLE_TERMS, MEANING_ONLY_NOTE, NO_PINNED_MESSAGE, MEMORY_INSTRUCTIONS, NEEDS_REVIEW_HELP, now, MEMORY_CACHE_TTL_MS;
+var MEMORY_CATEGORIES, MEMORY_STATES, VIAS, MAX_TEXT, MAX_ENTITY, MAX_REASON, MAX_TAGS, MAX_TAG, MAX_CLIENT_NAME, uuidArg, MAX_IMPORT, CREATED_REVISION, MAX_ENCRYPTED_PAYLOAD_LENGTH, NoteVerificationError, MemoryTooLongError, isStr, isStrOrNull, oneOf, NEAR_DUPLICATE_SCORE, NEAR_DUPLICATE_LIMIT, round, NO_SCORES, STORAGE_MESSAGES, KeyContextError, isRetryable, USER_DATA_TEXT, NEEDS_REVIEW_TEXT, PROFILE_TOKEN_BUDGET, CHARS_PER_TOKEN, PROFILE_URI, NO_SEARCHABLE_TERMS, MEANING_ONLY_NOTE, CURSOR_WITH_QUERY, BAD_CURSOR, NO_QUERY_OR_FILTER, NO_PINNED_MESSAGE, MEMORY_INSTRUCTIONS, NEEDS_REVIEW_HELP, SEARCH_MEMORY_DESCRIPTION, now, MEMORY_CACHE_TTL_MS;
 var init_memory = __esm({
   "../mcp/src/memory.ts"() {
     "use strict";
@@ -23357,6 +23573,8 @@ var init_memory = __esm({
     oneOf = (xs, x) => isStr(x) && xs.includes(x);
     NEAR_DUPLICATE_SCORE = 0.6;
     NEAR_DUPLICATE_LIMIT = 3;
+    round = (x, places) => Math.round(x * 10 ** places) / 10 ** places;
+    NO_SCORES = { score: null, lexicalScore: null, semanticScore: null };
     STORAGE_MESSAGES = ["Memory limit reached", "Memory storage limit reached"];
     KeyContextError = class extends Error {
       constructor(reason) {
@@ -23374,9 +23592,13 @@ var init_memory = __esm({
     PROFILE_URI = "memory://profile";
     NO_SEARCHABLE_TERMS = "The query has no searchable characters: memory search matches ASCII letters and digits only, so accented or non-Latin text cannot be searched.";
     MEANING_ONLY_NOTE = "The query has no ASCII letters or digits, which word matching ignores: these results were found only by meaning, through local embeddings.";
+    CURSOR_WITH_QUERY = "A cursor pages a listing (a category or entity with no query); a search does not page. Leave out the cursor, or the query.";
+    BAD_CURSOR = "That cursor is not one search_memory returned. Use the nextCursor of the previous page, or leave it out to start again.";
+    NO_QUERY_OR_FILTER = "Nothing to search for: give a query, or a category or entity to list the memories that match it.";
     NO_PINNED_MESSAGE = "No pinned memories yet. Only the user pins memories, in the Squirrel Notes app (Memory); agents cannot pin. Pinned memories appear here. Use search_memory to look for anything else.";
     MEMORY_INSTRUCTIONS = "Squirrel Notes keeps the user's encrypted notes and long-term memories. At the start of a session, call get_memory_profile (or read the resource memory://profile) to load the memories the user has pinned as always relevant (only the user pins, in the app). Use search_memory before asking the user something they may already have told you, and remember_memory, supersede_memory and invalidate_memory to keep memories current. " + NEEDS_REVIEW_TEXT;
     NEEDS_REVIEW_HELP = "`needsReview: true` means the memory was written by an agent and the user has not confirmed it yet; it is still in effect. " + USER_DATA_TEXT;
+    SEARCH_MEMORY_DESCRIPTION = `Search the user's long-term memories (short facts and preferences saved by agents or the user). Ranks active memories by their relevance to the query: matching words in the text, entity and tags, and, when the user has installed local embeddings, similar meaning. Common English words (stopwords such as "what", "does", "he", "is") are ignored by word matching unless the query has nothing else. Word matching uses ASCII letters and digits only (as in the app's search): other letters, such as accented or non-Latin ones, are ignored by it, so without local embeddings a query or memory written only in them cannot be found. The response says which ranking ran: "hybrid" (words and meaning), "lexical" (words only) or "none" (a listing). Each hit has \`score\`, which orders this response only and cannot be compared across searches, and two scores that can: \`lexicalScore\` (0\u20131, the share of the query's words, stopwords aside, that the memory contains; a query word that only begins a memory word counts half) and \`semanticScore\` (the cosine similarity of meaning, null unless the ranking is hybrid). As a guide, measured on a synthetic test set: a hit with semanticScore below 0.45 and lexicalScore below 0.67 is rarely the answer (about 1 in 20); at semanticScore 0.45 or more about half are, and at lexicalScore 0.67 or more (two thirds of the query's words, as delivered) about 9 in 10 are. semanticScore is a cosine, from -1 to 1 (in practice about -0.1 to 0.9). Without a query, a category or entity filter lists the matching memories, newest first, \`limit\` (at most 20) at a time: pass the response's \`nextCursor\` as \`cursor\` for the next page (null on the last). \`total\` is how many match in all; a memory edited during a walk may be missed, so compare against \`total\` or start again. ${NEEDS_REVIEW_HELP} Superseded and invalidated memories are left out unless asked for.`;
     now = () => (/* @__PURE__ */ new Date()).toISOString();
     MEMORY_CACHE_TTL_MS = 6e4;
   }
@@ -24610,6 +24832,7 @@ var memory_semantic_exports = {};
 __export(memory_semantic_exports, {
   RRF_K: () => RRF_K,
   SemanticMemoryIndex: () => SemanticMemoryIndex,
+  aboveFloor: () => aboveFloor,
   blendRanks: () => blendRanks,
   memoryEmbeddingText: () => memoryEmbeddingText
 });
@@ -24648,15 +24871,18 @@ var init_memory_semantic = __esm({
       batchSize;
       settled;
       /**
-       * The `candidates` whose cosine similarity to `query` reaches the model's
-       * minimum, with that similarity, best first; or null, meaning "rank
-       * lexically". The caller weighs them (recency, ADR-0444) before fusing.
+       * Every candidate that has a vector, with its cosine similarity to `query`,
+       * best first, and the model's minimum alongside, from one embedding of the
+       * query; or null, meaning "rank lexically". search_memory fuses those at or
+       * above the minimum (`aboveFloor`), weighed by recency, and reports each
+       * hit's similarity as `semanticScore` (ADR-0444, amended). A candidate not
+       * embedded within the time budget is absent.
        *
        * `all` is every memory the list returned: it decides which vectors are kept
        * on file. `candidates` is the subset search_memory has already filtered
        * (state, category, entity).
        */
-      async rank(query, all, candidates2, dek) {
+      async score(query, all, candidates2, dek) {
         const epoch = this.epoch;
         const state = await this.settledState();
         if (state.kind !== "ready") return null;
@@ -24669,12 +24895,11 @@ var init_memory_semantic = __esm({
           const scored = [];
           for (const id of candidates2) {
             const e = vectors.get(id);
-            if (!e) continue;
-            const similarity = dot(q, e.vector);
-            if (similarity >= embedder.minSimilarity) scored.push({ id, similarity });
+            if (e) scored.push({ id, similarity: dot(q, e.vector) });
           }
           await this.writeChain;
-          return scored.sort((a, b) => b.similarity - a.similarity || (a.id < b.id ? -1 : 1));
+          scored.sort((a, b) => b.similarity - a.similarity || (a.id < b.id ? -1 : 1));
+          return { similarities: scored, minSimilarity: embedder.minSimilarity };
         } catch {
           this.state = { kind: "off" };
           this.options.log("memory: semantic search failed in the embedding runtime; using lexical search for the rest of this session");

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@squirrelnotes.app/mcp-embeddings",
-  "version": "2.1.1-test.341",
+  "version": "2.1.1-test.343",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@squirrelnotes.app/mcp-embeddings",
-      "version": "2.1.1-test.341",
+      "version": "2.1.1-test.343",
       "license": "MIT",
       "dependencies": {
         "onnxruntime-node": "1.30.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squirrelnotes.app/mcp-embeddings",
-  "version": "2.1.1-test.341",
+  "version": "2.1.1-test.343",
   "description": "Opt-in local semantic memory search for the Squirrel Notes MCP (stdio). The embedding model runs on your machine; no memory text is sent anywhere to be embedded.",
   "type": "module",
   "repository": {
@@ -45,7 +45,7 @@
     "onnxruntime-node": "1.30.0"
   },
   "devDependencies": {
-    "@modelcontextprotocol/sdk": "1.27.1",
+    "@modelcontextprotocol/sdk": "1.31.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
     "esbuild": "^0.28.1",