mem0ai 2.1.38 → 2.2.1

package/dist/oss/index.mjs

@@ -12,7 +12,9 @@ var MemoryConfigSchema = z.object({
       modelProperties: z.record(z.string(), z.any()).optional(),
       apiKey: z.string().optional(),
       model: z.union([z.string(), z.any()]).optional(),
-      baseURL: z.string().optional()
+      baseURL: z.string().optional(),
+      embeddingDims: z.number().optional(),
+      url: z.string().optional()
     })
   }),
   vectorStore: z.object({
@@ -61,6 +63,7 @@ var OpenAIEmbedder = class {
   constructor(config) {
     this.openai = new OpenAI({ apiKey: config.apiKey });
     this.model = config.model || "text-embedding-3-small";
+    this.embeddingDims = config.embeddingDims || 1536;
   }
   async embed(text) {
     const response = await this.openai.embeddings.create({
@@ -98,6 +101,7 @@ var OllamaEmbedder = class {
       host: config.url || "http://localhost:11434"
     });
     this.model = config.model || "nomic-embed-text:latest";
+    this.embeddingDims = config.embeddingDims || 768;
     this.ensureModelExists().catch((err) => {
       logger.error(`Error ensuring model exists: ${err}`);
     });
@@ -140,7 +144,7 @@ var OpenAILLM = class {
       apiKey: config.apiKey,
       baseURL: config.baseURL
     });
-    this.model = config.model || "gpt-4o-mini";
+    this.model = config.model || "gpt-4.1-nano-2025-04-14";
   }
   async generateResponse(messages, responseFormat, tools) {
     const completion = await this.openai.chat.completions.create({
@@ -269,7 +273,12 @@ var AnthropicLLM = class {
       system: typeof (systemMessage == null ? void 0 : systemMessage.content) === "string" ? systemMessage.content : void 0,
       max_tokens: 4096
     });
-    return response.content[0].text;
+    const firstBlock = response.content[0];
+    if (firstBlock.type === "text") {
+      return firstBlock.text;
+    } else {
+      throw new Error("Unexpected response type from Anthropic API");
+    }
   }
   async generateChat(messages) {
     const response = await this.generateResponse(messages);
@@ -2171,14 +2180,17 @@ create table ${this.tableName} (
 import { GoogleGenAI } from "@google/genai";
 var GoogleEmbedder = class {
   constructor(config) {
-    this.google = new GoogleGenAI({ apiKey: config.apiKey });
-    this.model = config.model || "text-embedding-004";
+    this.google = new GoogleGenAI({
+      apiKey: config.apiKey || process.env.GOOGLE_API_KEY
+    });
+    this.model = config.model || "gemini-embedding-001";
+    this.embeddingDims = config.embeddingDims || 1536;
   }
   async embed(text) {
     const response = await this.google.models.embedContent({
       model: this.model,
       contents: text,
-      config: { outputDimensionality: 768 }
+      config: { outputDimensionality: this.embeddingDims }
     });
     return response.embeddings[0].values;
   }
@@ -2307,6 +2319,7 @@ var AzureOpenAIEmbedder = class {
       ...rest
     });
     this.model = config.model || "text-embedding-3-small";
+    this.embeddingDims = config.embeddingDims || 1536;
   }
   async embed(text) {
     const response = await this.client.embeddings.create({
@@ -3057,6 +3070,449 @@ var LangchainVectorStore = class {
   }
 };
 
+// src/oss/src/vector_stores/azure_ai_search.ts
+import {
+  SearchClient,
+  SearchIndexClient,
+  AzureKeyCredential
+} from "@azure/search-documents";
+import { DefaultAzureCredential } from "@azure/identity";
+var AzureAISearch = class {
+  constructor(config) {
+    this.serviceName = config.serviceName;
+    this.indexName = config.collectionName;
+    this.embeddingModelDims = config.embeddingModelDims;
+    this.compressionType = config.compressionType || "none";
+    this.useFloat16 = config.useFloat16 || false;
+    this.hybridSearch = config.hybridSearch || false;
+    this.vectorFilterMode = config.vectorFilterMode || "preFilter";
+    this.apiKey = config.apiKey;
+    const serviceEndpoint = `https://${this.serviceName}.search.windows.net`;
+    const credential = this.apiKey && this.apiKey !== "" && this.apiKey !== "your-api-key" ? new AzureKeyCredential(this.apiKey) : new DefaultAzureCredential();
+    this.searchClient = new SearchClient(
+      serviceEndpoint,
+      this.indexName,
+      credential
+    );
+    this.indexClient = new SearchIndexClient(serviceEndpoint, credential);
+    this.initialize().catch(console.error);
+  }
+  /**
+   * Initialize the Azure AI Search index if it doesn't exist
+   */
+  async initialize() {
+    try {
+      const collections = await this.listCols();
+      if (!collections.includes(this.indexName)) {
+        await this.createCol();
+      }
+    } catch (error) {
+      console.error("Error initializing Azure AI Search:", error);
+      throw error;
+    }
+  }
+  /**
+   * Create a new index in Azure AI Search
+   */
+  async createCol() {
+    const vectorType = this.useFloat16 ? "Collection(Edm.Half)" : "Collection(Edm.Single)";
+    const compressionConfigurations = [];
+    let compressionName = void 0;
+    if (this.compressionType === "scalar") {
+      compressionName = "myCompression";
+      compressionConfigurations.push({
+        kind: "scalarQuantization",
+        compressionName
+      });
+    } else if (this.compressionType === "binary") {
+      compressionName = "myCompression";
+      compressionConfigurations.push({
+        kind: "binaryQuantization",
+        compressionName
+      });
+    }
+    const fields = [
+      {
+        name: "id",
+        type: "Edm.String",
+        key: true
+      },
+      {
+        name: "user_id",
+        type: "Edm.String",
+        filterable: true
+      },
+      {
+        name: "run_id",
+        type: "Edm.String",
+        filterable: true
+      },
+      {
+        name: "agent_id",
+        type: "Edm.String",
+        filterable: true
+      },
+      {
+        name: "vector",
+        type: vectorType,
+        searchable: true,
+        vectorSearchDimensions: this.embeddingModelDims,
+        vectorSearchProfileName: "my-vector-config"
+      },
+      {
+        name: "payload",
+        type: "Edm.String",
+        searchable: true
+      }
+    ];
+    const vectorSearch = {
+      profiles: [
+        {
+          name: "my-vector-config",
+          algorithmConfigurationName: "my-algorithms-config",
+          compressionName: this.compressionType !== "none" ? compressionName : void 0
+        }
+      ],
+      algorithms: [
+        {
+          kind: "hnsw",
+          name: "my-algorithms-config"
+        }
+      ],
+      compressions: compressionConfigurations
+    };
+    const index = {
+      name: this.indexName,
+      fields,
+      vectorSearch
+    };
+    await this.indexClient.createOrUpdateIndex(index);
+  }
+  /**
+   * Generate a document for insertion
+   */
+  generateDocument(vector, payload, id) {
+    const document = {
+      id,
+      vector,
+      payload: JSON.stringify(payload)
+    };
+    for (const field of ["user_id", "run_id", "agent_id"]) {
+      if (field in payload) {
+        document[field] = payload[field];
+      }
+    }
+    return document;
+  }
+  /**
+   * Insert vectors into the index
+   */
+  async insert(vectors, ids, payloads) {
+    console.log(
+      `Inserting ${vectors.length} vectors into index ${this.indexName}`
+    );
+    const documents = vectors.map(
+      (vector, idx) => this.generateDocument(vector, payloads[idx] || {}, ids[idx])
+    );
+    const response = await this.searchClient.uploadDocuments(documents);
+    for (const result of response.results) {
+      if (!result.succeeded) {
+        throw new Error(
+          `Insert failed for document ${result.key}: ${result.errorMessage}`
+        );
+      }
+    }
+  }
+  /**
+   * Sanitize filter keys to remove non-alphanumeric characters
+   */
+  sanitizeKey(key) {
+    return key.replace(/[^\w]/g, "");
+  }
+  /**
+   * Build OData filter expression from SearchFilters
+   */
+  buildFilterExpression(filters) {
+    const filterConditions = [];
+    for (const [key, value] of Object.entries(filters)) {
+      const safeKey = this.sanitizeKey(key);
+      if (typeof value === "string") {
+        const safeValue = value.replace(/'/g, "''");
+        filterConditions.push(`${safeKey} eq '${safeValue}'`);
+      } else {
+        filterConditions.push(`${safeKey} eq ${value}`);
+      }
+    }
+    return filterConditions.join(" and ");
+  }
+  /**
+   * Extract JSON from payload string
+   * Handles cases where payload might have extra text
+   */
+  extractJson(payload) {
+    try {
+      JSON.parse(payload);
+      return payload;
+    } catch (e) {
+      const match = payload.match(/\{.*\}/s);
+      return match ? match[0] : payload;
+    }
+  }
+  /**
+   * Search for similar vectors
+   */
+  async search(query, limit = 5, filters) {
+    const filterExpression = filters ? this.buildFilterExpression(filters) : void 0;
+    const vectorQuery = {
+      kind: "vector",
+      vector: query,
+      kNearestNeighborsCount: limit,
+      fields: ["vector"]
+    };
+    let searchResults;
+    if (this.hybridSearch) {
+      searchResults = await this.searchClient.search("*", {
+        vectorSearchOptions: {
+          queries: [vectorQuery],
+          filterMode: this.vectorFilterMode
+        },
+        filter: filterExpression,
+        top: limit,
+        searchFields: ["payload"]
+      });
+    } else {
+      searchResults = await this.searchClient.search("*", {
+        vectorSearchOptions: {
+          queries: [vectorQuery],
+          filterMode: this.vectorFilterMode
+        },
+        filter: filterExpression,
+        top: limit
+      });
+    }
+    const results = [];
+    for await (const result of searchResults.results) {
+      const payloadStr = result.document.payload;
+      const payload = JSON.parse(this.extractJson(payloadStr));
+      results.push({
+        id: result.document.id,
+        score: result.score,
+        payload
+      });
+    }
+    return results;
+  }
+  /**
+   * Delete a vector by ID
+   */
+  async delete(vectorId) {
+    const response = await this.searchClient.deleteDocuments([
+      { id: vectorId }
+    ]);
+    for (const result of response.results) {
+      if (!result.succeeded) {
+        throw new Error(
+          `Delete failed for document ${vectorId}: ${result.errorMessage}`
+        );
+      }
+    }
+    console.log(
+      `Deleted document with ID '${vectorId}' from index '${this.indexName}'.`
+    );
+  }
+  /**
+   * Update a vector and its payload
+   */
+  async update(vectorId, vector, payload) {
+    const document = { id: vectorId };
+    if (vector) {
+      document.vector = vector;
+    }
+    if (payload) {
+      document.payload = JSON.stringify(payload);
+      for (const field of ["user_id", "run_id", "agent_id"]) {
+        if (field in payload) {
+          document[field] = payload[field];
+        }
+      }
+    }
+    const response = await this.searchClient.mergeOrUploadDocuments([document]);
+    for (const result of response.results) {
+      if (!result.succeeded) {
+        throw new Error(
+          `Update failed for document ${vectorId}: ${result.errorMessage}`
+        );
+      }
+    }
+  }
+  /**
+   * Retrieve a vector by ID
+   */
+  async get(vectorId) {
+    try {
+      const result = await this.searchClient.getDocument(vectorId);
+      const payloadStr = result.payload;
+      const payload = JSON.parse(this.extractJson(payloadStr));
+      return {
+        id: result.id,
+        payload
+      };
+    } catch (error) {
+      if ((error == null ? void 0 : error.statusCode) === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all collections (indexes)
+   */
+  async listCols() {
+    const names = [];
+    for await (const index of this.indexClient.listIndexes()) {
+      names.push(index.name);
+    }
+    return names;
+  }
+  /**
+   * Delete the index
+   */
+  async deleteCol() {
+    await this.indexClient.deleteIndex(this.indexName);
+  }
+  /**
+   * Get information about the index
+   */
+  async colInfo() {
+    const index = await this.indexClient.getIndex(this.indexName);
+    return {
+      name: index.name,
+      fields: index.fields
+    };
+  }
+  /**
+   * List all vectors in the index
+   */
+  async list(filters, limit = 100) {
+    const filterExpression = filters ? this.buildFilterExpression(filters) : void 0;
+    const searchResults = await this.searchClient.search("*", {
+      filter: filterExpression,
+      top: limit
+    });
+    const results = [];
+    for await (const result of searchResults.results) {
+      const payloadStr = result.document.payload;
+      const payload = JSON.parse(this.extractJson(payloadStr));
+      results.push({
+        id: result.document.id,
+        score: result.score,
+        payload
+      });
+    }
+    return [results, results.length];
+  }
+  /**
+   * Generate a random user ID
+   */
+  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);
+      }
+    );
+  }
+  /**
+   * Get user ID from memory_migrations collection
+   * Required by VectorStore interface
+   */
+  async getUserId() {
+    try {
+      const collections = await this.listCols();
+      const migrationIndexExists = collections.includes("memory_migrations");
+      if (!migrationIndexExists) {
+        const migrationIndex = {
+          name: "memory_migrations",
+          fields: [
+            {
+              name: "id",
+              type: "Edm.String",
+              key: true
+            },
+            {
+              name: "user_id",
+              type: "Edm.String",
+              searchable: false,
+              filterable: true
+            }
+          ]
+        };
+        await this.indexClient.createOrUpdateIndex(migrationIndex);
+      }
+      const searchResults = await this.searchClient.search("*", {
+        top: 1
+      });
+      for await (const result of searchResults.results) {
+        const userId = result.document.user_id;
+        if (userId) {
+          return userId;
+        }
+      }
+      const randomUserId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+      await this.searchClient.uploadDocuments([
+        {
+          id: this.generateUUID(),
+          user_id: randomUserId
+        }
+      ]);
+      return randomUserId;
+    } catch (error) {
+      console.error("Error getting user ID:", error);
+      throw error;
+    }
+  }
+  /**
+   * Set user ID in memory_migrations collection
+   * Required by VectorStore interface
+   */
+  async setUserId(userId) {
+    try {
+      const searchResults = await this.searchClient.search("*", {
+        top: 1
+      });
+      let pointId = this.generateUUID();
+      for await (const result of searchResults.results) {
+        pointId = result.document.id;
+        break;
+      }
+      await this.searchClient.mergeOrUploadDocuments([
+        {
+          id: pointId,
+          user_id: userId
+        }
+      ]);
+    } catch (error) {
+      console.error("Error setting user ID:", error);
+      throw error;
+    }
+  }
+  /**
+   * Reset the index by deleting and recreating it
+   */
+  async reset() {
+    console.log(`Resetting index ${this.indexName}...`);
+    try {
+      await this.deleteCol();
+      await this.createCol();
+    } catch (error) {
+      console.error(`Error resetting index ${this.indexName}:`, error);
+      throw error;
+    }
+  }
+};
+
 // src/oss/src/utils/factory.ts
 var EmbedderFactory = class {
   static create(provider, config) {
@@ -3119,6 +3575,8 @@ var VectorStoreFactory = class {
         return new LangchainVectorStore(config);
       case "vectorize":
         return new VectorizeDB(config);
+      case "azure-ai-search":
+        return new AzureAISearch(config);
       default:
         throw new Error(`Unsupported vector store provider: ${provider}`);
     }
@@ -3233,6 +3691,7 @@ var ConfigManager = class {
             apiKey: (userConf == null ? void 0 : userConf.apiKey) !== void 0 ? userConf.apiKey : defaultConf.apiKey,
             model: finalModel,
             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
           };
         })()
@@ -3443,7 +3902,7 @@ var MemoryGraph = class {
     }
     this.llm = LLMFactory.create(this.llmProvider, this.config.llm.config);
     this.structuredLlm = LLMFactory.create(
-      "openai_structured",
+      this.llmProvider,
       this.config.llm.config
     );
     this.threshold = 0.7;
@@ -4183,8 +4642,13 @@ var Memory = class _Memory {
       return returnedMemories;
     }
     const parsedMessages = messages.map((m) => m.content).join("\n");
-    const [systemPrompt, userPrompt] = this.customPrompt ? [this.customPrompt, `Input:
-${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
+    const [systemPrompt, userPrompt] = this.customPrompt ? [
+      this.customPrompt.toLowerCase().includes("json") ? this.customPrompt : `${this.customPrompt}
+
+You MUST return a valid JSON object with a 'facts' key containing an array of strings.`,
+      `Input:
+${parsedMessages}`
+    ] : getFactRetrievalMessages(parsedMessages);
     const response = await this.llm.generateResponse(
       [
         { role: "system", content: systemPrompt },
@@ -4562,6 +5026,7 @@ ${parsedMessages}`] : getFactRetrievalMessages(parsedMessages);
 };
 export {
   AnthropicLLM,
+  AzureAISearch,
   AzureOpenAIEmbedder,
   EmbedderFactory,
   GoogleEmbedder,