memories-lite 0.9.0

package/dist/types/index.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryConfigSchema = void 0;
+const zod_1 = require("zod");
+exports.MemoryConfigSchema = zod_1.z.object({
+    version: zod_1.z.string().optional(),
+    embedder: zod_1.z.object({
+        provider: zod_1.z.string(),
+        config: zod_1.z.object({
+            dimension: zod_1.z.number().optional(),
+            modelProperties: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+            apiKey: zod_1.z.string().optional(),
+            model: zod_1.z.union([zod_1.z.string(), zod_1.z.any()]).optional(),
+        }),
+    }),
+    vectorStore: zod_1.z.object({
+        provider: zod_1.z.string(),
+        config: zod_1.z
+            .object({
+            collectionName: zod_1.z.string().optional(),
+            dimension: zod_1.z.number().optional(),
+            client: zod_1.z.any().optional(),
+            scoring: zod_1.z.object({
+                procedural: zod_1.z.object({
+                    alpha: zod_1.z.number(),
+                    beta: zod_1.z.number(),
+                    gamma: zod_1.z.number(),
+                    halfLifeDays: zod_1.z.number(),
+                }),
+                episodic: zod_1.z.object({
+                    alpha: zod_1.z.number(),
+                    beta: zod_1.z.number(),
+                    gamma: zod_1.z.number(),
+                    halfLifeDays: zod_1.z.number(),
+                }),
+                factual: zod_1.z.object({
+                    alpha: zod_1.z.number(),
+                    beta: zod_1.z.number(),
+                    gamma: zod_1.z.number(),
+                    halfLifeDays: zod_1.z.number(),
+                }),
+                semantic: zod_1.z.object({
+                    alpha: zod_1.z.number(),
+                    beta: zod_1.z.number(),
+                    gamma: zod_1.z.number(),
+                    halfLifeDays: zod_1.z.number(),
+                }),
+                assistant_preference: zod_1.z.object({
+                    alpha: zod_1.z.number(),
+                    beta: zod_1.z.number(),
+                    gamma: zod_1.z.number(),
+                    halfLifeDays: zod_1.z.number(),
+                }),
+                default: zod_1.z.object({
+                    alpha: zod_1.z.number(),
+                    beta: zod_1.z.number(),
+                    gamma: zod_1.z.number(),
+                    halfLifeDays: zod_1.z.number(),
+                }),
+            }).optional(),
+            recencyCleanupThreshold: zod_1.z.number().min(0).max(1).optional(),
+        })
+            .passthrough(),
+    }),
+    llm: zod_1.z.object({
+        provider: zod_1.z.string(),
+        config: zod_1.z.object({
+            apiKey: zod_1.z.string().optional(),
+            model: zod_1.z.union([zod_1.z.string(), zod_1.z.any()]).optional(),
+            modelProperties: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+        }),
+    }),
+    historyDbPath: zod_1.z.string().optional(),
+    customPrompt: zod_1.z.string().optional(),
+    enableGraph: zod_1.z.boolean().optional(),
+    graphStore: zod_1.z
+        .object({
+        provider: zod_1.z.string(),
+        config: zod_1.z.object({
+            url: zod_1.z.string(),
+            username: zod_1.z.string(),
+            password: zod_1.z.string(),
+        }),
+        llm: zod_1.z
+            .object({
+            provider: zod_1.z.string(),
+            config: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+        })
+            .optional(),
+        customPrompt: zod_1.z.string().optional(),
+    })
+        .optional(),
+    historyStore: zod_1.z
+        .object({
+        provider: zod_1.z.string(),
+        config: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+    })
+        .optional(),
+    disableHistory: zod_1.z.boolean().optional(),
+});

package/dist/utils/bm25.d.ts

@@ -0,0 +1,13 @@
+export declare class BM25 {
+    private documents;
+    private k1;
+    private b;
+    private avgDocLength;
+    private docFreq;
+    private docLengths;
+    private idf;
+    constructor(documents: string[][], k1?: number, b?: number);
+    private computeIdf;
+    private score;
+    search(query: string[]): string[][];
+}

package/dist/utils/bm25.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BM25 = void 0;
+class BM25 {
+    constructor(documents, 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();
+    }
+    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));
+        }
+    }
+    score(query, doc, index) {
+        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) {
+        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);
+    }
+}
+exports.BM25 = BM25;

package/dist/utils/factory.d.ts

@@ -0,0 +1,13 @@
+import { EmbeddingConfig, HistoryStoreConfig, LLMConfig } from "../types";
+import { Embedder } from "../embeddings/base";
+import { LLM } from "../llms/base";
+import { HistoryManager } from "../storage/base";
+export declare class EmbedderFactory {
+    static create(provider: string, config: EmbeddingConfig): Embedder;
+}
+export declare class LLMFactory {
+    static create(provider: string, config: LLMConfig): LLM;
+}
+export declare class HistoryManagerFactory {
+    static create(provider: string, config: HistoryStoreConfig): HistoryManager;
+}

