Added Mem0 TS Library (#2270)

mem0-ts/src/client/index.ts

@@ -0,0 +1,36 @@
+import { MemoryClient } from "./mem0";
+import type { TelemetryClient, TelemetryInstance } from "./telemetry.types";
+import {
+  telemetry,
+  captureClientEvent,
+  generateHash,
+} from "./telemetry.browser";
+import type * as MemoryTypes from "./mem0.types";
+
+// Re-export all types from mem0.types
+export type {
+  MemoryOptions,
+  ProjectOptions,
+  Memory,
+  MemoryHistory,
+  MemoryUpdateBody,
+  ProjectResponse,
+  PromptUpdatePayload,
+  SearchOptions,
+  Webhook,
+  WebhookPayload,
+  Messages,
+  Message,
+  AllUsers,
+  User,
+} from "./mem0.types";
+
+// Export telemetry types
+export type { TelemetryClient, TelemetryInstance };
+
+// Export telemetry implementation
+export { telemetry, captureClientEvent, generateHash };
+
+// Export the main client
+export { MemoryClient };
+export default MemoryClient;

mem0-ts/src/client/mem0.ts

@@ -0,0 +1,560 @@
+import axios from "axios";
+import {
+  AllUsers,
+  ProjectOptions,
+  Memory,
+  MemoryHistory,
+  MemoryOptions,
+  MemoryUpdateBody,
+  ProjectResponse,
+  PromptUpdatePayload,
+  SearchOptions,
+  Webhook,
+  WebhookPayload,
+} from "./mem0.types";
+import { captureClientEvent, generateHash } from "./telemetry";
+
+class APIError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "APIError";
+  }
+}
+
+interface ClientOptions {
+  apiKey: string;
+  host?: string;
+  organizationName?: string;
+  projectName?: string;
+  organizationId?: string;
+  projectId?: string;
+}
+
+export default class MemoryClient {
+  apiKey: string;
+  host: string;
+  organizationName: string | null;
+  projectName: string | null;
+  organizationId: string | number | null;
+  projectId: string | number | null;
+  headers: Record<string, string>;
+  client: any;
+  telemetryId: string;
+
+  _validateApiKey(): any {
+    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");
+    }
+  }
+
+  _validateOrgProject(): void {
+    // Check for organizationName/projectName pair
+    if (
+      (this.organizationName === null && this.projectName !== null) ||
+      (this.organizationName !== null && this.projectName === null)
+    ) {
+      console.warn(
+        "Warning: Both organizationName and projectName must be provided together when using either. This will be removedfrom the version 1.0.40. Note that organizationName/projectName are being deprecated in favor of organizationId/projectId.",
+      );
+    }
+
+    // Check for organizationId/projectId pair
+    if (
+      (this.organizationId === null && this.projectId !== null) ||
+      (this.organizationId !== null && this.projectId === null)
+    ) {
+      console.warn(
+        "Warning: Both organizationId and projectId must be provided together when using either. This will be removedfrom the version 1.0.40.",
+      );
+    }
+  }
+
+  constructor(options: ClientOptions) {
+    this.apiKey = options.apiKey;
+    this.host = options.host || "https://api.mem0.ai";
+    this.organizationName = options.organizationName || null;
+    this.projectName = options.projectName || null;
+    this.organizationId = options.organizationId || null;
+    this.projectId = options.projectId || null;
+
+    this.headers = {
+      Authorization: `Token ${this.apiKey}`,
+      "Content-Type": "application/json",
+    };
+
+    this.client = axios.create({
+      baseURL: this.host,
+      headers: { Authorization: `Token ${this.apiKey}` },
+      timeout: 60000,
+    });
+
+    this._validateApiKey();
+    this._validateOrgProject();
+
+    // Initialize with a temporary ID that will be updated
+    this.telemetryId = "";
+
+    // Initialize the client
+    this._initializeClient();
+  }
+
+  private async _initializeClient() {
+    try {
+      // do this only in browser
+      if (typeof window !== "undefined") {
+        this.telemetryId = await generateHash(this.apiKey);
+        await captureClientEvent("init", this);
+      }
+
+      // Wrap methods after initialization
+      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);
+      this.batchUpdate = this.wrapMethod("batch_update", this.batchUpdate);
+      this.batchDelete = this.wrapMethod("batch_delete", this.batchDelete);
+      this.getProject = this.wrapMethod("get_project", this.getProject);
+      this.updateProject = this.wrapMethod(
+        "update_project",
+        this.updateProject,
+      );
+      this.getWebhooks = this.wrapMethod("get_webhook", this.getWebhooks);
+      this.createWebhook = this.wrapMethod(
+        "create_webhook",
+        this.createWebhook,
+      );
+      this.updateWebhook = this.wrapMethod(
+        "update_webhook",
+        this.updateWebhook,
+      );
+      this.deleteWebhook = this.wrapMethod(
+        "delete_webhook",
+        this.deleteWebhook,
+      );
+    } catch (error) {
+      console.error("Failed to initialize client:", error);
+    }
+  }
+
+  wrapMethod(methodName: any, method: any) {
+    return async function (...args: any) {
+      // @ts-ignore
+      await captureClientEvent(methodName, this);
+      // @ts-ignore
+      return method.apply(this, args);
+    }.bind(this);
+  }
+
+  async _fetchWithErrorHandling(url: string, options: any): Promise<any> {
+    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;
+  }
+
+  _preparePayload(
+    messages: string | Array<{ role: string; content: string }>,
+    options: MemoryOptions,
+  ): object {
+    const payload: any = {};
+    if (typeof messages === "string") {
+      payload.messages = [{ role: "user", content: messages }];
+    } else if (Array.isArray(messages)) {
+      payload.messages = messages;
+    }
+    return { ...payload, ...options };
+  }
+
+  _prepareParams(options: MemoryOptions): object {
+    return Object.fromEntries(
+      Object.entries(options).filter(([_, v]) => v != null),
+    );
+  }
+
+  async add(
+    messages: string | Array<{ role: string; content: string }>,
+    options: MemoryOptions = {},
+  ): Promise<Array<Memory>> {
+    this._validateOrgProject();
+    if (this.organizationName != null && this.projectName != null) {
+      options.org_name = this.organizationName;
+      options.project_name = this.projectName;
+    }
+
+    if (this.organizationId != null && this.projectId != null) {
+      options.org_id = this.organizationId;
+      options.project_id = this.projectId;
+
+      if (options.org_name) delete options.org_name;
+      if (options.project_name) delete options.project_name;
+    }
+
+    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 update(memoryId: string, message: string): Promise<Array<Memory>> {
+    this._validateOrgProject();
+    const payload = {
+      text: message,
+    };
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/v1/memories/${memoryId}/`,
+      {
+        method: "PUT",
+        headers: this.headers,
+        body: JSON.stringify(payload),
+      },
+    );
+    return response;
+  }
+
+  async get(memoryId: string): Promise<Memory> {
+    return this._fetchWithErrorHandling(
+      `${this.host}/v1/memories/${memoryId}/`,
+      {
+        headers: this.headers,
+      },
+    );
+  }
+
+  async getAll(options?: SearchOptions): Promise<Array<Memory>> {
+    this._validateOrgProject();
+    const { api_version, page, page_size, ...otherOptions } = options!;
+    if (this.organizationName != null && this.projectName != null) {
+      otherOptions.org_name = this.organizationName;
+      otherOptions.project_name = this.projectName;
+    }
+
+    let appendedParams = "";
+    let paginated_response = false;
+
+    if (page && page_size) {
+      appendedParams += `page=${page}&page_size=${page_size}`;
+      paginated_response = true;
+    }
+
+    if (this.organizationId != null && this.projectId != null) {
+      otherOptions.org_id = this.organizationId;
+      otherOptions.project_id = this.projectId;
+
+      if (otherOptions.org_name) delete otherOptions.org_name;
+      if (otherOptions.project_name) delete otherOptions.project_name;
+    }
+
+    if (api_version === "v2") {
+      let url = paginated_response
+        ? `${this.host}/v2/memories/?${appendedParams}`
+        : `${this.host}/v2/memories/`;
+      return this._fetchWithErrorHandling(url, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(otherOptions),
+      });
+    } else {
+      // @ts-ignore
+      const params = new URLSearchParams(this._prepareParams(otherOptions));
+      const url = paginated_response
+        ? `${this.host}/v1/memories/?${params}&${appendedParams}`
+        : `${this.host}/v1/memories/?${params}`;
+      return this._fetchWithErrorHandling(url, {
+        headers: this.headers,
+      });
+    }
+  }
+
+  async search(query: string, options?: SearchOptions): Promise<Array<Memory>> {
+    this._validateOrgProject();
+    const { api_version, ...otherOptions } = options!;
+    const payload = { query, ...otherOptions };
+    if (this.organizationName != null && this.projectName != null) {
+      payload.org_name = this.organizationName;
+      payload.project_name = this.projectName;
+    }
+
+    if (this.organizationId != null && this.projectId != null) {
+      payload.org_id = this.organizationId;
+      payload.project_id = this.projectId;
+
+      if (payload.org_name) delete payload.org_name;
+      if (payload.project_name) delete payload.project_name;
+    }
+    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: string): Promise<{ message: string }> {
+    return this._fetchWithErrorHandling(
+      `${this.host}/v1/memories/${memoryId}/`,
+      {
+        method: "DELETE",
+        headers: this.headers,
+      },
+    );
+  }
+
+  async deleteAll(options: MemoryOptions = {}): Promise<{ message: string }> {
+    this._validateOrgProject();
+    if (this.organizationName != null && this.projectName != null) {
+      options.org_name = this.organizationName;
+      options.project_name = this.projectName;
+    }
+
+    if (this.organizationId != null && this.projectId != null) {
+      options.org_id = this.organizationId;
+      options.project_id = this.projectId;
+
+      if (options.org_name) delete options.org_name;
+      if (options.project_name) delete options.project_name;
+    }
+    // @ts-ignore
+    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: string): Promise<Array<MemoryHistory>> {
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/v1/memories/${memoryId}/history/`,
+      {
+        headers: this.headers,
+      },
+    );
+    return response;
+  }
+
+  async users(): Promise<AllUsers> {
+    this._validateOrgProject();
+    const options: MemoryOptions = {};
+    if (this.organizationName != null && this.projectName != null) {
+      options.org_name = this.organizationName;
+      options.project_name = this.projectName;
+    }
+
+    if (this.organizationId != null && this.projectId != null) {
+      options.org_id = this.organizationId;
+      options.project_id = this.projectId;
+
+      if (options.org_name) delete options.org_name;
+      if (options.project_name) delete options.project_name;
+    }
+    // @ts-ignore
+    const params = new URLSearchParams(options);
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/v1/entities/?${params}`,
+      {
+        headers: this.headers,
+      },
+    );
+    return response;
+  }
+
+  async deleteUser(
+    entityId: string,
+    entity: { type: string } = { type: "user" },
+  ): Promise<{ message: string }> {
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/v1/entities/${entity.type}/${entityId}/`,
+      {
+        method: "DELETE",
+        headers: this.headers,
+      },
+    );
+    return response;
+  }
+
+  async deleteUsers(): Promise<{ message: string }> {
+    this._validateOrgProject();
+    const entities = await this.users();
+
+    for (const entity of entities.results) {
+      let options: MemoryOptions = {};
+      if (this.organizationName != null && this.projectName != null) {
+        options.org_name = this.organizationName;
+        options.project_name = this.projectName;
+      }
+
+      if (this.organizationId != null && this.projectId != null) {
+        options.org_id = this.organizationId;
+        options.project_id = this.projectId;
+
+        if (options.org_name) delete options.org_name;
+        if (options.project_name) delete options.project_name;
+      }
+      await this.client.delete(`/v1/entities/${entity.type}/${entity.id}/`, {
+        params: options,
+      });
+    }
+    return { message: "All users, agents, and sessions deleted." };
+  }
+
+  async batchUpdate(memories: Array<MemoryUpdateBody>): Promise<string> {
+    const memoriesBody = memories.map((memory) => ({
+      memory_id: memory.memoryId,
+      text: memory.text,
+    }));
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/v1/batch/`,
+      {
+        method: "PUT",
+        headers: this.headers,
+        body: JSON.stringify({ memories: memoriesBody }),
+      },
+    );
+    return response;
+  }
+
+  async batchDelete(memories: Array<string>): Promise<string> {
+    const memoriesBody = memories.map((memory) => ({
+      memory_id: memory,
+    }));
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/v1/batch/`,
+      {
+        method: "DELETE",
+        headers: this.headers,
+        body: JSON.stringify({ memories: memoriesBody }),
+      },
+    );
+    return response;
+  }
+
+  async getProject(options: ProjectOptions): Promise<ProjectResponse> {
+    this._validateOrgProject();
+
+    const { fields } = options;
+
+    if (!(this.organizationId && this.projectId)) {
+      throw new Error(
+        "organizationId and projectId must be set to access instructions or categories",
+      );
+    }
+
+    const params = new URLSearchParams();
+    fields?.forEach((field) => params.append("fields", field));
+
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/api/v1/orgs/organizations/${this.organizationId}/projects/${this.projectId}/?${params.toString()}`,
+      {
+        headers: this.headers,
+      },
+    );
+    return response;
+  }
+
+  async updateProject(
+    prompts: PromptUpdatePayload,
+  ): Promise<Record<string, any>> {
+    this._validateOrgProject();
+
+    if (!(this.organizationId && this.projectId)) {
+      throw new Error(
+        "organizationId and projectId must be set to update instructions or categories",
+      );
+    }
+
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/api/v1/orgs/organizations/${this.organizationId}/projects/${this.projectId}/`,
+      {
+        method: "PATCH",
+        headers: this.headers,
+        body: JSON.stringify(prompts),
+      },
+    );
+    return response;
+  }
+
+  // WebHooks
+  async getWebhooks(data?: { projectId?: string }): Promise<Array<Webhook>> {
+    const project_id = data?.projectId || this.projectId;
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/api/v1/webhooks/projects/${project_id}/`,
+      {
+        headers: this.headers,
+      },
+    );
+    return response;
+  }
+
+  async createWebhook(webhook: WebhookPayload): Promise<Webhook> {
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/api/v1/webhooks/projects/${this.projectId}/`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(webhook),
+      },
+    );
+    return response;
+  }
+
+  async updateWebhook(webhook: WebhookPayload): Promise<{ message: string }> {
+    const project_id = webhook.projectId || this.projectId;
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/api/v1/webhooks/${webhook.webhookId}/`,
+      {
+        method: "PUT",
+        headers: this.headers,
+        body: JSON.stringify({
+          ...webhook,
+          projectId: project_id,
+        }),
+      },
+    );
+    return response;
+  }
+
+  async deleteWebhook(data: {
+    webhookId: string;
+  }): Promise<{ message: string }> {
+    const webhook_id = data.webhookId || data;
+    const response = await this._fetchWithErrorHandling(
+      `${this.host}/api/v1/webhooks/${webhook_id}/`,
+      {
+        method: "DELETE",
+        headers: this.headers,
+      },
+    );
+    return response;
+  }
+}
+
+export { MemoryClient };

mem0-ts/src/client/mem0.types.ts

@@ -0,0 +1,156 @@
+export interface MemoryOptions {
+  user_id?: string;
+  agent_id?: string;
+  app_id?: string;
+  run_id?: string;
+  metadata?: Record<string, any>;
+  filters?: Record<string, any>;
+  org_name?: string | null; // Deprecated
+  project_name?: string | null; // Deprecated
+  org_id?: string | number | null;
+  project_id?: string | number | null;
+  infer?: boolean;
+  page?: number;
+  page_size?: number;
+  includes?: string;
+  excludes?: string;
+  enable_graph?: boolean;
+  start_date?: string;
+  end_date?: string;
+}
+
+export interface ProjectOptions {
+  fields?: string[];
+}
+
+export enum API_VERSION {
+  V1 = "v1",
+  V2 = "v2",
+}
+
+export interface Messages {
+  role: string;
+  content: string;
+}
+
+export interface Message extends Messages {}
+
+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?: API_VERSION | string;
+  limit?: number;
+  enable_graph?: boolean;
+  threshold?: number;
+  top_k?: number;
+  only_metadata_based_search?: boolean;
+  keyword_search?: boolean;
+  fields?: string[];
+  categories?: string[];
+  rerank?: boolean;
+}
+
+enum Event {
+  ADD = "ADD",
+  UPDATE = "UPDATE",
+  DELETE = "DELETE",
+  NOOP = "NOOP",
+}
+
+export interface MemoryData {
+  memory: string;
+}
+
+export interface Memory {
+  id: 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;
+  owner?: string | null;
+  agent_id?: string | null;
+  app_id?: string | null;
+  run_id?: string | null;
+}
+
+export interface MemoryUpdateBody {
+  memoryId: string;
+  text: string;
+}
+
+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 interface ProjectResponse {
+  custom_instructions?: string;
+  custom_categories?: string[];
+  [key: string]: any;
+}
+
+interface custom_categories {
+  [key: string]: any;
+}
+
+export interface PromptUpdatePayload {
+  custom_instructions?: string;
+  custom_categories?: custom_categories[];
+  [key: string]: any;
+}
+
+enum WebhookEvent {
+  MEMORY_ADDED = "memory_add",
+  MEMORY_UPDATED = "memory_update",
+  MEMORY_DELETED = "memory_delete",
+}
+
+export interface Webhook {
+  webhook_id?: string;
+  name: string;
+  url: string;
+  project?: string;
+  created_at?: Date;
+  updated_at?: Date;
+  is_active?: boolean;
+  event_types?: WebhookEvent[];
+}
+
+export interface WebhookPayload {
+  eventTypes: WebhookEvent[];
+  projectId: string;
+  webhookId: string;
+  name: string;
+  url: string;
+}

mem0-ts/src/client/telemetry.browser.ts

@@ -0,0 +1,85 @@
+// @ts-nocheck
+import type { PostHog } from "posthog-js";
+import type { TelemetryClient } from "./telemetry.types";
+
+let version = "1.0.20";
+
+const MEM0_TELEMETRY = process.env.MEM0_TELEMETRY !== "false";
+const POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX";
+const POSTHOG_HOST = "https://us.i.posthog.com";
+
+// Browser-specific hash function using Web Crypto API
+async function generateHash(input: string): Promise<string> {
+  const msgBuffer = new TextEncoder().encode(input);
+  const hashBuffer = await window.crypto.subtle.digest("SHA-256", msgBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+class BrowserTelemetry implements TelemetryClient {
+  client: PostHog | null = null;
+
+  constructor(projectApiKey: string, host: string) {
+    if (MEM0_TELEMETRY) {
+      this.initializeClient(projectApiKey, host);
+    }
+  }
+
+  private async initializeClient(projectApiKey: string, host: string) {
+    try {
+      const posthog = await import("posthog-js").catch(() => null);
+      if (posthog) {
+        posthog.init(projectApiKey, { api_host: host });
+        this.client = posthog;
+      }
+    } catch (error) {
+      // Silently fail if posthog-js is not available
+      this.client = null;
+    }
+  }
+
+  async captureEvent(distinctId: string, eventName: string, properties = {}) {
+    if (!this.client || !MEM0_TELEMETRY) return;
+
+    const eventProperties = {
+      client_source: "browser",
+      client_version: getVersion(),
+      browser: window.navigator.userAgent,
+      ...properties,
+    };
+
+    try {
+      this.client.capture(eventName, eventProperties);
+    } catch (error) {
+      // Silently fail if telemetry fails
+    }
+  }
+
+  async shutdown() {
+    // No shutdown needed for browser client
+  }
+}
+
+function getVersion() {
+  return version;
+}
+
+const telemetry = new BrowserTelemetry(POSTHOG_API_KEY, POSTHOG_HOST);
+
+async function captureClientEvent(
+  eventName: string,
+  instance: any,
+  additionalData = {},
+) {
+  const eventData = {
+    function: `${instance.constructor.name}`,
+    ...additionalData,
+  };
+  await telemetry.captureEvent(
+    instance.telemetryId,
+    `client.${eventName}`,
+    eventData,
+  );
+}
+
+export { telemetry, captureClientEvent, generateHash };

mem0-ts/src/client/telemetry.node.ts

@@ -0,0 +1,107 @@
+// @ts-nocheck
+import type { TelemetryClient } from "./telemetry.types";
+
+let version = "1.0.20";
+
+const MEM0_TELEMETRY = process.env.MEM0_TELEMETRY !== "false";
+const POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX";
+const POSTHOG_HOST = "https://us.i.posthog.com";
+
+// Node-specific hash function using crypto module
+function generateHash(input: string): string {
+  const crypto = require("crypto");
+  return crypto.createHash("sha256").update(input).digest("hex");
+}
+
+class NodeTelemetry implements TelemetryClient {
+  client: any = null;
+
+  constructor(projectApiKey: string, host: string) {
+    if (MEM0_TELEMETRY) {
+      this.initializeClient(projectApiKey, host);
+    }
+  }
+
+  private async initializeClient(projectApiKey: string, host: string) {
+    try {
+      const { PostHog } = await import("posthog-node").catch(() => ({
+        PostHog: null,
+      }));
+      if (PostHog) {
+        this.client = new PostHog(projectApiKey, { host, flushAt: 1 });
+      }
+    } catch (error) {
+      // Silently fail if posthog-node is not available
+      this.client = null;
+    }
+  }
+
+  async captureEvent(distinctId: string, eventName: string, properties = {}) {
+    if (!this.client || !MEM0_TELEMETRY) return;
+
+    const eventProperties = {
+      client_source: "nodejs",
+      client_version: getVersion(),
+      ...this.getEnvironmentInfo(),
+      ...properties,
+    };
+
+    try {
+      this.client.capture({
+        distinctId,
+        event: eventName,
+        properties: eventProperties,
+      });
+    } catch (error) {
+      // Silently fail if telemetry fails
+    }
+  }
+
+  private getEnvironmentInfo() {
+    try {
+      const os = require("os");
+      return {
+        node_version: process.version,
+        os: process.platform,
+        os_version: os.release(),
+        os_arch: os.arch(),
+      };
+    } catch (error) {
+      return {};
+    }
+  }
+
+  async shutdown() {
+    if (this.client) {
+      try {
+        return this.client.shutdown();
+      } catch (error) {
+        // Silently fail shutdown
+      }
+    }
+  }
+}
+
+function getVersion() {
+  return version;
+}
+
+const telemetry = new NodeTelemetry(POSTHOG_API_KEY, POSTHOG_HOST);
+
+async function captureClientEvent(
+  eventName: string,
+  instance: any,
+  additionalData = {},
+) {
+  const eventData = {
+    function: `${instance.constructor.name}`,
+    ...additionalData,
+  };
+  await telemetry.captureEvent(
+    instance.telemetryId,
+    `client.${eventName}`,
+    eventData,
+  );
+}
+
+export { telemetry, captureClientEvent, generateHash };

mem0-ts/src/client/telemetry.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+// Re-export browser telemetry by default
+export * from "./telemetry.browser";

mem0-ts/src/client/telemetry.types.ts

@@ -0,0 +1,15 @@
+export interface TelemetryClient {
+  captureEvent(
+    distinctId: string,
+    eventName: string,
+    properties?: Record<string, any>,
+  ): Promise<void>;
+  shutdown(): Promise<void>;
+}
+
+export interface TelemetryInstance {
+  telemetryId: string;
+  constructor: {
+    name: string;
+  };
+}

mem0-ts/src/client/tests/memoryClient.test.ts

@@ -0,0 +1,391 @@
+import { MemoryClient } from "../mem0";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const apiKey = process.env.MEM0_API_KEY || "";
+// const client = new MemoryClient({ apiKey, host: 'https://api.mem0.ai', organizationId: "org_gRNd1RrQa4y52iK4tG8o59hXyVbaULikgq4kethC", projectId: "proj_7RfMkWs0PMgXYweGUNKqV9M9mgIRNt5XcupE7mSP" });
+// const client = new MemoryClient({ apiKey, host: 'https://api.mem0.ai', organizationName: "saket-default-org", projectName: "default-project" });
+const client = new MemoryClient({ apiKey, host: "https://api.mem0.ai" });
+
+// Generate a random string
+const randomString = () => {
+  return (
+    Math.random().toString(36).substring(2, 15) +
+    Math.random().toString(36).substring(2, 15)
+  );
+};
+
+describe("MemoryClient API", () => {
+  let userId: string, memoryId: string;
+
+  beforeAll(() => {
+    userId = randomString();
+  });
+
+  const messages1 = [
+    { role: "user", content: "Hey, I am Alex. I'm now a vegetarian." },
+    { role: "assistant", content: "Hello Alex! Glad to hear!" },
+  ];
+
+  it("should add messages successfully", async () => {
+    const res = await client.add(messages1, { user_id: userId || "" });
+
+    // Validate the response contains an iterable list
+    expect(Array.isArray(res)).toBe(true);
+
+    // Validate the fields of the first message in the response
+    const message = res[0];
+    expect(typeof message.id).toBe("string");
+    expect(typeof message.data?.memory).toBe("string");
+    expect(typeof message.event).toBe("string");
+
+    // Store the memory ID for later use
+    memoryId = message.id;
+  });
+
+  it("should retrieve the specific memory by ID", async () => {
+    const memory = await client.get(memoryId);
+
+    // Validate that the memory fields have the correct types and values
+
+    // Should be a string (memory id)
+    expect(typeof memory.id).toBe("string");
+
+    // Should be a string (the actual memory content)
+    expect(typeof memory.memory).toBe("string");
+
+    // Should be a string and equal to the userId
+    expect(typeof memory.user_id).toBe("string");
+    expect(memory.user_id).toBe(userId);
+
+    // Should be null or any object (metadata)
+    expect(
+      memory.metadata === null || typeof memory.metadata === "object",
+    ).toBe(true);
+
+    // Should be an array of strings or null (categories)
+    expect(Array.isArray(memory.categories) || memory.categories === null).toBe(
+      true,
+    );
+    if (Array.isArray(memory.categories)) {
+      memory.categories.forEach((category) => {
+        expect(typeof category).toBe("string");
+      });
+    }
+
+    // Should be a valid date (created_at)
+    expect(new Date(memory.created_at || "").toString()).not.toBe(
+      "Invalid Date",
+    );
+
+    // Should be a valid date (updated_at)
+    expect(new Date(memory.updated_at || "").toString()).not.toBe(
+      "Invalid Date",
+    );
+  });
+
+  it("should retrieve all users successfully", async () => {
+    const allUsers = await client.users();
+
+    // Validate the number of users is a number
+    expect(typeof allUsers.count).toBe("number");
+
+    // Validate the structure of the first user
+    const firstUser = allUsers.results[0];
+    expect(typeof firstUser.id).toBe("string");
+    expect(typeof firstUser.name).toBe("string");
+    expect(typeof firstUser.created_at).toBe("string");
+    expect(typeof firstUser.updated_at).toBe("string");
+    expect(typeof firstUser.total_memories).toBe("number");
+    expect(typeof firstUser.type).toBe("string");
+
+    // Find the user with the name matching userId
+    const entity = allUsers.results.find((user) => user.name === userId);
+    expect(entity).not.toBeUndefined();
+
+    // Store the entity ID for later use
+    const entity_id = entity?.id;
+    expect(typeof entity_id).toBe("string");
+  });
+
+  it("should retrieve all memories for the user", async () => {
+    const res3 = await client.getAll({ user_id: userId });
+
+    // Validate that res3 is an iterable list (array)
+    expect(Array.isArray(res3)).toBe(true);
+
+    if (res3.length > 0) {
+      // Iterate through the first memory for validation (you can loop through all if needed)
+      const memory = res3[0];
+
+      // Should be a string (memory id)
+      expect(typeof memory.id).toBe("string");
+
+      // Should be a string (the actual memory content)
+      expect(typeof memory.memory).toBe("string");
+
+      // Should be a string and equal to the userId
+      expect(typeof memory.user_id).toBe("string");
+      expect(memory.user_id).toBe(userId);
+
+      // Should be null or an object (metadata)
+      expect(
+        memory.metadata === null || typeof memory.metadata === "object",
+      ).toBe(true);
+
+      // Should be an array of strings or null (categories)
+      expect(
+        Array.isArray(memory.categories) || memory.categories === null,
+      ).toBe(true);
+      if (Array.isArray(memory.categories)) {
+        memory.categories.forEach((category) => {
+          expect(typeof category).toBe("string");
+        });
+      }
+
+      // Should be a valid date (created_at)
+      expect(new Date(memory.created_at || "").toString()).not.toBe(
+        "Invalid Date",
+      );
+
+      // Should be a valid date (updated_at)
+      expect(new Date(memory.updated_at || "").toString()).not.toBe(
+        "Invalid Date",
+      );
+    } else {
+      // If there are no memories, assert that the list is empty
+      expect(res3.length).toBe(0);
+    }
+  });
+
+  it("should search and return results based on provided query and filters (API version 2)", async () => {
+    const searchOptionsV2 = {
+      query: "What do you know about me?",
+      filters: {
+        OR: [{ user_id: userId }, { agent_id: "shopping-assistant" }],
+      },
+      threshold: 0.1,
+      api_version: "v2",
+    };
+
+    const searchResultV2 = await client.search(
+      "What do you know about me?",
+      searchOptionsV2,
+    );
+
+    // Validate that searchResultV2 is an iterable list (array)
+    expect(Array.isArray(searchResultV2)).toBe(true);
+
+    if (searchResultV2.length > 0) {
+      // Iterate through the first search result for validation (you can loop through all if needed)
+      const memory = searchResultV2[0];
+
+      // Should be a string (memory id)
+      expect(typeof memory.id).toBe("string");
+
+      // Should be a string (the actual memory content)
+      expect(typeof memory.memory).toBe("string");
+
+      if (memory.user_id) {
+        // Should be a string and equal to userId
+        expect(typeof memory.user_id).toBe("string");
+        expect(memory.user_id).toBe(userId);
+      }
+
+      if (memory.agent_id) {
+        // Should be a string (agent_id)
+        expect(typeof memory.agent_id).toBe("string");
+        expect(memory.agent_id).toBe("shopping-assistant");
+      }
+
+      // Should be null or an object (metadata)
+      expect(
+        memory.metadata === null || typeof memory.metadata === "object",
+      ).toBe(true);
+
+      // Should be an array of strings or null (categories)
+      expect(
+        Array.isArray(memory.categories) || memory.categories === null,
+      ).toBe(true);
+      if (Array.isArray(memory.categories)) {
+        memory.categories.forEach((category) => {
+          expect(typeof category).toBe("string");
+        });
+      }
+
+      // Should be a valid date (created_at)
+      expect(new Date(memory.created_at || "").toString()).not.toBe(
+        "Invalid Date",
+      );
+
+      // Should be a valid date (updated_at)
+      expect(new Date(memory.updated_at || "").toString()).not.toBe(
+        "Invalid Date",
+      );
+
+      // Should be a number (score)
+      expect(typeof memory.score).toBe("number");
+    } else {
+      // If no search results, assert that the list is empty
+      expect(searchResultV2.length).toBe(0);
+    }
+  });
+
+  it("should search and return results based on provided query (API version 1)", async () => {
+    const searchResultV1 = await client.search("What is my name?", {
+      user_id: userId,
+    });
+
+    // Validate that searchResultV1 is an iterable list (array)
+    expect(Array.isArray(searchResultV1)).toBe(true);
+
+    if (searchResultV1.length > 0) {
+      // Iterate through the first search result for validation (you can loop through all if needed)
+      const memory = searchResultV1[0];
+
+      // Should be a string (memory id)
+      expect(typeof memory.id).toBe("string");
+
+      // Should be a string (the actual memory content)
+      expect(typeof memory.memory).toBe("string");
+
+      // Should be a string and equal to userId
+      expect(typeof memory.user_id).toBe("string");
+      expect(memory.user_id).toBe(userId);
+
+      // Should be null or an object (metadata)
+      expect(
+        memory.metadata === null || typeof memory.metadata === "object",
+      ).toBe(true);
+
+      // Should be an array of strings or null (categories)
+      expect(
+        Array.isArray(memory.categories) || memory.categories === null,
+      ).toBe(true);
+      if (Array.isArray(memory.categories)) {
+        memory.categories.forEach((category) => {
+          expect(typeof category).toBe("string");
+        });
+      }
+
+      // Should be a valid date (created_at)
+      expect(new Date(memory.created_at || "").toString()).not.toBe(
+        "Invalid Date",
+      );
+
+      // Should be a valid date (updated_at)
+      expect(new Date(memory.updated_at || "").toString()).not.toBe(
+        "Invalid Date",
+      );
+
+      // Should be a number (score)
+      expect(typeof memory.score).toBe("number");
+    } else {
+      // If no search results, assert that the list is empty
+      expect(searchResultV1.length).toBe(0);
+    }
+  });
+
+  it("should retrieve history of a specific memory and validate the fields", async () => {
+    const res22 = await client.history(memoryId);
+
+    // Validate that res22 is an iterable list (array)
+    expect(Array.isArray(res22)).toBe(true);
+
+    if (res22.length > 0) {
+      // Iterate through the first history entry for validation (you can loop through all if needed)
+      const historyEntry = res22[0];
+
+      // Should be a string (history entry id)
+      expect(typeof historyEntry.id).toBe("string");
+
+      // Should be a string (memory id related to the history entry)
+      expect(typeof historyEntry.memory_id).toBe("string");
+
+      // Should be a string and equal to userId
+      expect(typeof historyEntry.user_id).toBe("string");
+      expect(historyEntry.user_id).toBe(userId);
+
+      // Should be a string or null (old memory)
+      expect(
+        historyEntry.old_memory === null ||
+          typeof historyEntry.old_memory === "string",
+      ).toBe(true);
+
+      // Should be a string or null (new memory)
+      expect(
+        historyEntry.new_memory === null ||
+          typeof historyEntry.new_memory === "string",
+      ).toBe(true);
+
+      // Should be an array of strings or null (categories)
+      expect(
+        Array.isArray(historyEntry.categories) ||
+          historyEntry.categories === null,
+      ).toBe(true);
+      if (Array.isArray(historyEntry.categories)) {
+        historyEntry.categories.forEach((category) => {
+          expect(typeof category).toBe("string");
+        });
+      }
+
+      // Should be a valid date (created_at)
+      expect(new Date(historyEntry.created_at).toString()).not.toBe(
+        "Invalid Date",
+      );
+
+      // Should be a valid date (updated_at)
+      expect(new Date(historyEntry.updated_at).toString()).not.toBe(
+        "Invalid Date",
+      );
+
+      // Should be a string, one of: ADD, UPDATE, DELETE, NOOP
+      expect(["ADD", "UPDATE", "DELETE", "NOOP"]).toContain(historyEntry.event);
+
+      // Validate conditions based on event type
+      if (historyEntry.event === "ADD") {
+        expect(historyEntry.old_memory).toBeNull();
+        expect(historyEntry.new_memory).not.toBeNull();
+      } else if (historyEntry.event === "UPDATE") {
+        expect(historyEntry.old_memory).not.toBeNull();
+        expect(historyEntry.new_memory).not.toBeNull();
+      } else if (historyEntry.event === "DELETE") {
+        expect(historyEntry.old_memory).not.toBeNull();
+        expect(historyEntry.new_memory).toBeNull();
+      }
+
+      // Should be a list of objects or null (input)
+      expect(
+        Array.isArray(historyEntry.input) || historyEntry.input === null,
+      ).toBe(true);
+      if (Array.isArray(historyEntry.input)) {
+        historyEntry.input.forEach((input) => {
+          // Each input should be an object
+          expect(typeof input).toBe("object");
+
+          // Should have string content
+          expect(typeof input.content).toBe("string");
+
+          // Should have a role that is either 'user' or 'assistant'
+          expect(["user", "assistant"]).toContain(input.role);
+        });
+      }
+    } else {
+      // If no history entries, assert that the list is empty
+      expect(res22.length).toBe(0);
+    }
+  });
+
+  it("should delete the user successfully", async () => {
+    const allUsers = await client.users();
+    const entity = allUsers.results.find((user) => user.name === userId);
+
+    if (entity) {
+      const deletedUser = await client.deleteUser(entity.id);
+
+      // Validate the deletion message
+      expect(deletedUser.message).toBe("Entity deleted successfully!");
+    }
+  });
+});