@retrivora-ai/rag-engine 1.8.1 → 1.8.3

package/dist/SimpleGraphProvider-SLOXO4M7.mjs

@@ -1,62 +0,0 @@
-import "./chunk-X4TOT24V.mjs";
-
-// src/providers/graphdb/BaseGraphProvider.ts
-var BaseGraphProvider = class {
-  constructor(config) {
-    this.config = config;
-  }
-};
-
-// src/providers/graphdb/SimpleGraphProvider.ts
-var SimpleGraphProvider = class extends BaseGraphProvider {
-  constructor() {
-    super(...arguments);
-    this.nodes = /* @__PURE__ */ new Map();
-    this.edges = [];
-  }
-  async initialize() {
-    console.log("[SimpleGraphProvider] Initialised in-memory graph store.");
-  }
-  async addNodes(nodes) {
-    for (const node of nodes) {
-      this.nodes.set(node.id, node);
-    }
-  }
-  async addEdges(edges) {
-    this.edges.push(...edges);
-  }
-  async query(queryText, limit = 5) {
-    const q = queryText.toLowerCase();
-    const matchedNodes = Array.from(this.nodes.values()).filter(
-      (node) => node.id.toLowerCase().includes(q) || node.label.toLowerCase().includes(q) || JSON.stringify(node.properties).toLowerCase().includes(q)
-    ).slice(0, limit);
-    const matchedNodeIds = new Set(matchedNodes.map((n) => n.id));
-    const matchedEdges = this.edges.filter(
-      (edge) => matchedNodeIds.has(edge.source) || matchedNodeIds.has(edge.target)
-    );
-    for (const edge of matchedEdges) {
-      if (!matchedNodeIds.has(edge.source)) {
-        const source = this.nodes.get(edge.source);
-        if (source) matchedNodes.push(source);
-      }
-      if (!matchedNodeIds.has(edge.target)) {
-        const target = this.nodes.get(edge.target);
-        if (target) matchedNodes.push(target);
-      }
-    }
-    return {
-      nodes: Array.from(new Set(matchedNodes)),
-      edges: matchedEdges
-    };
-  }
-  async ping() {
-    return true;
-  }
-  async disconnect() {
-    this.nodes.clear();
-    this.edges = [];
-  }
-};
-export {
-  SimpleGraphProvider
-};

package/dist/UniversalVectorProvider-IN67OS56.mjs

@@ -1,9 +0,0 @@
-import {
-  UniversalVectorProvider
-} from "./chunk-LR3VMDVK.mjs";
-import "./chunk-YLTMFW4M.mjs";
-import "./chunk-IMP6FUCY.mjs";
-import "./chunk-X4TOT24V.mjs";
-export {
-  UniversalVectorProvider
-};

package/dist/WeaviateProvider-5FWDFITI.mjs

@@ -1,8 +0,0 @@
-import {
-  WeaviateProvider
-} from "./chunk-M6JSPGAR.mjs";
-import "./chunk-IMP6FUCY.mjs";
-import "./chunk-X4TOT24V.mjs";
-export {
-  WeaviateProvider
-};

package/dist/chunk-5AJ4XHLW.mjs

