@lov3kaizen/agentsea-embeddings 1.0.1 → 1.1.0

package/dist/stores/index.js

@@ -33,13 +33,21 @@ __export(stores_exports, {
   BaseStore: () => BaseStore,
   ChromaStore: () => ChromaStore,
   MemoryStore: () => MemoryStore,
+  MilvusSdkBackend: () => MilvusSdkBackend,
+  MilvusStore: () => MilvusStore,
+  PgVectorStore: () => PgVectorStore,
   PineconeStore: () => PineconeStore,
   QdrantStore: () => QdrantStore,
+  WeaviateSdkBackend: () => WeaviateSdkBackend,
+  WeaviateStore: () => WeaviateStore,
   createChromaStore: () => createChromaStore,
   createMemoryStore: () => createMemoryStore,
+  createMilvusStore: () => createMilvusStore,
+  createPgVectorStore: () => createPgVectorStore,
   createPineconeStore: () => createPineconeStore,
   createQdrantStore: () => createQdrantStore,
-  createStore: () => createStore
+  createStore: () => createStore,
+  createWeaviateStore: () => createWeaviateStore
 });
 module.exports = __toCommonJS(stores_exports);
 
@@ -478,6 +486,8 @@ var MemoryStore = class extends BaseStore {
     }
     return Promise.resolve({
       deletedCount,
+      requestedCount: ids.length,
+      countExact: true,
       durationMs: performance.now() - startTime
     });
   }
@@ -490,6 +500,8 @@ var MemoryStore = class extends BaseStore {
       this.namespaces.clear();
       return Promise.resolve({
         deletedCount: count2,
+        requestedCount: count2,
+        countExact: true,
         durationMs: performance.now() - startTime
       });
     }
@@ -497,6 +509,8 @@ var MemoryStore = class extends BaseStore {
     if (!nsIds) {
       return Promise.resolve({
         deletedCount: 0,
+        requestedCount: 0,
+        countExact: true,
         durationMs: performance.now() - startTime
       });
     }
@@ -507,6 +521,8 @@ var MemoryStore = class extends BaseStore {
     this.namespaces.delete(namespace);
     return Promise.resolve({
       deletedCount: count,
+      requestedCount: count,
+      countExact: true,
       durationMs: performance.now() - startTime
     });
   }
@@ -710,6 +726,8 @@ var PineconeStore = class extends BaseStore {
     );
     return {
       deletedCount: ids.length,
+      requestedCount: ids.length,
+      countExact: false,
       durationMs: performance.now() - startTime
     };
   }
@@ -717,13 +735,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
     };
   }
@@ -884,12 +904,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,
@@ -898,7 +921,9 @@ var ChromaStore = class extends BaseStore {
       }
     });
     return {
-      deletedCount: -1,
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
       durationMs: performance.now() - startTime
     };
   }
@@ -1088,12 +1113,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, {
@@ -1104,7 +1132,9 @@ var QdrantStore = class extends BaseStore {
       });
     }
     return {
-      deletedCount: -1,
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
       durationMs: performance.now() - startTime
     };
   }
@@ -1148,6 +1178,747 @@ function createQdrantStore(config) {
   return new QdrantStore(config);
 }
 
+// src/core/optional-import.ts
+function importOptional(name) {
+  return import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    name
+  );
+}
+
+// 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;
+  }
+};
+function createPgVectorStore(config) {
+  return new PgVectorStore(config);
+}
+
+// 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 };
+  }
+};
+function createWeaviateStore(config) {
+  return new WeaviateStore(config);
+}
+
+// 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__" });
+  }
+};
+function createMilvusStore(config) {
+  return new MilvusStore(config);
+}
+
 // src/stores/index.ts
 function createStore(type, config) {
   switch (type) {
@@ -1159,8 +1930,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.`
+      );
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -1168,11 +1947,19 @@ function createStore(type, config) {
   BaseStore,
   ChromaStore,
   MemoryStore,
+  MilvusSdkBackend,
+  MilvusStore,
+  PgVectorStore,
   PineconeStore,
   QdrantStore,
+  WeaviateSdkBackend,
+  WeaviateStore,
   createChromaStore,
   createMemoryStore,
+  createMilvusStore,
+  createPgVectorStore,
   createPineconeStore,
   createQdrantStore,
-  createStore
+  createStore,
+  createWeaviateStore
 });