mem0ai 1.0.16 → 1.0.18

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "mem0ai",
-    "version": "1.0.16",
+    "version": "1.0.18",
     "description": "The Memory Layer For Your AI Apps",
     "main": "src/index.js",
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "jest"
     },
     "types": "src/index.d.ts",
     "keywords": [
@@ -28,5 +28,16 @@
         "require": "./src/index.cjs",
         "import": "./dist/index.js"
     },
-    "module": "dist/index.mjs"
-}
+    "module": "dist/index.mjs",
+    "devDependencies": {
+        "@types/node": "^22.7.6",
+        "dotenv": "^16.4.5",
+        "jest": "^29.7.0",
+        "rollup": "^4.24.0"
+    },
+    "dependencies": {
+        "axios": "^1.7.7",
+        "crypto": "^1.0.1",
+        "posthog-node": "^4.2.1"
+    }
+}

package/src/index.cjs

@@ -1,5 +1,70 @@
 'use strict';
 
+var crypto = require('crypto');
+var axios = require('axios');
+var posthogNode = require('posthog-node');
+var os = require('os');
+var path = require('path');
+var fs = require('fs');
+
+process.env.MEM0_TELEMETRY !== "false";
+
+class AnonymousTelemetry {
+  constructor(projectApiKey, host) {
+    this.client = new posthogNode.PostHog(projectApiKey, { host, flushAt: 1 });
+  }
+
+  async captureEvent(distinctId, eventName, properties = {}) {
+    const eventProperties = {
+      client_source: "nodejs",
+      client_version: getVersion(),
+      node_version: process.version,
+      os: process.platform,
+      os_version: os.release(),
+      os_arch: os.arch(),
+      ...properties,
+    };
+
+    try {
+      this.client.capture({
+        distinctId: distinctId,
+        event: eventName,
+        properties: eventProperties,
+      });
+    } catch (error) {
+      console.error("Error capturing event:", error);
+    }
+  }
+
+  async shutdown() {
+    return this.client.shutdown();
+  }
+}
+
+function getVersion() {
+  const packageJsonPath = path.join(__dirname, "..", "package.json");
+  const packageJsonContent = fs.readFileSync(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonContent);
+  return packageJson.version;
+}
+
+const telemetry = new AnonymousTelemetry(
+  "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX",
+  "https://us.i.posthog.com"
+);
+
+async function captureClientEvent(eventName, instance, additionalData = {}) {
+  const eventData = {
+    function: `${instance.constructor.name}`,
+    ...additionalData,
+  };
+  await telemetry.captureEvent(
+    instance.telemetryId,
+    `client.${eventName}`,
+    eventData
+  );
+}
+
 class APIError extends Error {
     constructor(message) {
         super(message);
@@ -28,7 +93,36 @@ class MemoryClient {
             'Content-Type': 'application/json'
         };
 
+        this.telemetryId = crypto.createHash('md5').update(this.apiKey).digest('hex');
+
+        this.client = axios.create({
+            baseURL: this.host,
+            headers: { Authorization: `Token ${this.apiKey}` },
+            timeout: 60000,
+        });
+
+        captureClientEvent('init', this);
+
         this._validateApiKey();
+
+        // Apply error handler and telemetry to methods
+        this.add = this.wrapMethod('add', this.add);
+        this.get = this.wrapMethod('get', this.get);
+        this.getAll = this.wrapMethod('get_all', this.getAll);
+        this.search = this.wrapMethod('search', this.search);
+        this.delete = this.wrapMethod('delete', this.delete);
+        this.deleteAll = this.wrapMethod('delete_all', this.deleteAll);
+        this.history = this.wrapMethod('history', this.history);
+        this.users = this.wrapMethod('users', this.users);
+        this.deleteUser = this.wrapMethod('delete_user', this.deleteUser);
+        this.deleteUsers = this.wrapMethod('delete_users', this.deleteUsers);
+    }
+
+    wrapMethod(methodName, method) {
+        return async function (...args) {
+            await captureClientEvent(methodName, this);
+            return method.apply(this, args);
+        }.bind(this);
     }
 
     _validateApiKey() {
@@ -141,6 +235,14 @@ class MemoryClient {
         return response;
     }
 
+    async deleteUser(entityId, entity = { type: 'user' }) {
+        const response = await this._fetchWithErrorHandling(`${this.host}/v1/entities/${entity.type}/${entityId}/`, {
+            method: 'DELETE',
+            headers: this.headers
+        });
+        return response;
+    }
+    
     async deleteUsers() {
         const entities = await this.users();
         for (const entity of entities.results) {
@@ -175,7 +277,6 @@ class MemoryClient {
     _prepareParams(options) {
         return Object.fromEntries(Object.entries(options).filter(([_, v]) => v != null));
     }
-
 }
 
 module.exports = MemoryClient;

package/src/index.d.ts

@@ -7,14 +7,76 @@ declare module 'mem0ai' {
     filters?: Record<string, any>;
   }
 
+  enum API_VERSION {
+    V1 = 'v1',
+    V2 = 'v2',
+  }
+
+  export interface Messages {
+    role: string;
+    content: string;
+  }
+
+  export interface MemoryHistory {
+    id: string;
+    memory_id: string;
+    input: Array<Messages>;
+    old_memory: string | null;
+    new_memory: string | null;
+    user_id: string;
+    categories: Array<string>;
+    event: Event | string;
+    created_at: Date;
+    updated_at: Date;
+  }
+
   export interface SearchOptions extends MemoryOptions {
-    api_version?: 'v1' | 'v2';
+    api_version?: API_VERSION | string;
     limit?: number;
   }
 
+  enum Event{
+    ADD = 'ADD',
+    UPDATE = 'UPDATE',
+    DELETE = 'DELETE',
+    NOOP = 'NOOP',
+  }
+
+  export interface MemoryData {
+    memory: string;
+  }
+
   export interface Memory {
     id: string;
-    messages: Array<{ role: string; content: string }>;
+    messages?: Array<Messages>;
+    event?: Event | string;
+    data?: MemoryData | null;
+    memory?: string;
+    user_id?: string;
+    hash?: string;
+    categories?: Array<string>;
+    created_at?: Date;
+    updated_at?: Date;
+    memory_type?: string;
+    score?: number;
+    metadata?: any | null;
+  }
+
+  export interface User {
+    id: string;
+    name: string;
+    created_at: Date;
+    updated_at: Date;
+    total_memories: number;
+    owner: string;
+    type: string;
+  }
+
+  export interface AllUsers {
+    count: number;
+    results: Array<User>;
+    next: any;
+    previous: any;
   }
 
   export class MemoryClient {
@@ -28,24 +90,26 @@ declare module 'mem0ai' {
     add(
       messages: string | Array<{ role: string; content: string }>,
       options?: MemoryOptions
-    ): Promise<Memory[]>;
+    ): Promise<Array<Memory>>;
 
     get(memoryId: string): Promise<Memory>;
 
-    getAll(options?: MemoryOptions & { api_version?: 'v1' | 'v2' }): Promise<{ results: Memory[] }>;
+    getAll(options?: MemoryOptions & { api_version?: 'v1' | 'v2' }): Promise<Array<Memory>>;
 
-    search(query: string, options?: SearchOptions): Promise<{ results: Memory[] }>;
+    search(query: string, options?: SearchOptions): Promise<Array<Memory>>; 
 
-    delete(memoryId: string): Promise<any>;
+    delete(memoryId: string): Promise<{ message: string }>;
 
-    deleteAll(options?: MemoryOptions): Promise<any>;
+    deleteAll(options?: MemoryOptions): Promise<{ message: string }>;
 
-    history(memoryId: string): Promise<any>;
+    history(memoryId: string): Promise<Array<MemoryHistory>>;
 
-    users(): Promise<any>;
+    users(): Promise<AllUsers>;
 
     deleteUsers(): Promise<{ message: string }>;
 
+    deleteUser(entityId: string, entity?: { type: string }): Promise<{ message: string }>;
+
     private _validateApiKey(): Promise<void>;
 
     private _preparePayload(

package/src/index.js

@@ -1,3 +1,7 @@
+import crypto from 'crypto';
+import axios from 'axios';
+import { captureClientEvent } from './telemetry.js';
+
 class APIError extends Error {
     constructor(message) {
         super(message);
@@ -26,7 +30,36 @@ class MemoryClient {
             'Content-Type': 'application/json'
         };
 
+        this.telemetryId = crypto.createHash('md5').update(this.apiKey).digest('hex');
+
+        this.client = axios.create({
+            baseURL: this.host,
+            headers: { Authorization: `Token ${this.apiKey}` },
+            timeout: 60000,
+        });
+
+        captureClientEvent('init', this);
+
         this._validateApiKey();
+
+        // Apply error handler and telemetry to methods
+        this.add = this.wrapMethod('add', this.add);
+        this.get = this.wrapMethod('get', this.get);
+        this.getAll = this.wrapMethod('get_all', this.getAll);
+        this.search = this.wrapMethod('search', this.search);
+        this.delete = this.wrapMethod('delete', this.delete);
+        this.deleteAll = this.wrapMethod('delete_all', this.deleteAll);
+        this.history = this.wrapMethod('history', this.history);
+        this.users = this.wrapMethod('users', this.users);
+        this.deleteUser = this.wrapMethod('delete_user', this.deleteUser);
+        this.deleteUsers = this.wrapMethod('delete_users', this.deleteUsers);
+    }
+
+    wrapMethod(methodName, method) {
+        return async function (...args) {
+            await captureClientEvent(methodName, this);
+            return method.apply(this, args);
+        }.bind(this);
     }
 
     _validateApiKey() {
@@ -139,6 +172,14 @@ class MemoryClient {
         return response;
     }
 
+    async deleteUser(entityId, entity = { type: 'user' }) {
+        const response = await this._fetchWithErrorHandling(`${this.host}/v1/entities/${entity.type}/${entityId}/`, {
+            method: 'DELETE',
+            headers: this.headers
+        });
+        return response;
+    }
+    
     async deleteUsers() {
         const entities = await this.users();
         for (const entity of entities.results) {
@@ -173,7 +214,6 @@ class MemoryClient {
     _prepareParams(options) {
         return Object.fromEntries(Object.entries(options).filter(([_, v]) => v != null));
     }
-
 }
 
-export default MemoryClient;
+export default MemoryClient;

package/src/telemetry.js

@@ -0,0 +1,64 @@
+import { PostHog } from "posthog-node";
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+const MEM0_TELEMETRY = process.env.MEM0_TELEMETRY !== "false";
+
+class AnonymousTelemetry {
+  constructor(projectApiKey, host) {
+    this.client = new PostHog(projectApiKey, { host, flushAt: 1 });
+  }
+
+  async captureEvent(distinctId, eventName, properties = {}) {
+    const eventProperties = {
+      client_source: "nodejs",
+      client_version: getVersion(),
+      node_version: process.version,
+      os: process.platform,
+      os_version: os.release(),
+      os_arch: os.arch(),
+      ...properties,
+    };
+
+    try {
+      this.client.capture({
+        distinctId: distinctId,
+        event: eventName,
+        properties: eventProperties,
+      });
+    } catch (error) {
+      console.error("Error capturing event:", error);
+    }
+  }
+
+  async shutdown() {
+    return this.client.shutdown();
+  }
+}
+
+function getVersion() {
+  const packageJsonPath = path.join(__dirname, "..", "package.json");
+  const packageJsonContent = fs.readFileSync(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonContent);
+  return packageJson.version;
+}
+
+const telemetry = new AnonymousTelemetry(
+  "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX",
+  "https://us.i.posthog.com"
+);
+
+async function captureClientEvent(eventName, instance, additionalData = {}) {
+  const eventData = {
+    function: `${instance.constructor.name}`,
+    ...additionalData,
+  };
+  await telemetry.captureEvent(
+    instance.telemetryId,
+    `client.${eventName}`,
+    eventData
+  );
+}
+
+export { telemetry, captureClientEvent };