mem0ai 2.1.9 → 2.1.10

package/dist/oss/index.d.mts

@@ -21,6 +21,15 @@ interface VectorStoreConfig {
     dimension?: number;
     [key: string]: any;
 }
+interface HistoryStoreConfig {
+    provider: string;
+    config: {
+        historyDbPath?: string;
+        supabaseUrl?: string;
+        supabaseKey?: string;
+        tableName?: string;
+    };
+}
 interface LLMConfig {
     provider?: string;
     config?: Record<string, any>;
@@ -52,6 +61,8 @@ interface MemoryConfig {
         provider: string;
         config: LLMConfig;
     };
+    historyStore?: HistoryStoreConfig;
+    disableHistory?: boolean;
     historyDbPath?: string;
     customPrompt?: string;
     graphStore?: GraphStoreConfig;
@@ -216,6 +227,17 @@ declare const MemoryConfigSchema: z.ZodObject<{
         } | undefined;
         customPrompt?: string | undefined;
     }>>;
+    historyStore: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        config: Record<string, any>;
+    }, {
+        provider: string;
+        config: Record<string, any>;
+    }>>;
+    disableHistory: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     embedder: {
         provider: string;
@@ -257,6 +279,11 @@ declare const MemoryConfigSchema: z.ZodObject<{
         } | undefined;
         customPrompt?: string | undefined;
     } | undefined;
