@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/stores/index.js

@@ -0,0 +1,1178 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/stores/index.ts
+var stores_exports = {};
+__export(stores_exports, {
+  BaseStore: () => BaseStore,
+  ChromaStore: () => ChromaStore,
+  MemoryStore: () => MemoryStore,
+  PineconeStore: () => PineconeStore,
+  QdrantStore: () => QdrantStore,
+  createChromaStore: () => createChromaStore,
+  createMemoryStore: () => createMemoryStore,
+  createPineconeStore: () => createPineconeStore,
+  createQdrantStore: () => createQdrantStore,
+  createStore: () => createStore
+});
+module.exports = __toCommonJS(stores_exports);
+
+// src/core/EmbeddingModel.ts
+var EmbeddingModel = class {
+  /**
+   * Get model dimensions
+   */
+  get dimensions() {
+    return this.info.dimensions;
+  }
+  /**
+   * Get max tokens
+   */
+  get maxTokens() {
+    return this.info.maxTokens;
+  }
+  /**
+   * Get max batch size
+   */
+  get maxBatchSize() {
+    return this.info.maxBatchSize;
+  }
+  /**
+   * Get model name
+   */
+  get name() {
+    return this.info.name;
+  }
+  /**
+   * Get provider name
+   */
+  get provider() {
+    return this.info.provider;
+  }
+  /**
+   * Count tokens in text (default implementation)
+   * Subclasses should override for accurate counting
+   */
+  countTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Check if text exceeds max tokens
+   */
+  exceedsMaxTokens(text) {
+    return this.countTokens(text) > this.maxTokens;
+  }
+  /**
+   * Truncate text to max tokens
+   */
+  truncateToMaxTokens(text) {
+    const tokens = this.countTokens(text);
+    if (tokens <= this.maxTokens) {
+      return text;
+    }
+    const ratio = this.maxTokens / tokens;
+    const targetLength = Math.floor(text.length * ratio * 0.95);
+    return text.slice(0, targetLength);
+  }
+  /**
+   * Calculate similarity between two vectors
+   */
+  static cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    if (magnitude === 0) {
+      return 0;
+    }
+    return dotProduct / magnitude;
+  }
+  /**
+   * Calculate Euclidean distance between two vectors
+   */
+  static euclideanDistance(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions mismatch: ${a.length} vs ${b.length}`);
+    }
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+      const diff = a[i] - b[i];
+      sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+  }
+  /**
+   * Calculate dot product of two vectors
+   */
+  static dotProduct(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions mismatch: ${a.length} vs ${b.length}`);
+    }
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result += a[i] * b[i];
+    }
+    return result;
+  }
+  /**
+   * Normalize a vector to unit length
+   */
+  static normalize(vector) {
+    let norm = 0;
+    for (let i = 0; i < vector.length; i++) {
+      norm += vector[i] * vector[i];
+    }
+    norm = Math.sqrt(norm);
+    if (norm === 0) {
+      return vector.slice();
+    }
+    return vector.map((v) => v / norm);
+  }
+  /**
+   * Average multiple vectors
+   */
+  static average(vectors) {
+    if (vectors.length === 0) {
+      throw new Error("Cannot average empty array of vectors");
+    }
+    const dimensions = vectors[0].length;
+    const result = new Array(dimensions).fill(0);
+    for (const vector of vectors) {
+      if (vector.length !== dimensions) {
+        throw new Error(
+          `Vector dimensions mismatch: expected ${dimensions}, got ${vector.length}`
+        );
+      }
+      for (let i = 0; i < dimensions; i++) {
+        result[i] += vector[i];
+      }
+    }
+    for (let i = 0; i < dimensions; i++) {
+      result[i] /= vectors.length;
+    }
+    return result;
+  }
+  /**
+   * Weighted average of vectors
+   */
+  static weightedAverage(vectors, weights) {
+    if (vectors.length === 0) {
+      throw new Error("Cannot average empty array of vectors");
+    }
+    if (vectors.length !== weights.length) {
+      throw new Error("Vectors and weights arrays must have same length");
+    }
+    const dimensions = vectors[0].length;
+    const result = new Array(dimensions).fill(0);
+    let totalWeight = 0;
+    for (let j = 0; j < vectors.length; j++) {
+      const vector = vectors[j];
+      const weight = weights[j];
+      totalWeight += weight;
+      if (vector.length !== dimensions) {
+        throw new Error(
+          `Vector dimensions mismatch: expected ${dimensions}, got ${vector.length}`
+        );
+      }
+      for (let i = 0; i < dimensions; i++) {
+        result[i] += vector[i] * weight;
+      }
+    }
+    if (totalWeight === 0) {
+      throw new Error("Total weight cannot be zero");
+    }
+    for (let i = 0; i < dimensions; i++) {
+      result[i] /= totalWeight;
+    }
+    return result;
+  }
+};
+var ModelRegistry = class {
+  models = /* @__PURE__ */ new Map();
+  defaultModel = null;
+  /**
+   * Register a model
+   */
+  register(model, isDefault = false) {
+    const key = `${model.provider}:${model.name}`;
+    this.models.set(key, model);
+    if (isDefault || this.defaultModel === null) {
+      this.defaultModel = key;
+    }
+  }
+  /**
+   * Get a model by provider and name
+   */
+  get(provider, name) {
+    return this.models.get(`${provider}:${name}`);
+  }
+  /**
+   * Get model by key
+   */
+  getByKey(key) {
+    return this.models.get(key);
+  }
+  /**
+   * Get the default model
+   */
+  getDefault() {
+    if (this.defaultModel === null) {
+      return void 0;
+    }
+    return this.models.get(this.defaultModel);
+  }
+  /**
+   * Set default model
+   */
+  setDefault(provider, name) {
+    const key = `${provider}:${name}`;
+    if (!this.models.has(key)) {
+      throw new Error(`Model ${key} not found in registry`);
+    }
+    this.defaultModel = key;
+  }
+  /**
+   * List all registered models
+   */
+  list() {
+    return Array.from(this.models.values()).map((m) => m.info);
+  }
+  /**
+   * Check if a model is registered
+   */
+  has(provider, name) {
+    return this.models.has(`${provider}:${name}`);
+  }
+  /**
+   * Remove a model
+   */
+  remove(provider, name) {
+    const key = `${provider}:${name}`;
+    if (this.defaultModel === key) {
+      this.defaultModel = null;
+    }
+    return this.models.delete(key);
+  }
+  /**
+   * Clear all models
+   */
+  clear() {
+    this.models.clear();
+    this.defaultModel = null;
+  }
+};
+var modelRegistry = new ModelRegistry();
+
+// 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
+var fs = __toESM(require("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,
+      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,
+        durationMs: performance.now() - startTime
+      });
+    }
+    const nsIds = this.namespaces.get(namespace);
+    if (!nsIds) {
+      return Promise.resolve({
+        deletedCount: 0,
+        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,
+      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/core/utils.ts
+function batch(items, batchSize) {
+  const batches = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    batches.push(items.slice(i, i + batchSize));
+  }
+  return batches;
+}
+
+// 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,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async deleteAll(options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    const namespace = options?.namespace ?? this.namespace;
+    const ns = this.index.namespace(
+      namespace
+    );
+    await ns.deleteAll();
+    return {
+      deletedCount: -1,
+      // Unknown count
+      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,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async deleteAll(_options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    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: -1,
+      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,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async deleteAll(_options) {
+    await this.ensureInitialized();
+    const startTime = performance.now();
+    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: -1,
+      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/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);
+    default:
+      return new MemoryStore(config);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseStore,
+  ChromaStore,
+  MemoryStore,
+  PineconeStore,
+  QdrantStore,
+  createChromaStore,
+  createMemoryStore,
+  createPineconeStore,
+  createQdrantStore,
+  createStore
+});