mem0ai 2.1.13 → 2.1.15

package/dist/oss/index.mjs

@@ -331,6 +331,12 @@ var MemoryVectorStore = class {
         payload TEXT NOT NULL
       )
     `);
+    await this.run(`
+      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) => {
@@ -465,6 +471,28 @@ 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`
+    );
+    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
+    ]);
+    return randomUserId;
+  }
+  async setUserId(userId) {
+    await this.run(`DELETE FROM memory_migrations`);
+    await this.run(`INSERT INTO memory_migrations (user_id) VALUES (?)`, [
+      userId
+    ]);
+  }
+  async initialize() {
+    await this.init();
+  }
 };
 
 // src/oss/src/vector_stores/qdrant.ts
@@ -497,49 +525,8 @@ var Qdrant = class {
       this.client = new QdrantClient(params);
     }
     this.collectionName = config.collectionName;
-    this.createCol(config.embeddingModelDims, config.onDisk || false);
-  }
-  async createCol(vectorSize, onDisk, distance = "Cosine") {
-    var _a, _b;
-    try {
-      const collections = await this.client.getCollections();
-      const exists = collections.collections.some(
-        (col) => col.name === this.collectionName
-      );
-      if (!exists) {
-        const vectorParams = {
-          size: vectorSize,
-          distance,
-          on_disk: onDisk
-        };
-        try {
-          await this.client.createCollection(this.collectionName, {
-            vectors: vectorParams
-          });
-        } catch (error) {
-          if ((error == null ? void 0 : error.status) === 409) {
-            const collectionInfo = await this.client.getCollection(
-              this.collectionName
-            );
-            const vectorConfig = (_b = (_a = collectionInfo.config) == null ? void 0 : _a.params) == null ? void 0 : _b.vectors;
-            if (!vectorConfig || vectorConfig.size !== vectorSize) {
-              throw new Error(
-                `Collection ${this.collectionName} exists but has wrong configuration. Expected vector size: ${vectorSize}, got: ${vectorConfig == null ? void 0 : vectorConfig.size}`
-              );
-            }
-            return;
-          }
-          throw error;
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        console.error("Error creating/verifying collection:", error.message);
-      } else {
-        console.error("Error creating/verifying collection:", error);
-      }
-      throw error;
-    }
+    this.dimension = config.dimension || 1536;
+    this.initialize().catch(console.error);
   }
   createFilter(filters) {
     if (!filters) return void 0;
@@ -633,6 +620,131 @@ var Qdrant = class {
     }));
     return [results, response.points.length];
   }
+  generateUUID() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
+      /[xy]/g,
+      function(c) {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      }
+    );
+  }
+  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
+          }
+        });
+      }
+      const result = await this.client.scroll("memory_migrations", {
+        limit: 1,
+        with_payload: true
+      });
+      if (result.points.length > 0) {
+        return (_a2 = result.points[0].payload) == null ? void 0 : _a2.user_id;
+      }
+      const randomUserId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+      await this.client.upsert("memory_migrations", {
+        points: [
+          {
+            id: this.generateUUID(),
+            vector: [0],
+            payload: { user_id: randomUserId }
+          }
+        ]
+      });
+      return randomUserId;
+    } catch (error) {
+      console.error("Error getting user ID:", error);
+      throw error;
+    }
+  }
+  async setUserId(userId) {
+    try {
+      const result = await this.client.scroll("memory_migrations", {
+        limit: 1,
+        with_payload: true
+      });
+      const pointId = result.points.length > 0 ? result.points[0].id : this.generateUUID();
+      await this.client.upsert("memory_migrations", {
+        points: [
+          {
+            id: pointId,
+            vector: [0],
+            payload: { user_id: userId }
+          }
+        ]
+      });
+    } catch (error) {
+      console.error("Error setting user ID:", error);
+      throw error;
+    }
+  }
+  async initialize() {
+    var _a2, _b;
+    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
+            );
+            const vectorConfig = (_b = (_a2 = collectionInfo.config) == null ? void 0 : _a2.params) == null ? void 0 : _b.vectors;
+            if (!vectorConfig || vectorConfig.size !== this.dimension) {
+              throw new Error(
+                `Collection ${this.collectionName} exists but has wrong configuration. Expected vector size: ${this.dimension}, got: ${vectorConfig == null ? void 0 : 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 (error) {
+          if ((error == null ? void 0 : error.status) === 409) {
+          } else {
+            throw error;
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error initializing Qdrant:", error);
+      throw error;
+    }
+  }
 };
 
 // src/oss/src/vector_stores/redis.ts
@@ -729,48 +841,6 @@ var RedisDB = class {
       throw err;
     });
   }
