mem0ai 2.1.8 → 2.1.10

package/dist/oss/index.js

@@ -33,10 +33,13 @@ __export(index_exports, {
   AnthropicLLM: () => AnthropicLLM,
   EmbedderFactory: () => EmbedderFactory,
   GroqLLM: () => GroqLLM,
+  HistoryManagerFactory: () => HistoryManagerFactory,
   LLMFactory: () => LLMFactory,
   Memory: () => Memory,
   MemoryConfigSchema: () => MemoryConfigSchema,
   MemoryVectorStore: () => MemoryVectorStore,
+  OllamaEmbedder: () => OllamaEmbedder,
+  OllamaLLM: () => OllamaLLM,
   OpenAIEmbedder: () => OpenAIEmbedder,
   OpenAILLM: () => OpenAILLM,
   OpenAIStructuredLLM: () => OpenAIStructuredLLM,
@@ -47,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
@@ -90,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
@@ -116,6 +124,60 @@ var OpenAIEmbedder = class {
   }
 };
 
+// src/oss/src/embeddings/ollama.ts
+var import_ollama = require("ollama");
+
+// src/oss/src/utils/logger.ts
+var logger = {
+  info: (message) => console.log(`[INFO] ${message}`),
+  error: (message) => console.error(`[ERROR] ${message}`),
+  debug: (message) => console.debug(`[DEBUG] ${message}`),
+  warn: (message) => console.warn(`[WARN] ${message}`)
+};
+
+// src/oss/src/embeddings/ollama.ts
+var OllamaEmbedder = class {
+  constructor(config) {
+    // Using this variable to avoid calling the Ollama server multiple times
+    this.initialized = false;
+    this.ollama = new import_ollama.Ollama({
+      host: config.url || "http://localhost:11434"
+    });
+    this.model = config.model || "nomic-embed-text:latest";
+    this.ensureModelExists().catch((err) => {
+      logger.error(`Error ensuring model exists: ${err}`);
+    });
+  }
+  async embed(text) {
+    try {
+      await this.ensureModelExists();
+    } catch (err) {
+      logger.error(`Error ensuring model exists: ${err}`);
+    }
+    const response = await this.ollama.embeddings({
+      model: this.model,
+      prompt: text
+    });
+    return response.embedding;
+  }
+  async embedBatch(texts) {
+    const response = await Promise.all(texts.map((text) => this.embed(text)));
+    return response;
+  }
+  async ensureModelExists() {
+    if (this.initialized) {
+      return true;
+    }
+    const local_models = await this.ollama.list();
+    if (!local_models.models.find((m) => m.name === this.model)) {
+      logger.info(`Pulling model ${this.model}...`);
+      await this.ollama.pull({ model: this.model });
+    }
+    this.initialized = true;
+    return true;
+  }
+};
+
 // src/oss/src/llms/openai.ts
 var import_openai2 = __toESM(require("openai"));
 var OpenAILLM = class {
@@ -1073,12 +1135,459 @@ var RedisDB = class {
   }
 };
 
+// src/oss/src/llms/ollama.ts
+var import_ollama2 = require("ollama");
+var OllamaLLM = class {
+  constructor(config) {
+    // Using this variable to avoid calling the Ollama server multiple times
+    this.initialized = false;
+    var _a;
+    this.ollama = new import_ollama2.Ollama({
+      host: ((_a = config.config) == null ? void 0 : _a.url) || "http://localhost:11434"
+    });
+    this.model = config.model || "llama3.1:8b";
+    this.ensureModelExists().catch((err) => {
+      logger.error(`Error ensuring model exists: ${err}`);
+    });
+  }
+  async generateResponse(messages, responseFormat, tools) {
+    try {
+      await this.ensureModelExists();
+    } catch (err) {
+      logger.error(`Error ensuring model exists: ${err}`);
+    }
+    const completion = await this.ollama.chat({
+      model: this.model,
+      messages: messages.map((msg) => {
+        const role = msg.role;
+        return {
+          role,
+          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        };
+      }),
+      ...(responseFormat == null ? void 0 : responseFormat.type) === "json_object" && { format: "json" },
+      ...tools && { tools, tool_choice: "auto" }
+    });
+    const response = completion.message;
+    if (response.tool_calls) {
+      return {
+        content: response.content || "",
+        role: response.role,
+        toolCalls: response.tool_calls.map((call) => ({
+          name: call.function.name,
+          arguments: JSON.stringify(call.function.arguments)
+        }))
+      };
+    }
+    return response.content || "";
+  }
+  async generateChat(messages) {
+    try {
+      await this.ensureModelExists();
+    } catch (err) {
+      logger.error(`Error ensuring model exists: ${err}`);
+    }
+    const completion = await this.ollama.chat({
+      messages: messages.map((msg) => {
+        const role = msg.role;
+        return {
+          role,
+          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        };
+      }),
+      model: this.model
+    });
+    const response = completion.message;
+    return {
+      content: response.content || "",
+      role: response.role
+    };
+  }
+  async ensureModelExists() {
+    if (this.initialized) {
+      return true;
+    }
+    const local_models = await this.ollama.list();
+    if (!local_models.models.find((m) => m.name === this.model)) {
+      logger.info(`Pulling model ${this.model}...`);
+      await this.ollama.pull({ model: this.model });
+    }
+    this.initialized = true;
+    return true;
+  }
+};
+
+// src/oss/src/vector_stores/supabase.ts
+var import_supabase_js = require("@supabase/supabase-js");
+var SupabaseDB = class {
+  constructor(config) {
+    this.client = (0, import_supabase_js.createClient)(config.supabaseUrl, config.supabaseKey);
+    this.tableName = config.tableName;
+    this.embeddingColumnName = config.embeddingColumnName || "embedding";
+    this.metadataColumnName = config.metadataColumnName || "metadata";
+    this.initialize().catch((err) => {
+      console.error("Failed to initialize Supabase:", err);
+      throw err;
+    });
+  }
+  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,
+        [this.metadataColumnName]: {}
+      }).select();
+      if (testError) {
+        console.error("Test insert error:", testError);
+        throw new Error(
+          `Vector operations failed. Please ensure:
+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.`
+        );
+      }
+      await this.client.from(this.tableName).delete().eq("id", "test_vector");
+      console.log("Connected to Supabase successfully");
+    } catch (error) {
+      console.error("Error during Supabase initialization:", error);
+      throw error;
+    }
+  }
+  async insert(vectors, ids, payloads) {
+    try {
+      const data = vectors.map((vector, idx) => ({
+        id: ids[idx],
+        [this.embeddingColumnName]: vector,
+        [this.metadataColumnName]: {
+          ...payloads[idx],
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }));
+      const { error } = await this.client.from(this.tableName).insert(data);
+      if (error) throw error;
+    } catch (error) {
+      console.error("Error during vector insert:", error);
+      throw error;
+    }
+  }
+  async search(query, limit = 5, filters) {
+    try {
+      const rpcQuery = {
+        query_embedding: query,
+        match_count: limit
+      };
+      if (filters) {
+        rpcQuery.filter = filters;
+      }
+      const { data, error } = await this.client.rpc("match_vectors", rpcQuery);
+      if (error) throw error;
+      if (!data) return [];
+      const results = data;
+      return results.map((result) => ({
+        id: result.id,
+        payload: result.metadata,
+        score: result.similarity
+      }));
+    } catch (error) {
+      console.error("Error during vector search:", error);
+      throw error;
+    }
+  }
+  async get(vectorId) {
+    try {
+      const { data, error } = await this.client.from(this.tableName).select("*").eq("id", vectorId).single();
+      if (error) throw error;
+      if (!data) return null;
+      return {
+        id: data.id,
+        payload: data[this.metadataColumnName]
+      };
+    } catch (error) {
+      console.error("Error getting vector:", error);
+      throw error;
+    }
+  }
+  async update(vectorId, vector, payload) {
+    try {
+      const { error } = await this.client.from(this.tableName).update({
+        [this.embeddingColumnName]: vector,
+        [this.metadataColumnName]: {
+          ...payload,
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }).eq("id", vectorId);
+      if (error) throw error;
+    } catch (error) {
+      console.error("Error during vector update:", error);
+      throw error;
+    }
+  }
+  async delete(vectorId) {
+    try {
+      const { error } = await this.client.from(this.tableName).delete().eq("id", vectorId);
+      if (error) throw error;
+    } catch (error) {
+      console.error("Error deleting vector:", error);
+      throw error;
+    }
+  }
+  async deleteCol() {
+    try {
+      const { error } = await this.client.from(this.tableName).delete().neq("id", "");
+      if (error) throw error;
+    } catch (error) {
+      console.error("Error deleting collection:", error);
+      throw error;
+    }
+  }
+  async list(filters, limit = 100) {
+    try {
+      let query = this.client.from(this.tableName).select("*", { count: "exact" }).limit(limit);
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          query = query.eq(`${this.metadataColumnName}->>${key}`, value);
+        });
+      }
+      const { data, error, count } = await query;
+      if (error) throw error;
+      const results = data.map((item) => ({
+        id: item.id,
+        payload: item[this.metadataColumnName]
+      }));
+      return [results, count || 0];
+    } catch (error) {
+      console.error("Error listing vectors:", error);
+      throw error;
+    }
+  }
+};
+
+// 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) {
     switch (provider.toLowerCase()) {
       case "openai":
         return new OpenAIEmbedder(config);
+      case "ollama":
+        return new OllamaEmbedder(config);
       default:
         throw new Error(`Unsupported embedder provider: ${provider}`);
     }
