@bojanrajkovic/mcp-paprika 1.0.0 → 1.0.3

package/dist/features/discover-feature.js

@@ -1,4 +1,4 @@
-import { EmbeddingClient } from "./embeddings.js";
+import { EmbeddingClient, EMBEDDING_SCHEMA_VERSION } from "./embeddings.js";
 import { VectorStore } from "./vector-store.js";
 import { registerDiscoverTool } from "../tools/discover.js";
 import { getCacheDir } from "../utils/xdg.js";
@@ -9,13 +9,16 @@ export async function setupDiscoverFeature(server, ctx, sync, config) {
         return;
     }
     const embedder = new EmbeddingClient(embeddingsConfig);
-    const vectorStore = new VectorStore(getCacheDir(), embedder);
+    const vectorStore = new VectorStore(getCacheDir(), embedder, embeddingsConfig.model, EMBEDDING_SCHEMA_VERSION);
     await vectorStore.init();
     registerDiscoverTool(server, ctx, vectorStore);
     // Cold-start initial indexing: the initial sync.syncOnce() in index.ts fires
-    // sync:complete BEFORE this subscription exists. On first-ever startup (empty
-    // vector index), explicitly index all recipes already in the store.
-    if (vectorStore.size === 0 && ctx.store.size > 0) {
+    // sync:complete BEFORE this subscription exists. Re-index all recipes when
+    // the vector store is empty or significantly out of sync with the recipe
+    // store (e.g. stale test data, orphaned entries from a prior crash, or
+    // a model/dimension change that invalidated the old vectors).
+    if (ctx.store.size > 0 && vectorStore.size < ctx.store.size * 0.9) {
+        vectorStore.clearHashes();
         await vectorStore.indexRecipes(ctx.store.getAll(), (uids) => ctx.store.resolveCategories(uids));
     }
     sync.events.on("sync:complete", async (result) => {

package/dist/features/embeddings.d.ts

@@ -56,6 +56,14 @@ export declare class EmbeddingClient {
      */
     embed(text: string): Promise<Array<number>>;
 }
+/**
+ * Schema version for the embedding text format.
+ *
+ * Bump this whenever `recipeToEmbeddingText` changes (fields added/removed,
+ * format restructured) so that the vector store detects the change and
+ * triggers a full re-index on next startup.
+ */
+export declare const EMBEDDING_SCHEMA_VERSION = 1;
 /**
  * Convert a recipe to text suitable for embedding.
  *

package/dist/features/embeddings.js

@@ -157,6 +157,14 @@ export class EmbeddingClient {
         return first;
     }
 }
+/**
+ * Schema version for the embedding text format.
+ *
+ * Bump this whenever `recipeToEmbeddingText` changes (fields added/removed,
+ * format restructured) so that the vector store detects the change and
+ * triggers a full re-index on next startup.
+ */
+export const EMBEDDING_SCHEMA_VERSION = 1;
 /**
  * Convert a recipe to text suitable for embedding.
  *

package/dist/features/vector-store.d.ts

@@ -47,16 +47,27 @@ import type { Recipe, CategoryUid } from "../paprika/types.js";
 export declare class VectorStore {
     private readonly _vectorsDir;
     private readonly _hashIndexPath;
+    private readonly _metaPath;
     private readonly _index;
     private readonly _embedder;
+    private readonly _modelId;
+    private readonly _schemaVersion;
     private _hashes;
-    constructor(cacheDir: string, embedder: EmbeddingClient);
+    constructor(cacheDir: string, embedder: EmbeddingClient, modelId: string, schemaVersion: number);
     init(): Promise<void>;
     private _loadHashIndex;
+    private _loadMeta;
+    private _persistMeta;
     private _backupFile;
     indexRecipes(recipes: ReadonlyArray<Recipe>, resolveCats: (uids: ReadonlyArray<CategoryUid>) => ReadonlyArray<string>): Promise<IndexingResult>;
     indexRecipe(recipe: Readonly<Recipe>, categoryNames: ReadonlyArray<string>): Promise<IndexingResult>;
     get size(): number;
+    /**
+     * Reset the in-memory hash index so that the next `indexRecipes()` call
+     * re-embeds every recipe regardless of prior state.  The stale on-disk
+     * hash file is overwritten once indexing persists the new hashes.
+     */
+    clearHashes(): void;
     private _persistHashes;
     search(query: string, topK?: number): Promise<ReadonlyArray<SemanticResult>>;
     removeRecipe(uid: string): Promise<void>;

package/dist/features/vector-store.js

@@ -39,17 +39,27 @@ function isNodeError(error) {
 function log(msg) {
     process.stderr.write(`[mcp-paprika:vectors] ${msg}\n`);
 }
+const VectorMetaSchema = z.object({
+    model: z.string(),
+    schemaVersion: z.number().int().optional(),
+});
 export class VectorStore {
     _vectorsDir;
     _hashIndexPath;
+    _metaPath;
     _index;
     _embedder;
+    _modelId;
+    _schemaVersion;
     _hashes = {};
-    constructor(cacheDir, embedder) {
+    constructor(cacheDir, embedder, modelId, schemaVersion) {
         this._vectorsDir = join(cacheDir, "vectors");
         this._hashIndexPath = join(this._vectorsDir, "hash-index.json");
+        this._metaPath = join(this._vectorsDir, "vector-meta.json");
         this._index = new LocalIndex(this._vectorsDir);
         this._embedder = embedder;
+        this._modelId = modelId;
+        this._schemaVersion = schemaVersion;
     }
     async init() {
         await mkdir(this._vectorsDir, { recursive: true });
@@ -70,6 +80,18 @@ export class VectorStore {
         }
         // Load hash map — follows DiskCache pattern (disk-cache.ts:60-88)
         await this._loadHashIndex();
+        // Invalidate vectors when the embedding model or schema version changes.
+        const meta = await this._loadMeta();
+        if (meta !== null) {
+            if (meta.model !== this._modelId) {
+                log(`embedding model changed (${meta.model} → ${this._modelId}), clearing vector index`);
+                this._hashes = {};
+            }
+            else if ((meta.schemaVersion ?? 0) !== this._schemaVersion) {
+                log(`embedding schema version changed (${String(meta.schemaVersion ?? 0)} → ${String(this._schemaVersion)}), clearing vector index`);
+                this._hashes = {};
+            }
+        }
     }
     async _loadHashIndex() {
         let raw;
@@ -102,6 +124,36 @@ export class VectorStore {
         }
         this._hashes = result.data;
     }
+    async _loadMeta() {
+        let raw;
+        try {
+            raw = await readFile(this._metaPath, "utf-8");
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+        try {
+            return VectorMetaSchema.parse(JSON.parse(raw));
+        }
+        catch {
+            return null;
+        }
+    }
+    async _persistMeta() {
+        const tmpPath = join(this._vectorsDir, `.vector-meta-${Date.now().toString()}.tmp`);
+        const fh = await open(tmpPath, "w");
+        try {
+            await fh.writeFile(JSON.stringify({ model: this._modelId, schemaVersion: this._schemaVersion }));
+            await fh.sync();
+        }
+        finally {
+            await fh.close();
+        }
+        await rename(tmpPath, this._metaPath);
+    }
     async _backupFile(src, dest) {
         try {
             await rename(src, dest);
@@ -158,11 +210,12 @@ export class VectorStore {
                 cause: error instanceof Error ? error : undefined,
             });
         }
-        // Update hash map
+        // Update hash map and model metadata
         for (const entry of toEmbed) {
             this._hashes[entry.recipe.uid] = entry.hash;
         }
         await this._persistHashes();
+        await this._persistMeta();
         return { indexed: toEmbed.length, skipped, total: recipes.length };
     }
     async indexRecipe(recipe, categoryNames) {
@@ -171,6 +224,14 @@ export class VectorStore {
     get size() {
         return Object.keys(this._hashes).length;
     }
+    /**
+     * Reset the in-memory hash index so that the next `indexRecipes()` call
+     * re-embeds every recipe regardless of prior state.  The stale on-disk
+     * hash file is overwritten once indexing persists the new hashes.
+     */
+    clearHashes() {
+        this._hashes = {};
+    }
     async _persistHashes() {
         const tmpPath = join(this._vectorsDir, `.hash-index-${Date.now().toString()}.tmp`);
         const fh = await open(tmpPath, "w");
@@ -185,7 +246,7 @@ export class VectorStore {
     }
     async search(query, topK = 10) {
         const vector = await this._embedder.embed(query);
-        const results = await this._index.queryItems(vector, topK);
+        const results = await this._index.queryItems(vector, query, topK);
         return results.map((r) => ({
             uid: r.item.id,
             score: r.score,

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@bojanrajkovic/mcp-paprika",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "MCP server for Paprika recipe manager",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bojanrajkovic/mcp-paprika"
+  },
   "bin": {
     "mcp-paprika": "dist/index.js"
   },