+    historyStore?: {
+        provider: string;
+        config: Record<string, any>;
+    } | undefined;
+    disableHistory?: boolean | undefined;
 }, {
     embedder: {
         provider: string;
@@ -298,6 +325,11 @@ declare const MemoryConfigSchema: z.ZodObject<{
         } | undefined;
         customPrompt?: string | undefined;
     } | undefined;
+    historyStore?: {
+        provider: string;
+        config: Record<string, any>;
+    } | undefined;
+    disableHistory?: boolean | undefined;
 }>;
 
 interface Entity {
@@ -528,6 +560,13 @@ declare class RedisDB implements VectorStore {
     close(): Promise<void>;
 }
 
+interface HistoryManager {
+    addHistory(memoryId: string, previousValue: string | null, newValue: string | null, action: string, createdAt?: string, updatedAt?: string, isDeleted?: number): Promise<void>;
+    getHistory(memoryId: string): Promise<any[]>;
+    reset(): Promise<void>;
+    close(): void;
+}
+
 declare class EmbedderFactory {
     static create(provider: string, config: EmbeddingConfig): Embedder;
 }
@@ -537,5 +576,8 @@ declare class LLMFactory {
 declare class VectorStoreFactory {
     static create(provider: string, config: VectorStoreConfig): VectorStore;
 }
+declare class HistoryManagerFactory {
+    static create(provider: string, config: HistoryStoreConfig): HistoryManager;
+}
 
-export { type AddMemoryOptions, AnthropicLLM, type DeleteAllMemoryOptions, type Embedder, EmbedderFactory, type EmbeddingConfig, type Entity, type GetAllMemoryOptions, type GraphStoreConfig, GroqLLM, type LLM, type LLMConfig, LLMFactory, type LLMResponse, Memory, type MemoryConfig, MemoryConfigSchema, type MemoryItem, MemoryVectorStore, type Message, type MultiModalMessages, type Neo4jConfig, OllamaEmbedder, OllamaLLM, OpenAIEmbedder, OpenAILLM, OpenAIStructuredLLM, Qdrant, RedisDB, type SearchFilters, type SearchMemoryOptions, type SearchResult, type VectorStore, type VectorStoreConfig, VectorStoreFactory, type VectorStoreResult };
+export { type AddMemoryOptions, AnthropicLLM, type DeleteAllMemoryOptions, type Embedder, EmbedderFactory, type EmbeddingConfig, type Entity, type GetAllMemoryOptions, type GraphStoreConfig, GroqLLM, HistoryManagerFactory, type HistoryStoreConfig, type LLM, type LLMConfig, LLMFactory, type LLMResponse, Memory, type MemoryConfig, MemoryConfigSchema, type MemoryItem, MemoryVectorStore, type Message, type MultiModalMessages, type Neo4jConfig, OllamaEmbedder, OllamaLLM, OpenAIEmbedder, OpenAILLM, OpenAIStructuredLLM, Qdrant, RedisDB, type SearchFilters, type SearchMemoryOptions, type SearchResult, type VectorStore, type VectorStoreConfig, VectorStoreFactory, type VectorStoreResult };

package/dist/oss/index.d.ts

@@ -21,6 +21,15 @@ interface VectorStoreConfig {
     dimension?: number;
     [key: string]: any;
 }
+interface HistoryStoreConfig {
+    provider: string;
+    config: {
+        historyDbPath?: string;
+        supabaseUrl?: string;
+        supabaseKey?: string;
+        tableName?: string;
+    };
+}
 interface LLMConfig {
     provider?: string;
     config?: Record<string, any>;
@@ -52,6 +61,8 @@ interface MemoryConfig {
         provider: string;
         config: LLMConfig;
     };
+    historyStore?: HistoryStoreConfig;
+    disableHistory?: boolean;
     historyDbPath?: string;
     customPrompt?: string;
     graphStore?: GraphStoreConfig;
@@ -216,6 +227,17 @@ declare const MemoryConfigSchema: z.ZodObject<{
         } | undefined;
         customPrompt?: string | undefined;
     }>>;
+    historyStore: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        config: Record<string, any>;
+    }, {
+        provider: string;
+        config: Record<string, any>;
+    }>>;
+    disableHistory: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     embedder: {
         provider: string;
@@ -257,6 +279,11 @@ declare const MemoryConfigSchema: z.ZodObject<{
         } | undefined;
         customPrompt?: string | undefined;
     } | undefined;
+    historyStore?: {
+        provider: string;
+        config: Record<string, any>;
+    } | undefined;
+    disableHistory?: boolean | undefined;
 }, {
     embedder: {
         provider: string;
@@ -298,6 +325,11 @@ declare const MemoryConfigSchema: z.ZodObject<{
         } | undefined;
         customPrompt?: string | undefined;
     } | undefined;
+    historyStore?: {
+        provider: string;
+        config: Record<string, any>;
+    } | undefined;
+    disableHistory?: boolean | undefined;
 }>;
 
 interface Entity {
@@ -528,6 +560,13 @@ declare class RedisDB implements VectorStore {
     close(): Promise<void>;
 }
 
+interface HistoryManager {
+    addHistory(memoryId: string, previousValue: string | null, newValue: string | null, action: string, createdAt?: string, updatedAt?: string, isDeleted?: number): Promise<void>;
+    getHistory(memoryId: string): Promise<any[]>;
+    reset(): Promise<void>;
+    close(): void;
+}
+
 declare class EmbedderFactory {
     static create(provider: string, config: EmbeddingConfig): Embedder;
 }
@@ -537,5 +576,8 @@ declare class LLMFactory {
 declare class VectorStoreFactory {
     static create(provider: string, config: VectorStoreConfig): VectorStore;
 }
+declare class HistoryManagerFactory {
+    static create(provider: string, config: HistoryStoreConfig): HistoryManager;
+}
 
-export { type AddMemoryOptions, AnthropicLLM, type DeleteAllMemoryOptions, type Embedder, EmbedderFactory, type EmbeddingConfig, type Entity, type GetAllMemoryOptions, type GraphStoreConfig, GroqLLM, type LLM, type LLMConfig, LLMFactory, type LLMResponse, Memory, type MemoryConfig, MemoryConfigSchema, type MemoryItem, MemoryVectorStore, type Message, type MultiModalMessages, type Neo4jConfig, OllamaEmbedder, OllamaLLM, OpenAIEmbedder, OpenAILLM, OpenAIStructuredLLM, Qdrant, RedisDB, type SearchFilters, type SearchMemoryOptions, type SearchResult, type VectorStore, type VectorStoreConfig, VectorStoreFactory, type VectorStoreResult };
+export { type AddMemoryOptions, AnthropicLLM, type DeleteAllMemoryOptions, type Embedder, EmbedderFactory, type EmbeddingConfig, type Entity, type GetAllMemoryOptions, type GraphStoreConfig, GroqLLM, HistoryManagerFactory, type HistoryStoreConfig, type LLM, type LLMConfig, LLMFactory, type LLMResponse, Memory, type MemoryConfig, MemoryConfigSchema, type MemoryItem, MemoryVectorStore, type Message, type MultiModalMessages, type Neo4jConfig, OllamaEmbedder, OllamaLLM, OpenAIEmbedder, OpenAILLM, OpenAIStructuredLLM, Qdrant, RedisDB, type SearchFilters, type SearchMemoryOptions, type SearchResult, type VectorStore, type VectorStoreConfig, VectorStoreFactory, type VectorStoreResult };

package/dist/oss/index.js

@@ -33,6 +33,7 @@ __export(index_exports, {
   AnthropicLLM: () => AnthropicLLM,
   EmbedderFactory: () => EmbedderFactory,
   GroqLLM: () => GroqLLM,
+  HistoryManagerFactory: () => HistoryManagerFactory,
   LLMFactory: () => LLMFactory,
   Memory: () => Memory,
   MemoryConfigSchema: () => MemoryConfigSchema,
@@ -49,7 +50,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/oss/src/memory/index.ts
-var import_uuid = require("uuid");
+var import_uuid3 = require("uuid");
 var import_crypto = require("crypto");
 
 // src/oss/src/types/index.ts
@@ -92,7 +93,12 @@ var MemoryConfigSchema = import_zod.z.object({
       config: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
     }).optional(),
     customPrompt: import_zod.z.string().optional()
-  }).optional()
+  }).optional(),
+  historyStore: import_zod.z.object({
+    provider: import_zod.z.string(),
+    config: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+  }).optional(),
+  disableHistory: import_zod.z.boolean().optional()
 });
 
 // src/oss/src/embeddings/openai.ts