@@ -1095,6 +1604,8 @@ var LLMFactory = class {
         return new AnthropicLLM(config);
       case "groq":
         return new GroqLLM(config);
+      case "ollama":
+        return new OllamaLLM(config);
       default:
         throw new Error(`Unsupported LLM provider: ${provider}`);
     }
@@ -1111,11 +1622,32 @@ var VectorStoreFactory = class {
       case "redis":
         return new RedisDB(config);
       // Type assertion needed as config is extended
+      case "supabase":
+        return new SupabaseDB(config);
+      // Type assertion needed as config is extended
       default:
         throw new Error(`Unsupported vector store provider: ${provider}`);
     }
   }
 };
+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) {
@@ -1348,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",
@@ -1455,7 +1938,12 @@ var DEFAULT_MEMORY_CONFIG = {
       }
     }
   },
-  historyDbPath: "memory.db"
+  historyStore: {
+    provider: "sqlite",
+    config: {
+      historyDbPath: "memory.db"
+    }
+  }
 };
 
 // src/oss/src/config/manager.ts
@@ -1492,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);
@@ -1707,14 +2200,6 @@ function getDeleteMessages(existingMemoriesString, data, userId) {
   ];
 }
 
-// src/oss/src/utils/logger.ts
-var logger = {
-  info: (message) => console.log(`[INFO] ${message}`),
-  error: (message) => console.error(`[ERROR] ${message}`),
-  debug: (message) => console.debug(`[DEBUG] ${message}`),
-  warn: (message) => console.warn(`[WARN] ${message}`)
-};
-
 // src/oss/src/memory/graph_memory.ts
 var MemoryGraph = class {
   constructor(config) {
@@ -2278,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;
@@ -2581,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,
@@ -2657,10 +3155,13 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
   AnthropicLLM,
   EmbedderFactory,
   GroqLLM,
+  HistoryManagerFactory,
   LLMFactory,
   Memory,
   MemoryConfigSchema,
   MemoryVectorStore,
+  OllamaEmbedder,
+  OllamaLLM,
   OpenAIEmbedder,
   OpenAILLM,
   OpenAIStructuredLLM,