-  async initialize() {
-    try {
-      await this.client.connect();
-      console.log("Connected to Redis");
-      const modulesResponse = await this.client.moduleList();
-      const hasSearch = modulesResponse.some((module) => {
-        var _a;
-        const moduleMap = /* @__PURE__ */ new Map();
-        for (let i = 0; i < module.length; i += 2) {
-          moduleMap.set(module[i], module[i + 1]);
-        }
-        return ((_a = moduleMap.get("name")) == null ? void 0 : _a.toLowerCase()) === "search";
-      });
-      if (!hasSearch) {
-        throw new Error(
-          "RediSearch module is not loaded. Please ensure Redis Stack is properly installed and running."
-        );
-      }
-      let retries = 0;
-      const maxRetries = 3;
-      while (retries < maxRetries) {
-        try {
-          await this.createIndex();
-          console.log("Redis index created successfully");
-          break;
-        } catch (error) {
-          console.error(
-            `Error creating index (attempt ${retries + 1}/${maxRetries}):`,
-            error
-          );
-          retries++;
-          if (retries === maxRetries) {
-            throw error;
-          }
-          await new Promise((resolve) => setTimeout(resolve, 1e3));
-        }
-      }
-    } catch (error) {
-      console.error("Error during Redis initialization:", error);
-      throw error;
-    }
-  }
   async createIndex() {
     try {
       try {
@@ -815,6 +885,52 @@ var RedisDB = class {
       throw error;
     }
   }
+  async initialize() {
+    try {
+      await this.client.connect();
+      console.log("Connected to Redis");
+      const modulesResponse = await this.client.moduleList();
+      const hasSearch = modulesResponse.some((module) => {
+        var _a2;
+        const moduleMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < module.length; i += 2) {
+          moduleMap.set(module[i], module[i + 1]);
+        }
+        return ((_a2 = moduleMap.get("name")) == null ? void 0 : _a2.toLowerCase()) === "search";
+      });
+      if (!hasSearch) {
+        throw new Error(
+          "RediSearch module is not loaded. Please ensure Redis Stack is properly installed and running."
+        );
+      }
+      let retries = 0;
+      const maxRetries = 3;
+      while (retries < maxRetries) {
+        try {
+          await this.createIndex();
+          console.log("Redis index created successfully");
+          break;
+        } catch (error) {
+          console.error(
+            `Error creating index (attempt ${retries + 1}/${maxRetries}):`,
+            error
+          );
+          retries++;
+          if (retries === maxRetries) {
+            throw error;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("Error initializing Redis:", error.message);
+      } else {
+        console.error("Error initializing Redis:", error);
+      }
+      throw error;
+    }
+  }
   async insert(vectors, ids, payloads) {
     const data = vectors.map((vector, idx) => {
       const payload = toSnakeCase(payloads[idx]);
@@ -885,7 +1001,7 @@ var RedisDB = class {
         searchOptions
       );
       return results.documents.map((doc) => {
-        var _a;
+        var _a2;
         const resultPayload = {
           hash: doc.value.hash,
           data: doc.value.memory,
@@ -901,7 +1017,7 @@ var RedisDB = class {
         return {
           id: doc.value.memory_id,
           payload: toCamelCase(resultPayload),
-          score: (_a = Number(doc.value.__vector_score)) != null ? _a : 0
+          score: (_a2 = Number(doc.value.__vector_score)) != null ? _a2 : 0
         };
       });
     } catch (error) {
@@ -1082,6 +1198,28 @@ var RedisDB = class {
   async close() {
     await this.client.quit();
   }
+  async getUserId() {
+    try {
+      const userId = await this.client.get("memory_migrations:1");
+      if (userId) {
+        return userId;
+      }
+      const randomUserId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+      await this.client.set("memory_migrations:1", randomUserId);
+      return randomUserId;
+    } catch (error) {
+      console.error("Error getting user ID:", error);
+      throw error;
+    }
+  }
+  async setUserId(userId) {
+    try {
+      await this.client.set("memory_migrations:1", userId);
+    } catch (error) {
+      console.error("Error setting user ID:", error);
+      throw error;
+    }
+  }
 };
 
 // src/oss/src/llms/ollama.ts
@@ -1090,9 +1228,9 @@ var OllamaLLM = class {
   constructor(config) {
     // Using this variable to avoid calling the Ollama server multiple times
     this.initialized = false;
-    var _a;
+    var _a2;
     this.ollama = new Ollama2({
-      host: ((_a = config.config) == null ? void 0 : _a.url) || "http://localhost:11434"
+      host: ((_a2 = config.config) == null ? void 0 : _a2.url) || "http://localhost:11434"
     });
     this.model = config.model || "llama3.1:8b";
     this.ensureModelExists().catch((err) => {
@@ -1214,6 +1352,12 @@ create table if not exists memories (
   updated_at timestamp with time zone default timezone('utc', now())
 );
 
+-- Create the memory migrations table
+create table if not exists memory_migrations (
+  user_id text primary key,
+  created_at timestamp with time zone default timezone('utc', now())
+);
+
 -- Create the vector similarity search function
 create or replace function match_vectors(
   query_embedding vector(1536),
@@ -1360,6 +1504,39 @@ See the SQL migration instructions in the code comments.`
       throw error;
     }
   }
+  async getUserId() {
+    try {
+      const { data: tableExists } = await this.client.from("memory_migrations").select("user_id").limit(1);
+      if (!tableExists || tableExists.length === 0) {
+        const randomUserId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+        const { error: insertError } = await this.client.from("memory_migrations").insert({ user_id: randomUserId });
+        if (insertError) throw insertError;
+        return randomUserId;
+      }
+      const { data, error } = await this.client.from("memory_migrations").select("user_id").limit(1);
+      if (error) throw error;
+      if (!data || data.length === 0) {
+        const randomUserId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+        const { error: insertError } = await this.client.from("memory_migrations").insert({ user_id: randomUserId });
+        if (insertError) throw insertError;
+        return randomUserId;
+      }
+      return data[0].user_id;
+    } catch (error) {
+      console.error("Error getting user ID:", error);
+      return "anonymous-supabase";
+    }
+  }
+  async setUserId(userId) {
+    try {
+      const { error: deleteError } = await this.client.from("memory_migrations").delete().neq("user_id", "");
+      if (deleteError) throw deleteError;
+      const { error: insertError } = await this.client.from("memory_migrations").insert({ user_id: userId });
+      if (insertError) throw insertError;
+    } catch (error) {
+      console.error("Error setting user ID:", error);
+    }
+  }
 };
 
 // src/oss/src/storage/SQLiteManager.ts
@@ -1529,6 +1706,70 @@ create table ${this.tableName} (
   }
 };
 
+// src/oss/src/embeddings/google.ts
+import { GoogleGenAI } from "@google/genai";
+var GoogleEmbedder = class {
+  constructor(config) {
+    this.google = new GoogleGenAI({ apiKey: config.apiKey });
+    this.model = config.model || "text-embedding-004";
+  }
+  async embed(text) {
+    const response = await this.google.models.embedContent({
+      model: this.model,
+      contents: text,
+      config: { outputDimensionality: 768 }
+    });
+    return response.embeddings[0].values;
+  }
+  async embedBatch(texts) {
+    const response = await this.google.models.embedContent({
+      model: this.model,
+      contents: texts,
+      config: { outputDimensionality: 768 }
+    });
+    return response.embeddings.map((item) => item.values);
+  }
+};
+
+// src/oss/src/llms/google.ts
+import { GoogleGenAI as GoogleGenAI2 } from "@google/genai";
+var GoogleLLM = class {
+  constructor(config) {
+    this.google = new GoogleGenAI2({ apiKey: config.apiKey });
+    this.model = config.model || "gemini-2.0-flash";
+  }
+  async generateResponse(messages, responseFormat, tools) {
+    var _a2;
+    const completion = await this.google.models.generateContent({
+      contents: messages.map((msg) => ({
+        parts: [
+          {
+            text: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+          }
+        ],
+        role: msg.role === "system" ? "model" : "user"
+      })),
+      model: this.model
+      // config: {
+      //   responseSchema: {}, // Add response schema if needed
+      // },
+    });
+    const text = (_a2 = completion.text) == null ? void 0 : _a2.replace(/^```json\n/, "").replace(/\n```$/, "");
+    return text || "";
+  }
+  async generateChat(messages) {
+    const completion = await this.google.models.generateContent({
+      contents: messages,
+      model: this.model
+    });
+    const response = completion.candidates[0].content;
+    return {
+      content: response.parts[0].text || "",
+      role: response.role
+    };
+  }
+};
+
 // src/oss/src/utils/factory.ts
 var EmbedderFactory = class {
   static create(provider, config) {
@@ -1537,6 +1778,8 @@ var EmbedderFactory = class {
         return new OpenAIEmbedder(config);
       case "ollama":
         return new OllamaEmbedder(config);
+      case "google":
+        return new GoogleEmbedder(config);
       default:
         throw new Error(`Unsupported embedder provider: ${provider}`);
     }
@@ -1555,6 +1798,8 @@ var LLMFactory = class {
         return new GroqLLM(config);
       case "ollama":
         return new OllamaLLM(config);
+      case "google":
+        return new GoogleLLM(config);
       default:
         throw new Error(`Unsupported LLM provider: ${provider}`);
     }
@@ -1898,11 +2143,11 @@ var DEFAULT_MEMORY_CONFIG = {
 // src/oss/src/config/manager.ts
 var ConfigManager = class {
   static mergeConfig(userConfig = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     const mergedConfig = {
       version: userConfig.version || DEFAULT_MEMORY_CONFIG.version,
       embedder: {
-        provider: ((_a = userConfig.embedder) == null ? void 0 : _a.provider) || DEFAULT_MEMORY_CONFIG.embedder.provider,
+        provider: ((_a2 = userConfig.embedder) == null ? void 0 : _a2.provider) || DEFAULT_MEMORY_CONFIG.embedder.provider,
         config: {
           apiKey: ((_c = (_b = userConfig.embedder) == null ? void 0 : _b.config) == null ? void 0 : _c.apiKey) || DEFAULT_MEMORY_CONFIG.embedder.config.apiKey,
           model: ((_e = (_d = userConfig.embedder) == null ? void 0 : _d.config) == null ? void 0 : _e.model) || DEFAULT_MEMORY_CONFIG.embedder.config.model
@@ -2152,9 +2397,9 @@ function getDeleteMessages(existingMemoriesString, data, userId) {
 // src/oss/src/memory/graph_memory.ts
 var MemoryGraph = class {
   constructor(config) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
     this.config = config;
-    if (!((_b = (_a = config.graphStore) == null ? void 0 : _a.config) == null ? void 0 : _b.url) || !((_d = (_c = config.graphStore) == null ? void 0 : _c.config) == null ? void 0 : _d.username) || !((_f = (_e = config.graphStore) == null ? void 0 : _e.config) == null ? void 0 : _f.password)) {
+    if (!((_b = (_a2 = config.graphStore) == null ? void 0 : _a2.config) == null ? void 0 : _b.url) || !((_d = (_c = config.graphStore) == null ? void 0 : _c.config) == null ? void 0 : _d.username) || !((_f = (_e = config.graphStore) == null ? void 0 : _e.config) == null ? void 0 : _f.password)) {
       throw new Error("Neo4j configuration is incomplete");
     }
     this.graph = neo4j.driver(
@@ -2308,9 +2553,9 @@ var MemoryGraph = class {
     return entityTypeMap;
   }
   async _establishNodesRelationsFromData(data, filters, entityTypeMap) {
-    var _a;
+    var _a2;
     let messages;
-    if ((_a = this.config.graphStore) == null ? void 0 : _a.customPrompt) {
+    if ((_a2 = this.config.graphStore) == null ? void 0 : _a2.customPrompt) {
       messages = [
         {
           role: "system",
@@ -2469,7 +2714,7 @@ Text: ${data}`
     return results;
   }
   async _addEntities(toBeAdded, userId, entityTypeMap) {
-    var _a, _b;
+    var _a2, _b;
     const results = [];
     const session = this.graph.session();
     try {
@@ -2540,7 +2785,7 @@ Text: ${data}`
             RETURN source.name AS source, type(r) AS relationship, destination.name AS target
           `;
           params = {
-            source_id: (_a = sourceNodeSearchResult[0]) == null ? void 0 : _a.elementId,
+            source_id: (_a2 = sourceNodeSearchResult[0]) == null ? void 0 : _a2.elementId,
             destination_id: (_b = destinationNodeSearchResult[0]) == null ? void 0 : _b.elementId,
             user_id: userId
           };
@@ -2695,6 +2940,76 @@ var parse_vision_messages = async (messages) => {
   return parsed_messages;
 };
 
+// src/oss/src/utils/telemetry.ts
+var version = "2.1.15";
+var MEM0_TELEMETRY = true;
+var _a;
+try {
+  MEM0_TELEMETRY = ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.MEM0_TELEMETRY) === "false" ? false : true;
+} catch (error) {
+}
+var POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX";
+var POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/";
+var UnifiedTelemetry = class {
+  constructor(projectApiKey, host) {
+    this.apiKey = projectApiKey;
+    this.host = host;
+  }
+  async captureEvent(distinctId, eventName, properties = {}) {
+    if (!MEM0_TELEMETRY) return;
+    const eventProperties = {
+      client_version: version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...properties,
+      $process_person_profile: distinctId === "anonymous" || distinctId === "anonymous-supabase" ? false : true,
+      $lib: "posthog-node"
+    };
+    const payload = {
+      api_key: this.apiKey,
+      distinct_id: distinctId,
+      event: eventName,
+      properties: eventProperties
+    };
+    try {
+      const response = await fetch(this.host, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        console.error("Telemetry event capture failed:", await response.text());
+      }
+    } catch (error) {
+      console.error("Telemetry event capture failed:", error);
+    }
+  }
+  async shutdown() {
+  }
+};
+var telemetry = new UnifiedTelemetry(POSTHOG_API_KEY, POSTHOG_HOST);
+async function captureClientEvent(eventName, instance, additionalData = {}) {
+  if (!instance.telemetryId) {
+    console.warn("No telemetry ID found for instance");
+    return;
+  }
+  const eventData = {
+    function: `${instance.constructor.name}`,
+    method: eventName,
+    api_host: instance.host,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    client_version: version,
+    client_source: "nodejs",
+    ...additionalData
+  };
+  await telemetry.captureEvent(
+    instance.telemetryId,
+    `mem0.${eventName}`,
+    eventData
+  );
+}
+
 // src/oss/src/memory/index.ts
 var Memory = class _Memory {
   constructor(config = {}) {
@@ -2729,9 +3044,46 @@ var Memory = class _Memory {
     this.collectionName = this.config.vectorStore.config.collectionName;
     this.apiVersion = this.config.version || "v1.0";
     this.enableGraph = this.config.enableGraph || false;
+    this.telemetryId = "anonymous";
     if (this.enableGraph && this.config.graphStore) {
       this.graphMemory = new MemoryGraph(this.config);
     }
+    this._initializeTelemetry();
+  }
+  async _initializeTelemetry() {
+    try {
+      await this._getTelemetryId();
+      await captureClientEvent("init", this, {
+        api_version: this.apiVersion,
+        client_type: "Memory",
+        collection_name: this.collectionName,
+        enable_graph: this.enableGraph
+      });
+    } catch (error) {
+    }
+  }
+  async _getTelemetryId() {
+    try {
+      if (!this.telemetryId || this.telemetryId === "anonymous" || this.telemetryId === "anonymous-supabase") {
+        this.telemetryId = await this.vectorStore.getUserId();
+      }
+      return this.telemetryId;
+    } catch (error) {
+      this.telemetryId = "anonymous";
+      return this.telemetryId;
+    }
+  }
+  async _captureEvent(methodName, additionalData = {}) {
+    try {
+      await this._getTelemetryId();
+      await captureClientEvent(methodName, this, {
+        ...additionalData,
+        api_version: this.apiVersion,
+        collection_name: this.collectionName
+      });
+    } catch (error) {
+      console.error(`Failed to capture ${methodName} event:`, error);
+    }
   }
   static fromConfig(configDict) {
     try {
@@ -2743,6 +3095,12 @@ var Memory = class _Memory {
     }
   }
   async add(messages, config) {
+    await this._captureEvent("add", {
+      message_count: Array.isArray(messages) ? messages.length : 1,
+      has_metadata: !!config.metadata,
+      has_filters: !!config.filters,
+      infer: config.infer
+    });
     const {
       userId,
       agentId,
@@ -2929,6 +3287,11 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
     return { ...memoryItem, ...filters };
   }
   async search(query, config) {
+    await this._captureEvent("search", {
+      query_length: query.length,
+      limit: config.limit,
+      has_filters: !!config.filters
+    });
     const { userId, agentId, runId, limit = 100, filters = {} } = config;
     if (userId) filters.userId = userId;
     if (agentId) filters.agentId = agentId;
@@ -2979,15 +3342,22 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
     };
   }
   async update(memoryId, data) {
+    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._captureEvent("delete", { memory_id: memoryId });
     await this.deleteMemory(memoryId);
     return { message: "Memory deleted successfully!" };
   }
   async deleteAll(config) {
+    await this._captureEvent("delete_all", {
+      has_user_id: !!config.userId,
+      has_agent_id: !!config.agentId,
+      has_run_id: !!config.runId
+    });
     const { userId, agentId, runId } = config;
     const filters = {};
     if (userId) filters.userId = userId;
@@ -3008,6 +3378,7 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
     return this.db.getHistory(memoryId);
   }
   async reset() {
+    await this._captureEvent("reset");
     await this.db.reset();
     await this.vectorStore.deleteCol();
     if (this.graphMemory) {
@@ -3019,6 +3390,12 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
     );
   }
   async getAll(config) {
+    await this._captureEvent("get_all", {
+      limit: config.limit,
+      has_user_id: !!config.userId,
+      has_agent_id: !!config.agentId,
+      has_run_id: !!config.runId
+    });
     const { userId, agentId, runId, limit = 100 } = config;
     const filters = {};
     if (userId) filters.userId = userId;
@@ -3122,6 +3499,8 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
 export {
   AnthropicLLM,
   EmbedderFactory,
+  GoogleEmbedder,
+  GoogleLLM,
   GroqLLM,
   HistoryManagerFactory,
   LLMFactory,