mem0ai 1.0.11 → 1.0.13

package/README.md

@@ -1,15 +1,16 @@
 # Mem0 - The Memory layer for your AI apps
 
+
 Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users.
 
 Get started with Mem0 Platform in minutes using the Node.js client.
 
 ## 1. Installation
 
-Install the Mem0 Node.js package:
+Install the Mem0 package:
 
 ```bash
-npm install mem0ai
+npm i mem0ai
 ```
 
 ## 2. API Key Setup
@@ -20,15 +21,18 @@ npm install mem0ai
 ## 3. Instantiate Client
 
 ```javascript
-const MemoryClient = require('mem0ai');
-const client = new MemoryClient('your-api-key');
+import MemoryClient from 'mem0ai';
+
+const apiKey = 'your-api-key-here';
+const client = new MemoryClient(apiKey);
 ```
 
 Alternatively, you can set the `MEM0_API_KEY` environment variable and instantiate the client without passing the API key:
 
 ```javascript
-const MemoryClient = require('mem0ai');
-const client = new MemoryClient();
+import MemoryClient from 'mem0ai';
+
+const client = new MemoryClient(process.env.MEM0_API_KEY);
 ```
 
 ## 4. Memory Operations
@@ -244,18 +248,19 @@ client.add("Delete all of my food preferences", { user_id: "alex" })
 
 ## 5. Error Handling
 
-The MemoryClient throws `APIError` for any API-related errors. You can catch and handle these errors as follows:
+The MemoryClient throws errors for any API-related issues. You can catch and handle these errors as follows:
 
 ```javascript
-client.add(messages, { user_id: "alex" })
-  .then(result => console.log(result))
-  .catch(error => {
-    if (error.name === 'APIError') {
-      console.error('API Error:', error.message);
-    } else {
-      console.error('Unexpected error:', error);
-    }
-  });
+try {
+  const result = await client.add(messages, { user_id: "alex" });
+  console.log(result);
+} catch (error) {
+  if (error.name === 'APIError') {
+    console.error('API Error:', error.message);
+  } else {
+    console.error('Unexpected error:', error);
+  }
+}
 ```
 
 ## 6. Using with async/await
@@ -265,16 +270,67 @@ All methods of the MemoryClient return promises, so you can use them with async/
 ```javascript
 async function addMemory() {
   try {
+    const messages = [
+      { role: "user", content: "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts." },
+      { role: "assistant", content: "Hello Alex! I've noted that you're a vegetarian and have a nut allergy. I'll keep this in mind for any food-related recommendations or discussions." }
+    ];
     const result = await client.add(messages, { user_id: "alex" });
-    console.log(result);
+    console.log('Memory added:', result);
+
+    const searchResult = await client.search("What are Alex's dietary restrictions?", { user_id: "alex" });
+    console.log('Search result:', searchResult);
   } catch (error) {
-    console.error('Error adding memory:', error);
+    console.error('Error:', error);
   }
 }
 
 addMemory();
 ```
 
+## 7. Testing the Client
+
+To test the MemoryClient in a Node.js environment, you can create a simple script:
+
+```javascript
+// test-mem0.js
+import MemoryClient from 'mem0ai';
+
+const apiKey = 'your-api-key-here';
+const client = new MemoryClient(apiKey);
+
+async function testMemoryOperations() {
+  try {
+    // Add a memory
+    const addResult = await client.add([
+      { role: "user", content: "My favorite color is blue." }
+    ], { user_id: "test-user" });
+    console.log('Memory added:', addResult);
+
+    // Search for memories
+    const searchResult = await client.search("What's my favorite color?", { user_id: "test-user" });
+    console.log('Search result:', searchResult);
+
+    // Get all memories
+    const allMemories = await client.getAll({ user_id: "test-user" });
+    console.log('All memories:', allMemories);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+testMemoryOperations();
+```
+
+Run this script using Node.js:
+
+```bash
+node test-mem0.js
+```
+
+This will perform basic operations (add, search, getAll) and log the results, allowing you to verify that the client is working correctly with your API key.
+
+Remember to replace 'your-api-key-here' with your actual Mem0 API key when testing.
+
 ## Getting Help
 
 If you have any questions or need assistance, please reach out to us:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mem0ai",
