mem0ai 1.0.0

package/README.md

@@ -0,0 +1,224 @@
+# mem0ai
+
+Get started with Mem0 Platform in minutes using the Node.js client.
+
+## 1. Installation
+
+Install the Mem0 Node.js package:
+
+```bash
+npm install mem0ai
+```
+
+## 2. API Key Setup
+
+1. Sign in to [Mem0 Platform](https://app.mem0.ai/dashboard/api-keys)
+2. Copy your API Key from the dashboard
+
+## 3. Instantiate Client
+
+```javascript
+const MemoryClient = require('mem0ai');
+const client = new MemoryClient('your-api-key');
+```
+
+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();
+```
+
+## 4. Memory Operations
+
+Mem0 provides a simple and customizable interface for performing CRUD operations on memory.
+
+### 4.1 Create Memories
+
+You can create long-term and short-term memories for your users, AI Agents, etc. Here are some examples:
+
+#### Long-term memory for a user
+
+```javascript
+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." }
+];
+
+client.add(messages, { user_id: "alex" })
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
+#### Short-term memory for a user session
+
+```javascript
+const messages = [
+  { role: "user", content: "I'm planning a trip to Japan next month." },
+  { role: "assistant", content: "That's exciting, Alex! A trip to Japan next month sounds wonderful. Would you like some recommendations for vegetarian-friendly restaurants in Japan?" },
+  { role: "user", content: "Yes, please! Especially in Tokyo." },
+  { role: "assistant", content: "Great! I'll remember that you're interested in vegetarian restaurants in Tokyo for your upcoming trip. I'll prepare a list for you in our next interaction." }
+];
+
+client.add(messages, { user_id: "alex123", session_id: "trip-planning-2024" })
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
+#### Long-term memory for agents
+
+```javascript
+const messages = [
+  { role: "system", content: "You are a personalized travel assistant. Remember user preferences and provide tailored recommendations." },
+  { role: "assistant", content: "Understood. I'll maintain personalized travel preferences for each user and provide customized recommendations based on their dietary restrictions, interests, and past interactions." }
+];
+
+client.add(messages, { agent_id: "travel-assistant" })
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
+### 4.2 Search Relevant Memories
+
+You can get related memories for a given natural language question using our search method.
+
+```javascript
+const query = "What do you know about me?";
+client.search(query, { user_id: "alex" })
+  .then(results => console.log(results))
+  .catch(error => console.error(error));
+```
+
+Similarly, you can search for agent memories by passing the `agent_id` option:
+
+```javascript
+client.search("What are the learnings from previous runs?", { agent_id: "travel-assistant" })
+  .then(results => console.log(results))
+  .catch(error => console.error(error));
+```
+
+### 4.3 Get All Memories
+
+Fetch all memories for a user, agent, or session using the getAll() method.
+
+#### Get all memories of an AI Agent
+
+```javascript
+client.getAll({ agent_id: "travel-assistant" })
+  .then(memories => console.log(memories))
+  .catch(error => console.error(error));
+```
+
+#### Get all memories of a user
+
+```javascript
+client.getAll({ user_id: "alex" })
+  .then(memories => console.log(memories))
+  .catch(error => console.error(error));
+```
+
+#### Get short-term memories for a session
+
+```javascript
+client.getAll({ user_id: "alex123", session_id: "trip-planning-2024" })
+  .then(memories => console.log(memories))
+  .catch(error => console.error(error));
+```
+
+#### Get specific memory
+
+```javascript
+client.get("memory-id-here")
+  .then(memory => console.log(memory))
+  .catch(error => console.error(error));
+```
+
+### 4.4 Memory History
+
+Get history of how a memory has changed over time:
+
+```javascript
+// Add some message to create history
+let messages = [{ role: "user", content: "I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.." }];
+client.add(messages, { user_id: "alex" })
+  .then(result => {
+    // Add second message to update history
+    messages.push({ role: 'user', content: 'I turned vegetarian now.' });
+    return client.add(messages, { user_id: "alex" });
+  })
+  .then(result => {
+    // Get history of how memory changed over time
+    const memoryId = result.id; // Assuming the API returns the memory ID
+    return client.history(memoryId);
+  })
+  .then(history => console.log(history))
+  .catch(error => console.error(error));
+```
+
+### 4.5 Delete Memory
+
+Delete specific memory:
+
+```javascript
+client.delete("memory-id-here")
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
+Delete all memories of a user:
+
+```javascript
+client.deleteAll({ user_id: "alex" })
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
+Fun fact: You can also delete the memory using the `add()` method by passing a natural language command:
+
+```javascript
+client.add("Delete all of my food preferences", { user_id: "alex" })
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
+## 5. Error Handling
+
+The MemoryClient throws `APIError` for any API-related errors. 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);
+    }
+  });
+```
+
+## 6. Using with async/await
+
+All methods of the MemoryClient return promises, so you can use them with async/await:
+
+```javascript
+async function addMemory() {
+  try {
+    const result = await client.add(messages, { user_id: "alex" });
+    console.log(result);
+  } catch (error) {
+    console.error('Error adding memory:', error);
+  }
+}
+
+addMemory();
+```
+
+## Getting Help
+
+If you have any questions or need assistance, please reach out to us:
+
+- Email: support@mem0.ai
+- [Join our discord community](https://mem0.ai/discord)
+- [Join our slack community](https://mem0.ai/slack)
+- GitHub Issues: [Report bugs or request features](https://github.com/mem0ai/mem0ai-node/issues)

package/examples/basic-usage.js

@@ -0,0 +1,30 @@
+const MemoryClient = require('../src/index');
+
+async function main() {
+  const apiKey = 'your_api_key_here';
+  const client = new MemoryClient(apiKey);
+
+  try {
+    // Add a new memory
+    const addResult = await client.add('This is a test memory');
+    console.log('Memory added:', addResult);
+
+    // Get all memories
+    const allMemories = await client.getAll();
+    console.log('All memories:', allMemories);
+
+    // Search memories
+    const searchResult = await client.search('test');
+    console.log('Search results:', searchResult);
+
+    // Delete a memory (assuming we have a memory ID from the add result)
+    if (addResult && addResult.id) {
+      const deleteResult = await client.delete(addResult.id);
+      console.log('Memory deleted:', deleteResult);
+    }
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "mem0ai",
+  "version": "1.0.0",
+  "description": "The memory layer for personalized AI",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["mem0", "api", "client", "memory", "llm", "long-term-memory", "ai"],
+  "author": "Deshraj Yadav",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "axios": "^0.21.1"
+  }
+}

package/src/index.js

@@ -0,0 +1,113 @@
+const axios = require('axios');
+
+class APIError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'APIError';
+  }
+}
+
+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;
+      }
+    }
+  };
+}
+
+class MemoryClient {
+  constructor(apiKey, host = 'https://api.mem0.ai/v1') {
+    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.client = axios.create({
+      baseURL: this.host,
+      headers: { Authorization: `Token ${this.apiKey}` },
+      timeout: 60000,
+    });
+
+    this._validateApiKey();
+  }
+
+  async _validateApiKey() {
+    try {
+      await this.client.get('/memories/', { params: { user_id: 'test' } });
+    } catch (error) {
+      throw new Error('Invalid API Key. Please get a valid API Key from https://app.mem0.ai');
+    }
+  }
+
+  @apiErrorHandler
+  async add(messages, options = {}) {
+    const payload = this._preparePayload(messages, options);
+    const response = await this.client.post('/memories/', payload);
+    return response.data;
+  }
+
+  @apiErrorHandler
+  async get(memoryId) {
+    const response = await this.client.get(`/memories/${memoryId}/`);
+    return response.data;
+  }
+
+  @apiErrorHandler
+  async getAll(options = {}) {
+    const params = this._prepareParams(options);
+    const response = await this.client.get('/memories/', { params });
+    return response.data;
+  }
+
+  @apiErrorHandler
+  async search(query, options = {}) {
+    const payload = { query, ...options };
+    const response = await this.client.post('/memories/search/', payload);
+    return response.data;
+  }
+
+  @apiErrorHandler
+  async delete(memoryId) {
+    const response = await this.client.delete(`/memories/${memoryId}/`);
+    return response.data;
+  }
+
+  @apiErrorHandler
+  async deleteAll(options = {}) {
+    const params = this._prepareParams(options);
+    const response = await this.client.delete('/memories/', { params });
+    return response.data;
+  }
+
+  @apiErrorHandler
+  async history(memoryId) {
+    const response = await this.client.get(`/memories/${memoryId}/history/`);
+    return response.data;
+  }
+
+  _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 };
+  }
+
+  _prepareParams(options) {
+    return Object.fromEntries(Object.entries(options).filter(([_, v]) => v != null));
+  }
+}
+
+module.exports = MemoryClient;