mem0ai 2.1.7 → 2.1.9

package/dist/oss/index.mjs

@@ -68,6 +68,60 @@ var OpenAIEmbedder = class {
   }
 };
 
+// src/oss/src/embeddings/ollama.ts
+import { Ollama } from "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 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
 import OpenAI2 from "openai";
 var OpenAILLM = class {
@@ -1025,12 +1079,243 @@ var RedisDB = class {
   }
 };
 
+// src/oss/src/llms/ollama.ts
+import { Ollama as Ollama2 } from "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 Ollama2({
+      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
+import { createClient as createClient2 } from "@supabase/supabase-js";
+var SupabaseDB = class {
+  constructor(config) {
+    this.client = createClient2(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);
+      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
+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/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}`);
     }
@@ -1047,6 +1332,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}`);
     }
@@ -1063,6 +1350,9 @@ 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}`);
     }
@@ -1659,14 +1949,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) {
@@ -2612,6 +2894,8 @@ export {
   Memory,
   MemoryConfigSchema,
   MemoryVectorStore,
+  OllamaEmbedder,
+  OllamaLLM,
   OpenAIEmbedder,
   OpenAILLM,
   OpenAIStructuredLLM,