-    "version": "1.0.11",
+    "version": "1.0.13",
     "description": "The Memory layer for your AI apps",
     "main": "src/index.js",
     "scripts": {
@@ -19,12 +19,12 @@
     "author": "Deshraj Yadav",
     "license": "Apache-2.0",
     "dependencies": {
-        "axios": "^0.21.1",
-        "posthog-node": "^4.2.0"
+        "posthog-js": "^1.167.0"
     },
     "files": [
         "src/",
         "package.json",
         "README.md"
-    ]
+    ],
+    "module": "dist/index.mjs"
 }

package/src/index.d.ts

@@ -1,30 +1,61 @@
 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;
-  }
+  export interface MemoryOptions {
+    user_id?: string;
+    agent_id?: string;
+    app_id?: string;
+    metadata?: Record<string, any>;
+    filters?: Record<string, any>;
+  }
+
+  export interface SearchOptions extends MemoryOptions {
+    api_version?: 'v1' | 'v2';
+    limit?: number;
+  }
+
+  export interface Memory {
+    id: string;
+    messages: Array<{ role: string; content: string }>;
+  }
+
+  export class MemoryClient {
+    constructor(
+      apiKey: string,
+      host?: string,
+      organizationName?: string,
+      projectName?: string
+    );
+
+    add(
+      messages: string | Array<{ role: string; content: string }>,
+      options?: MemoryOptions
+    ): Promise<Memory>;
+
+    get(memoryId: string): Promise<Memory>;
+
+    getAll(options?: MemoryOptions & { api_version?: 'v1' | 'v2' }): 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 }>;
+
+    private _validateApiKey(): Promise<void>;
+
+    private _preparePayload(
+      messages: string | Array<{ role: string; content: string }>,
+      options: MemoryOptions
+    ): object;
+
+    private _prepareParams(options: MemoryOptions): object;
+  }
+
+  export { MemoryClient };
+  export default MemoryClient;
+}

package/src/index.js

@@ -1,226 +1,219 @@
-const axios = require('axios');
-const crypto = require('crypto');
-const { telemetry, captureClientEvent } = require('./telemetry');
-
-/**
- * @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
- */
+import { telemetry, captureClientEvent } from './telemetry.js';
+import crypto from 'crypto';
 
 class APIError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'APIError';
