@melandlabs/memory-store 0.2.6 → 0.2.7

package/dist/{config-BYfTzG3h.d.ts → config-Ll6ktm4D.d.ts}

@@ -155,8 +155,21 @@ interface UnifiedSearchDeps {
     }>>;
 }
 interface MemoryStoreConfig {
-    /** Database handle factory. Required for any persistence. */
+    /**
+     * Database handle factory. Required for the Postgres backend
+     * (`OPENCONTEXT_MEMORY_STORE_BACKEND=postgres`).
+     */
     db?: MemoryStoreDb;
+    /**
+     * Custom SQLite database file path for the default SQLite backend.
+     *
+     * If provided, this takes precedence over the `MEMORY_STORE_DB_PATH`
+     * environment variable and the default `~/.opencontext/memory/store.db`.
+     *
+     * For backward compatibility with early tutorials, `db.path` is also
+     * honoured when `db` is supplied as `{ type, path }`.
+     */
+    dbPath?: string;
     /** Environment helpers. Defaults to a process.env-only stub if omitted. */
     env?: MemoryStoreEnv;
     /** Vector backend config. Defaults to env-based detection. */

package/dist/http.d.ts

@@ -1,4 +1,4 @@
-import { M as MemoryStoreConfig } from './config-BYfTzG3h.js';
+import { M as MemoryStoreConfig } from './config-Ll6ktm4D.js';
 
 /**
  * @melandlabs/memory-store/http — HTTP server entry.

package/dist/http.js

@@ -183,16 +183,17 @@ __export(sqlite_raw_message_store_exports, {
   lexicalSearchRawMessages: () => lexicalSearchRawMessages,
   resolveSQLiteRawMessageDbPath: () => resolveSQLiteRawMessageDbPath
 });
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -265,33 +266,43 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();
     }
   };
 }
+function resolveDbPath(config) {
+  if (!config) return void 0;
+  if (config.dbPath) return config.dbPath;
+  if (config.db && typeof config.db === "object" && "path" in config.db) {
+    return config.db.path;
+  }
+  return void 0;
+}
 function configureRawMessageStore(config) {
   moduleConfig = config;
-  moduleStore = createRawMessageStore({ env: config.env });
+  moduleStore = createRawMessageStore({ env: config.env, dbPath: resolveDbPath(config) });
   return moduleStore;
 }
 function getRawMessageStorageBackend() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getBackend();
 }
 function isRawMessageStorageAvailable() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.isAvailable();
 }
 async function getRawMessageManager() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getManager();
 }
@@ -620,7 +631,8 @@ function createUnifiedSearch(deps = {}) {
           const results = await manager2.searchMessagesSemantically({
             userId: input.userId,
             queryEmbedding,
-            limit
+            limit,
+            threshold
           });
           semantic = results.map((r) => ({
             type: "memory",

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { M as MemoryStoreConfig } from './config-BYfTzG3h.js';
-export { E as EmbedQueryFn, a as MemoryStoreDb, b as MemoryStoreEnv, U as UnifiedSearchInsightsResult, c as UnifiedSearchKnowledgeResult, V as VectorBackend } from './config-BYfTzG3h.js';
+import { M as MemoryStoreConfig } from './config-Ll6ktm4D.js';
+export { E as EmbedQueryFn, a as MemoryStoreDb, b as MemoryStoreEnv, U as UnifiedSearchInsightsResult, c as UnifiedSearchKnowledgeResult, V as VectorBackend } from './config-Ll6ktm4D.js';
 import { UnifiedSearch } from './search/unified-search.js';
 export { UnifiedMemorySearchInput, UnifiedMemorySearchOutput, UnifiedMemorySearchResult, UnifiedMemorySearchSource, UnifiedMemorySearchWarning, clampUnifiedMemorySearchLimit, clampUnifiedMemorySearchThreshold, createUnifiedSearch, isRawMemorySemanticResult, mergeUnifiedMemorySearchResults, normalizeUnifiedMemorySearchSources, toKnowledgeResult, toMemoryResult } from './search/unified-search.js';
 import { RawMessageStore, getRawMessageManager } from './storage/raw-message-store.js';

package/dist/index.js

@@ -114,16 +114,17 @@ __export(sqlite_raw_message_store_exports, {
   lexicalSearchRawMessages: () => lexicalSearchRawMessages,
   resolveSQLiteRawMessageDbPath: () => resolveSQLiteRawMessageDbPath
 });
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -196,33 +197,43 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();
     }
   };
 }
+function resolveDbPath(config) {
+  if (!config) return void 0;
+  if (config.dbPath) return config.dbPath;
+  if (config.db && typeof config.db === "object" && "path" in config.db) {
+    return config.db.path;
+  }
+  return void 0;
+}
 function configureRawMessageStore(config) {
   moduleConfig = config;
-  moduleStore = createRawMessageStore({ env: config.env });
+  moduleStore = createRawMessageStore({ env: config.env, dbPath: resolveDbPath(config) });
   return moduleStore;
 }
 function getRawMessageStorageBackend() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getBackend();
 }
 function isRawMessageStorageAvailable() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.isAvailable();
 }
 async function getRawMessageManager() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getManager();
 }
@@ -551,7 +562,8 @@ function createUnifiedSearch(deps = {}) {
           const results = await manager2.searchMessagesSemantically({
             userId: input.userId,
             queryEmbedding,
-            limit
+            limit,
+            threshold
           });
           semantic = results.map((r) => ({
             type: "memory",
@@ -651,7 +663,8 @@ init_raw_message_store();
 init_raw_message_store();
 init_postgres_raw_message_factory();
 async function createMemoryStore(config = {}) {
-  const raw = createRawMessageStore({ env: config.env });
+  const dbPath = config.dbPath ?? (config.db && "path" in config.db ? config.db.path : void 0);
+  const raw = createRawMessageStore({ env: config.env, dbPath });
   const search = createUnifiedSearch(config.unified);
   configureRawMessageStore(config);
   return {

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { M as MemoryStoreConfig } from './config-BYfTzG3h.js';
+import { M as MemoryStoreConfig } from './config-Ll6ktm4D.js';
 
 /**
  * @melandlabs/memory-store/mcp — MCP server entry.

package/dist/mcp.js

@@ -184,16 +184,17 @@ __export(sqlite_raw_message_store_exports, {
   lexicalSearchRawMessages: () => lexicalSearchRawMessages,
   resolveSQLiteRawMessageDbPath: () => resolveSQLiteRawMessageDbPath
 });
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -266,33 +267,43 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();
     }
   };
 }
+function resolveDbPath(config) {
+  if (!config) return void 0;
+  if (config.dbPath) return config.dbPath;
+  if (config.db && typeof config.db === "object" && "path" in config.db) {
+    return config.db.path;
+  }
+  return void 0;
+}
 function configureRawMessageStore(config) {
   moduleConfig = config;
-  moduleStore = createRawMessageStore({ env: config.env });
+  moduleStore = createRawMessageStore({ env: config.env, dbPath: resolveDbPath(config) });
   return moduleStore;
 }
 function getRawMessageStorageBackend() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getBackend();
 }
 function isRawMessageStorageAvailable() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.isAvailable();
 }
 async function getRawMessageManager() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getManager();
 }
@@ -621,7 +632,8 @@ function createUnifiedSearch(deps = {}) {
           const results = await manager2.searchMessagesSemantically({
             userId: input.userId,
             queryEmbedding,
-            limit
+            limit,
+            threshold
           });
           semantic = results.map((r) => ({
             type: "memory",

package/dist/search/unified-search.d.ts

@@ -1,4 +1,4 @@
-import { d as UnifiedSearchDeps } from '../config-BYfTzG3h.js';
+import { d as UnifiedSearchDeps } from '../config-Ll6ktm4D.js';
 
 /**
  * Pure helpers used by the unified memory search pipeline.

package/dist/search/unified-search.js

@@ -108,16 +108,17 @@ __export(sqlite_raw_message_store_exports, {
   lexicalSearchRawMessages: () => lexicalSearchRawMessages,
   resolveSQLiteRawMessageDbPath: () => resolveSQLiteRawMessageDbPath
 });
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -190,33 +191,43 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();
     }
   };
 }
+function resolveDbPath(config) {
+  if (!config) return void 0;
+  if (config.dbPath) return config.dbPath;
+  if (config.db && typeof config.db === "object" && "path" in config.db) {
+    return config.db.path;
+  }
+  return void 0;
+}
 function configureRawMessageStore(config) {
   moduleConfig = config;
-  moduleStore = createRawMessageStore({ env: config.env });
+  moduleStore = createRawMessageStore({ env: config.env, dbPath: resolveDbPath(config) });
   return moduleStore;
 }
 function getRawMessageStorageBackend() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getBackend();
 }
 function isRawMessageStorageAvailable() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.isAvailable();
 }
 async function getRawMessageManager() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getManager();
 }
@@ -545,7 +556,8 @@ function createUnifiedSearch(deps = {}) {
           const results = await manager2.searchMessagesSemantically({
             userId: input.userId,
             queryEmbedding,
-            limit
+            limit,
+            threshold
           });
           semantic = results.map((r) => ({
             type: "memory",

package/dist/server/cli-http.js

@@ -184,16 +184,17 @@ __export(sqlite_raw_message_store_exports, {
   lexicalSearchRawMessages: () => lexicalSearchRawMessages,
   resolveSQLiteRawMessageDbPath: () => resolveSQLiteRawMessageDbPath
 });
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -266,33 +267,43 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();
     }
   };
 }
+function resolveDbPath(config) {
+  if (!config) return void 0;
+  if (config.dbPath) return config.dbPath;
+  if (config.db && typeof config.db === "object" && "path" in config.db) {
+    return config.db.path;
+  }
+  return void 0;
+}
 function configureRawMessageStore(config) {
   moduleConfig = config;
-  moduleStore = createRawMessageStore({ env: config.env });
+  moduleStore = createRawMessageStore({ env: config.env, dbPath: resolveDbPath(config) });
   return moduleStore;
 }
 function getRawMessageStorageBackend() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getBackend();
 }
 function isRawMessageStorageAvailable() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.isAvailable();
 }
 async function getRawMessageManager() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getManager();
 }
@@ -621,7 +632,8 @@ function createUnifiedSearch(deps = {}) {
           const results = await manager2.searchMessagesSemantically({
             userId: input.userId,
             queryEmbedding,
-            limit
+            limit,
+            threshold
           });
           semantic = results.map((r) => ({
             type: "memory",

package/dist/server/cli-mcp.js

@@ -185,16 +185,17 @@ __export(sqlite_raw_message_store_exports, {
   lexicalSearchRawMessages: () => lexicalSearchRawMessages,
   resolveSQLiteRawMessageDbPath: () => resolveSQLiteRawMessageDbPath
 });
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -267,33 +268,43 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();
     }
   };
 }
+function resolveDbPath(config) {
+  if (!config) return void 0;
+  if (config.dbPath) return config.dbPath;
+  if (config.db && typeof config.db === "object" && "path" in config.db) {
+    return config.db.path;
+  }
+  return void 0;
+}
 function configureRawMessageStore(config) {
   moduleConfig = config;
-  moduleStore = createRawMessageStore({ env: config.env });
+  moduleStore = createRawMessageStore({ env: config.env, dbPath: resolveDbPath(config) });
   return moduleStore;
 }
 function getRawMessageStorageBackend() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getBackend();
 }
 function isRawMessageStorageAvailable() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.isAvailable();
 }
 async function getRawMessageManager() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getManager();
 }
@@ -622,7 +633,8 @@ function createUnifiedSearch(deps = {}) {
           const results = await manager2.searchMessagesSemantically({
             userId: input.userId,
             queryEmbedding,
-            limit
+            limit,
+            threshold
           });
           semantic = results.map((r) => ({
             type: "memory",

package/dist/server/cli-shared.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as UnifiedSearchDeps } from '../config-BYfTzG3h.js';
+import { d as UnifiedSearchDeps } from '../config-Ll6ktm4D.js';
 
 /**
  * Shared argv parsing + `unified.*` wiring for the memory-store CLI bins.

package/dist/server/cli-shared.js

@@ -35,13 +35,14 @@ function isRawMessageChromaEnabled() {
 // src/storage/sqlite-raw-message-store.ts
 var manager = null;
 var DEFAULT_SQLITE_PATH = join(homedir(), ".opencontext", "memory", "store.db");
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -87,7 +88,9 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();

package/dist/storage/postgres-raw-message-factory.d.ts

@@ -1,4 +1,4 @@
-import { b as MemoryStoreEnv } from '../config-BYfTzG3h.js';
+import { b as MemoryStoreEnv } from '../config-Ll6ktm4D.js';
 
 /**
  * Lazy registration slot for the host's Postgres-backed raw message

package/dist/storage/raw-message-store.d.ts

@@ -1,5 +1,5 @@
 import { RawMessageStorageManager } from '@melandlabs/indexeddb/storage';
-import { b as MemoryStoreEnv, M as MemoryStoreConfig } from '../config-BYfTzG3h.js';
+import { b as MemoryStoreEnv, M as MemoryStoreConfig } from '../config-Ll6ktm4D.js';
 
 /**
  * Top-level raw-message store facade.
@@ -45,6 +45,8 @@ type RawMessageStorageManagerWithSearch = RawMessageStorageManager & {
 };
 interface CreateRawMessageStoreOptions {
     env?: MemoryStoreEnv;
+    /** Custom SQLite DB file path. Only used by the SQLite backend. */
+    dbPath?: string;
 }
 interface RawMessageStore {
     getManager(): Promise<RawMessageStorageManagerWithSearch>;

package/dist/storage/raw-message-store.js

@@ -34,13 +34,14 @@ function isRawMessageChromaEnabled() {
 // src/storage/sqlite-raw-message-store.ts
 var manager = null;
 var DEFAULT_SQLITE_PATH = join(homedir(), ".opencontext", "memory", "store.db");
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,
@@ -86,7 +87,9 @@ function createRawMessageStore(options = {}) {
         }
         return pg;
       }
-      return await getSQLiteRawMessageManager();
+      return await getSQLiteRawMessageManager({
+        dbPath: options.dbPath
+      });
     },
     async close() {
       await closeSQLiteRawMessageManager();
@@ -95,26 +98,34 @@ function createRawMessageStore(options = {}) {
 }
 var moduleStore = null;
 var moduleConfig = null;
+function resolveDbPath(config) {
+  if (!config) return void 0;
+  if (config.dbPath) return config.dbPath;
+  if (config.db && typeof config.db === "object" && "path" in config.db) {
+    return config.db.path;
+  }
+  return void 0;
+}
 function configureRawMessageStore(config) {
   moduleConfig = config;
-  moduleStore = createRawMessageStore({ env: config.env });
+  moduleStore = createRawMessageStore({ env: config.env, dbPath: resolveDbPath(config) });
   return moduleStore;
 }
 function getRawMessageStorageBackend() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getBackend();
 }
 function isRawMessageStorageAvailable() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.isAvailable();
 }
 async function getRawMessageManager() {
   if (!moduleStore) {
-    moduleStore = createRawMessageStore({ env: moduleConfig?.env });
+    moduleStore = createRawMessageStore({ env: moduleConfig?.env, dbPath: resolveDbPath(moduleConfig) });
   }
   return moduleStore.getManager();
 }

