@aeriondyseti/vector-memory-mcp 2.0.0-rc.3 → 2.0.0

package/README.md

@@ -11,7 +11,7 @@ A local-first MCP server that provides vector-based memory storage. Uses local e
 
 ## Features
 
-- **Local & Private** - All embeddings generated locally, data stored in a single SQLite file
+- **Local & Private** - All embeddings generated locally ([all-MiniLM-L6-v2](https://huggingface.co/Xenova/all-MiniLM-L6-v2), 384-dim), data stored in a single SQLite file
 - **Semantic Search** - Hybrid vector + full-text search with intent-based ranking
 - **Batch Operations** - Store, update, delete, and retrieve multiple memories at once
 - **Session Waypoints** - Save and restore project context between sessions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriondyseti/vector-memory-mcp",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0",
   "description": "A zero-configuration RAG memory server for MCP clients",
   "type": "module",
   "main": "src/index.ts",

package/src/config/index.ts

@@ -5,6 +5,11 @@ import packageJson from "../../package.json" with { type: "json" };
 
 export const VERSION = packageJson.version;
 
+/** Debug mode: auto-enabled for pre-release versions (dev/rc), or via VECTOR_MEMORY_DEBUG env var */
+export const DEBUG = process.env.VECTOR_MEMORY_DEBUG === "1"
+  || VERSION.includes("-dev.")
+  || VERSION.includes("-rc.");
+
 export type TransportMode = "stdio" | "http" | "both";
 
 export interface ConversationHistoryConfig {

package/src/db/memory.repository.ts

@@ -181,11 +181,13 @@ export class MemoryRepository {
 
     // Full-text search
     const ftsQuery = sanitizeFtsQuery(query);
-    const ftsResults = this.db
-      .prepare(
-        "SELECT id FROM memories_fts WHERE memories_fts MATCH ? LIMIT ?",
-      )
-      .all(ftsQuery, candidateLimit) as Array<{ id: string }>;
+    const ftsResults: Array<{ id: string }> = ftsQuery
+      ? (this.db
+          .prepare(
+            "SELECT id FROM memories_fts WHERE memories_fts MATCH ? LIMIT ?",
+          )
+          .all(ftsQuery, candidateLimit) as Array<{ id: string }>)
+      : [];
 
     // Compute RRF scores and pick top ids
     const rrfScores = hybridRRF(vectorResults, ftsResults);

package/src/db/sqlite-utils.ts

@@ -29,7 +29,7 @@ export function sanitizeFtsQuery(query: string): string {
 
 /**
  * Compute hybrid RRF scores from two ranked result lists.
- * Returns a map of id -> combined RRF score, sorted descending.
+ * Returns a map of id -> combined RRF score.
  */
 export function hybridRRF(
   vectorResults: Array<{ id: string }>,

package/src/http/server.ts

@@ -198,7 +198,9 @@ export function createHttpApp(memoryService: MemoryService, config: Config): Hon
       // Fetch referenced memories in a single query
       const memoryIds = (waypoint.metadata.memory_ids as string[] | undefined) ?? [];
       const memories = await memoryService.getMultiple(memoryIds);
-      const referencedMemories = memories.map((m) => ({ id: m.id, content: m.content }));
+      const referencedMemories = memories
+        .filter((m) => !isDeleted(m))
+        .map((m) => ({ id: m.id, content: m.content }));
 
       return c.json({
         content: waypoint.content,
@@ -221,7 +223,13 @@ export function createHttpApp(memoryService: MemoryService, config: Config): Hon
       }
 
       const body = await c.req.json().catch(() => ({}));
-      const since = body.since ? new Date(body.since as string) : undefined;
+      let since: Date | undefined;
+      if (body.since) {
+        since = new Date(body.since as string);
+        if (isNaN(since.getTime())) {
+          return c.json({ error: "Invalid 'since' date format" }, 400);
+        }
+      }
       const result = await conversationService.indexConversations(
         body.path as string | undefined,
         since

package/src/index.ts

@@ -16,7 +16,7 @@ async function runMigrate(args: string[]): Promise<void> {
   const config = loadConfig(overrides);
 
   const source = config.dbPath;
-  const target = source + ".sqlite";
+  const target = source.endsWith(".sqlite") ? source.replace(/\.sqlite$/, "-migrated.sqlite") : source + ".sqlite";
 
   if (!isLanceDbDirectory(source)) {
     console.error(

package/src/mcp/handlers.ts

@@ -3,16 +3,64 @@ import type { MemoryService } from "../services/memory.service.js";
 import type { ConversationHistoryService } from "../services/conversation.service.js";
 import type { SearchIntent } from "../types/memory.js";
 import type { HistoryFilters, SearchResult } from "../types/conversation.js";
+import { DEBUG } from "../config/index.js";
+
+/**
+ * Safely coerce a tool argument to an array. Handles the case where the MCP
+ * transport delivers a JSON-serialized string instead of a parsed array.
+ */
+function asArray<T>(value: unknown, fieldName: string): T[] {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    if (DEBUG) {
+      console.error(
+        `[vector-memory-mcp] DEBUG: ${fieldName} received as string (${value.length} chars) instead of array — parsing`
+      );
+    }
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed;
+      if (DEBUG) {
+        console.error(
+          `[vector-memory-mcp] DEBUG: ${fieldName} parsed as ${typeof parsed}, not array`
+        );
+      }
+    } catch { /* fall through */ }
+  } else if (DEBUG) {
+    console.error(
+      `[vector-memory-mcp] DEBUG: ${fieldName} has unexpected type: ${typeof value}`
+    );
+  }
+  throw new Error(`${fieldName} must be an array`);
+}
+
+function errorText(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
+
+function parseDate(value: unknown, fieldName: string): Date | undefined {
+  if (value === undefined) return undefined;
+  const date = new Date(value as string);
+  if (isNaN(date.getTime())) {
+    throw new Error(`${fieldName} is not a valid date`);
+  }
+  return date;
+}
 
 export async function handleStoreMemories(
   args: Record<string, unknown> | undefined,
   service: MemoryService
 ): Promise<CallToolResult> {
-  const memories = args?.memories as Array<{
+  let memories: Array<{
     content: string;
     embedding_text?: string;
     metadata?: Record<string, unknown>;
   }>;
+  try {
+    memories = asArray(args?.memories, "memories");
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: errorText(e) }] };
+  }
 
   const ids: string[] = [];
   for (const item of memories) {
@@ -41,7 +89,12 @@ export async function handleDeleteMemories(
   args: Record<string, unknown> | undefined,
   service: MemoryService
 ): Promise<CallToolResult> {
-  const ids = args?.ids as string[];
+  let ids: string[];
+  try {
+    ids = asArray(args?.ids, "ids");
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: errorText(e) }] };
+  }
   const results: string[] = [];
 
   for (const id of ids) {
@@ -66,16 +119,26 @@ export async function handleUpdateMemories(
   args: Record<string, unknown> | undefined,
   service: MemoryService
 ): Promise<CallToolResult> {
-  const updates = args?.updates as Array<{
+  let updates: Array<{
     id: string;
     content?: string;
     embedding_text?: string;
     metadata?: Record<string, unknown>;
   }>;
+  try {
+    updates = asArray(args?.updates, "updates");
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: errorText(e) }] };
+  }
 
   const results: string[] = [];
 
   for (const update of updates) {
+    if (!update.id || typeof update.id !== "string") {
+      results.push("Skipped update: missing required id field");
+      continue;
+    }
+
     const memory = await service.update(update.id, {
       content: update.content,
       embeddingText: update.embedding_text,
@@ -103,7 +166,10 @@ export async function handleSearchMemories(
   args: Record<string, unknown> | undefined,
   service: MemoryService
 ): Promise<CallToolResult> {
-  const query = args?.query as string;
+  const query = args?.query;
+  if (typeof query !== "string" || query.trim() === "") {
+    return { isError: true, content: [{ type: "text", text: "query is required and must be a non-empty string" }] };
+  }
   const intent = (args?.intent as SearchIntent) ?? "fact_check";
   const limit = (args?.limit as number) ?? 10;
   const includeDeleted = (args?.include_deleted as boolean) ?? false;
@@ -111,10 +177,17 @@ export async function handleSearchMemories(
   // history_only implies include_history
   const includeHistory = historyOnly ? true : (args?.include_history as boolean | undefined);
 
+  let historyFilters: HistoryFilters;
+  try {
+    historyFilters = parseHistoryFilters(args);
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: errorText(e) }] };
+  }
+
   const results = await service.search(query, intent, limit, includeDeleted, {
     includeHistory,
     historyOnly,
-    historyFilters: parseHistoryFilters(args),
+    historyFilters,
   });
 
   if (results.length === 0) {
@@ -166,7 +239,12 @@ export async function handleGetMemories(
   args: Record<string, unknown> | undefined,
   service: MemoryService
 ): Promise<CallToolResult> {
-  const ids = args?.ids as string[];
+  let ids: string[];
+  try {
+    ids = asArray(args?.ids, "ids");
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: errorText(e) }] };
+  }
 
   const memories = await service.getMultiple(ids);
   const memoryMap = new Map(memories.map((m) => [m.id, m]));
@@ -261,12 +339,8 @@ function parseHistoryFilters(
   return {
     sessionId: args?.session_id as string | undefined,
     role: args?.role_filter as string | undefined,
-    after: args?.history_after
-      ? new Date(args.history_after as string)
-      : undefined,
-    before: args?.history_before
-      ? new Date(args.history_before as string)
-      : undefined,
+    after: parseDate(args?.history_after, "history_after"),
+    before: parseDate(args?.history_before, "history_before"),
   };
 }
 
@@ -301,6 +375,9 @@ export async function handleIndexConversations(
   const path = args?.path as string | undefined;
   const sinceStr = args?.since as string | undefined;
   const since = sinceStr ? new Date(sinceStr) : undefined;
+  if (since && isNaN(since.getTime())) {
+    return { isError: true, content: [{ type: "text", text: "Invalid 'since' date format" }] };
+  }
 
   const result = await conversationService.indexConversations(path, since);
 

package/src/migration.ts

@@ -18,6 +18,7 @@ function toEpochMs(value: unknown): number {
   if (typeof value === "number") return value;
   if (value instanceof Date) return value.getTime();
   if (typeof value === "bigint") return Number(value);
+  console.warn(`⚠️ Unexpected timestamp type: ${typeof value} (value: ${value}), using current time`);
   return Date.now();
 }
 
@@ -28,7 +29,10 @@ function toFloatArray(vec: unknown): number[] {
   if (vec && typeof (vec as any).toArray === "function") {
     return Array.from((vec as any).toArray());
   }
-  if (ArrayBuffer.isView(vec)) return Array.from(new Float32Array((vec as DataView).buffer));
+  if (ArrayBuffer.isView(vec)) {
+    const view = vec as DataView;
+    return Array.from(new Float32Array(view.buffer, view.byteOffset, view.byteLength / 4));
+  }
   return [];
 }
 
@@ -226,6 +230,7 @@ export async function migrate(opts: MigrateOptions): Promise<MigrateResult> {
   }
 
   // ── Finalize ────────────────────────────────────────────────────
+  await lanceDb.close?.();
   sqliteDb.close();
 
   const { size } = statSync(target);
@@ -247,8 +252,8 @@ export function formatMigrationSummary(
    ${result.memoriesMigrated} memories, ${result.conversationChunksMigrated} conversation chunks
 
 Next steps:
-   1. Backup:   mv ${source} ${source}.lance-backup
-   2. Activate: mv ${target} ${source}
+   1. Backup:   mv "${source}" "${source}.lance-backup"
+   2. Activate: mv "${target}" "${source}"
    3. Restart your MCP server
 `;
 }

package/src/services/memory.service.ts

@@ -237,6 +237,7 @@ export class MemoryService {
                 updatedAt: row.createdAt,
                 source: "conversation_history" as const,
                 score: row.rrfScore * historyWeight,
+                supersededBy: null,
                 sessionId: (row.metadata?.session_id as string) ?? "",
                 role: (row.metadata?.role as string) ?? "unknown",
                 messageIndexStart: (row.metadata?.message_index_start as number) ?? 0,

package/src/services/parsers/claude-code.parser.ts

@@ -227,6 +227,7 @@ export class ClaudeCodeSessionParser implements SessionLogParser {
       if (since && lastModified <= since) continue;
 
       const sessionId = basename(entry, ".jsonl");
+      if (!UUID_PATTERN.test(sessionId)) continue;
       const project = extractProjectFromDir(projectDir);
 
       files.push({

package/src/types/conversation.ts

@@ -71,7 +71,7 @@ export interface SearchResult {
   source: "memory" | "conversation_history";
   score: number;
   // Memory-specific fields
-  supersededBy?: string | null;
+  supersededBy: string | null;
   usefulness?: number;
   accessCount?: number;
   lastAccessed?: Date | null;