diff --git a/apps/memos-local-openclaw/src/embedding/local.ts b/apps/memos-local-openclaw/src/embedding/local.ts index a87242ea8..7a913c54b 100644 --- a/apps/memos-local-openclaw/src/embedding/local.ts +++ b/apps/memos-local-openclaw/src/embedding/local.ts @@ -2,6 +2,10 @@ import type { Logger } from "../types"; import { DEFAULTS } from "../types"; let extractorPromise: Promise | null = null; +let callCount = 0; + +// Read from env or use default +const RESET_AFTER_CALLS = parseInt(process.env.MEMOS_EMBED_RESET_AFTER_CALLS || "50", 10); function getExtractor(log: Logger): Promise { if (extractorPromise) return extractorPromise; @@ -23,13 +27,55 @@ function getExtractor(log: Logger): Promise { return extractorPromise; } +async function resetExtractor(log: Logger): Promise { + if (!extractorPromise) return; + + try { + const ext = await extractorPromise; + // Attempt to dispose the pipeline to free ONNX session resources + if (typeof ext?.dispose === "function") { + await ext.dispose(); + } + } catch (err) { + log.warn(`Failed to dispose extractor: ${err}`); + } + + extractorPromise = null; + callCount = 0; + log.debug("Local embedding pipeline reset to free native memory"); +} + export async function embedLocal(texts: string[], log: Logger): Promise { const ext = await getExtractor(log); const results: number[][] = []; for (const text of texts) { const output = await ext(text, { pooling: "mean", normalize: true }); + + // Extract the embedding vector results.push(Array.from(output.data as Float32Array).slice(0, DEFAULTS.localEmbeddingDimensions)); + + // Explicitly release the output tensor to prevent ONNX memory leak + try { + // Null out the data reference + (output as any).data = null; + } catch {} + + try { + // Call dispose if available + if (typeof (output as any).dispose === "function") { + (output as any).dispose(); + } + } catch {} + + callCount++; + } + + // Periodically reset the pipeline to prevent long-term memory accumulation + // Set MEMOS_EMBED_RESET_AFTER_CALLS=0 to disable periodic reset + if (RESET_AFTER_CALLS > 0 && callCount >= RESET_AFTER_CALLS) { + log.debug(`Reached ${callCount} embedding calls, resetting pipeline to free native memory`); + await resetExtractor(log); } return results; diff --git a/apps/memos-local-openclaw/tests/embedding-memory-leak.test.ts b/apps/memos-local-openclaw/tests/embedding-memory-leak.test.ts new file mode 100644 index 000000000..58dafa8c1 --- /dev/null +++ b/apps/memos-local-openclaw/tests/embedding-memory-leak.test.ts @@ -0,0 +1,128 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import type { Logger } from "../src/types"; + +const mockTransformers = vi.hoisted(() => { + const disposeOutput = vi.fn(); + const disposeExtractor = vi.fn(); + const extractor = vi.fn(async () => ({ + data: new Float32Array(384).fill(0.5), + dispose: disposeOutput, + })); + Object.assign(extractor, { dispose: disposeExtractor }); + return { + disposeOutput, + disposeExtractor, + extractor, + pipeline: vi.fn(async () => extractor), + }; +}); + +vi.mock("@huggingface/transformers", () => ({ + pipeline: mockTransformers.pipeline, +})); + +function createLogger(): Logger { + return { + debug: vi.fn(), + info: vi.fn(), + warn: vi.fn(), + error: vi.fn(), + }; +} + +async function loadEmbedLocal() { + vi.resetModules(); + return import("../src/embedding/local"); +} + +describe("embedLocal memory leak fix", () => { + beforeEach(() => { + vi.clearAllMocks(); + delete process.env.MEMOS_EMBED_RESET_AFTER_CALLS; + }); + + afterEach(() => { + delete process.env.MEMOS_EMBED_RESET_AFTER_CALLS; + vi.restoreAllMocks(); + }); + + it("should dispose tensor output after each embedding call", async () => { + const { embedLocal } = await loadEmbedLocal(); + const mockLogger = createLogger(); + const texts = ["test embedding 1", "test embedding 2"]; + + const result = await embedLocal(texts, mockLogger); + + // Verify we got valid embeddings + expect(result).toHaveLength(2); + expect(result[0]).toHaveLength(384); // all-MiniLM-L6-v2 dimension + expect(result[1]).toHaveLength(384); + + // Verify embeddings are valid numbers + result.forEach(embedding => { + embedding.forEach(value => { + expect(typeof value).toBe("number"); + expect(isFinite(value)).toBe(true); + }); + }); + + expect(mockTransformers.pipeline).toHaveBeenCalledTimes(1); + expect(mockTransformers.extractor).toHaveBeenCalledTimes(2); + expect(mockTransformers.disposeOutput).toHaveBeenCalledTimes(2); + }); + + it("should handle multiple consecutive calls without crashing", async () => { + const { embedLocal } = await loadEmbedLocal(); + const mockLogger = createLogger(); + // Simulate multiple embedding calls that would trigger the leak + const calls = 10; + + for (let i = 0; i < calls; i++) { + const result = await embedLocal([`test text ${i}`], mockLogger); + expect(result).toHaveLength(1); + expect(result[0]).toHaveLength(384); + } + + // If we reached here without OOM, the tensor disposal is working + expect(mockTransformers.pipeline).toHaveBeenCalledTimes(1); + expect(mockTransformers.disposeOutput).toHaveBeenCalledTimes(calls); + }); + + it("should reset pipeline after RESET_AFTER_CALLS threshold", async () => { + // Set a low threshold for testing + process.env.MEMOS_EMBED_RESET_AFTER_CALLS = "5"; + const { embedLocal } = await loadEmbedLocal(); + const mockLogger = createLogger(); + + // This will trigger a reset after 5 calls + const calls = 6; + + for (let i = 0; i < calls; i++) { + const result = await embedLocal([`test ${i}`], mockLogger); + expect(result[0]).toHaveLength(384); + } + + // Verify reset was logged + expect(mockLogger.debug).toHaveBeenCalledWith( + expect.stringContaining("Reached 5 embedding calls") + ); + expect(mockTransformers.disposeExtractor).toHaveBeenCalledTimes(1); + }); + + it("should allow disabling periodic reset via env variable", async () => { + process.env.MEMOS_EMBED_RESET_AFTER_CALLS = "0"; + const { embedLocal } = await loadEmbedLocal(); + const mockLogger = createLogger(); + + // Run many calls - should not trigger reset + for (let i = 0; i < 100; i++) { + await embedLocal([`test ${i}`], mockLogger); + } + + // Verify no reset was logged + expect(mockLogger.debug).not.toHaveBeenCalledWith( + expect.stringContaining("Reached") + ); + expect(mockTransformers.disposeExtractor).not.toHaveBeenCalled(); + }); +});