-  }
-}
-
-/**
- * @template T
- * @param {(...args: any[]) => Promise<T>} fn
- * @returns {(...args: any[]) => Promise<T>}
- */
-function apiErrorHandler(fn) {
-  return async function (...args) {
-    try {
-      return await fn.apply(this, args);
-    } catch (error) {
-      if (error.response) {
-        throw new APIError(`API request failed: ${error.response.data}`);
-      } else if (error.request) {
-        throw new APIError(`Request failed: ${error.message}`);
-      } else {
-        throw error;
-      }
-    }
-  };
+    constructor(message) {
+        super(message);
+        this.name = 'APIError';
+    }
 }
 
 /**
  * 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;
-
-    if (!this.apiKey) {
-      throw new Error('API Key not provided. Please provide an API Key.');
-    }
-
-    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.bind(this));
-    this.get = this.wrapMethod('get', this.get.bind(this));
-    this.getAll = this.wrapMethod('get_all', this.getAll.bind(this));
-    this.search = this.wrapMethod('search', this.search.bind(this));
-    this.delete = this.wrapMethod('delete', this.delete.bind(this));
-    this.deleteAll = this.wrapMethod('delete_all', this.deleteAll.bind(this));
-    this.history = this.wrapMethod('history', this.history.bind(this));
-    this.deleteUsers = this.wrapMethod('delete_users', this.deleteUsers.bind(this));
-  }
-
-  wrapMethod(eventName, method) {
-    return apiErrorHandler(async (...args) => {
-      const result = await method(...args);
-      await captureClientEvent(eventName, this);
-      return result;
-    });
-  }
-
-  async _validateApiKey() {
-    try {
-      await this.client.get('/v1/memories/', { params: { user_id: 'test' } });
-    } catch (error) {
-      throw new Error('Invalid API Key. Please get a valid API Key from https://app.mem0.ai');
-    }
-  }
-
-  /**
-   * @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 { 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 };
-    const endpoint = api_version === 'v2' ? '/v2/memories/search/' : '/v1/memories/search/';
-    const response = await this.client.post(endpoint, payload);
-    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') {
-      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));
-  }
+    /**
+     * @param {string} apiKey
+     * @param {string} [host]
+     * @param {string} [organizationName]
+     * @param {string} [projectName]
+     */
+    constructor(apiKey, host = 'https://api.mem0.ai', organizationName = null, projectName = null) {
+        this.apiKey = apiKey;
+        this.host = host;
+        this.organizationName = organizationName;
+        this.projectName = projectName;
+        this.telemetryId = crypto.createHash('md5').update(this.apiKey).digest('hex');
+
+        this.headers = {
+            'Authorization': `Token ${this.apiKey}`,
+            'Content-Type': 'application/json'
+        };
+
+        this._validateApiKey();
+
+        captureClientEvent('init', this, {
+            host: this.host,
+            organization_name: this.organizationName,
+            project_name: this.projectName,
+        });
+
+        this._wrapMethods();
+    }
+
+    _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}`);
+        }
+        return response.json();
+    }
+
+    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)
+        });
+        captureClientEvent('add', this, { messages_count: messages.length });
+        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)
+        });
+        captureClientEvent('search', this, { query_length: query.length });
+        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) {
+        return this._fetchWithErrorHandling(`${this.host}/v1/memories/${memoryId}/history/`, {
+            headers: this.headers
+        });
+    }
+
+    async users() {
+        const params = new URLSearchParams({
+            organization_name: this.organizationName,
+            project_name: this.projectName
+        });
+        return this._fetchWithErrorHandling(`${this.host}/v1/entities/?${params}`, {
+            headers: this.headers
+        });
+    }
+
+    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));
+    }
+
+    _wrapMethods() {
+        // Apply error handler and telemetry to methods
+        this.add = this._wrapMethod('add', this.add.bind(this));
+        this.get = this._wrapMethod('get', this.get.bind(this));
+        this.getAll = this._wrapMethod('get_all', this.getAll.bind(this));
+        this.search = this._wrapMethod('search', this.search.bind(this));
+        this.delete = this._wrapMethod('delete', this.delete.bind(this));
+        this.deleteAll = this._wrapMethod('delete_all', this.deleteAll.bind(this));
+        this.history = this._wrapMethod('history', this.history.bind(this));
+        this.deleteUsers = this._wrapMethod('delete_users', this.deleteUsers.bind(this));
+    }
+
+    _wrapMethod(methodName, method) {
+        return async (...args) => {
+            try {
+                const result = await method(...args);
+                captureClientEvent(methodName, this, { success: true });
+                return result;
+            } catch (error) {
+                captureClientEvent(methodName, this, { success: false, error: error.message });
+                throw error;
+            }
+        };
+    }
 }
 
-module.exports = MemoryClient;
+export default MemoryClient;
 
-process.on('beforeExit', async () => {
-  await telemetry.shutdown();
-});
+// Add a way to manually shutdown telemetry if needed
+MemoryClient.shutdownTelemetry = async () => {
+    await telemetry.shutdown();
+};

package/src/telemetry.js

@@ -1,56 +1,29 @@
-const { PostHog } = require('posthog-node');
-const os = require('os');
-const path = require('path');
-const fs = require('fs');
+import posthog from 'posthog-js';
 
-const MEM0_TELEMETRY = process.env.MEM0_TELEMETRY !== 'false';
+posthog.init('phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX', { api_host: 'https://us.i.posthog.com' });
 
 class AnonymousTelemetry {
-  constructor(projectApiKey, host) {
-    this.client = new PostHog(projectApiKey, { host });
-    if (!MEM0_TELEMETRY) {
-      this.client.disable();
-    }
-  }
 
   async captureEvent(distinctId, eventName, properties = {}) {
+    if (eventName === 'client.init') {
+      posthog.identify(distinctId);
+    }
     const eventProperties = {
-      client_source: 'nodejs',
-      client_version: getVersion(),
-      node_version: process.version,
-      os: process.platform,
-      os_version: os.release(),
-      os_arch: os.arch(),
+      client_source: 'js',
       ...properties
     };
 
-    try {
-      await this.client.capture({
-        distinctId: distinctId,
-        event: eventName,
-        properties: eventProperties
-      });
-    } catch (error) {
-      console.error('Error capturing event:', error);
-    }
+    posthog.capture(eventName, {
+      properties: eventProperties
+    });
   }
 
   async shutdown() {
-    return this.client.shutdown();
+    await posthog.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'
-);
+const telemetry = new AnonymousTelemetry();
 
 async function captureClientEvent(eventName, instance, additionalData = {}) {
   const eventData = {
@@ -60,4 +33,4 @@ async function captureClientEvent(eventName, instance, additionalData = {}) {
   await telemetry.captureEvent(instance.telemetryId, `client.${eventName}`, eventData);
 }
 
-module.exports = { telemetry, captureClientEvent };
+export { telemetry, captureClientEvent };