mem0ai 2.2.4 → 2.4.0

package/dist/oss/index.js

@@ -83,6 +83,7 @@ var MemoryConfigSchema = import_zod.z.object({
     config: import_zod.z.object({
       collectionName: import_zod.z.string().optional(),
       dimension: import_zod.z.number().optional(),
+      dbPath: import_zod.z.string().optional(),
       client: import_zod.z.any().optional()
     }).passthrough()
   }),
@@ -122,7 +123,10 @@ var MemoryConfigSchema = import_zod.z.object({
 var import_openai = __toESM(require("openai"));
 var OpenAIEmbedder = class {
   constructor(config) {
-    this.openai = new import_openai.default({ apiKey: config.apiKey });
+    this.openai = new import_openai.default({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL || config.url
+    });
     this.model = config.model || "text-embedding-3-small";
     this.embeddingDims = config.embeddingDims || 1536;
   }
@@ -470,57 +474,56 @@ var MistralLLM = class {
 };
 
 // src/oss/src/vector_stores/memory.ts
-var import_sqlite3 = __toESM(require("sqlite3"));
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+
+// src/oss/src/utils/sqlite.ts
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
+function getDefaultVectorStoreDbPath() {
+  return import_path.default.join(import_os.default.homedir(), ".mem0", "vector_store.db");
+}
+function ensureSQLiteDirectory(dbPath) {
+  if (!dbPath || dbPath === ":memory:" || dbPath.startsWith("file:")) {
+    return;
+  }
+  import_fs.default.mkdirSync(import_path.default.dirname(dbPath), { recursive: true });
+}
+
+// src/oss/src/vector_stores/memory.ts
 var MemoryVectorStore = class {
   constructor(config) {
     this.dimension = config.dimension || 1536;
-    this.dbPath = import_path.default.join(process.cwd(), "vector_store.db");
-    if (config.dbPath) {
-      this.dbPath = config.dbPath;
+    this.dbPath = config.dbPath || getDefaultVectorStoreDbPath();
+    if (!config.dbPath) {
+      const oldDefault = import_path2.default.join(process.cwd(), "vector_store.db");
+      if (import_fs2.default.existsSync(oldDefault) && oldDefault !== this.dbPath) {
+        console.warn(
+          `[mem0] Default vector_store.db location changed from ${oldDefault} to ${this.dbPath}. Move your existing file or set vectorStore.config.dbPath explicitly.`
+        );
+      }
     }
-    this.db = new import_sqlite3.default.Database(this.dbPath);
-    this.init().catch(console.error);
+    ensureSQLiteDirectory(this.dbPath);
+    this.db = new import_better_sqlite3.default(this.dbPath);
+    this.init();
   }
-  async init() {
-    await this.run(`
+  init() {
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS vectors (
         id TEXT PRIMARY KEY,
         vector BLOB NOT NULL,
         payload TEXT NOT NULL
       )
     `);
-    await this.run(`
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS memory_migrations (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         user_id TEXT NOT NULL UNIQUE
       )
     `);
   }
-  async run(sql, params = []) {
-    return new Promise((resolve, reject) => {
-      this.db.run(sql, params, (err) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    });
-  }
-  async all(sql, params = []) {
-    return new Promise((resolve, reject) => {
-      this.db.all(sql, params, (err, rows) => {
-        if (err) reject(err);
-        else resolve(rows);
-      });
-    });
-  }
-  async getOne(sql, params = []) {
-    return new Promise((resolve, reject) => {
-      this.db.get(sql, params, (err, row) => {
-        if (err) reject(err);
-        else resolve(row);
-      });
-    });
-  }
   cosineSimilarity(a, b) {
     let dotProduct = 0;
     let normA = 0;
@@ -539,18 +542,23 @@ var MemoryVectorStore = class {
     );
   }
   async insert(vectors, ids, payloads) {
-    for (let i = 0; i < vectors.length; i++) {
-      if (vectors[i].length !== this.dimension) {
-        throw new Error(
-          `Vector dimension mismatch. Expected ${this.dimension}, got ${vectors[i].length}`
-        );
+    const stmt = this.db.prepare(
+      `INSERT OR REPLACE INTO vectors (id, vector, payload) VALUES (?, ?, ?)`
+    );
+    const insertMany = this.db.transaction(
+      (vecs, vIds, vPayloads) => {
+        for (let i = 0; i < vecs.length; i++) {
+          if (vecs[i].length !== this.dimension) {
+            throw new Error(
+              `Vector dimension mismatch. Expected ${this.dimension}, got ${vecs[i].length}`
+            );
+          }
+          const vectorBuffer = Buffer.from(new Float32Array(vecs[i]).buffer);
+          stmt.run(vIds[i], vectorBuffer, JSON.stringify(vPayloads[i]));
+        }
       }
-      const vectorBuffer = Buffer.from(new Float32Array(vectors[i]).buffer);
-      await this.run(
-        `INSERT OR REPLACE INTO vectors (id, vector, payload) VALUES (?, ?, ?)`,
-        [ids[i], vectorBuffer, JSON.stringify(payloads[i])]
-      );
-    }
+    );
+    insertMany(vectors, ids, payloads);
   }
   async search(query, limit = 10, filters) {
     if (query.length !== this.dimension) {
@@ -558,10 +566,14 @@ var MemoryVectorStore = class {
         `Query dimension mismatch. Expected ${this.dimension}, got ${query.length}`
       );
     }
-    const rows = await this.all(`SELECT * FROM vectors`);
+    const rows = this.db.prepare(`SELECT * FROM vectors`).all();
     const results = [];
     for (const row of rows) {
-      const vector = new Float32Array(row.vector.buffer);
+      const vector = new Float32Array(
+        row.vector.buffer,
+        row.vector.byteOffset,
+        row.vector.byteLength / 4
+      );
       const payload = JSON.parse(row.payload);
       const memoryVector = {
         id: row.id,
@@ -581,9 +593,7 @@ var MemoryVectorStore = class {
     return results.slice(0, limit);
   }
   async get(vectorId) {
-    const row = await this.getOne(`SELECT * FROM vectors WHERE id = ?`, [
-      vectorId
-    ]);
+    const row = this.db.prepare(`SELECT * FROM vectors WHERE id = ?`).get(vectorId);
     if (!row) return null;
     const payload = JSON.parse(row.payload);
     return {
@@ -598,27 +608,29 @@ var MemoryVectorStore = class {
       );
     }
     const vectorBuffer = Buffer.from(new Float32Array(vector).buffer);
-    await this.run(`UPDATE vectors SET vector = ?, payload = ? WHERE id = ?`, [
-      vectorBuffer,
-      JSON.stringify(payload),
-      vectorId
-    ]);
+    this.db.prepare(`UPDATE vectors SET vector = ?, payload = ? WHERE id = ?`).run(vectorBuffer, JSON.stringify(payload), vectorId);
   }
   async delete(vectorId) {
-    await this.run(`DELETE FROM vectors WHERE id = ?`, [vectorId]);
+    this.db.prepare(`DELETE FROM vectors WHERE id = ?`).run(vectorId);
   }
   async deleteCol() {
-    await this.run(`DROP TABLE IF EXISTS vectors`);
-    await this.init();
+    this.db.exec(`DROP TABLE IF EXISTS vectors`);
+    this.init();
   }
   async list(filters, limit = 100) {
-    const rows = await this.all(`SELECT * FROM vectors`);
+    const rows = this.db.prepare(`SELECT * FROM vectors`).all();
     const results = [];
     for (const row of rows) {
       const payload = JSON.parse(row.payload);
       const memoryVector = {
         id: row.id,
-        vector: Array.from(new Float32Array(row.vector.buffer)),
+        vector: Array.from(
+          new Float32Array(
+            row.vector.buffer,
+            row.vector.byteOffset,
+            row.vector.byteLength / 4
+          )
+        ),
         payload
       };
       if (this.filterVector(memoryVector, filters)) {
@@ -631,32 +643,26 @@ var MemoryVectorStore = class {
     return [results.slice(0, limit), results.length];
   }
   async getUserId() {
-    const row = await this.getOne(
-      `SELECT user_id FROM memory_migrations LIMIT 1`
-    );
+    const row = this.db.prepare(`SELECT user_id FROM memory_migrations LIMIT 1`).get();
     if (row) {
       return row.user_id;
     }
     const randomUserId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-    await this.run(`INSERT INTO memory_migrations (user_id) VALUES (?)`, [
-      randomUserId
-    ]);
+    this.db.prepare(`INSERT INTO memory_migrations (user_id) VALUES (?)`).run(randomUserId);
     return randomUserId;
   }
   async setUserId(userId) {
-    await this.run(`DELETE FROM memory_migrations`);
-    await this.run(`INSERT INTO memory_migrations (user_id) VALUES (?)`, [
-      userId
-    ]);
+    this.db.prepare(`DELETE FROM memory_migrations`).run();
+    this.db.prepare(`INSERT INTO memory_migrations (user_id) VALUES (?)`).run(userId);
   }
   async initialize() {
-    await this.init();
+    this.init();
   }
 };
 
 // src/oss/src/vector_stores/qdrant.ts
 var import_js_client_rest = require("@qdrant/js-client-rest");
-var fs = __toESM(require("fs"));
+var fs3 = __toESM(require("fs"));
 var Qdrant = class {
   constructor(config) {
     if (config.client) {
@@ -676,8 +682,8 @@ var Qdrant = class {
       if (!Object.keys(params).length) {
         params.path = config.path;
         if (!config.onDisk && config.path) {
-          if (fs.existsSync(config.path) && fs.statSync(config.path).isDirectory()) {
-            fs.rmSync(config.path, { recursive: true });
+          if (fs3.existsSync(config.path) && fs3.statSync(config.path).isDirectory()) {
+            fs3.rmSync(config.path, { recursive: true });
           }
         }
       }
@@ -792,19 +798,7 @@ var Qdrant = class {
   async getUserId() {
     var _a2;
     try {
-      const collections = await this.client.getCollections();
-      const userCollectionExists = collections.collections.some(
-        (col) => col.name === "memory_migrations"
-      );
-      if (!userCollectionExists) {
-        await this.client.createCollection("memory_migrations", {
-          vectors: {
-            size: 1,
-            distance: "Cosine",
-            on_disk: false
-          }
-        });
-      }
+      await this.ensureCollection("memory_migrations", 1);
       const result = await this.client.scroll("memory_migrations", {
         limit: 1,
         with_payload: true
@@ -849,56 +843,50 @@ var Qdrant = class {
       throw error;
     }
   }
-  async initialize() {
-    var _a2, _b;
+  async ensureCollection(name, size) {
+    var _a2, _b, _c;
     try {
-      const collections = await this.client.getCollections();
-      const exists = collections.collections.some(
-        (c) => c.name === this.collectionName
-      );
-      if (!exists) {
-        try {
-          await this.client.createCollection(this.collectionName, {
-            vectors: {
-              size: this.dimension,
-              distance: "Cosine"
-            }
-          });
-        } catch (error) {
-          if ((error == null ? void 0 : error.status) === 409) {
-            const collectionInfo = await this.client.getCollection(
-              this.collectionName
-            );
+      await this.client.createCollection(name, {
+        vectors: {
+          size,
+          distance: "Cosine"
+        }
+      });
+    } catch (error) {
+      if ((error == null ? void 0 : error.status) === 409) {
+        if (name === this.collectionName) {
+          try {
+            const collectionInfo = await this.client.getCollection(name);
             const vectorConfig = (_b = (_a2 = collectionInfo.config) == null ? void 0 : _a2.params) == null ? void 0 : _b.vectors;
-            if (!vectorConfig || vectorConfig.size !== this.dimension) {
+            if (vectorConfig && vectorConfig.size !== size) {
               throw new Error(
-                `Collection ${this.collectionName} exists but has wrong configuration. Expected vector size: ${this.dimension}, got: ${vectorConfig == null ? void 0 : vectorConfig.size}`
+                `Collection ${name} exists but has wrong vector size. Expected: ${size}, got: ${vectorConfig.size}`
               );
             }
-          } else {
-            throw error;
-          }
-        }
-      }
-      const userExists = collections.collections.some(
-        (c) => c.name === "memory_migrations"
-      );
-      if (!userExists) {
-        try {
-          await this.client.createCollection("memory_migrations", {
-            vectors: {
-              size: 1,
-              // Minimal size since we only store user_id
-              distance: "Cosine"
+          } catch (verifyError) {
+            if ((_c = verifyError == null ? void 0 : verifyError.message) == null ? void 0 : _c.includes("wrong vector size")) {
+              throw verifyError;
             }
-          });
-        } catch (error) {
-          if ((error == null ? void 0 : error.status) === 409) {
-          } else {
-            throw error;
+            console.warn(
+              `Collection '${name}' exists (409) but dimension verification failed: ${(verifyError == null ? void 0 : verifyError.message) || verifyError}. Proceeding anyway.`
+            );
           }
         }
+      } else {
+        throw error;
       }
+    }
+  }
+  async initialize() {
+    if (!this._initPromise) {
+      this._initPromise = this._doInitialize();
+    }
+    return this._initPromise;
+  }
+  async _doInitialize() {
+    try {
+      await this.ensureCollection(this.collectionName, this.dimension);
+      await this.ensureCollection("memory_migrations", 1);
     } catch (error) {
       console.error("Error initializing Qdrant:", error);
       throw error;
@@ -1193,6 +1181,12 @@ var VectorizeDB = class {
     }
   }
   async initialize() {
+    if (!this._initPromise) {
+      this._initPromise = this._doInitialize();
+    }
+    return this._initPromise;
+  }
+  async _doInitialize() {
     var _a2, _b, _c, _d, _e;
     try {
       let indexFound = false;
@@ -1416,6 +1410,12 @@ var RedisDB = class {
     }
   }
   async initialize() {
+    if (!this._initPromise) {
+      this._initPromise = this._doInitialize();
+    }
+    return this._initPromise;
+  }
+  async _doInitialize() {
     try {
       await this.client.connect();
       console.log("Connected to Redis");
@@ -1848,6 +1848,12 @@ var SupabaseDB = class {
     });
   }
   async initialize() {
+    if (!this._initPromise) {
+      this._initPromise = this._doInitialize();
+    }
+    return this._initPromise;
+  }
+  async _doInitialize() {
     try {
       const testVector = Array(1536).fill(0);
       try {
@@ -2072,14 +2078,15 @@ See the SQL migration instructions in the code comments.`
 };
 
 // src/oss/src/storage/SQLiteManager.ts
-var import_sqlite32 = __toESM(require("sqlite3"));
+var import_better_sqlite32 = __toESM(require("better-sqlite3"));
 var SQLiteManager = class {
   constructor(dbPath) {
-    this.db = new import_sqlite32.default.Database(dbPath);
-    this.init().catch(console.error);
+    ensureSQLiteDirectory(dbPath);
+    this.db = new import_better_sqlite32.default(dbPath);
+    this.init();
   }
-  async init() {
-    await this.run(`
+  init() {
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS memory_history (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         memory_id TEXT NOT NULL,
@@ -2091,48 +2098,32 @@ var SQLiteManager = class {
         is_deleted INTEGER DEFAULT 0
       )
     `);
-  }
-  async run(sql, params = []) {
-    return new Promise((resolve, reject) => {
-      this.db.run(sql, params, (err) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    });
-  }
-  async all(sql, params = []) {
-    return new Promise((resolve, reject) => {
-      this.db.all(sql, params, (err, rows) => {
-        if (err) reject(err);
-        else resolve(rows);
-      });
-    });
+    this.stmtInsert = this.db.prepare(
+      `INSERT INTO memory_history
+      (memory_id, previous_value, new_value, action, created_at, updated_at, is_deleted)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    this.stmtSelect = this.db.prepare(
+      "SELECT * FROM memory_history WHERE memory_id = ? ORDER BY id DESC"
+    );
   }
   async addHistory(memoryId, previousValue, newValue, action, createdAt, updatedAt, isDeleted = 0) {
-    await this.run(
-      `INSERT INTO memory_history 
-      (memory_id, previous_value, new_value, action, created_at, updated_at, is_deleted)
-      VALUES (?, ?, ?, ?, ?, ?, ?)`,
-      [
-        memoryId,
-        previousValue,
-        newValue,
-        action,
-        createdAt,
-        updatedAt,
-        isDeleted
-      ]
+    this.stmtInsert.run(
+      memoryId,
+      previousValue,
+      newValue,
+      action,
+      createdAt != null ? createdAt : null,
+      updatedAt != null ? updatedAt : null,
+      isDeleted
     );
   }
   async getHistory(memoryId) {
-    return this.all(
-      "SELECT * FROM memory_history WHERE memory_id = ? ORDER BY id DESC",
-      [memoryId]
-    );
+    return this.stmtSelect.all(memoryId);
   }
   async reset() {
-    await this.run("DROP TABLE IF EXISTS memory_history");
-    await this.init();
+    this.db.exec("DROP TABLE IF EXISTS memory_history");
+    this.init();
   }
   close() {
     this.db.close();
@@ -2260,7 +2251,7 @@ var GoogleEmbedder = class {
     const response = await this.google.models.embedContent({
       model: this.model,
       contents: texts,
-      config: { outputDimensionality: 768 }
+      config: { outputDimensionality: this.embeddingDims }
     });
     return response.embeddings.map((item) => item.values);
   }
@@ -2655,7 +2646,7 @@ function getUpdateMemoryMessages(retrievedOldMemory, newRetrievedFacts) {
   Do not return anything except the JSON format.`;
 }
 function removeCodeBlocks(text) {
-  return text.replace(/```[^`]*```/g, "");
+  return text.replace(/```(?:\w+)?\n?([\s\S]*?)```/g, "$1").trim();
 }
 
 // src/oss/src/graphs/tools.ts
@@ -3160,6 +3151,12 @@ var AzureAISearch = class {
    * Initialize the Azure AI Search index if it doesn't exist
    */
   async initialize() {
+    if (!this._initPromise) {
+      this._initPromise = this._doInitialize();
+    }
+    return this._initPromise;
+  }
+  async _doInitialize() {
     try {
       const collections = await this.listCols();
       if (!collections.includes(this.indexName)) {
@@ -3731,7 +3728,7 @@ var DEFAULT_MEMORY_CONFIG = {
 // src/oss/src/config/manager.ts
 var ConfigManager = class {
   static mergeConfig(userConfig = {}) {
-    var _a2, _b, _c;
+    var _a2, _b, _c, _d, _e, _f, _g;
     const mergedConfig = {
       version: userConfig.version || DEFAULT_MEMORY_CONFIG.version,
       embedder: {
@@ -3749,6 +3746,7 @@ var ConfigManager = class {
           return {
             apiKey: (userConf == null ? void 0 : userConf.apiKey) !== void 0 ? userConf.apiKey : defaultConf.apiKey,
             model: finalModel,
+            baseURL: userConf == null ? void 0 : userConf.baseURL,
             url: userConf == null ? void 0 : userConf.url,
             embeddingDims: userConf == null ? void 0 : userConf.embeddingDims,
             modelProperties: (userConf == null ? void 0 : userConf.modelProperties) !== void 0 ? userConf.modelProperties : defaultConf.modelProperties
@@ -3758,24 +3756,22 @@ var ConfigManager = class {
       vectorStore: {
         provider: ((_b = userConfig.vectorStore) == null ? void 0 : _b.provider) || DEFAULT_MEMORY_CONFIG.vectorStore.provider,
         config: (() => {
-          var _a3;
+          var _a3, _b2, _c2;
           const defaultConf = DEFAULT_MEMORY_CONFIG.vectorStore.config;
           const userConf = (_a3 = userConfig.vectorStore) == null ? void 0 : _a3.config;
+          const explicitDimension = (userConf == null ? void 0 : userConf.dimension) || ((_c2 = (_b2 = userConfig.embedder) == null ? void 0 : _b2.config) == null ? void 0 : _c2.embeddingDims) || void 0;
           if ((userConf == null ? void 0 : userConf.client) && typeof userConf.client === "object") {
             return {
               client: userConf.client,
-              // Include other fields from userConf if necessary, or omit defaults
               collectionName: userConf.collectionName,
-              // Can be undefined
-              dimension: userConf.dimension || defaultConf.dimension,
-              // Merge dimension
+              dimension: explicitDimension,
               ...userConf
               // Include any other passthrough fields from user
             };
           } else {
             return {
               collectionName: (userConf == null ? void 0 : userConf.collectionName) || defaultConf.collectionName,
-              dimension: (userConf == null ? void 0 : userConf.dimension) || defaultConf.dimension,
+              dimension: explicitDimension,
               // Ensure client is not carried over from defaults if not provided by user
               client: void 0,
               // Include other passthrough fields from userConf even if no client
@@ -3804,16 +3800,28 @@ var ConfigManager = class {
           };
         })()
       },
-      historyDbPath: userConfig.historyDbPath || DEFAULT_MEMORY_CONFIG.historyDbPath,
+      historyDbPath: userConfig.historyDbPath || ((_e = (_d = userConfig.historyStore) == null ? void 0 : _d.config) == null ? void 0 : _e.historyDbPath) || ((_g = (_f = DEFAULT_MEMORY_CONFIG.historyStore) == null ? void 0 : _f.config) == null ? void 0 : _g.historyDbPath),
       customPrompt: userConfig.customPrompt,
       graphStore: {
         ...DEFAULT_MEMORY_CONFIG.graphStore,
         ...userConfig.graphStore
       },
-      historyStore: {
-        ...DEFAULT_MEMORY_CONFIG.historyStore,
-        ...userConfig.historyStore
-      },
+      historyStore: (() => {
+        var _a3, _b2;
+        const defaultHistoryStore = DEFAULT_MEMORY_CONFIG.historyStore;
+        const historyProvider = ((_a3 = userConfig.historyStore) == null ? void 0 : _a3.provider) || defaultHistoryStore.provider;
+        const isSqlite = historyProvider.toLowerCase() === "sqlite";
+        return {
+          ...defaultHistoryStore,
+          ...userConfig.historyStore,
+          provider: historyProvider,
+          config: {
+            ...isSqlite ? defaultHistoryStore.config : {},
+            ...isSqlite && userConfig.historyDbPath ? { historyDbPath: userConfig.historyDbPath } : {},
+            ...(_b2 = userConfig.historyStore) == null ? void 0 : _b2.config
+          }
+        };
+      })(),
       disableHistory: userConfig.disableHistory || DEFAULT_MEMORY_CONFIG.disableHistory,
       enableGraph: userConfig.enableGraph || DEFAULT_MEMORY_CONFIG.enableGraph
     };
@@ -3923,6 +3931,8 @@ Memory Format:
 source -- relationship -- destination
 
 Provide a list of deletion instructions, each specifying the relationship to be deleted.
+
+Respond in JSON format.
 `;
 function getDeleteMessages(existingMemoriesString, data, userId) {
   return [
@@ -4060,7 +4070,7 @@ var MemoryGraph = class {
       [
         {
           role: "system",
-          content: `You are a smart assistant who understands entities and their types in a given text. If user message contains self reference such as 'I', 'me', 'my' etc. then use ${filters["userId"]} as the source entity. Extract all the entities from the text. ***DO NOT*** answer the question itself if the given text is a question.`
+          content: `You are a smart assistant who understands entities and their types in a given text. If user message contains self reference such as 'I', 'me', 'my' etc. then use ${filters["userId"]} as the source entity. Extract all the entities from the text. ***DO NOT*** answer the question itself if the given text is a question. Respond in JSON format.`
         },
         { role: "user", content: data }
       ],
@@ -4558,10 +4568,6 @@ var Memory = class _Memory {
       this.config.embedder.provider,
       this.config.embedder.config
     );
-    this.vectorStore = VectorStoreFactory.create(
-      this.config.vectorStore.provider,
-      this.config.vectorStore.config
-    );
     this.llm = LLMFactory.create(
       this.config.llm.provider,
       this.config.llm.config
@@ -4569,16 +4575,10 @@ var Memory = class _Memory {
     if (this.config.disableHistory) {
       this.db = new DummyHistoryManager();
     } else {
-      const defaultConfig = {
-        provider: "sqlite",
-        config: {
-          historyDbPath: this.config.historyDbPath || ":memory:"
-        }
-      };
-      this.db = this.config.historyStore && !this.config.disableHistory ? HistoryManagerFactory.create(
+      this.db = HistoryManagerFactory.create(
         this.config.historyStore.provider,
         this.config.historyStore
-      ) : HistoryManagerFactory.create("sqlite", defaultConfig);
+      );
     }
     this.collectionName = this.config.vectorStore.config.collectionName;
     this.apiVersion = this.config.version || "v1.0";
@@ -4587,7 +4587,51 @@ var Memory = class _Memory {
     if (this.enableGraph && this.config.graphStore) {
       this.graphMemory = new MemoryGraph(this.config);
     }
-    this._initializeTelemetry();
+    this._initPromise = this._autoInitialize().catch((error) => {
+      this._initError = error instanceof Error ? error : new Error(String(error));
+      console.error(this._initError);
+    });
+  }
+  /**
+   * If no explicit dimension was provided, runs a probe embedding to
+   * detect it. Then creates and initializes the vector store.
+   */
+  async _autoInitialize() {
+    if (!this.config.vectorStore.config.dimension) {
+      try {
+        const probe = await this.embedder.embed("dimension probe");
+        this.config.vectorStore.config.dimension = probe.length;
+      } catch (error) {
+        throw new Error(
+          `Failed to auto-detect embedding dimension from provider '${this.config.embedder.provider}': ${error.message}. Please set 'dimension' in vectorStore.config or 'embeddingDims' in embedder.config explicitly.`
+        );
+      }
+    }
+    this.vectorStore = VectorStoreFactory.create(
+      this.config.vectorStore.provider,
+      this.config.vectorStore.config
+    );
+    await this.vectorStore.initialize();
+    await this._initializeTelemetry();
+  }
+  /**
+   * Ensures that auto-initialization (dimension detection + vector store
+   * creation) has completed before any public method proceeds.
+   * If a previous init attempt failed, retries automatically.
+   */
+  async _ensureInitialized() {
+    await this._initPromise;
+    if (this._initError) {
+      this._initError = void 0;
+      this._initPromise = this._autoInitialize().catch((error) => {
+        this._initError = error instanceof Error ? error : new Error(String(error));
+        console.error(this._initError);
+      });
+      await this._initPromise;
+      if (this._initError) {
+        throw this._initError;
+      }
+    }
   }
   async _initializeTelemetry() {
     try {
@@ -4634,6 +4678,7 @@ var Memory = class _Memory {
     }
   }
   async add(messages, config) {
+    await this._ensureInitialized();
     await this._captureEvent("add", {
       message_count: Array.isArray(messages) ? messages.length : 1,
       has_metadata: !!config.metadata,
@@ -4820,6 +4865,7 @@ ${parsedMessages}`
     return results;
   }
   async get(memoryId) {
+    await this._ensureInitialized();
     const memory = await this.vectorStore.get(memoryId);
     if (!memory) return null;
     const filters = {
@@ -4852,6 +4898,7 @@ ${parsedMessages}`
     return { ...memoryItem, ...filters };
   }
   async search(query, config) {
+    await this._ensureInitialized();
     await this._captureEvent("search", {
       query_length: query.length,
       limit: config.limit,
@@ -4907,17 +4954,20 @@ ${parsedMessages}`
     };
   }
   async update(memoryId, data) {
+    await this._ensureInitialized();
     await this._captureEvent("update", { memory_id: memoryId });
     const embedding = await this.embedder.embed(data);
     await this.updateMemory(memoryId, data, { [data]: embedding });
     return { message: "Memory updated successfully!" };
   }
   async delete(memoryId) {
+    await this._ensureInitialized();
     await this._captureEvent("delete", { memory_id: memoryId });
     await this.deleteMemory(memoryId);
     return { message: "Memory deleted successfully!" };
   }
   async deleteAll(config) {
+    await this._ensureInitialized();
     await this._captureEvent("delete_all", {
       has_user_id: !!config.userId,
       has_agent_id: !!config.agentId,
@@ -4940,9 +4990,11 @@ ${parsedMessages}`
     return { message: "Memories deleted successfully!" };
   }
   async history(memoryId) {
+    await this._ensureInitialized();
     return this.db.getHistory(memoryId);
   }
   async reset() {
+    await this._ensureInitialized();
     await this._captureEvent("reset");
     await this.db.reset();
     if (this.config.vectorStore.provider.toLowerCase() !== "langchain") {
@@ -4966,18 +5018,19 @@ ${parsedMessages}`
       this.config.embedder.provider,
       this.config.embedder.config
     );
-    this.vectorStore = VectorStoreFactory.create(
-      this.config.vectorStore.provider,
-      this.config.vectorStore.config
-      // This will pass the original client instance back
-    );
     this.llm = LLMFactory.create(
       this.config.llm.provider,
       this.config.llm.config
     );
-    this._initializeTelemetry();
+    this._initError = void 0;
+    this._initPromise = this._autoInitialize().catch((error) => {
+      this._initError = error instanceof Error ? error : new Error(String(error));
+      console.error(this._initError);
+    });
+    await this._initPromise;
   }
   async getAll(config) {
+    await this._ensureInitialized();
     await this._captureEvent("get_all", {
       limit: config.limit,
       has_user_id: !!config.userId,