@@ -1227,6 +1233,11 @@ var SupabaseDB = class {
   async initialize() {
     try {
       const testVector = Array(1536).fill(0);
+      try {
+        await this.client.from(this.tableName).delete().eq("id", "test_vector");
+      } catch (error) {
+        console.warn("No test vector to delete, safe to ignore.");
+      }
       const { error: testError } = await this.client.from(this.tableName).insert({
         id: "test_vector",
         [this.embeddingColumnName]: testVector,
@@ -1239,6 +1250,50 @@ var SupabaseDB = class {
 1. The vector extension is enabled
 2. The table "${this.tableName}" exists with correct schema
 3. The match_vectors function is created
+
+RUN THE FOLLOWING SQL IN YOUR SUPABASE SQL EDITOR:
+
+-- Enable the vector extension
+create extension if not exists vector;
+
+-- Create the memories table
+create table if not exists memories (
+  id text primary key,
+  embedding vector(1536),
+  metadata jsonb,
+  created_at timestamp with time zone default timezone('utc', now()),
+  updated_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),
+  match_count int,
+  filter jsonb default '{}'::jsonb
+)
+returns table (
+  id text,
+  similarity float,
+  metadata jsonb
+)
+language plpgsql
+as $$
+begin
+  return query
+    select
+      id,
+      similarity,
+      metadata
+    from memories
+    where case
+      when filter::text = '{}'::text then true
+      else metadata @> filter
+    end
+    order by embedding <=> query_embedding
+    limit match_count;
+end;
+$$;
+
 See the SQL migration instructions in the code comments.`
         );
       }
@@ -1358,6 +1413,173 @@ See the SQL migration instructions in the code comments.`
   }
 };
 
+// src/oss/src/storage/SQLiteManager.ts
+var import_sqlite32 = __toESM(require("sqlite3"));
+var SQLiteManager = class {
+  constructor(dbPath) {
+    this.db = new import_sqlite32.default.Database(dbPath);
+    this.init().catch(console.error);
+  }
+  async init() {
+    await this.run(`
+      CREATE TABLE IF NOT EXISTS memory_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        memory_id TEXT NOT NULL,
+        previous_value TEXT,
+        new_value TEXT,
+        action TEXT NOT NULL,
+        created_at TEXT,
+        updated_at TEXT,
+        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);
+      });
+    });
+  }
+  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
+      ]
+    );
+  }
+  async getHistory(memoryId) {
+    return this.all(
+      "SELECT * FROM memory_history WHERE memory_id = ? ORDER BY id DESC",
+      [memoryId]
+    );
+  }
+  async reset() {
+    await this.run("DROP TABLE IF EXISTS memory_history");
+    await this.init();
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/oss/src/storage/MemoryHistoryManager.ts
+var import_uuid = require("uuid");
+var MemoryHistoryManager = class {
+  constructor() {
+    this.memoryStore = /* @__PURE__ */ new Map();
+  }
+  async addHistory(memoryId, previousValue, newValue, action, createdAt, updatedAt, isDeleted = 0) {
+    const historyEntry = {
+      id: (0, import_uuid.v4)(),
+      memory_id: memoryId,
+      previous_value: previousValue,
+      new_value: newValue,
+      action,
+      created_at: createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: updatedAt || null,
+      is_deleted: isDeleted
+    };
+    this.memoryStore.set(historyEntry.id, historyEntry);
+  }
+  async getHistory(memoryId) {
+    return Array.from(this.memoryStore.values()).filter((entry) => entry.memory_id === memoryId).sort(
+      (a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+    ).slice(0, 100);
+  }
+  async reset() {
+    this.memoryStore.clear();
+  }
+  close() {
+    return;
+  }
+};
+
+// src/oss/src/storage/SupabaseHistoryManager.ts
+var import_supabase_js2 = require("@supabase/supabase-js");
+var import_uuid2 = require("uuid");
+var SupabaseHistoryManager = class {
+  constructor(config) {
+    this.tableName = config.tableName || "memory_history";
+    this.supabase = (0, import_supabase_js2.createClient)(config.supabaseUrl, config.supabaseKey);
+    this.initializeSupabase().catch(console.error);
+  }
+  async initializeSupabase() {
+    const { error } = await this.supabase.from(this.tableName).select("id").limit(1);
+    if (error) {
+      console.error(
+        "Error: Table does not exist. Please run this SQL in your Supabase SQL Editor:"
+      );
+      console.error(`
+create table ${this.tableName} (
+  id text primary key,
+  memory_id text not null,
+  previous_value text,
+  new_value text,
+  action text not null,
+  created_at timestamp with time zone default timezone('utc', now()),
+  updated_at timestamp with time zone,
+  is_deleted integer default 0
+);
+      `);
+      throw error;
+    }
+  }
+  async addHistory(memoryId, previousValue, newValue, action, createdAt, updatedAt, isDeleted = 0) {
+    const historyEntry = {
+      id: (0, import_uuid2.v4)(),
+      memory_id: memoryId,
+      previous_value: previousValue,
+      new_value: newValue,
+      action,
+      created_at: createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: updatedAt || null,
+      is_deleted: isDeleted
+    };
+    const { error } = await this.supabase.from(this.tableName).insert(historyEntry);
+    if (error) {
+      console.error("Error adding history to Supabase:", error);
+      throw error;
+    }
+  }
+  async getHistory(memoryId) {
+    const { data, error } = await this.supabase.from(this.tableName).select("*").eq("memory_id", memoryId).order("created_at", { ascending: false }).limit(100);
+    if (error) {
+      console.error("Error getting history from Supabase:", error);
+      throw error;
+    }
+    return data || [];
+  }
+  async reset() {
+    const { error } = await this.supabase.from(this.tableName).delete().neq("id", "");
+    if (error) {
+      console.error("Error resetting Supabase history:", error);
+      throw error;
+    }
+  }
+  close() {
+    return;
+  }
+};
+
 // src/oss/src/utils/factory.ts
 var EmbedderFactory = class {
   static create(provider, config) {
@@ -1408,6 +1630,24 @@ var VectorStoreFactory = class {
     }
   }
 };
+var HistoryManagerFactory = class {
+  static create(provider, config) {
+    switch (provider.toLowerCase()) {
+      case "sqlite":
+        return new SQLiteManager(config.config.historyDbPath || ":memory:");
+      case "supabase":
+        return new SupabaseHistoryManager({
+          supabaseUrl: config.config.supabaseUrl || "",
+          supabaseKey: config.config.supabaseKey || "",
+          tableName: config.config.tableName || "memory_history"
+        });
+      case "memory":
+        return new MemoryHistoryManager();
+      default:
+        throw new Error(`Unsupported history store provider: ${provider}`);
+    }
+  }
+};
 
 // src/oss/src/prompts/index.ts
 function getFactRetrievalMessages(parsedMessages) {
@@ -1640,76 +1880,27 @@ function removeCodeBlocks(text) {
   return text.replace(/```[^`]*```/g, "");
 }
 
-// src/oss/src/storage/SQLiteManager.ts
-var import_sqlite32 = __toESM(require("sqlite3"));
-var SQLiteManager = class {
-  constructor(dbPath) {
-    this.db = new import_sqlite32.default.Database(dbPath);
-    this.init().catch(console.error);
-  }
-  async init() {
-    await this.run(`
-      CREATE TABLE IF NOT EXISTS memory_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        memory_id TEXT NOT NULL,
-        previous_value TEXT,
-        new_value TEXT,
-        action TEXT NOT NULL,
-        created_at TEXT,
-        updated_at TEXT,
-        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);
-      });
-    });
+// src/oss/src/storage/DummyHistoryManager.ts
+var DummyHistoryManager = class {
+  constructor() {
   }
   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
-      ]
-    );
+    return;
   }
   async getHistory(memoryId) {
-    return this.all(
-      "SELECT * FROM memory_history WHERE memory_id = ? ORDER BY id DESC",
-      [memoryId]
-    );
+    return [];
   }
   async reset() {
-    await this.run("DROP TABLE IF EXISTS memory_history");
-    await this.init();
+    return;
   }
   close() {
-    this.db.close();
+    return;
   }
 };
 
 // src/oss/src/config/defaults.ts
 var DEFAULT_MEMORY_CONFIG = {
+  disableHistory: false,
   version: "v1.1",
   embedder: {
     provider: "openai",
@@ -1747,7 +1938,12 @@ var DEFAULT_MEMORY_CONFIG = {
       }
     }
   },
-  historyDbPath: "memory.db"
+  historyStore: {
+    provider: "sqlite",
+    config: {
+      historyDbPath: "memory.db"
+    }
+  }
 };
 
 // src/oss/src/config/manager.ts
@@ -1784,6 +1980,11 @@ var ConfigManager = class {
         ...DEFAULT_MEMORY_CONFIG.graphStore,
         ...userConfig.graphStore
       },
+      historyStore: {
+        ...DEFAULT_MEMORY_CONFIG.historyStore,
+        ...userConfig.historyStore
+      },
+      disableHistory: userConfig.disableHistory || DEFAULT_MEMORY_CONFIG.disableHistory,
       enableGraph: userConfig.enableGraph || DEFAULT_MEMORY_CONFIG.enableGraph
     };
     return MemoryConfigSchema.parse(mergedConfig);
@@ -2562,7 +2763,20 @@ var Memory = class _Memory {
       this.config.llm.provider,
       this.config.llm.config
     );
-    this.db = new SQLiteManager(this.config.historyDbPath || ":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.config.historyStore.provider,
+        this.config.historyStore
+      ) : HistoryManagerFactory.create("sqlite", defaultConfig);
+    }
     this.collectionName = this.config.vectorStore.config.collectionName;
     this.apiVersion = this.config.version || "v1.0";
     this.enableGraph = this.config.enableGraph || false;
@@ -2865,7 +3079,7 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
     return { results };
   }
   async createMemory(data, existingEmbeddings, metadata) {
-    const memoryId = (0, import_uuid.v4)();
+    const memoryId = (0, import_uuid3.v4)();
     const embedding = existingEmbeddings[data] || await this.embedder.embed(data);
     const memoryMetadata = {
       ...metadata,
@@ -2941,6 +3155,7 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
   AnthropicLLM,
   EmbedderFactory,
   GroqLLM,
+  HistoryManagerFactory,
   LLMFactory,
   Memory,
   MemoryConfigSchema,