memories-lite 0.9.0

package/src/utils/bm25.ts

@@ -0,0 +1,64 @@
+export class BM25 {
+  private documents: string[][];
+  private k1: number;
+  private b: number;
+  private avgDocLength: number;
+  private docFreq: Map<string, number>;
+  private docLengths: number[];
+  private idf: Map<string, number>;
+
+  constructor(documents: string[][], k1 = 1.5, b = 0.75) {
+    this.documents = documents;
+    this.k1 = k1;
+    this.b = b;
+    this.docLengths = documents.map((doc) => doc.length);
+    this.avgDocLength =
+      this.docLengths.reduce((a, b) => a + b, 0) / documents.length;
+    this.docFreq = new Map();
+    this.idf = new Map();
+    this.computeIdf();
+  }
+
+  private computeIdf() {
+    const N = this.documents.length;
+
+    // Count document frequency for each term
+    for (const doc of this.documents) {
+      const terms = new Set(doc);
+      for (const term of terms) {
+        this.docFreq.set(term, (this.docFreq.get(term) || 0) + 1);
+      }
+    }
+
+    // Compute IDF for each term
+    for (const [term, freq] of this.docFreq) {
+      this.idf.set(term, Math.log((N - freq + 0.5) / (freq + 0.5) + 1));
+    }
+  }
+
+  private score(query: string[], doc: string[], index: number): number {
+    let score = 0;
+    const docLength = this.docLengths[index];
+
+    for (const term of query) {
+      const tf = doc.filter((t) => t === term).length;
+      const idf = this.idf.get(term) || 0;
+
+      score +=
+        (idf * tf * (this.k1 + 1)) /
+        (tf +
+          this.k1 * (1 - this.b + (this.b * docLength) / this.avgDocLength));
+    }
+
+    return score;
+  }
+
+  search(query: string[]): string[][] {
+    const scores = this.documents.map((doc, idx) => ({
+      doc,
+      score: this.score(query, doc, idx),
+    }));
+
+    return scores.sort((a, b) => b.score - a.score).map((item) => item.doc);
+  }
+}

package/src/utils/factory.ts