package/dist/storage/sqlite-raw-message-store.d.ts

@@ -1,5 +1,5 @@
 import { SQLiteRawMessageManager } from '@melandlabs/sqlite';
-import { b as MemoryStoreEnv } from '../config-BYfTzG3h.js';
+import { b as MemoryStoreEnv } from '../config-Ll6ktm4D.js';
 
 /**
  * SQLite-backed raw message store.
@@ -18,13 +18,16 @@ import { b as MemoryStoreEnv } from '../config-BYfTzG3h.js';
  * Resolve the SQLite DB file path from env vars. Exposed so other storage
  * layers (vector index) can stay in sync with the same default.
  */
-declare function resolveSQLiteRawMessageDbPath(): string;
+declare function resolveSQLiteRawMessageDbPath(dbPath?: string): string;
 /**
  * Local SQLite is the default. Every host (Tauri, server, CLI, tests) can
  * open the manager; the only failure mode is filesystem write permission.
  */
 declare function isSQLiteRawMessageStorageAvailable(_env?: MemoryStoreEnv): boolean;
-declare function getSQLiteRawMessageManager(_env?: MemoryStoreEnv): Promise<SQLiteRawMessageManager>;
+declare function getSQLiteRawMessageManager(options?: {
+    env?: MemoryStoreEnv;
+    dbPath?: string;
+}): Promise<SQLiteRawMessageManager>;
 declare function closeSQLiteRawMessageManager(): Promise<void>;
 /**
  * Test-only: reset the singleton. Used by vitest between test cases.

package/dist/storage/sqlite-raw-message-store.js

@@ -27,16 +27,17 @@ function isRawMessageChromaEnabled() {
 // src/storage/sqlite-raw-message-store.ts
 var manager = null;
 var DEFAULT_SQLITE_PATH = join(homedir(), ".opencontext", "memory", "store.db");
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
+  if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
 }
-async function getSQLiteRawMessageManager(_env) {
+async function getSQLiteRawMessageManager(options = {}) {
   if (!manager) {
-    const dbPath = resolveSQLiteRawMessageDbPath();
+    const dbPath = resolveSQLiteRawMessageDbPath(options.dbPath);
     mkdirSync(dirname(dbPath), { recursive: true });
     manager = new SQLiteRawMessageManager({
       dbPath,

package/dist/storage/sqlite-vector-index.d.ts

@@ -1,5 +1,5 @@
 import { VectorSearchResult } from '@melandlabs/rag/vector-service';
-import { b as MemoryStoreEnv } from '../config-BYfTzG3h.js';
+import { b as MemoryStoreEnv } from '../config-Ll6ktm4D.js';
 
 /**
  * SQLite-vec-backed raw-message + insight vector index.

package/dist/storage/sqlite-vector-index.js

@@ -9,7 +9,7 @@ import '@melandlabs/rag';
 
 // src/storage/sqlite-raw-message-store.ts
 var DEFAULT_SQLITE_PATH = join(homedir(), ".opencontext", "memory", "store.db");
-function resolveSQLiteRawMessageDbPath() {
+function resolveSQLiteRawMessageDbPath(dbPath) {
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
   return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melandlabs/memory-store",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "type": "module",
   "files": [
     "dist",
@@ -60,14 +60,14 @@
     "@modelcontextprotocol/sdk": "^1.25.3",
     "hono": "^4.6.14",
     "zod": "^4.3.6",
-    "@melandlabs/shared": "0.2.0",
-    "@melandlabs/sqlite": "0.2.0",
-    "@melandlabs/ai": "0.2.0",
-    "@melandlabs/rag": "0.2.0"
+    "@melandlabs/ai": "0.2.1",
+    "@melandlabs/sqlite": "0.2.1",
+    "@melandlabs/shared": "0.2.1",
+    "@melandlabs/rag": "0.2.1"
   },
   "peerDependencies": {
-    "@melandlabs/ai-rag": "0.2.2",
-    "@melandlabs/indexeddb": "0.2.0"
+    "@melandlabs/ai-rag": "0.2.3",
+    "@melandlabs/indexeddb": "0.2.1"
   },
   "peerDependenciesMeta": {
     "@melandlabs/ai-rag": {
@@ -80,8 +80,8 @@
   "devDependencies": {
     "@types/node": "^22.13.10",
     "typescript": "^5.6.3",
-    "@melandlabs/ai-rag": "0.2.2",
-    "@melandlabs/config": "0.2.0"
+    "@melandlabs/config": "0.2.1",
+    "@melandlabs/ai-rag": "0.2.3"
   },
   "scripts": {
     "build": "tsup",