mem0ai 1.0.15 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mem0ai",
-    "version": "1.0.15",
+    "version": "1.0.16",
     "description": "The Memory Layer For Your AI Apps",
     "main": "src/index.js",
     "scripts": {
@@ -23,5 +23,10 @@
         "package.json",
         "README.md"
     ],
+    "type": "module",
+    "exports": {
+        "require": "./src/index.cjs",
+        "import": "./dist/index.js"
+    },
     "module": "dist/index.mjs"
 }

package/src/index.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+class APIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'APIError';
+    }
+}
+
+/**
+ * MemoryClient for interacting with the mem0ai API
+ */
+class MemoryClient {
+    /**
+     * @param {string} apiKey
+     * @param {string} [host]
+     * @param {string} [organizationName]
+     * @param {string} [projectName]
+     */
+    constructor(apiKey, host = 'https://api.mem0.ai', organizationName = null, projectName = "default-project") {
+        this.apiKey = apiKey;
+        this.host = host;
+        this.organizationName = organizationName;
+        this.projectName = projectName;
+
+        this.headers = {
+            'Authorization': `Token ${this.apiKey}`,
+            'Content-Type': 'application/json'
+        };
+
+        this._validateApiKey();
+    }
+
+    _validateApiKey() {
+        if (!this.apiKey) {
+            throw new Error('Mem0 API key is required');
+        }
+        if (typeof this.apiKey !== 'string') {
+            throw new Error('Mem0 API key must be a string');
+        }
+        if (this.apiKey.trim() === '') {
+            throw new Error('Mem0 API key cannot be empty');
+        }
+    }
+
+    async _fetchWithErrorHandling(url, options) {
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            const errorData = await response.text();
+            throw new APIError(`API request failed: ${errorData}`);
+        }
+        const jsonResponse = await response.json();
+        return jsonResponse;
+    }
+
+    async add(messages, options = {}) {
+        options.organization_name = this.organizationName;
+        options.project_name = this.projectName;
+        const payload = this._preparePayload(messages, options);
+        const response = await this._fetchWithErrorHandling(`${this.host}/v1/memories/`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(payload)
+        });
+        return response;
+    }
+
+    async get(memoryId) {
+        return this._fetchWithErrorHandling(`${this.host}/v1/memories/${memoryId}/`, {
+            headers: this.headers
+        });
+    }
+
+    async getAll(options = {}) {
+        const { api_version, ...otherOptions } = options;
+
+        otherOptions.organization_name = this.organizationName;
+        otherOptions.project_name = this.projectName;
+
+        if (api_version === 'v2') {
+            return this._fetchWithErrorHandling(`${this.host}/v2/memories/`, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify(otherOptions)
+            });
+        } else {
+            const params = new URLSearchParams(this._prepareParams(otherOptions));
+            return this._fetchWithErrorHandling(`${this.host}/v1/memories/?${params}`, {
+                headers: this.headers
+            });
+        }
+    }
+
+    async search(query, options = {}) {
+        const { api_version, ...otherOptions } = options;
+        const payload = { query, ...otherOptions };
+        payload.organization_name = this.organizationName;
+        payload.project_name = this.projectName;
+        const endpoint = api_version === 'v2' ? '/v2/memories/search/' : '/v1/memories/search/';
+        const response = await this._fetchWithErrorHandling(`${this.host}${endpoint}`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(payload)
+        });
+        return response;
+    }
+
+    async delete(memoryId) {
+        return this._fetchWithErrorHandling(`${this.host}/v1/memories/${memoryId}/`, {
+            method: 'DELETE',
+            headers: this.headers
+        });
+    }
+
+    async deleteAll(options = {}) {
+        options.organization_name = this.organizationName;
+        options.project_name = this.projectName;
+        const params = new URLSearchParams(this._prepareParams(options));
+        const response = await this._fetchWithErrorHandling(`${this.host}/v1/memories/?${params}`, {
+            method: 'DELETE',
+            headers: this.headers
+        });
+        return response;
+    }
+
+    async history(memoryId) {
+        const response = await this._fetchWithErrorHandling(`${this.host}/v1/memories/${memoryId}/history/`, {
+            headers: this.headers
+        });
+        return response;
+    }
+
+    async users() {
+        const params = new URLSearchParams({
+            organization_name: this.organizationName,
+            project_name: this.projectName
+        });
+        const response = await this._fetchWithErrorHandling(`${this.host}/v1/entities/?${params}`, {
+            headers: this.headers
+        });
+        return response;
+    }
+
+    async deleteUsers() {
+        const entities = await this.users();
+        for (const entity of entities.results) {
+            const params = {
+                organization_name: this.organizationName,
+                project_name: this.projectName
+            };
+            await this.client.delete(`/v1/entities/${entity.type}/${entity.id}/`, { params });
+        }
+        return { message: "All users, agents, and sessions deleted." };
+    }
+
+    /**
+     * @param {string|Array<{role: string, content: string}>} messages
+     * @param {MemoryOptions} options
+     * @returns {Object}
+     */
+    _preparePayload(messages, options) {
+        const payload = {};
+        if (typeof messages === 'string') {
+            payload.messages = [{ role: 'user', content: messages }];
+        } else if (Array.isArray(messages)) {
+            payload.messages = messages;
+        }
+        return { ...payload, ...options };
+    }
+
+    /**
+     * @param {MemoryOptions} options
+     * @returns {Object}
+     */
+    _prepareParams(options) {
+        return Object.fromEntries(Object.entries(options).filter(([_, v]) => v != null));
+    }
+
+}
+
+module.exports = MemoryClient;

package/src/index.d.ts

@@ -28,7 +28,7 @@ declare module 'mem0ai' {
     add(
       messages: string | Array<{ role: string; content: string }>,
       options?: MemoryOptions
-    ): Promise<Memory>;
+    ): Promise<Memory[]>;
 
     get(memoryId: string): Promise<Memory>;
 

package/src/index.js

@@ -1,5 +1,3 @@
-import crypto from 'crypto';
-
 class APIError extends Error {
     constructor(message) {
         super(message);