memvid-mcp-server 1.0.0 → 1.0.1

package/dist/index.js

@@ -4,7 +4,213 @@
 import"dotenv/config";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { registerAllTools } from "./tools/index.js";
+
+// src/tools/definitions.ts
+import { z } from "zod";
+var ProjectNameSchema = z.string().describe("Unique identifier for the project");
+var CreateMemorySchema = z.object({
+  project_name: ProjectNameSchema
+});
+var AddContentSchema = z.object({
+  project_name: ProjectNameSchema,
+  content: z.string().describe("The text content to store"),
+  title: z.string().optional().describe("Title of the document"),
+  metadata: z.record(z.string(), z.any()).optional().describe("Key-value pairs for metadata"),
+  tags: z.array(z.string()).optional().describe("Array of string tags"),
+  enable_embedding: z.boolean().default(false).optional().describe("Enable vector embedding generation (requires AI provider setup)")
+});
+var SearchMemorySchema = z.object({
+  project_name: ProjectNameSchema,
+  query: z.string().describe("The search query"),
+  limit: z.number().default(5).optional(),
+  mode: z.enum(["auto", "lex", "sem"]).default("auto").optional().describe("Search mode: 'lex' (keyword), 'sem' (semantic/vector), 'auto' (smart selection)")
+});
+var AskMemorySchema = z.object({
+  project_name: ProjectNameSchema,
+  question: z.string().describe("The natural language question to ask")
+});
+
+// src/memory_manager.ts
+import { create, use } from "@memvid/sdk";
+import path from "path";
+import fs from "fs";
+import os from "os";
+
+class MemoryManager {
+  static instance;
+  memories;
+  storageDir;
+  constructor() {
+    this.memories = new Map;
+    this.storageDir = path.join(os.homedir(), ".memvid_mcp");
+    this.ensureStorageDir();
+  }
+  static getInstance() {
+    if (!MemoryManager.instance) {
+      MemoryManager.instance = new MemoryManager;
+    }
+    return MemoryManager.instance;
+  }
+  ensureStorageDir() {
+    if (!fs.existsSync(this.storageDir)) {
+      fs.mkdirSync(this.storageDir, { recursive: true });
+    }
+  }
+  getStoragePath(projectName) {
+    const safeName = projectName.replace(/[^a-z0-9_-]/gi, "_");
+    return path.join(this.storageDir, `${safeName}.mv2`);
+  }
+  async getMemory(projectName) {
+    if (this.memories.has(projectName)) {
+      return this.memories.get(projectName);
+    }
+    const memoryPath = this.getStoragePath(projectName);
+    console.error(`[Memvid] Loading memory: ${memoryPath}`);
+    let mem;
+    try {
+      if (!fs.existsSync(memoryPath)) {
+        mem = await create(memoryPath);
+      } else {
+        mem = await use("basic", memoryPath);
+      }
+      this.memories.set(projectName, mem);
+      return mem;
+    } catch (error) {
+      console.error(`[Memvid] Failed to load memory for ${projectName}:`, error);
+      throw error;
+    }
+  }
+}
+
+// src/tools/create.ts
+function registerCreateMemory(server) {
+  server.tool("create_or_open_memory", "Initialize or open a Memvid memory file for a specific project.", CreateMemorySchema.shape, async ({ project_name }) => {
+    const manager = MemoryManager.getInstance();
+    const path2 = manager.getStoragePath(project_name);
+    await manager.getMemory(project_name);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Successfully initialized memory for project '${project_name}' at ${path2}`
+        }
+      ]
+    };
+  });
+}
+
+// src/tools/add.ts
+function registerAddContent(server) {
+  server.tool("add_content", "Add a text document/content to the project's memory.", AddContentSchema.shape, async (args) => {
+    const manager = MemoryManager.getInstance();
+    const mem = await manager.getMemory(args.project_name);
+    await mem.put({
+      text: args.content,
+      title: args.title,
+      metadata: args.metadata,
+      labels: args.tags,
+      enableEmbedding: args.enable_embedding
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Added content to '${args.project_name}' memory.`
+        }
+      ]
+    };
+  });
+}
+
+// src/tools/search.ts
+function registerSearchMemory(server) {
+  server.tool("search_memory", "Search for content in the project's memory using semantic search.", SearchMemorySchema.shape, async (args) => {
+    const manager = MemoryManager.getInstance();
+    const mem = await manager.getMemory(args.project_name);
+    const results = await mem.find(args.query, {
+      k: args.limit,
+      mode: args.mode
+    });
+    const hits = results.hits || [];
+    const formatted = hits.map((hit) => {
+      return `[Title: ${hit.title || "Untitled"}]
+${hit.snippet || hit.text}
+(Score: ${hit.score})`;
+    }).join(`
+
+---
+
+`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatted || "No results found."
+        }
+      ]
+    };
+  });
+}
+
+// src/tools/ask.ts
+function registerAskMemory(server) {
+  server.tool("ask_memory", "Ask a natural language question about the content in the project's memory.", AskMemorySchema.shape, async (args) => {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: OPENAI_API_KEY environment variable is not set."
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      const manager = MemoryManager.getInstance();
+      const mem = await manager.getMemory(args.project_name);
+      const answer = await mem.ask(args.question, {
+        model: "gpt-4o",
+        modelApiKey: apiKey
+      });
+      const answerText = answer.text || answer.answer || JSON.stringify(answer);
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof answerText === "string" ? answerText : JSON.stringify(answerText)
+          }
+        ]
+      };
+    } catch (e) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error asking question: ${e.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+
+// src/tools/index.ts
+function registerAllTools(server) {
+  registerCreateMemory(server);
+  registerAddContent(server);
+  registerSearchMemory(server);
+  if (process.env.OPENAI_API_KEY) {
+    registerAskMemory(server);
+    console.error("AskMemory tool enabled (API key found).");
+  } else {
+    console.error("AskMemory tool disabled (no OPENAI_API_KEY found).");
+  }
+}
+
+// src/index.ts
 var server = new McpServer({
   name: "memvid-mcp-server",
   version: "1.0.0"

package/package.json

@@ -2,7 +2,7 @@
   "name": "memvid-mcp-server",
   "module": "index.ts",
   "description": "MCP Server for Memvid",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "logo": "https://memvid.io/logo.png",
   "keywords": [
     "mcp",
@@ -29,7 +29,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node --external '*'",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --packages external",
     "prepublishOnly": "bun run build"
   },
   "type": "module",