mem0ai 1.0.6 → 1.0.9

package/README.md

@@ -200,6 +200,14 @@ client.delete("memory-id-here")
   .catch(error => console.error(error));
 ```
 
+Delete all users for which you have memories:
+
+```javascript
+client.deleteUsers()
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
 Delete all memories of a user:
 
 ```javascript

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "mem0ai",
-    "version": "1.0.6",
+    "version": "1.0.9",
     "description": "The Memory layer for your AI apps",
     "main": "src/index.js",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1"
     },
+    "types": "src/index.d.ts",
     "keywords": [
         "mem0",
         "api",

package/src/index.d.ts

@@ -0,0 +1,30 @@
+declare module 'mem0ai' {
+    export interface MemoryOptions {
+      user_id?: string;
+    }
+
+    export interface SearchOptions extends MemoryOptions {
+      api_version?: 'v1' | 'v2';
+    }
+
+    export interface Memory {
+      id: string;
+      messages: Array<{ role: string; content: string }>;
+    }
+
+    export class MemoryClient {
+      constructor(apiKey: string, host?: string);
+
+      add(messages: string | Array<{ role: string; content: string }>, options?: MemoryOptions): Promise<Memory>;
+      get(memoryId: string): Promise<Memory>;
+      getAll(options?: MemoryOptions): Promise<{ results: Memory[] }>;
+      search(query: string, options?: SearchOptions): Promise<{ results: Memory[] }>;
+      delete(memoryId: string): Promise<any>;
+      deleteAll(options?: MemoryOptions): Promise<any>;
+      history(memoryId: string): Promise<any>;
+      users(): Promise<any>;
+      deleteUsers(): Promise<{ message: string }>;
+    }
+
+    export default MemoryClient;
+  }

package/src/index.js

@@ -1,5 +1,18 @@
 const axios = require('axios');
 
+/**
+ * @typedef {Object} MemoryOptions
+ * @property {string} [user_id]
+ *
+ * @typedef {Object} SearchOptions
+ * @property {string} [user_id]
+ * @property {('v1'|'v2')} [api_version]
+ *
+ * @typedef {Object} Memory
+ * @property {string} id
+ * @property {Array<{role: string, content: string}>} messages
+ */
+
 class APIError extends Error {
   constructor(message) {
     super(message);
@@ -7,6 +20,11 @@ class APIError extends Error {
   }
 }
 
+/**
+ * @template T
+ * @param {(...args: any[]) => Promise<T>} fn
+ * @returns {(...args: any[]) => Promise<T>}
+ */
 function apiErrorHandler(fn) {
   return async function (...args) {
     try {
@@ -23,7 +41,14 @@ function apiErrorHandler(fn) {
   };
 }
 
+/**
+ * MemoryClient for interacting with the mem0ai API
+ */
 class MemoryClient {
+  /**
+   * @param {string} apiKey
+   * @param {string} [host]
+   */
   constructor(apiKey, host = 'https://api.mem0.ai') {
     this.apiKey = apiKey || process.env.MEM0_API_KEY;
     this.host = host;
@@ -48,6 +73,7 @@ class MemoryClient {
     this.delete = apiErrorHandler(this.delete.bind(this));
     this.deleteAll = apiErrorHandler(this.deleteAll.bind(this));
     this.history = apiErrorHandler(this.history.bind(this));
+    this.deleteUsers = apiErrorHandler(this.deleteUsers.bind(this));
   }
 
   async _validateApiKey() {
@@ -58,23 +84,49 @@ class MemoryClient {
     }
   }
 
+  /**
+   * @param {string|Array<{role: string, content: string}>} messages
+   * @param {MemoryOptions} [options]
+   * @returns {Promise<Memory>}
+   */
   async add(messages, options = {}) {
     const payload = this._preparePayload(messages, options);
     const response = await this.client.post('/v1/memories/', payload);
     return response.data;
   }
 
+  /**
+   * @param {string} memoryId
+   * @returns {Promise<Memory>}
+   */
   async get(memoryId) {
     const response = await this.client.get(`/v1/memories/${memoryId}/`);
     return response.data;
   }
 
+  /**
+   * @param {MemoryOptions} [options]
+   * @returns {Promise<{results: Memory[]}>}
+   */
   async getAll(options = {}) {
-    const params = this._prepareParams(options);
-    const response = await this.client.get('/v1/memories/', { params });
-    return response.data;
+    const { api_version, ...otherOptions } = options;
+    const endpoint = api_version === 'v2' ? '/v2/memories/' : '/v1/memories/';
+
+    if (api_version === 'v2') {
+      const response = await this.client.post(endpoint, otherOptions);
+      return response.data;
+    } else {
+      const params = this._prepareParams(otherOptions);
+      const response = await this.client.get(endpoint, { params });
+      return response.data;
+    }
   }
 
+  /**
+   * @param {string} query
+   * @param {SearchOptions} [options]
+   * @returns {Promise<{results: Memory[]}>}
+   */
   async search(query, options = {}) {
     const { api_version, ...otherOptions } = options;
     const payload = { query, ...otherOptions };
@@ -83,27 +135,58 @@ class MemoryClient {
     return response.data;
   }
 
+  /**
+   * @param {string} memoryId
+   * @returns {Promise<any>}
+   */
   async delete(memoryId) {
     const response = await this.client.delete(`/v1/memories/${memoryId}/`);
     return response.data;
   }
 
+  /**
+   * @param {MemoryOptions} [options]
+   * @returns {Promise<any>}
+   */
   async deleteAll(options = {}) {
     const params = this._prepareParams(options);
     const response = await this.client.delete('/v1/memories/', { params });
     return response.data;
   }
 
+  /**
+   * @param {string} memoryId
+   * @returns {Promise<any>}
+   */
   async history(memoryId) {
     const response = await this.client.get(`/v1/memories/${memoryId}/history/`);
     return response.data;
   }
 
+  /**
+   * @returns {Promise<any>}
+   */
   async users() {
     const response = await this.client.get('/v1/entities/');
     return response.data;
   }
 
+  /**
+   * @returns {Promise<{message: string}>}
+   */
+  async deleteUsers() {
+    const entities = await this.users();
+    for (const entity of entities.results) {
+      await this.client.delete(`/entities/${entity.type}/${entity.id}/`);
+    }
+    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') {
@@ -114,6 +197,10 @@ class MemoryClient {
     return { ...payload, ...options };
   }
 
+  /**
+   * @param {MemoryOptions} options
+   * @returns {Object}
+   */
   _prepareParams(options) {
     return Object.fromEntries(Object.entries(options).filter(([_, v]) => v != null));
   }