@aeriondyseti/vector-memory-mcp 2.0.0-rc.4 → 2.1.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
@@ -103,14 +103,14 @@ Assistant: [calls search_memories with history_only: true, history_before/after
 
 CLI flags:
 
-| Flag | Default | Description |
-|------|---------|-------------|
-| `--db-file`, `-d` | `.vector-memory/memories.db` | Database location |
-| `--port`, `-p` | `3271` | HTTP server port |
-| `--no-http` | *(HTTP enabled)* | Disable HTTP/SSE transport |
-| `--enable-history` | *(disabled)* | Enable conversation history indexing |
-| `--history-path` | *(auto-detect)* | Path to session log directory |
-| `--history-weight` | `0.75` | Weight for history results in unified search |
+| Flag | Alias | Default | Description |
+|------|-------|---------|-------------|
+| `--db-file <path>` | `-d` | `.vector-memory/memories.db` | Database location (relative to cwd) |
+| `--port <number>` | `-p` | `3271` | HTTP server port |
+| `--no-http` | | *(HTTP enabled)* | Disable HTTP/SSE transport |
+| `--enable-history` | | *(disabled)* | Enable conversation history indexing |
+| `--history-path` | | *(auto-detect)* | Path to session log directory |
+| `--history-weight` | | `0.75` | Weight for history results in unified search |
 
 ---
 

package/package.json

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

package/src/config/index.ts

@@ -59,10 +59,19 @@ export function loadConfig(overrides: ConfigOverrides = {}): Config {
   const enableHttp = overrides.enableHttp ?? true;
 
   return {
-    dbPath: resolvePath(overrides.dbPath ?? DEFAULT_DB_PATH),
+    dbPath: resolvePath(
+      overrides.dbPath
+      ?? process.env.VECTOR_MEMORY_DB_PATH
+      ?? DEFAULT_DB_PATH
+    ),
     embeddingModel: DEFAULT_EMBEDDING_MODEL,
     embeddingDimension: DEFAULT_EMBEDDING_DIMENSION,
-    httpPort: overrides.httpPort ?? DEFAULT_HTTP_PORT,
+    httpPort:
+      overrides.httpPort
+      ?? (process.env.VECTOR_MEMORY_HTTP_PORT
+        ? parseInt(process.env.VECTOR_MEMORY_HTTP_PORT, 10)
+        : undefined)
+      ?? DEFAULT_HTTP_PORT,
     httpHost: DEFAULT_HTTP_HOST,
     enableHttp,
     transportMode,

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

@@ -38,6 +38,15 @@ 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
@@ -157,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;
@@ -165,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) {
@@ -320,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"),
   };
 }
 
@@ -360,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/conversation.service.ts

@@ -9,6 +9,7 @@ import type {
   IndexedSession,
   ParsedMessage,
   SessionFileInfo,
+  SessionIndexDetail,
 } from "../types/conversation.js";
 import type { ConversationHistoryConfig } from "../config/index.js";
 import { resolveSessionLogPath } from "../config/index.js";
@@ -175,12 +176,18 @@ export class ConversationHistoryService {
   async indexConversations(
     path?: string,
     since?: Date
-  ): Promise<{ indexed: number; skipped: number; errors: string[] }> {
+  ): Promise<{
+    indexed: number;
+    skipped: number;
+    errors: string[];
+    details: SessionIndexDetail[];
+  }> {
     if (!this.config.enabled) {
       return {
         indexed: 0,
         skipped: 0,
         errors: ["Conversation history indexing is not enabled"],
+        details: [],
       };
     }
 
@@ -190,6 +197,7 @@ export class ConversationHistoryService {
         indexed: 0,
         skipped: 0,
         errors: ["No session log path configured or detected"],
+        details: [],
       };
     }
 
@@ -203,39 +211,48 @@ export class ConversationHistoryService {
     let indexed = 0;
     let skipped = 0;
     const errors: string[] = [];
+    const details: SessionIndexDetail[] = [];
 
     for (const file of sessionFiles) {
       const existing = indexState.get(file.sessionId);
       if (existing && existing.lastModified >= file.lastModified.getTime()) {
         skipped++;
+        details.push({ sessionId: file.sessionId, project: file.project, status: "skipped" });
         continue;
       }
 
       try {
-        await this.indexSession(file, indexState);
+        const state = await this.indexSession(file, indexState);
         indexed++;
+        details.push({
+          sessionId: file.sessionId,
+          project: file.project,
+          status: "indexed",
+          chunks: state.chunkCount,
+          messages: state.messageCount,
+        });
       } catch (err) {
-        errors.push(
-          `${file.sessionId}: ${err instanceof Error ? err.message : String(err)}`
-        );
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push(`${file.sessionId}: ${message}`);
+        details.push({ sessionId: file.sessionId, project: file.project, status: "error", error: message });
       }
     }
 
     await this.saveIndexState(indexState);
-    return { indexed, skipped, errors };
+    return { indexed, skipped, errors, details };
   }
 
   private async indexSession(
     file: SessionFileInfo,
     indexState: Map<string, IndexedSession>
-  ): Promise<void> {
+  ): Promise<IndexedSession> {
     const messages = await this.parser.parse(
       file.filePath,
       this.config.indexSubagents
     );
     if (messages.length === 0) {
       // Still track it so we don't re-attempt
-      indexState.set(file.sessionId, {
+      const session: IndexedSession = {
         sessionId: file.sessionId,
         filePath: file.filePath,
         project: file.project,
@@ -245,8 +262,9 @@ export class ConversationHistoryService {
         indexedAt: new Date(),
         firstMessageAt: file.lastModified,
         lastMessageAt: file.lastModified,
-      });
-      return;
+      };
+      indexState.set(file.sessionId, session);
+      return session;
     }
 
     const chunks = chunkMessages(
@@ -280,7 +298,7 @@ export class ConversationHistoryService {
     await this.repository.insertBatch(rows);
 
     // Update index state
-    indexState.set(file.sessionId, {
+    const session: IndexedSession = {
       sessionId: file.sessionId,
       filePath: file.filePath,
       project: file.project,
@@ -290,7 +308,9 @@ export class ConversationHistoryService {
       indexedAt: new Date(),
       firstMessageAt: messages[0].timestamp,
       lastMessageAt: messages[messages.length - 1].timestamp,
-    });
+    };
+    indexState.set(file.sessionId, session);
+    return session;
   }
 
   async reindexSession(

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;
@@ -90,6 +90,19 @@ export interface SessionFileInfo {
   lastModified: Date;
 }
 
+/** Outcome status for a single session during indexing */
+export type IndexStatus = "indexed" | "skipped" | "error";
+
+/** Per-session detail returned from indexConversations */
+export interface SessionIndexDetail {
+  sessionId: string;
+  project: string;
+  status: IndexStatus;
+  chunks?: number;
+  messages?: number;
+  error?: string;
+}
+
 /** Search filter options for conversation history */
 export interface HistoryFilters {
   sessionId?: string;