@lov3kaizen/agentsea-embeddings 1.0.0 → 1.1.0

package/dist/index.js

@@ -1500,20 +1500,33 @@ function createVoyageProvider(config) {
   return new VoyageProvider(config);
 }
 
+// src/core/optional-import.ts
+function importOptional(name) {
+  return import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    name
+  );
+}
+
 // src/providers/LocalProvider.ts
 var LocalProvider = class extends BaseProvider {
   modelInfo;
   embedFn = null;
   normalize;
   batchSize;
+  modelPath;
+  /** Lazily-built ONNX extractor (only when loading from `modelPath`). */
+  extractorPromise;
   constructor(config) {
     super({ ...config, type: "local" });
     if (!config.embedFn && !config.modelPath) {
       throw new Error(
-        "Either embedFn or modelPath is required for local provider"
+        "`embedFn` or `modelPath` (ONNX) is required for the local provider"
       );
     }
     this.embedFn = config.embedFn ?? null;
+    this.modelPath = config.modelPath;
     this.normalize = config.normalize ?? true;
     this.batchSize = config.batchSize ?? 32;
     this.modelInfo = {
@@ -1527,10 +1540,43 @@ var LocalProvider = class extends BaseProvider {
       description: "Local embedding model"
     };
   }
+  /**
+   * Lazily load the ONNX feature-extraction pipeline from `modelPath` via
+   * Transformers.js and adapt it into a {@link LocalEmbeddingFn}.
+   */
+  getOnnxEmbedFn() {
+    if (!this.extractorPromise) {
+      this.extractorPromise = (async () => {
+        let mod;
+        try {
+          mod = await importOptional("@xenova/transformers");
+        } catch {
+          throw new Error(
+            'Loading local ONNX models from `modelPath` requires the "@xenova/transformers" package. Install it, or pass an `embedFn`.'
+          );
+        }
+        const transformers = mod;
+        return transformers.pipeline("feature-extraction", this.modelPath);
+      })();
+    }
+    return this.extractorPromise;
+  }
   get info() {
     return this.modelInfo;
   }
   async doEmbed(texts, options) {
+    if (!this.embedFn && this.modelPath) {
+      const extractor = await this.getOnnxEmbedFn();
+      this.embedFn = async (input) => {
+        const output = await extractor(input, {
+          pooling: "mean",
+          normalize: false
+          // we normalize below if configured
+        });
+        const list = output.tolist();
+        return Array.isArray(list[0]) ? list : [list];
+      };
+    }
     if (!this.embedFn) {
       throw new Error("No embedding function configured");
     }
@@ -3433,7 +3479,13 @@ var SQLiteCache = class extends BaseCache {
     `);
     updateStmt.run(Date.now(), key);
     const vectorBuffer = row.vector;
-    const vector = Array.from(new Float32Array(vectorBuffer.buffer));
+    const vector = Array.from(
+      new Float32Array(
+        vectorBuffer.buffer,
+        vectorBuffer.byteOffset,
+        vectorBuffer.byteLength / Float32Array.BYTES_PER_ELEMENT
+      )
+    );
     return {
       key: row.key,
       vector,
@@ -3984,6 +4036,8 @@ var MemoryStore = class extends BaseStore {
     }
     return Promise.resolve({
       deletedCount,
+      requestedCount: ids.length,
+      countExact: true,
       durationMs: performance.now() - startTime
     });
   }
@@ -3996,6 +4050,8 @@ var MemoryStore = class extends BaseStore {
       this.namespaces.clear();
       return Promise.resolve({
         deletedCount: count2,
+        requestedCount: count2,
+        countExact: true,
         durationMs: performance.now() - startTime
       });
     }
@@ -4003,6 +4059,8 @@ var MemoryStore = class extends BaseStore {
     if (!nsIds) {
       return Promise.resolve({
         deletedCount: 0,
+        requestedCount: 0,
+        countExact: true,
         durationMs: performance.now() - startTime
       });
     }
@@ -4013,6 +4071,8 @@ var MemoryStore = class extends BaseStore {
     this.namespaces.delete(namespace);
     return Promise.resolve({
       deletedCount: count,
+      requestedCount: count,
+      countExact: true,
       durationMs: performance.now() - startTime
     });
   }
@@ -4207,6 +4267,8 @@ var PineconeStore = class extends BaseStore {
     );
     return {
       deletedCount: ids.length,
+      requestedCount: ids.length,
+      countExact: false,
       durationMs: performance.now() - startTime
     };
   }
@@ -4214,13 +4276,15 @@ var PineconeStore = class extends BaseStore {
     await this.ensureInitialized();
     const startTime = performance.now();
     const namespace = options?.namespace ?? this.namespace;
+    const before = await this.getStats().catch(() => void 0);
     const ns = this.index.namespace(
       namespace
     );
     await ns.deleteAll();
     return {
-      deletedCount: -1,
-      // Unknown count
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
       durationMs: performance.now() - startTime
     };
   }
@@ -4381,12 +4445,15 @@ var ChromaStore = class extends BaseStore {
     await this.collection.delete({ ids });
     return {
       deletedCount: ids.length,
+      requestedCount: ids.length,
+      countExact: false,
       durationMs: performance.now() - startTime
     };
   }
   async deleteAll(_options) {
     await this.ensureInitialized();
     const startTime = performance.now();
+    const before = await this.getStats().catch(() => void 0);
     await this.client.deleteCollection({ name: this.collectionName });
     this.collection = await this.client.createCollection({
       name: this.collectionName,
@@ -4395,7 +4462,9 @@ var ChromaStore = class extends BaseStore {
       }
     });
     return {
-      deletedCount: -1,
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
       durationMs: performance.now() - startTime
     };
   }
@@ -4585,12 +4654,15 @@ var QdrantStore = class extends BaseStore {
     });
     return {
       deletedCount: ids.length,
+      requestedCount: ids.length,
+      countExact: false,
       durationMs: performance.now() - startTime
     };
   }
   async deleteAll(_options) {
     await this.ensureInitialized();
     const startTime = performance.now();
+    const before = await this.getStats().catch(() => void 0);
     await this.client.deleteCollection(this.collectionName);
     if (this.dimensions) {
       await this.client.createCollection(this.collectionName, {
@@ -4601,7 +4673,9 @@ var QdrantStore = class extends BaseStore {
       });
     }
     return {
-      deletedCount: -1,
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
       durationMs: performance.now() - startTime
     };
   }
@@ -4645,6 +4719,729 @@ function createQdrantStore(config) {
   return new QdrantStore(config);
 }
 
+// src/stores/PgVectorStore.ts
+var PgVectorStore = class extends BaseStore {
+  storeType = "pgvector";
+  pool;
+  injectedPool;
+  table;
+  vectorColumn;
+  contentColumn;
+  metadataColumn;
+  pgConfig;
+  initialized = false;
+  constructor(config) {
+    super(config);
+    if (!config.tableName) {
+      throw new Error("pgvector store requires a `tableName`");
+    }
+    this.pgConfig = config;
+    this.injectedPool = config.pool;
+    this.table = config.tableName;
+    this.vectorColumn = config.vectorColumn ?? "embedding";
+    this.contentColumn = config.contentColumn ?? "content";
+    this.metadataColumn = config.metadataColumn ?? "metadata";
+  }
+  /** The pgvector distance operator for the configured metric. */
+  get distanceOperator() {
+    switch (this.metric) {
+      case "euclidean":
+        return "<->";
+      case "dot_product":
+        return "<#>";
+      case "cosine":
+      default:
+        return "<=>";
+    }
+  }
+  async init() {
+    if (this.initialized) return;
+    if (this.injectedPool) {
+      this.pool = this.injectedPool;
+    } else {
+      let mod;
+      try {
+        mod = await importOptional("pg");
+      } catch {
+        throw new Error(
+          'pgvector store requires the "pg" package. Install it, or pass a pre-built `pool` to the store.'
+        );
+      }
+      const pg = mod.default ?? mod;
+      const Pool = pg.Pool;
+      this.pool = new Pool(
+        this.pgConfig.connectionString ? { connectionString: this.pgConfig.connectionString } : {
+          host: this.pgConfig.host,
+          port: this.pgConfig.port,
+          database: this.pgConfig.database,
+          user: this.pgConfig.user,
+          password: this.pgConfig.password
+        }
+      );
+    }
+    await this.pool.query("CREATE EXTENSION IF NOT EXISTS vector");
+    const dims = this.dimensions;
+    const vectorType = dims ? `vector(${dims})` : "vector";
+    await this.pool.query(
+      `CREATE TABLE IF NOT EXISTS ${this.ident(this.table)} (
+        id text PRIMARY KEY,
+        ${this.ident(this.contentColumn)} text,
+        ${this.ident(this.metadataColumn)} jsonb,
+        ${this.ident(this.vectorColumn)} ${vectorType}
+      )`
+    );
+    this.initialized = true;
+  }
+  async ensureInitialized() {
+    if (!this.initialized) await this.init();
+  }
+  /** Quote an SQL identifier to guard against injection via config names. */
+  ident(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  toVectorLiteral(vector) {
+    return `[${Array.from(vector).join(",")}]`;
+  }
+  async upsert(records, options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const batchSize = options?.batchSize ?? 100;
+    const upsertedIds = [];
+    const errors = [];
+    let completed = 0;
+    for (const group of batch(records, batchSize)) {
+      for (const record of group) {
+        try {
+          await this.pool.query(
+            `INSERT INTO ${this.ident(this.table)} (id, ${this.ident(this.contentColumn)}, ${this.ident(this.metadataColumn)}, ${this.ident(this.vectorColumn)})
+             VALUES ($1, $2, $3, $4)
+             ON CONFLICT (id) DO UPDATE SET
+               ${this.ident(this.contentColumn)} = EXCLUDED.${this.ident(this.contentColumn)},
+               ${this.ident(this.metadataColumn)} = EXCLUDED.${this.ident(this.metadataColumn)},
+               ${this.ident(this.vectorColumn)} = EXCLUDED.${this.ident(this.vectorColumn)}`,
+            [
+              record.id,
+              record.text ?? null,
+              JSON.stringify(record.metadata ?? {}),
+              this.toVectorLiteral(record.vector)
+            ]
+          );
+          upsertedIds.push(record.id);
+        } catch (e) {
+          errors.push({ id: record.id, error: e.message });
+        }
+      }
+      completed += group.length;
+      options?.onProgress?.({ completed, total: records.length });
+    }
+    return {
+      upsertedIds,
+      upsertedCount: upsertedIds.length,
+      errors,
+      durationMs: performance.now() - start
+    };
+  }
+  async query(vector, options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const topK = options?.topK ?? 10;
+    const params = [this.toVectorLiteral(vector)];
+    let where = "";
+    if (options?.filter && Object.keys(options.filter).length > 0) {
+      params.push(JSON.stringify(options.filter));
+      where = `WHERE ${this.ident(this.metadataColumn)} @> $${params.length}::jsonb`;
+    }
+    params.push(topK);
+    const op = this.distanceOperator;
+    const sql = `SELECT id, ${this.ident(this.contentColumn)} AS content, ${this.ident(this.metadataColumn)} AS metadata, ${this.ident(this.vectorColumn)} ${op} $1 AS distance FROM ${this.ident(this.table)} ${where} ORDER BY ${this.ident(this.vectorColumn)} ${op} $1 ASC LIMIT $${params.length}`;
+    const result = await this.pool.query(sql, params);
+    const matches = result.rows.map((row) => {
+      const distance = Number(row.distance);
+      const score = this.metric === "cosine" ? 1 - distance : 1 / (1 + distance);
+      return {
+        id: String(row.id),
+        text: row.content ?? "",
+        score,
+        distance,
+        metadata: row.metadata ?? {}
+      };
+    }).filter(
+      (m) => options?.minScore === void 0 || m.score >= options.minScore
+    );
+    return {
+      matches,
+      namespace: this.namespace,
+      durationMs: performance.now() - start
+    };
+  }
+  async delete(ids, _options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const result = await this.pool.query(
+      `DELETE FROM ${this.ident(this.table)} WHERE id = ANY($1)`,
+      [ids]
+    );
+    const deleted = result.rowCount ?? ids.length;
+    return {
+      deletedCount: deleted,
+      requestedCount: ids.length,
+      countExact: result.rowCount !== null,
+      durationMs: performance.now() - start
+    };
+  }
+  async deleteAll(_options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const result = await this.pool.query(
+      `DELETE FROM ${this.ident(this.table)}`
+    );
+    return {
+      deletedCount: result.rowCount ?? 0,
+      requestedCount: result.rowCount ?? void 0,
+      countExact: result.rowCount !== null,
+      durationMs: performance.now() - start
+    };
+  }
+  async getStats() {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `SELECT COUNT(*)::int AS count FROM ${this.ident(this.table)}`
+    );
+    const vectorCount = Number(result.rows[0]?.count ?? 0);
+    return {
+      type: this.storeType,
+      vectorCount,
+      namespaceCount: 1,
+      dimensions: this.dimensions ?? 0,
+      metric: this.metric,
+      lastUpdated: Date.now()
+    };
+  }
+  async checkHealth() {
+    const start = performance.now();
+    try {
+      await this.ensureInitialized();
+      await this.pool.query("SELECT 1");
+      return {
+        healthy: true,
+        latencyMs: performance.now() - start,
+        lastCheck: Date.now()
+      };
+    } catch (e) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - start,
+        lastCheck: Date.now(),
+        error: e.message
+      };
+    }
+  }
+  async close() {
+    if (this.pool && !this.injectedPool) {
+      await this.pool.end();
+    }
+    this.initialized = false;
+  }
+};
+
+// src/stores/WeaviateStore.ts
+var WeaviateStore = class extends BaseStore {
+  storeType = "weaviate";
+  backend;
+  injectedBackend;
+  className;
+  url;
+  apiKey;
+  initialized = false;
+  constructor(config) {
+    super(config);
+    if (!config.url) throw new Error("Weaviate store requires a `url`");
+    if (!config.className) {
+      throw new Error("Weaviate store requires a `className`");
+    }
+    this.url = config.url;
+    this.className = config.className;
+    this.apiKey = config.apiKey;
+    this.injectedBackend = config.backend;
+  }
+  async init() {
+    if (this.initialized) return;
+    this.backend = this.injectedBackend ?? await this.buildSdkBackend();
+    await this.backend.ensureClass(this.className, this.dimensions);
+    this.initialized = true;
+  }
+  async ensureInitialized() {
+    if (!this.initialized) await this.init();
+  }
+  /** Build a {@link WeaviateBackend} backed by the real `weaviate-ts-client`. */
+  async buildSdkBackend() {
+    let mod;
+    try {
+      mod = await importOptional("weaviate-ts-client");
+    } catch {
+      throw new Error(
+        'Weaviate store requires the "weaviate-ts-client" package. Install it, or pass a custom `backend`.'
+      );
+    }
+    const weaviate = mod.default ?? mod;
+    const u = new URL(this.url);
+    const client = weaviate.client({
+      scheme: u.protocol.replace(":", ""),
+      host: u.host,
+      apiKey: this.apiKey && weaviate.ApiKey ? new weaviate.ApiKey(this.apiKey) : void 0
+    });
+    return new WeaviateSdkBackend(client);
+  }
+  async upsert(records, options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const batchSize = options?.batchSize ?? 100;
+    const upsertedIds = [];
+    const errors = [];
+    let completed = 0;
+    for (const group of batch(records, batchSize)) {
+      try {
+        await this.backend.upsert(
+          this.className,
+          group.map((r) => ({
+            id: r.id,
+            vector: Array.from(r.vector),
+            properties: { ...r.metadata ?? {}, text: r.text ?? "" }
+          }))
+        );
+        upsertedIds.push(...group.map((r) => r.id));
+      } catch (e) {
+        for (const r of group)
+          errors.push({ id: r.id, error: e.message });
+      }
+      completed += group.length;
+      options?.onProgress?.({ completed, total: records.length });
+    }
+    return {
+      upsertedIds,
+      upsertedCount: upsertedIds.length,
+      errors,
+      durationMs: performance.now() - start
+    };
+  }
+  async query(vector, options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const topK = options?.topK ?? 10;
+    const hits = await this.backend.nearVector(
+      this.className,
+      Array.from(vector),
+      topK,
+      options?.filter
+    );
+    const matches = hits.map((h) => ({
+      id: h.id,
+      text: h.properties.text ?? "",
+      score: h.score,
+      metadata: h.properties
+    })).filter(
+      (m) => options?.minScore === void 0 || m.score >= options.minScore
+    );
+    return {
+      matches,
+      namespace: this.className,
+      durationMs: performance.now() - start
+    };
+  }
+  async delete(ids, _options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const deleted = await this.backend.deleteByIds(this.className, ids);
+    return {
+      deletedCount: deleted,
+      requestedCount: ids.length,
+      countExact: true,
+      durationMs: performance.now() - start
+    };
+  }
+  async deleteAll(_options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const deleted = await this.backend.deleteAll(this.className);
+    return {
+      deletedCount: deleted,
+      requestedCount: deleted,
+      countExact: true,
+      durationMs: performance.now() - start
+    };
+  }
+  async getStats() {
+    await this.ensureInitialized();
+    return {
+      type: this.storeType,
+      vectorCount: await this.backend.count(this.className),
+      namespaceCount: 1,
+      dimensions: this.dimensions ?? 0,
+      metric: this.metric,
+      lastUpdated: Date.now()
+    };
+  }
+  async checkHealth() {
+    const start = performance.now();
+    try {
+      await this.ensureInitialized();
+      await this.backend.ping();
+      return {
+        healthy: true,
+        latencyMs: performance.now() - start,
+        lastCheck: Date.now()
+      };
+    } catch (e) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - start,
+        lastCheck: Date.now(),
+        error: e.message
+      };
+    }
+  }
+  close() {
+    this.initialized = false;
+    return Promise.resolve();
+  }
+};
+var WeaviateSdkBackend = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async ensureClass(className, _dimensions) {
+    const schema = await this.client.schema.getter().do();
+    if (schema.classes?.some((c) => c.class === className)) return;
+    await this.client.schema.classCreator().withClass({ class: className, vectorizer: "none" }).do();
+  }
+  async upsert(className, objects) {
+    let batcher = this.client.batch.objectsBatcher();
+    for (const o of objects) {
+      batcher = batcher.withObject({
+        class: className,
+        id: o.id,
+        vector: o.vector,
+        properties: o.properties
+      });
+    }
+    await batcher.do();
+  }
+  async nearVector(className, vector, limit, filter) {
+    let q = this.client.graphql.get().withClassName(className).withFields("_additional { id certainty } text").withNearVector({ vector }).withLimit(limit);
+    if (filter) q = q.withWhere(this.toWhere(filter));
+    const res = await q.do();
+    const rows = res.data?.Get?.[className] ?? [];
+    return rows.map((row) => {
+      const additional = row._additional;
+      const { _additional, ...properties } = row;
+      void _additional;
+      return {
+        id: additional.id,
+        score: additional.certainty ?? 0,
+        properties
+      };
+    });
+  }
+  async deleteByIds(className, ids) {
+    let n = 0;
+    for (const id of ids) {
+      await this.client.data.deleter().withClassName(className).withId(id).do();
+      n++;
+    }
+    return n;
+  }
+  async deleteAll(className) {
+    const count = await this.count(className);
+    await this.client.schema.classCreator().withClass({ class: className, vectorizer: "none" }).do().catch(() => void 0);
+    return count;
+  }
+  async count(className) {
+    const res = await this.client.graphql.aggregate().withClassName(className).withFields("meta { count }").do();
+    const agg = res.data?.Aggregate?.[className] ?? [];
+    return agg[0]?.meta?.count ?? 0;
+  }
+  async ping() {
+    await this.client.misc.liveChecker().do();
+  }
+  toWhere(filter) {
+    const operands = Object.entries(filter).map(([path, value]) => ({
+      path: [path],
+      operator: "Equal",
+      ...typeof value === "number" ? { valueNumber: value } : typeof value === "boolean" ? { valueBoolean: value } : { valueText: String(value) }
+    }));
+    return operands.length === 1 ? operands[0] : { operator: "And", operands };
+  }
+};
+
+// src/stores/MilvusStore.ts
+var MilvusStore = class extends BaseStore {
+  storeType = "milvus";
+  backend;
+  injectedBackend;
+  collection;
+  milvusConfig;
+  initialized = false;
+  constructor(config) {
+    super(config);
+    if (!config.url) throw new Error("Milvus store requires a `url`");
+    if (!config.collectionName) {
+      throw new Error("Milvus store requires a `collectionName`");
+    }
+    if (!config.dimensions) {
+      throw new Error("Milvus store requires `dimensions`");
+    }
+    this.milvusConfig = config;
+    this.collection = config.collectionName;
+    this.injectedBackend = config.backend;
+  }
+  /** Milvus metric type string for the configured distance metric. */
+  get metricType() {
+    switch (this.metric) {
+      case "euclidean":
+        return "L2";
+      case "dot_product":
+        return "IP";
+      case "cosine":
+      default:
+        return "COSINE";
+    }
+  }
+  async init() {
+    if (this.initialized) return;
+    this.backend = this.injectedBackend ?? await this.buildSdkBackend();
+    await this.backend.ensureCollection(
+      this.collection,
+      this.dimensions,
+      this.metricType
+    );
+    this.initialized = true;
+  }
+  async ensureInitialized() {
+    if (!this.initialized) await this.init();
+  }
+  async buildSdkBackend() {
+    let mod;
+    try {
+      mod = await importOptional("@zilliz/milvus2-sdk-node");
+    } catch {
+      throw new Error(
+        'Milvus store requires the "@zilliz/milvus2-sdk-node" package. Install it, or pass a custom `backend`.'
+      );
+    }
+    const sdk = mod;
+    const client = new sdk.MilvusClient({
+      address: this.milvusConfig.url,
+      username: this.milvusConfig.username,
+      password: this.milvusConfig.password
+    });
+    return new MilvusSdkBackend(client);
+  }
+  async upsert(records, options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const batchSize = options?.batchSize ?? 100;
+    const upsertedIds = [];
+    const errors = [];
+    let completed = 0;
+    for (const group of batch(records, batchSize)) {
+      try {
+        await this.backend.upsert(
+          this.collection,
+          group.map((r) => ({
+            id: r.id,
+            vector: Array.from(r.vector),
+            text: r.text ?? "",
+            metadata: r.metadata ?? {}
+          }))
+        );
+        upsertedIds.push(...group.map((r) => r.id));
+      } catch (e) {
+        for (const r of group)
+          errors.push({ id: r.id, error: e.message });
+      }
+      completed += group.length;
+      options?.onProgress?.({ completed, total: records.length });
+    }
+    return {
+      upsertedIds,
+      upsertedCount: upsertedIds.length,
+      errors,
+      durationMs: performance.now() - start
+    };
+  }
+  async query(vector, options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const topK = options?.topK ?? 10;
+    const hits = await this.backend.search(
+      this.collection,
+      Array.from(vector),
+      topK,
+      options?.filter ? this.toExpr(options.filter) : void 0
+    );
+    const matches = hits.map((h) => ({
+      id: h.id,
+      text: h.text,
+      score: h.score,
+      metadata: h.metadata
+    })).filter(
+      (m) => options?.minScore === void 0 || m.score >= options.minScore
+    );
+    return {
+      matches,
+      namespace: this.collection,
+      durationMs: performance.now() - start
+    };
+  }
+  async delete(ids, _options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const deleted = await this.backend.deleteByIds(this.collection, ids);
+    return {
+      deletedCount: deleted,
+      requestedCount: ids.length,
+      countExact: true,
+      durationMs: performance.now() - start
+    };
+  }
+  async deleteAll(_options) {
+    await this.ensureInitialized();
+    const start = performance.now();
+    const deleted = await this.backend.deleteAll(this.collection);
+    return {
+      deletedCount: deleted,
+      requestedCount: deleted,
+      countExact: true,
+      durationMs: performance.now() - start
+    };
+  }
+  async getStats() {
+    await this.ensureInitialized();
+    return {
+      type: this.storeType,
+      vectorCount: await this.backend.count(this.collection),
+      namespaceCount: 1,
+      dimensions: this.dimensions ?? 0,
+      metric: this.metric,
+      lastUpdated: Date.now()
+    };
+  }
+  async checkHealth() {
+    const start = performance.now();
+    try {
+      await this.ensureInitialized();
+      await this.backend.ping();
+      return {
+        healthy: true,
+        latencyMs: performance.now() - start,
+        lastCheck: Date.now()
+      };
+    } catch (e) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - start,
+        lastCheck: Date.now(),
+        error: e.message
+      };
+    }
+  }
+  close() {
+    this.initialized = false;
+    return Promise.resolve();
+  }
+  /** Translate a flat equality filter to a Milvus boolean expression. */
+  toExpr(filter) {
+    return Object.entries(filter).map(
+      ([k, v]) => typeof v === "number" ? `metadata["${k}"] == ${v}` : `metadata["${k}"] == "${String(v)}"`
+    ).join(" && ");
+  }
+};
+var MilvusSdkBackend = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async ensureCollection(collection, dimensions, metric) {
+    const has = await this.client.hasCollection({
+      collection_name: collection
+    });
+    if (!has.value) {
+      await this.client.createCollection({
+        collection_name: collection,
+        fields: [
+          {
+            name: "id",
+            data_type: "VarChar",
+            is_primary_key: true,
+            max_length: 512
+          },
+          { name: "vector", data_type: "FloatVector", dim: dimensions },
+          { name: "text", data_type: "VarChar", max_length: 65535 },
+          { name: "metadata", data_type: "JSON" }
+        ]
+      });
+      await this.client.createIndex({
+        collection_name: collection,
+        field_name: "vector",
+        index_type: "HNSW",
+        metric_type: metric,
+        params: { M: 16, efConstruction: 200 }
+      });
+    }
+    await this.client.loadCollectionSync({ collection_name: collection });
+  }
+  async upsert(collection, rows) {
+    await this.client.insert({
+      collection_name: collection,
+      data: rows.map((r) => ({
+        id: r.id,
+        vector: r.vector,
+        text: r.text,
+        metadata: r.metadata
+      }))
+    });
+  }
+  async search(collection, vector, limit, filter) {
+    const res = await this.client.search({
+      collection_name: collection,
+      data: [vector],
+      limit,
+      filter,
+      output_fields: ["text", "metadata"]
+    });
+    return res.results.map((r) => ({
+      id: String(r.id),
+      score: Number(r.score),
+      text: r.text ?? "",
+      metadata: r.metadata ?? {}
+    }));
+  }
+  async deleteByIds(collection, ids) {
+    const list = ids.map((id) => `"${id}"`).join(", ");
+    await this.client.deleteEntities({
+      collection_name: collection,
+      expr: `id in [${list}]`
+    });
+    return ids.length;
+  }
+  async deleteAll(collection) {
+    const count = await this.count(collection);
+    await this.client.deleteEntities({
+      collection_name: collection,
+      expr: 'id != ""'
+    });
+    return count;
+  }
+  async count(collection) {
+    const stats = await this.client.getCollectionStatistics({
+      collection_name: collection
+    });
+    return Number(stats.data?.row_count ?? 0);
+  }
+  async ping() {
+    await this.client.hasCollection({ collection_name: "__ping__" });
+  }
+};
+
 // src/stores/index.ts
 function createStore(type, config) {
   switch (type) {
@@ -4656,8 +5453,16 @@ function createStore(type, config) {
       return new ChromaStore(config);
     case "qdrant":
       return new QdrantStore(config);
+    case "weaviate":
+      return new WeaviateStore(config);
+    case "milvus":
+      return new MilvusStore(config);
+    case "pgvector":
+      return new PgVectorStore(config);
     default:
-      return new MemoryStore(config);
+      throw new Error(
+        `Unknown vector store type "${String(type)}". Supported stores: memory, pinecone, chroma, qdrant, weaviate, milvus, pgvector.`
+      );
   }
 }