package/dist/utils/factory.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryManagerFactory = exports.LLMFactory = exports.EmbedderFactory = void 0;
+const openai_1 = require("../embeddings/openai");
+const openai_2 = require("../llms/openai");
+const openai_structured_1 = require("../llms/openai_structured");
+const MemoryHistoryManager_1 = require("../storage/MemoryHistoryManager");
+const google_1 = require("../embeddings/google");
+const google_2 = require("../llms/google");
+class EmbedderFactory {
+    static create(provider, config) {
+        switch (provider.toLowerCase()) {
+            case "openai":
+                return new openai_1.OpenAIEmbedder(config);
+            case "google":
+                return new google_1.GoogleEmbedder(config);
+            default:
+                throw new Error(`Unsupported embedder provider: ${provider}`);
+        }
+    }
+}
+exports.EmbedderFactory = EmbedderFactory;
+class LLMFactory {
+    static create(provider, config) {
+        switch (provider.toLowerCase()) {
+            case "openai":
+                return new openai_2.OpenAILLM(config);
+            case "openai_structured":
+                return new openai_structured_1.OpenAIStructuredLLM(config);
+            case "google":
+                return new google_2.GoogleLLM(config);
+            default:
+                throw new Error(`Unsupported LLM provider: ${provider}`);
+        }
+    }
+}
+exports.LLMFactory = LLMFactory;
+class HistoryManagerFactory {
+    static create(provider, config) {
+        switch (provider.toLowerCase()) {
+            case "sqlite":
+            case "memory":
+                return new MemoryHistoryManager_1.MemoryHistoryManager();
+            default:
+                throw new Error(`Unsupported history store provider: ${provider}`);
+        }
+    }
+}
+exports.HistoryManagerFactory = HistoryManagerFactory;

package/dist/utils/logger.d.ts

@@ -0,0 +1,7 @@
+export interface Logger {
+    info: (message: string) => void;
+    error: (message: string) => void;
+    debug: (message: string) => void;
+    warn: (message: string) => void;
+}
+export declare const logger: Logger;

package/dist/utils/logger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.logger = {
+    info: (message) => console.log(`[INFO] ${message}`),
+    error: (message) => console.error(`[ERROR] ${message}`),
+    debug: (message) => console.debug(`[DEBUG] ${message}`),
+    warn: (message) => console.warn(`[WARN] ${message}`),
+};

package/dist/utils/memory.d.ts

@@ -0,0 +1,3 @@
+import { Message } from "../types";
+declare const parse_vision_messages: (messages: Message[]) => Promise<Message[]>;
+export { parse_vision_messages };

package/dist/utils/memory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse_vision_messages = void 0;
+const openai_1 = require("../llms/openai");
+const get_image_description = async (image_url) => {
+    const llm = new openai_1.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) => {
+    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;
+};
+exports.parse_vision_messages = parse_vision_messages;

package/dist/utils/telemetry.d.ts

@@ -0,0 +1,11 @@
+import type { TelemetryClient, TelemetryInstance } from "./telemetry.types";
+declare class UnifiedTelemetry implements TelemetryClient {
+    private apiKey;
+    private host;
+    constructor(projectApiKey: string, host: string);
+    captureEvent(distinctId: string, eventName: string, properties?: {}): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare const telemetry: UnifiedTelemetry;
+declare function captureClientEvent(eventName: string, instance: TelemetryInstance, additionalData?: Record<string, any>): Promise<void>;
+export { telemetry, captureClientEvent };

package/dist/utils/telemetry.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetry = void 0;
+exports.captureClientEvent = captureClientEvent;
+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 {
+    constructor(projectApiKey, host) {
+        this.apiKey = projectApiKey;
+        this.host = host;
+    }
+    async captureEvent(distinctId, eventName, 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);
+exports.telemetry = telemetry;
+async function captureClientEvent(eventName, instance, additionalData = {}) {
+    if (!instance.telemetryId) {
+        console.warn("No telemetry ID found for instance");
+        return;
+    }
+    const eventData = {
+        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);
+}

package/dist/utils/telemetry.types.d.ts

@@ -0,0 +1,27 @@
+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/dist/utils/telemetry.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vectorstores/base.d.ts

@@ -0,0 +1,11 @@
+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;
+}

package/dist/vectorstores/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vectorstores/lite.d.ts

@@ -0,0 +1,40 @@
+import { VectorStore } from "./base";
+import { SearchFilters, VectorStoreConfig, VectorStoreResult } from "../types";
+/**
+ * LiteVectorStore provides a simple vector storage implementation.
+ *
+ * This class manages user-sensitive vector data, with each instance tied to a specific user.
+ * Data is stored in a local SQLite database with appropriate isolation between users.
+ * The user's identity is hashed for privacy and security purposes.
+ * ⚠️ User memories are typically small (usually <1000 vectors), therefore database optimization is not a priority.
+ *
+ * @implements {VectorStore}
+ */
+export declare class LiteVectorStore implements VectorStore {
+    private db;
+    private isSecure;
+    private dimension;
+    private currentUserId;
+    private scoringConfig;
+    private cleanupThreshold?;
+    private static cache;
+    constructor(config: VectorStoreConfig, currentUserId: string);
+    private init;
+    private run;
+    private all;
+    private getOne;
+    private cosineSimilarity;
+    private filterVector;
+    getInstanceId(): string;
+    static from(userId: string, config: VectorStoreConfig): Promise<LiteVectorStore>;
+    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]>;
+    private calculateRecencyScore;
+    private calculateHybridScore;
+    private _cleanupByRecency;
+}