@@ -0,0 +1,59 @@
+import { OpenAIEmbedder } from "../embeddings/openai";
+import { OpenAILLM } from "../llms/openai";
+import { OpenAIStructuredLLM } from "../llms/openai_structured";
+import {
+  EmbeddingConfig,
+  HistoryStoreConfig,
+  LLMConfig,
+  VectorStoreConfig,
+} from "../types";
+import { Embedder } from "../embeddings/base";
+import { LLM } from "../llms/base";
+import { VectorStore } from "../vectorstores/base";
+import { MemoryHistoryManager } from "../storage/MemoryHistoryManager";
+import { HistoryManager } from "../storage/base";
+import { GoogleEmbedder } from "../embeddings/google";
+import { GoogleLLM } from "../llms/google";
+import { LLMVectorStore } from '../vectorstores/llm';
+import { LiteVectorStore } from "../vectorstores/lite";
+
+export class EmbedderFactory {
+  static create(provider: string, config: EmbeddingConfig): Embedder {
+    switch (provider.toLowerCase()) {
+      case "openai":
+        return new OpenAIEmbedder(config);
+      case "google":
+        return new GoogleEmbedder(config);
+      default:
+        throw new Error(`Unsupported embedder provider: ${provider}`);
+    }
+  }
+}
+
+export class LLMFactory {
+  static create(provider: string, config: LLMConfig): LLM {
+    switch (provider.toLowerCase()) {
+      case "openai":
+        return new OpenAILLM(config);
+      case "openai_structured":
+        return new OpenAIStructuredLLM(config);
+      case "google":
+        return new GoogleLLM(config);
+      default:
+        throw new Error(`Unsupported LLM provider: ${provider}`);
+    }
+  }
+}
+
+
+export class HistoryManagerFactory {
+  static create(provider: string, config: HistoryStoreConfig): HistoryManager {
+    switch (provider.toLowerCase()) {
+      case "sqlite":
+      case "memory":
+        return new MemoryHistoryManager();
+      default:
+        throw new Error(`Unsupported history store provider: ${provider}`);
+    }
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,13 @@
+export interface Logger {
+  info: (message: string) => void;
+  error: (message: string) => void;
+  debug: (message: string) => void;
+  warn: (message: string) => void;
+}
+
+export const logger: Logger = {
+  info: (message: string) => console.log(`[INFO] ${message}`),
+  error: (message: string) => console.error(`[ERROR] ${message}`),
+  debug: (message: string) => console.debug(`[DEBUG] ${message}`),
+  warn: (message: string) => console.warn(`[WARN] ${message}`),
+};

package/src/utils/memory.ts

@@ -0,0 +1,48 @@
+import { OpenAILLM } from "../llms/openai";
+import { Message } from "../types";
+
+const get_image_description = async (image_url: string) => {
+  const llm = new OpenAILLM({
+    apiKey: process.env.OPENAI_API_KEY,
+  });
+  const response = await llm.generateResponse([
+    {
+      role: "user",
+      content:
+        "Provide a description of the image and do not include any additional text.",
+    },
+    {
+      role: "user",
+      content: { type: "image_url", image_url: { url: image_url } },
+    },
+  ]);
+  return response;
+};
+
+const parse_vision_messages = async (messages: Message[]) => {
+  const parsed_messages = [];
+  for (const message of messages) {
+    let new_message = {
+      role: message.role,
+      content: "",
+    };
+    if (message.role !== "system") {
+      if (
+        typeof message.content === "object" &&
+        message.content.type === "image_url"
+      ) {
+        const description = await get_image_description(
+          message.content.image_url.url,
+        );
+        new_message.content =
+          typeof description === "string"
+            ? description
+            : JSON.stringify(description);
+        parsed_messages.push(new_message);
+      } else parsed_messages.push(message);
+    }
+  }
+  return parsed_messages;
+};
+
+export { parse_vision_messages };

package/src/utils/telemetry.ts

@@ -0,0 +1,98 @@
+import type {
+  TelemetryClient,
+  TelemetryInstance,
+  TelemetryEventData,
+} from "./telemetry.types";
+
+let version = "2.1.16";
+
+// Safely check for process.env in different environments
+let MEM0_TELEMETRY = true;
+try {
+  MEM0_TELEMETRY = process?.env?.MEM0_TELEMETRY === "false" ? false : true;
+} catch (error) {}
+const POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX";
+const POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/";
+
+class UnifiedTelemetry implements TelemetryClient {
+  private apiKey: string;
+  private host: string;
+
+  constructor(projectApiKey: string, host: string) {
+    this.apiKey = projectApiKey;
+    this.host = host;
+  }
+
+  async captureEvent(distinctId: string, eventName: string, properties = {}) {
+    if (!MEM0_TELEMETRY) return;
+
+    const eventProperties = {
+      client_version: version,
+      timestamp: new Date().toISOString(),
+      ...properties,
+      $process_person_profile:
+        distinctId === "anonymous" || distinctId === "anonymous-supabase"
+          ? false
+          : true,
+      $lib: "posthog-node",
+    };
+
+    const payload = {
+      api_key: this.apiKey,
+      distinct_id: distinctId,
+      event: eventName,
+      properties: eventProperties,
+    };
+
+    try {
+      const response = await fetch(this.host, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        console.error("Telemetry event capture failed:", await response.text());
+      }
+    } catch (error) {
+      console.error("Telemetry event capture failed:", error);
+    }
+  }
+
+  async shutdown() {
+    // No shutdown needed for direct API calls
+  }
+}
+
+const telemetry = new UnifiedTelemetry(POSTHOG_API_KEY, POSTHOG_HOST);
+
+async function captureClientEvent(
+  eventName: string,
+  instance: TelemetryInstance,
+  additionalData: Record<string, any> = {},
+) {
+  if (!instance.telemetryId) {
+    console.warn("No telemetry ID found for instance");
+    return;
+  }
+
+  const eventData: TelemetryEventData = {
+    function: `${instance.constructor.name}`,
+    method: eventName,
+    api_host: instance.host,
+    timestamp: new Date().toISOString(),
+    client_version: version,
+    client_source: "nodejs",
+    ...additionalData,
+  };
+
+  await telemetry.captureEvent(
+    instance.telemetryId,
+    `mem0.${eventName}`,
+    eventData,
+  );
+}
+
+export { telemetry, captureClientEvent };

package/src/utils/telemetry.types.ts

@@ -0,0 +1,34 @@
+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;
+  };
+  host?: string;
+  apiKey?: string;
+}
+
+export interface TelemetryEventData {
+  function: string;
+  method: string;
+  api_host?: string;
+  timestamp?: string;
+  client_source: "browser" | "nodejs";
+  client_version: string;
+  [key: string]: any;
+}
+
+export interface TelemetryOptions {
+  enabled?: boolean;
+  apiKey?: string;
+  host?: string;
+  version?: string;
+}

package/src/vectorstores/base.ts

@@ -0,0 +1,27 @@
+import { SearchFilters, VectorStoreResult } from "../types";
+
+export interface VectorStore {
+  insert(
+    vectors: number[][],
+    ids: string[],
+    payloads: Record<string, any>[],
+  ): Promise<void>;
+  search(
+    query: number[],
+    limit?: number,
+    filters?: SearchFilters,
+  ): Promise<VectorStoreResult[]>;
+  get(vectorId: string): Promise<VectorStoreResult | null>;
+  update(
+    vectorId: string,
+    vector: number[],
+    payload: Record<string, any>,
+  ): Promise<void>;
+  delete(vectorId: string): Promise<void>;
+  deleteCol(): Promise<void>;
+  list(
+    filters?: SearchFilters,
+    limit?: number,
+  ): Promise<[VectorStoreResult[], number]>;
+  getInstanceId(): string;
+}