@@ -1,201 +0,0 @@
-import {
-  BaseVectorProvider
-} from "./chunk-IMP6FUCY.mjs";
-import {
-  __spreadValues
-} from "./chunk-X4TOT24V.mjs";
-
-// src/providers/vectordb/MongoDBProvider.ts
-import { MongoClient } from "mongodb";
-var MongoDBProvider = class extends BaseVectorProvider {
-  constructor(config) {
-    super(config);
-    const opts = config.options;
-    if (!opts.uri || !opts.database || !opts.collection) {
-      throw new Error("[MongoDBProvider] options uri, database, and collection are required.");
-    }
-    this.client = new MongoClient(opts.uri, { serverSelectionTimeoutMS: 5e3 });
-    this.dbName = opts.database;
-    this.collectionName = opts.collection;
-    this.embeddingKey = opts.embeddingKey || "embedding";
-    this.contentKey = opts.contentKey || "content";
-    this.metadataKey = opts.metadataKey || "metadata";
-  }
-  static getValidator() {
-    return {
-      validate(config) {
-        const errors = [];
-        const opts = config.options || {};
-        if (!opts.uri) {
-          errors.push({
-            field: "vectorDb.options.uri",
-            message: "MongoDB connection URI is required",
-            suggestion: "Set MONGODB_URI environment variable",
-            severity: "error"
-          });
-        }
-        if (!opts.database) {
-          errors.push({
-            field: "vectorDb.options.database",
-            message: "MongoDB database name is required",
-            severity: "error"
-          });
-        }
-        if (!opts.collection) {
-          errors.push({
-            field: "vectorDb.options.collection",
-            message: "MongoDB collection name is required",
-            severity: "error"
-          });
-        }
-        return errors;
-      }
-    };
-  }
-  static getHealthChecker() {
-    return {
-      async check(config) {
-        const opts = config.options || {};
-        const timestamp = Date.now();
-        try {
-          const { MongoClient: MongoClient2 } = await import("mongodb");
-          const client = new MongoClient2(opts.uri);
-          await client.connect();
-          const db = client.db(opts.database);
-          await db.command({ ping: 1 });
-          const collections = await db.listCollections({ name: opts.collection }).toArray();
-          await client.close();
-          return {
-            healthy: true,
-            provider: "mongodb",
-            capabilities: {
-              database: opts.database,
-              collection: opts.collection,
-              exists: collections.length > 0
-            },
-            timestamp
-          };
-        } catch (error) {
-          return {
-            healthy: false,
-            provider: "mongodb",
-            error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-            timestamp
-          };
-        }
-      }
-    };
-  }
-  async initialize() {
-    await this.client.connect();
-    this.db = this.client.db(this.dbName);
-    this.collection = this.db.collection(this.collectionName);
-  }
-  async upsert(doc, namespace) {
-    const document = __spreadValues({
-      _id: doc.id,
-      [this.embeddingKey]: doc.vector,
-      [this.contentKey]: doc.content,
-      [this.metadataKey]: doc.metadata || {}
-    }, namespace ? { namespace } : {});
-    await this.collection.updateOne({ _id: doc.id }, { $set: document }, { upsert: true });
-  }
-  async batchUpsert(docs, namespace) {
-    const operations = docs.map((doc) => ({
-      updateOne: {
-        filter: { _id: doc.id },
-        update: {
-          $set: __spreadValues({
-            [this.embeddingKey]: doc.vector,
-            [this.contentKey]: doc.content,
-            [this.metadataKey]: doc.metadata || {}
-          }, namespace ? { namespace } : {})
-        },
-        upsert: true
-      }
-    }));
-    await this.collection.bulkWrite(operations);
-  }
-  async query(vector, topK, namespace, filter) {
-    const publicFilter = this.sanitizeFilter(filter);
-    const vectorSearchFilter = {};
-    const matchFilter = {};
-    if (namespace) {
-      vectorSearchFilter.namespace = namespace;
-    }
-    for (const [key, value] of Object.entries(publicFilter)) {
-      if (key === "namespace") {
-        vectorSearchFilter.namespace = value;
-      } else {
-        matchFilter[key] = value;
-      }
-    }
-    const pipeline = [
-      {
-        $vectorSearch: __spreadValues({
-          index: this.config.indexName || "vector_index",
-          path: this.embeddingKey,
-          queryVector: vector,
-          numCandidates: this.config.options.numCandidates || Math.max(topK * 20, 200),
-          limit: topK * 2
-        }, Object.keys(vectorSearchFilter).length > 0 ? { filter: vectorSearchFilter } : {})
-      }
-    ];
-    if (Object.keys(matchFilter).length > 0) {
-      pipeline.push({ $match: matchFilter });
-    }
-    pipeline.push(
-      { $limit: topK },
-      {
-        $project: {
-          _id: 1,
-          [this.contentKey]: 1,
-          [this.metadataKey]: 1,
-          namespace: 1,
-          score: { $meta: "vectorSearchScore" }
-        }
-      }
-    );
-    const results = await this.collection.aggregate(pipeline).toArray();
-    return results.map((res) => ({
-      id: res._id,
-      content: res[this.contentKey],
-      metadata: res[this.metadataKey] || {},
-      score: res.score
-    }));
-  }
-  async delete(id, namespace) {
-    await this.collection.deleteOne(__spreadValues({ _id: id }, namespace ? { namespace } : {}));
-  }
-  async deleteNamespace(namespace) {
-    await this.collection.deleteMany({ namespace });
-  }
-  sanitizeFilter(filter) {
-    const sanitized = super.sanitizeFilter(filter);
-    const mongoFilter = {};
-    for (const [key, value] of Object.entries(sanitized)) {
-      if (key.startsWith("__") || key === "keywords" || key === "queryText") continue;
-      if (key === "namespace") {
-        mongoFilter[key] = value;
-      } else {
-        mongoFilter[`${this.metadataKey}.${key}`] = value;
-      }
-    }
-    return mongoFilter;
-  }
-  async ping() {
-    try {
-      await this.db.command({ ping: 1 });
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  async disconnect() {
-    await this.client.close();
-  }
-};
-
-export {
-  MongoDBProvider
-};

package/dist/chunk-5YGUXK7Z.mjs

@@ -1,80 +0,0 @@
-import {
-  BaseVectorProvider
-} from "./chunk-IMP6FUCY.mjs";
-import {
-  __spreadValues
-} from "./chunk-X4TOT24V.mjs";
-
-// src/providers/vectordb/RedisProvider.ts
-import axios from "axios";
-var RedisProvider = class extends BaseVectorProvider {
-  constructor(config) {
-    super(config);
-    const opts = config.options;
-    const baseUrl = opts.baseUrl || opts.url || (opts.host ? `http://${opts.host}:${opts.port || 6379}` : void 0);
-    if (!baseUrl) throw new Error("[RedisProvider] options.baseUrl is required");
-    this.http = axios.create({
-      baseURL: baseUrl,
-      headers: __spreadValues({
-        "Content-Type": "application/json"
-      }, opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {})
-    });
-  }
-  async initialize() {
-    await this.ping();
-  }
-  async upsert(doc, namespace) {
-    const key = namespace ? `${namespace}:${doc.id}` : String(doc.id);
-    await this.http.post("/", ["JSON.SET", key, "$", JSON.stringify({
-      vector: doc.vector,
-      content: doc.content,
-      metadata: doc.metadata || {}
-    })]);
-  }
-  async batchUpsert(docs, namespace) {
-    for (const doc of docs) {
-      await this.upsert(doc, namespace);
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async query(vector, topK, namespace, _filter) {
-    const payload = {
-      index: this.indexName,
-      vector,
-      topK,
-      namespace
-    };
-    const { data } = await this.http.post("/search", payload);
-    return (data.results || []).map((res) => ({
-      id: res["id"],
-      score: res["score"],
-      content: res["content"],
-      metadata: res["metadata"] || {}
-    }));
-  }
-  async delete(id, namespace) {
-    const key = namespace ? `${namespace}:${id}` : id;
-    await this.http.post("/", ["DEL", key]);
-  }
-  async deleteNamespace(namespace) {
-    console.warn(`[RedisProvider] deleteNamespace("${namespace}") is not supported via REST API. Use Redis CLI: SCAN + DEL`);
-  }
-  /**
-   * Redis is TCP-based and has no HTTP health endpoint.
-   * Returns true; actual connectivity is validated on the first operation.
-   */
-  async ping() {
-    try {
-      await this.http.post("/", ["PING"]);
-      return true;
-    } catch (e) {
-      return true;
-    }
-  }
-  async disconnect() {
-  }
-};
-
-export {
-  RedisProvider
-};