Feat: MemVid as a Provider

package.json

@@ -13,6 +13,7 @@
     "@ai-sdk/google": "^2.0.49",
     "@ai-sdk/openai": "^2.0.88",
     "@getzep/zep-cloud": "^3.13.0",
+    "@memvid/sdk": "^2.0.146",
     "ai": "^5.0.115",
     "drizzle-orm": "^0.45.1",
     "mem0ai": "^2.1.38",

src/providers/index.ts

@@ -3,11 +3,13 @@ import type { ConcurrencyConfig } from "../types/concurrency"
 import { SupermemoryProvider } from "./supermemory"
 import { Mem0Provider } from "./mem0"
 import { ZepProvider } from "./zep"
+import { MemVidProvider } from "./memvid"
 
 const providers: Record<ProviderName, new () => Provider> = {
   supermemory: SupermemoryProvider,
   mem0: Mem0Provider,
   zep: ZepProvider,
+  memvid: MemVidProvider,
 }
 
 export function createProvider(name: ProviderName): Provider {
@@ -35,4 +37,4 @@ export function getProviderInfo(name: ProviderName): {
   }
 }
 
-export { SupermemoryProvider, Mem0Provider, ZepProvider }
+export { SupermemoryProvider, Mem0Provider, ZepProvider, MemVidProvider }

src/providers/memvid/index.ts

@@ -0,0 +1,136 @@
+import { create, open } from "@memvid/sdk"
+import fs from "fs/promises"
+import path from "path"
+import type {
+  Provider,
+  ProviderConfig,
+  IngestOptions,
+  IngestResult,
+  SearchOptions,
+  IndexingProgressCallback,
+} from "../../types/provider"
+import type { UnifiedSession } from "../../types/unified"
+import { logger } from "../../utils/logger"
+
+const DATA_DIR = path.join(process.cwd(), "data", "memvid")
+
+export class MemVidProvider implements Provider {
+  name = "memvid"
+
+  private instances = new Map<string, Promise<any>>()
+
+  concurrency = {
+    default: 50,
+  }
+
+
+  async initialize(_config: ProviderConfig): Promise<void> {
+    try {
+        await fs.mkdir(DATA_DIR, { recursive: true })
+        logger.info(`Initialized MemVid provider. Data directory: ${DATA_DIR}`)
+    } catch (e) {
+        logger.error(`Failed to create data directory: ${e}`)
+        throw e
+    }
+  }
+
+  private getFilePath(containerTag: string): string {
+    const filename = containerTag.replace(/[^a-z0-9-]/gi, "_") + ".mv2"
+    return path.join(DATA_DIR, filename)
+  }
+
+  private async getMem(containerTag: string): Promise<any> {
+    if (this.instances.has(containerTag)) {
+        return this.instances.get(containerTag)
+    }
+
+    const promise = (async () => {
+        const filePath = this.getFilePath(containerTag)
+        try {
+            await fs.access(filePath)
+            return await open(filePath, "basic", { readOnly: false })
+        } catch {
+            return await create(filePath)
+        }
+    })()
+
+    this.instances.set(containerTag, promise)
+
+    try {
+        return await promise
+    } catch (e) {
+        this.instances.delete(containerTag)
+        throw e
+    }
+  }
+
+  async ingest(sessions: UnifiedSession[], options: IngestOptions): Promise<IngestResult> {
+    const mem = await this.getMem(options.containerTag)
+    const documentIds: string[] = []
+
+    try {
+        for (const session of sessions) {            
+            for (const message of session.messages) {
+                const text = `${message.role.toUpperCase()}: ${message.content}`
+
+                await mem.put({
+                    text,
+                    tags: [options.containerTag, session.sessionId],
+                    metadata: {
+                        sessionId: session.sessionId,
+                        role: message.role,
+                        timestamp: session.metadata?.date
+                    },
+                })
+                documentIds.push(`${session.sessionId}-${Date.now()}-${Math.random()}`)
+            }
+        }
+
+        await mem.seal()
+    } catch (e) {
+        logger.error(`MemVid ingest error: ${e}`)
+        throw e
+    }
+
+    return { documentIds }
+  }
+
+  async awaitIndexing(
+    result: IngestResult,
+    _containerTag: string,
+    onProgress?: IndexingProgressCallback
+  ): Promise<void> {
+    onProgress?.({
+        completedIds: result.documentIds,
+        failedIds: [],
+        total: result.documentIds.length
+    })
+  }
+
+  async search(query: string, options: SearchOptions): Promise<unknown[]> {
+    const mem = await this.getMem(options.containerTag)
+
+    const results = await mem.find(query, {
+        k: options.limit || 10,
+    })
+
+    return results.hits.map((h: any) => ({
+        content: h.text,
+        score: h.score,
+        metadata: h.metadata
+    }))
+  }
+
+  async clear(containerTag: string): Promise<void> {
+    this.instances.delete(containerTag)
+
+    const filePath = this.getFilePath(containerTag)
+    try {
+        await fs.unlink(filePath)
+        logger.info(`Deleted memory file: ${filePath}`)
+    } catch (e) {
+    }
+  }
+}
+
+export default MemVidProvider

src/types/provider.ts

@@ -47,4 +47,4 @@ export interface Provider {
   clear(containerTag: string): Promise<void>
 }
 
-export type ProviderName = "supermemory" | "mem0" | "zep"
+export type ProviderName = "supermemory" | "mem0" | "zep" | "memvid"

src/utils/config.ts

@@ -6,6 +6,7 @@ export interface Config {
   openaiApiKey: string
   anthropicApiKey: string
   googleApiKey: string
+  memvidApiKey: string
 }
 
 export const config: Config = {
@@ -16,6 +17,7 @@ export const config: Config = {
   openaiApiKey: process.env.OPENAI_API_KEY || "",
   anthropicApiKey: process.env.ANTHROPIC_API_KEY || "",
   googleApiKey: process.env.GOOGLE_API_KEY || "",
+  memvidApiKey: process.env.MEMVID_API_KEY || "local", // No API key needed for local MemVid
 }
 
 export function getProviderConfig(provider: string): { apiKey: string; baseUrl?: string } {
@@ -26,6 +28,8 @@ export function getProviderConfig(provider: string): { apiKey: string; baseUrl?:
       return { apiKey: config.mem0ApiKey }
     case "zep":
       return { apiKey: config.zepApiKey }
+    case "memvid":
+      return { apiKey: config.memvidApiKey }
     default:
       throw new Error(`Unknown provider: ${provider}`)
   }