@lov3kaizen/agentsea-embeddings 1.0.1 → 1.1.0

package/dist/chunk-JHWMXQ56.mjs

@@ -0,0 +1,1650 @@
+import {
+  importOptional
+} from "./chunk-2TCNSTX3.mjs";
+import {
+  batch
+} from "./chunk-3KM32UQK.mjs";
+import {
+  EmbeddingModel
+} from "./chunk-QAITLJ2E.mjs";
+
+// src/stores/BaseStore.ts
+var BaseStore = class {
+  /** Store configuration */
+  config;
+  constructor(config) {
+    this.config = {
+      namespace: config.namespace ?? "default",
+      dimensions: config.dimensions,
+      metric: config.metric ?? "cosine",
+      ...config
+    };
+  }
+  /**
+   * Get namespace
+   */
+  get namespace() {
+    return this.config.namespace ?? "default";
+  }
+  /**
+   * Get dimensions
+   */
+  get dimensions() {
+    return this.config.dimensions;
+  }
+  /**
+   * Get distance metric
+   */
+  get metric() {
+    return this.config.metric ?? "cosine";
+  }
+  /**
+   * Calculate similarity/distance between vectors
+   */
+  calculateScore(a, b) {
+    switch (this.metric) {
+      case "cosine":
+        return EmbeddingModel.cosineSimilarity(a, b);
+      case "euclidean": {
+        const dist = EmbeddingModel.euclideanDistance(a, b);
+        return 1 / (1 + dist);
+      }
+      case "dot_product":
+        return EmbeddingModel.dotProduct(a, b);
+      default:
+        return EmbeddingModel.cosineSimilarity(a, b);
+    }
+  }
+  /**
+   * Filter records by metadata
+   */
+  filterByMetadata(records, filter) {
+    if (!filter) return records;
+    return records.filter((record) => {
+      if (!record.metadata) return false;
+      for (const [key, value] of Object.entries(filter)) {
+        if (record.metadata[key] !== value) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+  /**
+   * Convert records to search results
+   */
+  toSearchResults(records, options) {
+    return records.map((record) => ({
+      id: record.id,
+      text: options?.includeText !== false ? record.text ?? "" : "",
+      score: record.score,
+      metadata: options?.includeMetadata !== false ? record.metadata ?? {} : {},
+      distance: this.metric !== "cosine" ? 1 - record.score : void 0
+    }));
+  }
+};
+
+// src/stores/MemoryStore.ts
+import * as fs from "fs/promises";
+var MemoryStore = class extends BaseStore {
+  storeType = "memory";
+  vectors = /* @__PURE__ */ new Map();
+  namespaces = /* @__PURE__ */ new Map();
+  persistPath;
+  persistInterval;
+  maxVectors;
+  constructor(config = { type: "memory" }) {
+    super(config);
+    this.maxVectors = config.maxVectors ?? 1e5;
+    this.persistPath = config.persistPath;
+    if (config.persistInterval && config.persistPath) {
+      this.persistInterval = setInterval(
+        () => void this.persist().catch(() => {
+        }),
+        config.persistInterval
+      );
+    }
+  }
+  async upsert(records, options) {
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    const upsertedIds = [];
+    const errors = [];
+    if (!this.namespaces.has(namespace)) {
+      this.namespaces.set(namespace, /* @__PURE__ */ new Set());
+    }
+    const nsIds = this.namespaces.get(namespace);
+    for (const record of records) {
+      try {
+        if (this.vectors.size >= this.maxVectors && !this.vectors.has(record.id)) {
+          const oldestId = this.vectors.keys().next().value;
+          if (oldestId) {
+            this.vectors.delete(oldestId);
+            for (const ns of this.namespaces.values()) {
+              ns.delete(oldestId);
+            }
+          }
+        }
+        this.vectors.set(record.id, record);
+        nsIds.add(record.id);
+        upsertedIds.push(record.id);
+      } catch (error) {
+        errors.push({ id: record.id, error: error.message });
+      }
+    }
+    return Promise.resolve({
+      upsertedIds,
+      upsertedCount: upsertedIds.length,
+      errors,
+      durationMs: performance.now() - startTime
+    });
+  }
+  async query(vector, options) {
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    const topK = options?.topK ?? 10;
+    const minScore = options?.minScore ?? 0;
+    const nsIds = this.namespaces.get(namespace);
+    if (!nsIds || nsIds.size === 0) {
+      return {
+        matches: [],
+        namespace,
+        durationMs: performance.now() - startTime
+      };
+    }
+    let scoredRecords = [];
+    for (const id of nsIds) {
+      const record = this.vectors.get(id);
+      if (!record) continue;
+      const score = this.calculateScore(vector, record.vector);
+      if (score >= minScore) {
+        scoredRecords.push({ ...record, score });
+      }
+    }
+    if (options?.filter) {
+      scoredRecords = this.filterByMetadata(
+        scoredRecords,
+        options.filter
+      );
+    }
+    scoredRecords.sort((a, b) => b.score - a.score);
+    const topResults = scoredRecords.slice(0, topK);
+    return Promise.resolve({
+      matches: this.toSearchResults(topResults, options),
+      namespace,
+      durationMs: performance.now() - startTime
+    });
+  }
+  async delete(ids, options) {
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    let deletedCount = 0;
+    const nsIds = this.namespaces.get(namespace);
+    for (const id of ids) {
+      if (this.vectors.has(id)) {
+        this.vectors.delete(id);
+        nsIds?.delete(id);
+        deletedCount++;
+      }
+    }
+    return Promise.resolve({
+      deletedCount,
+      requestedCount: ids.length,
+      countExact: true,
+      durationMs: performance.now() - startTime
+    });
+  }
+  async deleteAll(options) {
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    if (options?.deleteAll) {
+      const count2 = this.vectors.size;
+      this.vectors.clear();
+      this.namespaces.clear();
+      return Promise.resolve({
+        deletedCount: count2,
+        requestedCount: count2,
+        countExact: true,
+        durationMs: performance.now() - startTime
+      });
+    }
+    const nsIds = this.namespaces.get(namespace);
+    if (!nsIds) {
+      return Promise.resolve({
+        deletedCount: 0,
+        requestedCount: 0,
+        countExact: true,
+        durationMs: performance.now() - startTime
+      });
+    }
+    const count = nsIds.size;
+    for (const id of nsIds) {
+      this.vectors.delete(id);
+    }
+    this.namespaces.delete(namespace);
+    return Promise.resolve({
+      deletedCount: count,
+      requestedCount: count,
+      countExact: true,
+      durationMs: performance.now() - startTime
+    });
+  }
+  getStats() {
+    return Promise.resolve({
+      type: this.storeType,
+      vectorCount: this.vectors.size,
+      namespaceCount: this.namespaces.size,
+      dimensions: this.dimensions ?? 0,
+      metric: this.metric,
+      lastUpdated: Date.now()
+    });
+  }
+  checkHealth() {
+    return Promise.resolve({
+      healthy: true,
+      latencyMs: 0,
+      lastCheck: Date.now()
+    });
+  }
+  async close() {
+    if (this.persistInterval) {
+      clearInterval(this.persistInterval);
+    }
+    if (this.persistPath) {
+      await this.persist();
+    }
+  }
+  /**
+   * Persist store to file
+   */
+  async persist() {
+    if (!this.persistPath) return;
+    const data = {
+      vectors: Array.from(this.vectors.entries()),
+      namespaces: Array.from(this.namespaces.entries()).map(([k, v]) => [
+        k,
+        Array.from(v)
+      ])
+    };
+    await fs.writeFile(this.persistPath, JSON.stringify(data), "utf-8");
+  }
+  /**
+   * Load store from file
+   */
+  async load() {
+    if (!this.persistPath) return;
+    try {
+      const data = JSON.parse(await fs.readFile(this.persistPath, "utf-8"));
+      this.vectors = new Map(data.vectors);
+      this.namespaces = new Map(
+        data.namespaces.map(([k, v]) => [k, new Set(v)])
+      );
+    } catch {
+    }
+  }
+  /**
+   * Get all vectors
+   */
+  getAll() {
+    return Array.from(this.vectors.values());
+  }
+  /**
+   * Get vector by ID
+   */
+  getById(id) {
+    return this.vectors.get(id);
+  }
+};
+function createMemoryStore(config) {
+  return new MemoryStore(config);
+}
+
+// src/stores/PineconeStore.ts
+var PineconeStore = class extends BaseStore {
+  storeType = "pinecone";
+  client;
+  index;
+  apiKey;
+  indexName;
+  initialized = false;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("Pinecone API key is required");
+    }
+    if (!config.indexName) {
+      throw new Error("Pinecone index name is required");
+    }
+    this.apiKey = config.apiKey;
+    this.indexName = config.indexName;
+  }
+  /**
+   * Initialize Pinecone client
+   */
+  async init() {
+    if (this.initialized) return;
+    try {
+      const { Pinecone } = await import("@pinecone-database/pinecone");
+      this.client = new Pinecone({ apiKey: this.apiKey });
+      this.index = this.client.index(
+        this.indexName
+      );
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize Pinecone: ${error.message}`
+      );
+    }
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  async upsert(records, options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    const batchSize = options?.batchSize ?? 100;
+    const upsertedIds = [];
+    const errors = [];
+    const vectors = records.map((record) => ({
+      id: record.id,
+      values: record.vector,
+      metadata: {
+        ...record.metadata,
+        text: record.text
+      }
+    }));
+    const batches = batch(vectors, batchSize);
+    let completed = 0;
+    for (const batchVectors of batches) {
+      try {
+        const ns = this.index.namespace(namespace);
+        await ns.upsert(
+          batchVectors
+        );
+        upsertedIds.push(...batchVectors.map((v) => v.id));
+      } catch (error) {
+        for (const v of batchVectors) {
+          errors.push({ id: v.id, error: error.message });
+        }
+      }
+      completed += batchVectors.length;
+      options?.onProgress?.({ completed, total: records.length });
+    }
+    return {
+      upsertedIds,
+      upsertedCount: upsertedIds.length,
+      errors,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async query(vector, options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    const topK = options?.topK ?? 10;
+    const ns = this.index.namespace(
+      namespace
+    );
+    const result = await ns.query({
+      vector,
+      topK,
+      filter: options?.filter,
+      includeValues: options?.includeVectors ?? false,
+      includeMetadata: options?.includeMetadata ?? true
+    });
+    const matches = result.matches.map((match) => ({
+      id: match.id,
+      text: match.metadata?.text ?? "",
+      score: match.score,
+      metadata: match.metadata ?? {}
+    }));
+    const filtered = options?.minScore ? matches.filter((m) => m.score >= options.minScore) : matches;
+    return {
+      matches: filtered,
+      namespace,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async delete(ids, options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    const ns = this.index.namespace(
+      namespace
+    );
+    await ns.deleteMany(
+      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 namespace = options?.namespace ?? this.namespace;
+    const before = await this.getStats().catch(() => void 0);
+    const ns = this.index.namespace(
+      namespace
+    );
+    await ns.deleteAll();
+    return {
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async getStats() {
+    await this.ensureInitialized();
+    const stats = await this.index.describeIndexStats();
+    return {
+      type: this.storeType,
+      vectorCount: stats.totalVectorCount ?? 0,
+      namespaceCount: Object.keys(stats.namespaces ?? {}).length,
+      dimensions: stats.dimension,
+      metric: this.metric,
+      lastUpdated: Date.now()
+    };
+  }
+  async checkHealth() {
+    const startTime = performance.now();
+    try {
+      await this.ensureInitialized();
+      await this.index.describeIndexStats();
+      return {
+        healthy: true,
+        latencyMs: performance.now() - startTime,
+        lastCheck: Date.now()
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - startTime,
+        lastCheck: Date.now(),
+        error: error.message
+      };
+    }
+  }
+  async close() {
+    this.initialized = false;
+    return Promise.resolve();
+  }
+};
+function createPineconeStore(config) {
+  return new PineconeStore(config);
+}
+
+// src/stores/ChromaStore.ts
+var ChromaStore = class extends BaseStore {
+  storeType = "chroma";
+  client;
+  collection;
+  collectionName;
+  url;
+  initialized = false;
+  constructor(config) {
+    super(config);
+    if (!config.collectionName) {
+      throw new Error("Chroma collection name is required");
+    }
+    this.collectionName = config.collectionName;
+    this.url = config.url;
+  }
+  /**
+   * Initialize ChromaDB client
+   */
+  async init() {
+    if (this.initialized) return;
+    try {
+      const { ChromaClient } = await import("chromadb");
+      this.client = this.url ? new ChromaClient({ path: this.url }) : new ChromaClient();
+      this.collection = await this.client.getOrCreateCollection({
+        name: this.collectionName,
+        metadata: {
+          "hnsw:space": this.metricToChroma(this.metric)
+        }
+      });
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize ChromaDB: ${error.message}`
+      );
+    }
+  }
+  metricToChroma(metric) {
+    switch (metric) {
+      case "cosine":
+        return "cosine";
+      case "euclidean":
+        return "l2";
+      case "dot_product":
+        return "ip";
+      default:
+        return "cosine";
+    }
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  async upsert(records, _options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const ids = records.map((r) => r.id);
+    const embeddings = records.map((r) => r.vector);
+    const documents = records.map((r) => r.text ?? "");
+    const metadatas = records.map((r) => r.metadata ?? {});
+    const upsertedIds = [];
+    const errors = [];
+    try {
+      await this.collection.upsert({
+        ids,
+        embeddings,
+        documents,
+        metadatas
+      });
+      upsertedIds.push(...ids);
+    } catch (error) {
+      for (const id of ids) {
+        errors.push({ id, error: error.message });
+      }
+    }
+    return {
+      upsertedIds,
+      upsertedCount: upsertedIds.length,
+      errors,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async query(vector, options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const topK = options?.topK ?? 10;
+    const result = await this.collection.query({
+      queryEmbeddings: [vector],
+      nResults: topK,
+      where: options?.filter,
+      include: ["documents", "metadatas", "distances"]
+    });
+    const matches = (result.ids[0] ?? []).map((id, i) => {
+      const distance = result.distances?.[0]?.[i] ?? 0;
+      const score = 1 / (1 + distance);
+      return {
+        id,
+        text: result.documents?.[0]?.[i] ?? "",
+        score,
+        metadata: result.metadatas?.[0]?.[i] ?? {},
+        distance
+      };
+    });
+    const filtered = options?.minScore ? matches.filter((m) => m.score >= options.minScore) : matches;
+    return {
+      matches: filtered,
+      namespace: this.collectionName,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async delete(ids, _options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    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,
+      metadata: {
+        "hnsw:space": this.metricToChroma(this.metric)
+      }
+    });
+    return {
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async getStats() {
+    await this.ensureInitialized();
+    const count = await this.collection.count();
+    return {
+      type: this.storeType,
+      vectorCount: count,
+      namespaceCount: 1,
+      dimensions: this.dimensions ?? 0,
+      metric: this.metric,
+      lastUpdated: Date.now()
+    };
+  }
+  async checkHealth() {
+    const startTime = performance.now();
+    try {
+      await this.ensureInitialized();
+      await this.collection.count();
+      return {
+        healthy: true,
+        latencyMs: performance.now() - startTime,
+        lastCheck: Date.now()
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - startTime,
+        lastCheck: Date.now(),
+        error: error.message
+      };
+    }
+  }
+  async close() {
+    this.initialized = false;
+    return Promise.resolve();
+  }
+};
+function createChromaStore(config) {
+  return new ChromaStore(config);
+}
+
+// src/stores/QdrantStore.ts
+var QdrantStore = class extends BaseStore {
+  storeType = "qdrant";
+  client;
+  collectionName;
+  url;
+  apiKey;
+  initialized = false;
+  constructor(config) {
+    super(config);
+    if (!config.url) {
+      throw new Error("Qdrant URL is required");
+    }
+    if (!config.collectionName) {
+      throw new Error("Qdrant collection name is required");
+    }
+    this.url = config.url;
+    this.collectionName = config.collectionName;
+    this.apiKey = config.apiKey;
+  }
+  /**
+   * Initialize Qdrant client
+   */
+  async init() {
+    if (this.initialized) return;
+    try {
+      const { QdrantClient } = await import("@qdrant/js-client-rest");
+      this.client = new QdrantClient({
+        url: this.url,
+        apiKey: this.apiKey
+      });
+      const collections = await this.client.getCollections();
+      const exists = collections.collections.some(
+        (c) => c.name === this.collectionName
+      );
+      if (!exists && this.dimensions) {
+        await this.client.createCollection(this.collectionName, {
+          vectors: {
+            size: this.dimensions,
+            distance: this.metricToQdrant(this.metric)
+          }
+        });
+      }
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize Qdrant: ${error.message}`
+      );
+    }
+  }
+  metricToQdrant(metric) {
+    switch (metric) {
+      case "cosine":
+        return "Cosine";
+      case "euclidean":
+        return "Euclid";
+      case "dot_product":
+        return "Dot";
+      default:
+        return "Cosine";
+    }
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  async upsert(records, options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const batchSize = options?.batchSize ?? 100;
+    const upsertedIds = [];
+    const errors = [];
+    const points = records.map((record) => ({
+      id: record.id,
+      vector: record.vector,
+      payload: {
+        ...record.metadata,
+        text: record.text
+      }
+    }));
+    const batches = batch(points, batchSize);
+    let completed = 0;
+    for (const batchPoints of batches) {
+      try {
+        await this.client.upsert(this.collectionName, {
+          points: batchPoints
+        });
+        upsertedIds.push(...batchPoints.map((p) => p.id));
+      } catch (error) {
+        for (const p of batchPoints) {
+          errors.push({ id: p.id, error: error.message });
+        }
+      }
+      completed += batchPoints.length;
+      options?.onProgress?.({ completed, total: records.length });
+    }
+    return {
+      upsertedIds,
+      upsertedCount: upsertedIds.length,
+      errors,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async query(vector, options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const topK = options?.topK ?? 10;
+    const result = await this.client.search(this.collectionName, {
+      vector,
+      limit: topK,
+      filter: options?.filter ? this.buildQdrantFilter(options.filter) : void 0,
+      with_payload: options?.includeMetadata ?? true,
+      with_vector: options?.includeVectors ?? false,
+      score_threshold: options?.minScore
+    });
+    const matches = result.map((point) => ({
+      id: point.id.toString(),
+      text: point.payload?.text ?? "",
+      score: point.score,
+      metadata: point.payload ?? {}
+    }));
+    return {
+      matches,
+      namespace: this.collectionName,
+      durationMs: performance.now() - startTime
+    };
+  }
+  buildQdrantFilter(filter) {
+    const must = [];
+    for (const [key, value] of Object.entries(filter)) {
+      must.push({
+        key,
+        match: { value }
+      });
+    }
+    return { must };
+  }
+  async delete(ids, _options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    await this.client.delete(this.collectionName, {
+      points: 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(this.collectionName);
+    if (this.dimensions) {
+      await this.client.createCollection(this.collectionName, {
+        vectors: {
+          size: this.dimensions,
+          distance: this.metricToQdrant(this.metric)
+        }
+      });
+    }
+    return {
+      deletedCount: before?.vectorCount ?? 0,
+      requestedCount: before?.vectorCount,
+      countExact: before !== void 0,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async getStats() {
+    await this.ensureInitialized();
+    const info = await this.client.getCollection(this.collectionName);
+    return {
+      type: this.storeType,
+      vectorCount: info.vectors_count,
+      namespaceCount: 1,
+      dimensions: info.config?.params?.vectors?.size,
+      metric: this.metric,
+      lastUpdated: Date.now()
+    };
+  }
+  async checkHealth() {
+    const startTime = performance.now();
+    try {
+      await this.ensureInitialized();
+      await this.client.getCollection(this.collectionName);
+      return {
+        healthy: true,
+        latencyMs: performance.now() - startTime,
+        lastCheck: Date.now()
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - startTime,
+        lastCheck: Date.now(),
+        error: error.message
+      };
+    }
+  }
+  async close() {
+    this.initialized = false;
+    return Promise.resolve();
+  }
+};
+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;
+  }
+};
+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) {
+    case "memory":
+      return new MemoryStore(config);
+    case "pinecone":
+      return new PineconeStore(config);
+    case "chroma":
+      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:
+      throw new Error(
+        `Unknown vector store type "${String(type)}". Supported stores: memory, pinecone, chroma, qdrant, weaviate, milvus, pgvector.`
+      );
+  }
+}
+
+export {
+  BaseStore,
+  MemoryStore,
+  createMemoryStore,
+  PineconeStore,
+  createPineconeStore,
+  ChromaStore,
+  createChromaStore,
+  QdrantStore,
+  createQdrantStore,
+  PgVectorStore,
+  createPgVectorStore,
+  WeaviateStore,
+  WeaviateSdkBackend,
+  createWeaviateStore,
+  MilvusStore,
+  MilvusSdkBackend,
+  createMilvusStore,
+  createStore
+};