@retrivora-ai/rag-engine 0.4.5 → 1.0.0

package/dist/handlers/index.js

@@ -9,6 +9,7 @@ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -46,6 +47,22 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k, call, wait, clear) => it[k] = (x) => (call = new Promise((yes, no, run) => (run = () => resume(k, x, yes, no), q ? q.then(run) : run())), clear = () => q === wait && (q = 0), q = wait = call.then(clear, clear), call), q, it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 
 // src/utils/templateUtils.ts
 function isRecord(value) {
@@ -143,6 +160,60 @@ var init_PineconeProvider = __esm({
         if (!opts.apiKey) throw new Error("[PineconeProvider] options.apiKey is required");
         this.apiKey = opts.apiKey;
       }
+      static getValidator() {
+        return {
+          validate(config) {
+            const errors = [];
+            const opts = config.options || {};
+            if (!opts.apiKey) {
+              errors.push({
+                field: "vectorDb.options.apiKey",
+                message: "Pinecone API key is required",
+                suggestion: "Set PINECONE_API_KEY environment variable",
+                severity: "error"
+              });
+            }
+            return errors;
+          }
+        };
+      }
+      static getHealthChecker() {
+        return {
+          async check(config) {
+            var _a, _b;
+            const opts = config.options || {};
+            const indexName = config.indexName;
+            const timestamp = Date.now();
+            try {
+              const { Pinecone: Pinecone2 } = await import("@pinecone-database/pinecone");
+              const client = new Pinecone2({ apiKey: opts.apiKey });
+              const indexes = await client.listIndexes();
+              const indexNames = (_b = (_a = indexes.indexes) == null ? void 0 : _a.map((i) => i.name)) != null ? _b : [];
+              if (!indexNames.includes(indexName)) {
+                return {
+                  healthy: false,
+                  provider: "pinecone",
+                  error: `Index "${indexName}" not found. Available: ${indexNames.join(", ")}`,
+                  timestamp
+                };
+              }
+              return {
+                healthy: true,
+                provider: "pinecone",
+                capabilities: { indexes: indexNames.length, targetIndex: indexName },
+                timestamp
+              };
+            } catch (error) {
+              return {
+                healthy: false,
+                provider: "pinecone",
+                error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp
+              };
+            }
+          }
+        };
+      }
       async initialize() {
         var _a, _b;
         this.client = new import_pinecone.Pinecone({ apiKey: this.apiKey });
@@ -241,6 +312,61 @@ var init_PostgreSQLProvider = __esm({
         this.connectionString = opts.connectionString;
         this.dimensions = (_a = opts.dimensions) != null ? _a : 1536;
       }
+      static getValidator() {
+        return {
+          validate(config) {
+            const errors = [];
+            const opts = config.options || {};
+            if (!opts.connectionString) {
+              errors.push({
+                field: "vectorDb.options.connectionString",
+                message: "PostgreSQL connection string is required",
+                suggestion: "Set PGVECTOR_CONNECTION_STRING environment variable",
+                severity: "error"
+              });
+            }
+            if (opts.tables && typeof opts.tables !== "string" && !Array.isArray(opts.tables)) {
+              errors.push({
+                field: "vectorDb.options.tables",
+                message: "PostgreSQL tables must be a string or a string array",
+                severity: "error"
+              });
+            }
+            return errors;
+          }
+        };
+      }
+      static getHealthChecker() {
+        return {
+          async check(config) {
+            const opts = config.options || {};
+            const timestamp = Date.now();
+            try {
+              const { Client } = await import("pg");
+              const client = new Client({ connectionString: opts.connectionString });
+              await client.connect();
+              const result = await client.query(`
+            SELECT EXISTS(SELECT 1 FROM pg_extension WHERE extname = 'vector');
+          `);
+              const hasVector = result.rows[0].exists;
+              await client.end();
+              return {
+                healthy: true,
+                provider: "postgresql",
+                capabilities: { pgvectorInstalled: hasVector },
+                timestamp
+              };
+            } catch (error) {
+              return {
+                healthy: false,
+                provider: "postgresql",
+                error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp
+              };
+            }
+          }
+        };
+      }
       async initialize() {
         this.pool = new import_pg.Pool({ connectionString: this.connectionString });
         const client = await this.pool.connect();
@@ -326,20 +452,27 @@ var init_PostgreSQLProvider = __esm({
           }).join(" AND ");
           whereClause = whereClause ? `${whereClause} AND ${filterConditions}` : `WHERE ${filterConditions}`;
         }
-        const result = await this.pool.query(
-          `SELECT id, content, metadata, 1 - (embedding <=> $1::vector) AS score
-       FROM ${this.tableName}
-       ${whereClause}
-       ORDER BY embedding <=> $1::vector
-       LIMIT $2`,
-          params
-        );
-        return result.rows.map((row) => ({
-          id: String(row["id"]),
-          score: parseFloat(String(row["score"])),
-          content: String(row["content"]),
-          metadata: row["metadata"]
-        }));
+        const client = await this.pool.connect();
+        try {
+          const efSearch = this.config.options.efSearch || Math.max(topK * 10, 40);
+          await client.query(`SET LOCAL hnsw.ef_search = ${efSearch}`);
+          const result = await client.query(
+            `SELECT id, content, metadata, 1 - (embedding <=> $1::vector) AS score
+         FROM ${this.tableName}
+         ${whereClause}
+         ORDER BY embedding <=> $1::vector
+         LIMIT $2`,
+            params
+          );
+          return result.rows.map((row) => ({
+            id: String(row["id"]),
+            score: parseFloat(String(row["score"])),
+            content: String(row["content"]),
+            metadata: row["metadata"]
+          }));
+        } finally {
+          client.release();
+        }
       }
       async delete(id, namespace) {
         const where = namespace ? "WHERE id = $1 AND namespace = $2" : "WHERE id = $1";
@@ -389,6 +522,71 @@ var init_MongoDBProvider = __esm({
         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);
@@ -427,7 +625,7 @@ var init_MongoDBProvider = __esm({
               index: this.config.indexName || "vector_index",
               path: this.embeddingKey,
               queryVector: vector,
-              numCandidates: Math.max(topK * 10, 100),
+              numCandidates: this.config.options.numCandidates || Math.max(topK * 20, 200),
               limit: topK
             }, Object.keys(publicFilter).length > 0 || namespace ? { filter: __spreadValues(__spreadValues({}, publicFilter), namespace ? { namespace } : {}) } : {})
           },
@@ -455,10 +653,6 @@ var init_MongoDBProvider = __esm({
       async deleteNamespace(namespace) {
         await this.collection.deleteMany({ namespace });
       }
-      /**
-       * Sanitise and flatten filter for MongoDB.
-       * Strips internal engine fields and keywords.
-       */
       sanitizeFilter(filter) {
         const sanitized = super.sanitizeFilter(filter);
         const mongoFilter = {};
@@ -543,7 +737,11 @@ var init_MilvusProvider = __esm({
           vector,
           limit: topK,
           filter: namespace ? `namespace == "${namespace}"` : void 0,
-          outputFields: ["content", "metadata"]
+          outputFields: ["content", "metadata"],
+          searchParams: {
+            nprobe: this.config.options.nprobe || 16,
+            ef: this.config.options.efSearch || Math.max(topK * 10, 64)
+          }
         };
         const { data } = await this.http.post("/v1/vector/search", payload);
         return (data.data || []).map((res) => ({
@@ -683,6 +881,10 @@ var init_QdrantProvider = __esm({
           vector,
           limit: topK,
           with_payload: true,
+          params: {
+            hnsw_ef: this.config.options.efSearch || Math.max(topK * 20, 128),
+            exact: false
+          },
           filter: namespace ? {
             must: [{ key: "namespace", match: { value: namespace } }]
           } : void 0
@@ -978,17 +1180,17 @@ var init_WeaviateProvider = __esm({
         };
         await this.http.post("/v1/batch/objects", payload);
       }
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       async query(vector, topK, namespace, _filter) {
         var _a, _b;
+        const sanitizedFilter = this.sanitizeFilter(_filter);
+        const queryText = sanitizedFilter.queryText;
+        const searchParams = queryText ? `hybrid: { query: ${JSON.stringify(queryText)}, alpha: 0.5 }` : `nearVector: { vector: ${JSON.stringify(vector)} }`;
         const graphqlQuery = {
           query: `
         {
           Get {
             ${this.indexName}(
-              nearVector: {
-                vector: ${JSON.stringify(vector)}
-              }
+              ${searchParams}
               limit: ${topK}
               ${namespace ? `where: { path: ["namespace"], operator: Equal, valueString: "${namespace}" }` : ""}
             ) {
@@ -1321,7 +1523,6 @@ var PROVIDERS_WITH_EMBEDDINGS = [
   "rest",
   "universal_rest"
 ];
-var UI_VISUAL_STYLES = ["glass", "solid"];
 var UI_BORDER_RADIUS_OPTIONS = ["none", "sm", "md", "lg", "xl", "full"];
 
 // src/config/serverConfig.ts
@@ -1499,657 +1700,68 @@ var ConfigResolver = class {
   }
 };
 
-// src/core/ConfigValidator.ts
-var ConfigValidator = class {
-  /**
-   * Validates the entire RagConfig object.
-   * Returns an array of validation errors. Empty array = valid config.
-   */
-  static validate(config) {
-    const errors = [];
-    if (!config.projectId) {
-      errors.push({
-        field: "projectId",
-        message: "projectId is required",
-        severity: "error"
-      });
-    }
-    errors.push(...this.validateVectorDbConfig(config.vectorDb));
-    errors.push(...this.validateLLMConfig(config.llm));
-    if (config.embedding) {
-      errors.push(...this.validateEmbeddingConfig(config.embedding));
-    } else if (config.llm.provider === "anthropic") {
-      errors.push({
-        field: "embedding",
-        message: "Embedding config is required when using Anthropic LLM",
-        suggestion: 'Provide embedding config with provider (e.g., "openai" or "ollama")',
-        severity: "error"
-      });
-    }
-    if (config.ui) {
-      errors.push(...this.validateUIConfig(config.ui));
-    }
-    if (config.rag) {
-      errors.push(...this.validateRAGConfig(config.rag));
-    }
-    return errors;
-  }
-  static validateVectorDbConfig(config) {
-    const errors = [];
-    if (!config.provider) {
-      errors.push({
-        field: "vectorDb.provider",
-        message: "Vector database provider is required",
-        severity: "error"
-      });
-      return errors;
-    }
-    if (!config.indexName) {
-      errors.push({
-        field: "vectorDb.indexName",
-        message: "Vector database index name is required",
-        severity: "error"
-      });
-    }
-    switch (config.provider) {
-      case "pinecone":
-        errors.push(...this.validatePineconeConfig(config));
-        break;
-      case "pgvector":
-      case "postgresql":
-        errors.push(...this.validatePostgresConfig(config));
-        break;
-      case "mongodb":
-        errors.push(...this.validateMongoDBConfig(config));
-        break;
-      case "milvus":
-        errors.push(...this.validateMilvusConfig(config));
-        break;
-      case "qdrant":
-        errors.push(...this.validateQdrantConfig(config));
-        break;
-      case "chromadb":
-        errors.push(...this.validateChromaDBConfig(config));
-        break;
-      case "redis":
-        errors.push(...this.validateRedisConfig(config));
-        break;
-      case "weaviate":
-        errors.push(...this.validateWeaviateConfig(config));
-        break;
-      case "universal_rest":
-      case "rest":
-        errors.push(...this.validateRestConfig(config));
-        break;
-    }
-    return errors;
-  }
-  /**
-   * Pinecone — only needs apiKey (environment was removed in SDK v7+).
-   * Options key: { apiKey: string }
-   */
-  static validatePineconeConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    if (!opts.apiKey) {
-      errors.push({
-        field: "vectorDb.options.apiKey",
-        message: "Pinecone API key is required",
-        suggestion: "Set PINECONE_API_KEY environment variable",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * PostgreSQL / pgvector — needs a connection string.
-   * Options key: { connectionString: string }
-   */
-  static validatePostgresConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    if (!opts.connectionString) {
-      errors.push({
-        field: "vectorDb.options.connectionString",
-        message: "PostgreSQL connection string is required",
-        suggestion: "Set PGVECTOR_CONNECTION_STRING environment variable",
-        severity: "error"
-      });
-    }
-    if (opts.tables && typeof opts.tables !== "string" && !Array.isArray(opts.tables)) {
-      errors.push({
-        field: "vectorDb.options.tables",
-        message: "PostgreSQL tables must be a string or a string array",
-        severity: "error"
-      });
-    }
-    if (opts.searchFields && typeof opts.searchFields !== "string" && !Array.isArray(opts.searchFields)) {
-      errors.push({
-        field: "vectorDb.options.searchFields",
-        message: "PostgreSQL searchFields must be a string or a string array",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * MongoDB — needs uri, database, and collection.
-   * Options keys: { uri: string, database: string, collection: string }
-   */
-  static validateMongoDBConfig(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",
-        suggestion: "Set MONGODB_DB environment variable",
-        severity: "error"
-      });
-    }
-    if (!opts.collection) {
-      errors.push({
-        field: "vectorDb.options.collection",
-        message: "MongoDB collection name is required",
-        suggestion: "Set MONGODB_COLLECTION environment variable",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Milvus — accepts baseUrl OR uri (preferred) OR host+port.
-   * MilvusProvider reads opts.baseUrl ?? opts.uri.
-   * Options keys: { baseUrl?: string, uri?: string, host?: string, port?: number }
-   */
-  static validateMilvusConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    const hasBaseUrl = Boolean(opts.baseUrl || opts.uri);
-    const hasHostPort = Boolean(opts.host && opts.port);
-    if (!hasBaseUrl && !hasHostPort) {
-      errors.push({
-        field: "vectorDb.options.baseUrl",
-        message: 'Milvus connection is required: provide baseUrl (e.g., "http://localhost:19530") or host + port',
-        suggestion: "Set MILVUS_URL environment variable",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Qdrant — needs baseUrl (or url alias).
-   * Options keys: { baseUrl: string, apiKey?: string }
-   */
-  static validateQdrantConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    if (!opts.baseUrl && !opts.url) {
-      errors.push({
-        field: "vectorDb.options.baseUrl",
-        message: "Qdrant base URL is required",
-        suggestion: 'Set QDRANT_URL environment variable (e.g., "http://localhost:6333")',
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * ChromaDB — accepts baseUrl OR host.
-   * ChromaDBProvider reads opts.baseUrl.
-   * Options keys: { baseUrl?: string, host?: string, port?: number }
-   */
-  static validateChromaDBConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    if (!opts.baseUrl && !opts.host) {
-      errors.push({
-        field: "vectorDb.options.baseUrl",
-        message: 'ChromaDB connection is required: provide baseUrl (e.g., "http://localhost:8000") or host',
-        suggestion: "Set CHROMADB_URL environment variable",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Redis — accepts baseUrl OR url OR host+port.
-   * RedisProvider reads opts.baseUrl.
-   * Options keys: { baseUrl?: string, url?: string, host?: string, port?: number, apiKey?: string }
-   */
-  static validateRedisConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    const hasUrl = Boolean(opts.baseUrl || opts.url);
-    const hasHostPort = Boolean(opts.host && opts.port);
-    if (!hasUrl && !hasHostPort) {
-      errors.push({
-        field: "vectorDb.options.baseUrl",
-        message: "Redis connection is required: provide baseUrl/url or host + port",
-        suggestion: "Set REDIS_URL environment variable",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Weaviate — accepts baseUrl OR url.
-   * WeaviateProvider reads opts.baseUrl.
-   * Options keys: { baseUrl?: string, url?: string, apiKey?: string }
-   */
-  static validateWeaviateConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    if (!opts.baseUrl && !opts.url) {
-      errors.push({
-        field: "vectorDb.options.baseUrl",
-        message: "Weaviate instance URL is required",
-        suggestion: "Set WEAVIATE_URL environment variable",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Universal REST / custom REST adapter.
-   * Options key: { baseUrl: string }
-   */
-  static validateRestConfig(config) {
-    const errors = [];
-    const opts = config.options;
-    if (!opts.baseUrl) {
-      errors.push({
-        field: "vectorDb.options.baseUrl",
-        message: "REST API base URL is required",
-        suggestion: "Set VECTOR_BASE_URL environment variable",
-        severity: "error"
-      });
-    }
-    return errors;
+// src/llm/providers/OpenAIProvider.ts
+var import_openai = __toESM(require("openai"));
+var OpenAIProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
+    this.client = new import_openai.default({ apiKey: llmConfig.apiKey });
+    this.llmConfig = llmConfig;
+    this.embeddingConfig = embeddingConfig;
   }
-  static validateLLMConfig(config) {
-    var _a;
-    const errors = [];
-    if (!config.provider) {
-      errors.push({
-        field: "llm.provider",
-        message: "LLM provider is required",
-        severity: "error"
-      });
-      return errors;
-    }
-    if (!config.model) {
-      errors.push({
-        field: "llm.model",
-        message: "LLM model name is required",
-        suggestion: `e.g., "gpt-4o" for OpenAI, "claude-3-opus" for Anthropic`,
-        severity: "error"
-      });
-    }
-    switch (config.provider) {
-      case "openai":
+  static getValidator() {
+    return {
+      validate(config) {
+        const errors = [];
+        const isEmbedding = config.provider === "openai" && "dimensions" in config;
+        const prefix = isEmbedding ? "embedding" : "llm";
         if (!config.apiKey) {
           errors.push({
-            field: "llm.apiKey",
+            field: `${prefix}.apiKey`,
             message: "OpenAI API key is required",
             suggestion: "Set OPENAI_API_KEY environment variable",
             severity: "error"
           });
         }
-        break;
-      case "anthropic":
-        if (!config.apiKey) {
-          errors.push({
-            field: "llm.apiKey",
-            message: "Anthropic API key is required",
-            suggestion: "Set ANTHROPIC_API_KEY environment variable",
-            severity: "error"
-          });
-        }
-        break;
-      case "gemini":
-        if (!config.apiKey) {
-          errors.push({
-            field: "llm.apiKey",
-            message: "Gemini API key is required",
-            suggestion: "Set GEMINI_API_KEY environment variable",
-            severity: "error"
-          });
-        }
-        break;
-      case "ollama":
-        if (!config.baseUrl) {
+        if (!config.model) {
           errors.push({
-            field: "llm.baseUrl",
-            message: "Ollama base URL is required",
-            suggestion: 'Set LLM_BASE_URL environment variable (e.g., "http://localhost:11434")',
+            field: `${prefix}.model`,
+            message: "OpenAI model name is required",
+            suggestion: isEmbedding ? 'e.g., "text-embedding-3-small"' : 'e.g., "gpt-4o"',
             severity: "error"
           });
         }
-        break;
-      case "rest":
-      case "universal_rest":
-        if (!config.baseUrl && !((_a = config.options) == null ? void 0 : _a.baseUrl)) {
-          errors.push({
-            field: "llm.baseUrl",
-            message: "REST API base URL is required",
-            suggestion: "Set LLM_BASE_URL environment variable",
-            severity: "error"
-          });
-        }
-        break;
-    }
-    if (config.temperature !== void 0) {
-      if (config.temperature < 0 || config.temperature > 2) {
-        errors.push({
-          field: "llm.temperature",
-          message: "Temperature must be between 0 and 2",
-          severity: "error"
-        });
-      }
-    }
-    if (config.maxTokens !== void 0 && config.maxTokens <= 0) {
-      errors.push({
-        field: "llm.maxTokens",
-        message: "maxTokens must be greater than 0",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  static validateEmbeddingConfig(config) {
-    const errors = [];
-    if (!config.provider) {
-      errors.push({
-        field: "embedding.provider",
-        message: "Embedding provider is required",
-        severity: "error"
-      });
-      return errors;
-    }
-    if (!config.model) {
-      errors.push({
-        field: "embedding.model",
-        message: "Embedding model name is required",
-        suggestion: 'e.g., "text-embedding-3-small" for OpenAI, "nomic-embed-text" for Ollama',
-        severity: "error"
-      });
-    }
-    if (config.provider === "openai" && !config.apiKey) {
-      errors.push({
-        field: "embedding.apiKey",
-        message: "OpenAI API key is required for embedding",
-        suggestion: "Set OPENAI_API_KEY environment variable",
-        severity: "error"
-      });
-    }
-    if (config.provider === "gemini" && !config.apiKey) {
-      errors.push({
-        field: "embedding.apiKey",
-        message: "Gemini API key is required for embedding",
-        suggestion: "Set GEMINI_API_KEY environment variable",
-        severity: "error"
-      });
-    }
-    if (config.provider === "ollama" && !config.baseUrl) {
-      errors.push({
-        field: "embedding.baseUrl",
-        message: "Ollama base URL is required for embedding",
-        suggestion: "Set EMBEDDING_BASE_URL environment variable",
-        severity: "error"
-      });
-    }
-    if (config.dimensions !== void 0 && config.dimensions <= 0) {
-      errors.push({
-        field: "embedding.dimensions",
-        message: "Embedding dimensions must be greater than 0",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  static validateUIConfig(config) {
-    const errors = [];
-    if (config.primaryColor) {
-      if (!this.isValidCSSColor(config.primaryColor)) {
-        errors.push({
-          field: "ui.primaryColor",
-          message: "Invalid CSS color format",
-          suggestion: "Use valid CSS colors: hex (#FF0000), rgb, hsl, or named colors",
-          severity: "warning"
-        });
-      }
-    }
-    if (config.borderRadius) {
-      if (!UI_BORDER_RADIUS_OPTIONS.includes(config.borderRadius)) {
-        errors.push({
-          field: "ui.borderRadius",
-          message: `borderRadius must be one of: ${UI_BORDER_RADIUS_OPTIONS.join(", ")}`,
-          severity: "warning"
-        });
-      }
-    }
-    if (config.visualStyle) {
-      if (!UI_VISUAL_STYLES.includes(config.visualStyle)) {
-        errors.push({
-          field: "ui.visualStyle",
-          message: `visualStyle must be one of: ${UI_VISUAL_STYLES.join(", ")}`,
-          severity: "warning"
-        });
-      }
-    }
-    return errors;
-  }
-  static validateRAGConfig(config) {
-    const errors = [];
-    if (config.topK !== void 0) {
-      if (typeof config.topK !== "number" || config.topK <= 0) {
-        errors.push({
-          field: "rag.topK",
-          message: "topK must be a positive integer",
-          severity: "error"
-        });
-      }
-    }
-    if (config.scoreThreshold !== void 0) {
-      if (typeof config.scoreThreshold !== "number" || config.scoreThreshold < 0 || config.scoreThreshold > 1) {
-        errors.push({
-          field: "rag.scoreThreshold",
-          message: "scoreThreshold must be between 0 and 1",
-          severity: "error"
-        });
-      }
-    }
-    if (config.chunkSize !== void 0) {
-      if (typeof config.chunkSize !== "number" || config.chunkSize <= 0) {
-        errors.push({
-          field: "rag.chunkSize",
-          message: "chunkSize must be a positive integer",
-          severity: "error"
-        });
-      }
-    }
-    if (config.chunkOverlap !== void 0) {
-      if (typeof config.chunkOverlap !== "number" || config.chunkOverlap < 0) {
-        errors.push({
-          field: "rag.chunkOverlap",
-          message: "chunkOverlap must be a non-negative integer",
-          severity: "error"
-        });
+        return errors;
       }
-    }
-    return errors;
-  }
-  static isValidCSSColor(color) {
-    const hexRegex = /^#([0-9a-f]{3}){1,2}$/i;
-    const rgbRegex = /^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?\)$/i;
-    const hslRegex = /^hsla?\((\d+),\s*(\d+)%,\s*(\d+)%(?:,\s*(\d+(?:\.\d+)?))?\)$/i;
-    const namedColors = ["red", "blue", "green", "black", "white", "transparent"];
-    return hexRegex.test(color) || rgbRegex.test(color) || hslRegex.test(color) || namedColors.includes(color.toLowerCase());
-  }
-  /**
-   * Throws if there are error-level validation issues.
-   * Logs warnings to console.
-   */
-  static validateAndThrow(config) {
-    const errors = this.validate(config);
-    const errorItems = errors.filter((e) => e.severity === "error");
-    const warnings = errors.filter((e) => e.severity === "warning");
-    if (warnings.length > 0) {
-      console.warn("[ConfigValidator] Configuration warnings:");
-      warnings.forEach((w) => {
-        console.warn(`  ${w.field}: ${w.message}`);
-        if (w.suggestion) console.warn(`    Suggestion: ${w.suggestion}`);
-      });
-    }
-    if (errorItems.length > 0) {
-      const message = errorItems.map((e) => `${e.field}: ${e.message}${e.suggestion ? ` (${e.suggestion})` : ""}`).join("\n  ");
-      throw new Error(`[ConfigValidator] Configuration validation failed:
-  ${message}`);
-    }
-  }
-};
-
-// src/rag/DocumentChunker.ts
-var DocumentChunker = class {
-  constructor(chunkSize = 1e3, chunkOverlap = 200, separators = ["\n\n", "\n", " ", ""]) {
-    this.chunkSize = chunkSize;
-    this.chunkOverlap = chunkOverlap;
-    this.separators = separators;
+    };
   }
-  /**
-   * Split a single text string into overlapping chunks using a recursive strategy.
-   */
-  chunk(text, options = {}) {
-    const {
-      chunkSize = this.chunkSize,
-      chunkOverlap = this.chunkOverlap,
-      docId = `doc_${Date.now()}`,
-      metadata = {},
-      separators = this.separators
-    } = options;
-    const finalChunks = [];
-    const splits = this.recursiveSplit(text, separators, chunkSize);
-    let currentChunk = [];
-    let currentLength = 0;
-    let chunkIndex = 0;
-    for (const split of splits) {
-      if (currentLength + split.length > chunkSize && currentChunk.length > 0) {
-        finalChunks.push({
-          id: `${docId}_chunk_${chunkIndex++}`,
-          content: currentChunk.join("").trim(),
-          metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex: chunkIndex - 1 })
-        });
-        const overlapItems = [];
-        let overlapLen = 0;
-        for (let i = currentChunk.length - 1; i >= 0; i--) {
-          if (overlapLen + currentChunk[i].length <= chunkOverlap) {
-            overlapItems.unshift(currentChunk[i]);
-            overlapLen += currentChunk[i].length;
-          } else {
-            break;
-          }
+  static getHealthChecker() {
+    return {
+      async check(config) {
+        const timestamp = Date.now();
+        const apiKey = config.apiKey;
+        const modelName = config.model;
+        try {
+          const OpenAI2 = await import("openai");
+          const client = new OpenAI2.default({ apiKey });
+          const models = await client.models.list();
+          const hasModel = models.data.some((m) => m.id === modelName);
+          return {
+            healthy: true,
+            provider: "openai",
+            capabilities: { model: modelName, available: hasModel, totalModels: models.data.length },
+            timestamp
+          };
+        } catch (error) {
+          return {
+            healthy: false,
+            provider: "openai",
+            error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+            timestamp
+          };
         }
-        currentChunk = overlapItems;
-        currentLength = overlapLen;
-      }
-      currentChunk.push(split);
-      currentLength += split.length;
-    }
-    if (currentChunk.length > 0) {
-      finalChunks.push({
-        id: `${docId}_chunk_${chunkIndex}`,
-        content: currentChunk.join("").trim(),
-        metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex })
-      });
-    }
-    return finalChunks;
-  }
-  /**
-   * Recursively split text based on separators.
-   */
-  recursiveSplit(text, separators, chunkSize) {
-    const finalSplits = [];
-    let separator = separators[separators.length - 1];
-    let nextSeparators = [];
-    for (let i = 0; i < separators.length; i++) {
-      if (text.includes(separators[i])) {
-        separator = separators[i];
-        nextSeparators = separators.slice(i + 1);
-        break;
-      }
-    }
-    const parts = text.split(separator);
-    for (const part of parts) {
-      if (part.length <= chunkSize) {
-        finalSplits.push(part + separator);
-      } else if (nextSeparators.length > 0) {
-        finalSplits.push(...this.recursiveSplit(part, nextSeparators, chunkSize));
-      } else {
-        finalSplits.push(part);
       }
-    }
-    return finalSplits;
-  }
-  /**
-   * Chunk multiple documents at once.
-   */
-  chunkMany(documents) {
-    return documents.flatMap(
-      (doc) => this.chunk(doc.content, { docId: doc.docId, metadata: doc.metadata })
-    );
-  }
-};
-
-// src/rag/EntityExtractor.ts
-var EntityExtractor = class {
-  constructor(llm) {
-    this.llm = llm;
-  }
-  /**
-   * Extract nodes and edges from a text chunk.
-   */
-  async extract(text) {
-    const prompt = `
-Extract entities and relationships from the following text.
-Format the output as JSON with two keys: "nodes" (array of {id, label, properties}) and "edges" (array of {source, target, type, properties}).
-Use the same ID for the same entity.
-
-Text:
-"${text}"
-
-Output JSON:
-`;
-    const response = await this.llm.chat([
-      { role: "system", content: "You are an expert at knowledge graph extraction. Respond only with valid JSON." },
-      { role: "user", content: prompt }
-    ], "");
-    try {
-      const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
-      return JSON.parse(cleanJson);
-    } catch (e) {
-      console.warn("[EntityExtractor] Failed to parse LLM response as JSON:", response);
-      return { nodes: [], edges: [] };
-    }
-  }
-};
-
-// src/llm/providers/OpenAIProvider.ts
-var import_openai = __toESM(require("openai"));
-var OpenAIProvider = class {
-  constructor(llmConfig, embeddingConfig) {
-    if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
-    this.client = new import_openai.default({ apiKey: llmConfig.apiKey });
-    this.llmConfig = llmConfig;
-    this.embeddingConfig = embeddingConfig;
+    };
   }
   async chat(messages, context, options) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -2212,34 +1824,79 @@ var AnthropicProvider = class {
     this.llmConfig = llmConfig;
     this.embeddingConfig = embeddingConfig;
   }
-  async chat(messages, context, options) {
-    var _a, _b, _c;
-    const systemPrompt = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Use the context below to answer the user's question accurately.
-
-Context:
-${context}`;
-    const system = systemPrompt.includes("{{context}}") ? systemPrompt.replace("{{context}}", context) : `${systemPrompt}
-
-Context:
-${context}`;
-    const anthropicMessages = messages.map((m) => ({
-      role: m.role === "assistant" ? "assistant" : "user",
-      content: m.content
-    }));
-    const response = await this.client.messages.create({
-      model: this.llmConfig.model,
-      max_tokens: (_c = (_b = options == null ? void 0 : options.maxTokens) != null ? _b : this.llmConfig.maxTokens) != null ? _c : 1024,
-      system,
-      messages: anthropicMessages
+  static getValidator() {
+    return {
+      validate(config) {
+        const errors = [];
+        if (!config.apiKey) {
+          errors.push({
+            field: "llm.apiKey",
+            message: "Anthropic API key is required",
+            suggestion: "Set ANTHROPIC_API_KEY environment variable",
+            severity: "error"
+          });
+        }
+        if (!config.model) {
+          errors.push({
+            field: "llm.model",
+            message: "Anthropic model name is required",
+            suggestion: 'e.g., "claude-3-5-sonnet-20241022"',
+            severity: "error"
+          });
+        }
+        return errors;
+      }
+    };
+  }
+  static getHealthChecker() {
+    return {
+      async check(config) {
+        const timestamp = Date.now();
+        const apiKey = config.apiKey;
+        const modelName = config.model;
+        try {
+          const { default: Anthropic2 } = await import("@anthropic-ai/sdk");
+          const client = new Anthropic2({ apiKey });
+          await client.messages.create({
+            model: modelName,
+            max_tokens: 10,
+            messages: [{ role: "user", content: "ping" }]
+          });
+          return { healthy: true, provider: "anthropic", capabilities: { model: modelName }, timestamp };
+        } catch (error) {
+          return {
+            healthy: false,
+            provider: "anthropic",
+            error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+            timestamp
+          };
+        }
+      }
+    };
+  }
+  async chat(messages, context, options) {
+    var _a, _b, _c;
+    const systemPrompt = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Use the context below to answer the user's question accurately.
+
+Context:
+${context}`;
+    const system = systemPrompt.includes("{{context}}") ? systemPrompt.replace("{{context}}", context) : `${systemPrompt}
+
+Context:
+${context}`;
+    const anthropicMessages = messages.map((m) => ({
+      role: m.role === "assistant" ? "assistant" : "user",
+      content: m.content
+    }));
+    const response = await this.client.messages.create({
+      model: this.llmConfig.model,
+      max_tokens: (_c = (_b = options == null ? void 0 : options.maxTokens) != null ? _b : this.llmConfig.maxTokens) != null ? _c : 1024,
+      system,
+      messages: anthropicMessages
     });
     const block = response.content[0];
     return block.type === "text" ? block.text : "";
   }
-  /**
-   * Anthropic does not offer an embedding API.
-   * This method throws with a clear error so developers know to configure
-   * a separate embedding provider (OpenAI or Ollama).
-   */
   async embed(text, options) {
     void text;
     void options;
@@ -2275,22 +1932,66 @@ var OllamaProvider = class {
     this.llmConfig = llmConfig;
     this.embeddingConfig = embeddingConfig;
   }
+  static getValidator() {
+    return {
+      validate(config) {
+        const errors = [];
+        if (!config.model) {
+          const isEmbedding = config.provider === "ollama" && "dimensions" in config;
+          const prefix = isEmbedding ? "embedding" : "llm";
+          errors.push({
+            field: `${prefix}.model`,
+            message: "Ollama model name is required",
+            suggestion: 'e.g., "llama3" or "mistral"',
+            severity: "error"
+          });
+        }
+        return errors;
+      }
+    };
+  }
+  static getHealthChecker() {
+    return {
+      async check(config) {
+        const timestamp = Date.now();
+        const baseUrl = config.baseUrl || "http://localhost:11434";
+        const modelName = config.model;
+        try {
+          const axios9 = (await import("axios")).default;
+          const { data } = await axios9.get(`${baseUrl}/api/tags`);
+          const models = data.models || [];
+          const hasModel = models.some((m) => m.name === modelName || m.name.startsWith(`${modelName}:`));
+          return {
+            healthy: true,
+            provider: "ollama",
+            capabilities: {
+              baseUrl,
+              model: modelName,
+              available: hasModel,
+              totalModels: models.length
+            },
+            timestamp
+          };
+        } catch (e) {
+          return {
+            healthy: false,
+            provider: "ollama",
+            error: `Ollama server not reachable at ${baseUrl}. Is it running?`,
+            timestamp
+          };
+        }
+      }
+    };
+  }
   async chat(messages, context, options) {
-    var _a, _b, _c, _d, _e;
-    const systemPrompt = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Use the provided context to answer the user's question.
-
-Context:
-${context}`;
-    const system = systemPrompt.includes("{{context}}") ? systemPrompt.replace("{{context}}", context) : `${systemPrompt}
-
-Context:
-${context}`;
+    var _a, _b, _c, _d;
+    const system = this.buildSystemPrompt(context);
     const { data } = await this.http.post("/api/chat", {
       model: this.llmConfig.model,
       stream: false,
       options: {
-        temperature: (_c = (_b = options == null ? void 0 : options.temperature) != null ? _b : this.llmConfig.temperature) != null ? _c : 0.7,
-        num_predict: (_e = (_d = options == null ? void 0 : options.maxTokens) != null ? _d : this.llmConfig.maxTokens) != null ? _e : 1024
+        temperature: (_b = (_a = options == null ? void 0 : options.temperature) != null ? _a : this.llmConfig.temperature) != null ? _b : 0.7,
+        num_predict: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024
       },
       messages: [
         { role: "system", content: system },
@@ -2299,6 +2000,60 @@ ${context}`;
     });
     return data.message.content;
   }
+  chatStream(messages, context, options) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      const system = this.buildSystemPrompt(context);
+      const response = yield new __await(this.http.post("/api/chat", {
+        model: this.llmConfig.model,
+        stream: true,
+        options: {
+          temperature: (_b = (_a = options == null ? void 0 : options.temperature) != null ? _a : this.llmConfig.temperature) != null ? _b : 0.7,
+          num_predict: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024
+        },
+        messages: [
+          { role: "system", content: system },
+          ...messages.map((m) => ({ role: m.role, content: m.content }))
+        ]
+      }, { responseType: "stream" }));
+      try {
+        for (var iter = __forAwait(response.data), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          const lines = chunk.toString().split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              const json = JSON.parse(line);
+              if ((_e = json.message) == null ? void 0 : _e.content) {
+                yield json.message.content;
+              }
+              if (json.done) return;
+            } catch (e) {
+            }
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  buildSystemPrompt(context) {
+    var _a;
+    const systemPrompt = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Use the provided context to answer the user's question.
+
+Context:
+${context}`;
+    return systemPrompt.includes("{{context}}") ? systemPrompt.replace("{{context}}", context) : `${systemPrompt}
+
+Context:
+${context}`;
+  }
   async embed(text, options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const model = (_c = (_b = options == null ? void 0 : options.model) != null ? _b : (_a = this.embeddingConfig) == null ? void 0 : _a.model) != null ? _c : "nomic-embed-text";
@@ -2355,6 +2110,52 @@ var GeminiProvider = class {
       });
     }
   }
+  static getValidator() {
+    return {
+      validate(config) {
+        const errors = [];
+        if (!config.apiKey && !process.env.GOOGLE_GENAI_API_KEY) {
+          errors.push({
+            field: "llm.apiKey",
+            message: "Gemini API key is required",
+            suggestion: "Set GOOGLE_GENAI_API_KEY environment variable or provide in config",
+            severity: "error"
+          });
+        }
+        if (!config.model) {
+          errors.push({ field: "llm.model", message: "Gemini model name is required", severity: "error" });
+        }
+        return errors;
+      }
+    };
+  }
+  static getHealthChecker() {
+    return {
+      async check(config) {
+        const timestamp = Date.now();
+        const apiKey = config.apiKey || process.env.GOOGLE_GENAI_API_KEY || "";
+        const modelName = config.model;
+        try {
+          const { GoogleGenAI: GoogleGenAI2 } = await import("@google/genai");
+          const genAI = new GoogleGenAI2({ apiKey });
+          await genAI.models.get({ model: modelName });
+          return {
+            healthy: true,
+            provider: "gemini",
+            capabilities: { model: modelName },
+            timestamp
+          };
+        } catch (error) {
+          return {
+            healthy: false,
+            provider: "gemini",
+            error: error instanceof Error ? error.message : String(error),
+            timestamp
+          };
+        }
+      }
+    };
+  }
   sanitizeModel(model) {
     if (!model) return model;
     return model.split(":")[0];
@@ -2558,189 +2359,607 @@ ${context != null ? context : "None"}` },
     if (result === void 0) {
       throw new Error(`[UniversalLLMAdapter] Could not extract text from path '${extractPath}' in response.`);
     }
-    return String(result);
-  }
-  async embed(text) {
-    var _a, _b;
-    const path = (_a = this.opts.embedPath) != null ? _a : "/embeddings";
-    let payload;
-    if (this.opts.embedPayloadTemplate) {
-      payload = buildPayload(this.opts.embedPayloadTemplate, {
-        model: this.model,
-        input: text
+    return String(result);
+  }
+  async embed(text) {
+    var _a, _b;
+    const path = (_a = this.opts.embedPath) != null ? _a : "/embeddings";
+    let payload;
+    if (this.opts.embedPayloadTemplate) {
+      payload = buildPayload(this.opts.embedPayloadTemplate, {
+        model: this.model,
+        input: text
+      });
+    } else {
+      payload = {
+        model: this.model,
+        input: text
+      };
+    }
+    const { data } = await this.http.post(path, payload);
+    const extractPath = (_b = this.opts.embedExtractPath) != null ? _b : "data[0].embedding";
+    const vector = resolvePath(data, extractPath);
+    if (!Array.isArray(vector)) {
+      throw new Error(`[UniversalLLMAdapter] Expected a number array at '${extractPath}' for embeddings.`);
+    }
+    return vector;
+  }
+  async batchEmbed(texts) {
+    const vectors = [];
+    for (const text of texts) {
+      vectors.push(await this.embed(text));
+    }
+    return vectors;
+  }
+  async ping() {
+    try {
+      if (this.opts.pingPath) {
+        await this.http.get(this.opts.pingPath);
+      }
+      return true;
+    } catch (err) {
+      console.error("[UniversalLLMAdapter] Ping failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/llm/LLMFactory.ts
+var LLMFactory = class _LLMFactory {
+  static create(llmConfig, embeddingConfig) {
+    var _a;
+    switch (llmConfig.provider) {
+      case "openai":
+        return new OpenAIProvider(llmConfig, embeddingConfig);
+      case "anthropic":
+        return new AnthropicProvider(llmConfig, embeddingConfig);
+      case "ollama":
+        return new OllamaProvider(llmConfig, embeddingConfig);
+      case "gemini":
+        return new GeminiProvider(llmConfig, embeddingConfig);
+      case "rest":
+      case "universal_rest":
+      case "custom":
+        return new UniversalLLMAdapter(llmConfig);
+      default:
+        if (llmConfig.baseUrl || ((_a = llmConfig.options) == null ? void 0 : _a.baseUrl)) {
+          return new UniversalLLMAdapter(llmConfig);
+        }
+        throw new Error(`[LLMFactory] Unknown provider "${llmConfig.provider}"`);
+    }
+  }
+  static getValidator(provider) {
+    const providerClass = this.getProviderClass(provider);
+    return providerClass && providerClass.getValidator ? providerClass.getValidator() : null;
+  }
+  static getHealthChecker(provider) {
+    const providerClass = this.getProviderClass(provider);
+    return providerClass && providerClass.getHealthChecker ? providerClass.getHealthChecker() : null;
+  }
+  static getProviderClass(provider) {
+    switch (provider) {
+      case "openai":
+        return OpenAIProvider;
+      case "anthropic":
+        return AnthropicProvider;
+      case "ollama":
+        return OllamaProvider;
+      case "gemini":
+        return GeminiProvider;
+      case "rest":
+      case "universal_rest":
+      case "custom":
+        return UniversalLLMAdapter;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Creates a dedicated embedding-only provider.
+   */
+  static createEmbeddingProvider(embeddingConfig) {
+    const fakeLLMConfig = {
+      provider: embeddingConfig.provider,
+      model: embeddingConfig.model,
+      apiKey: embeddingConfig.apiKey,
+      baseUrl: embeddingConfig.baseUrl,
+      options: embeddingConfig.options
+    };
+    return _LLMFactory.create(fakeLLMConfig, embeddingConfig);
+  }
+};
+
+// src/core/ProviderRegistry.ts
+var ProviderRegistry = class {
+  static registerVectorProvider(name, providerClass) {
+    this.vectorProviders[name] = providerClass;
+    if (providerClass.getValidator) {
+      this.vectorValidators[name] = providerClass.getValidator();
+    }
+    if (providerClass.getHealthChecker) {
+      this.vectorHealthCheckers[name] = providerClass.getHealthChecker();
+    }
+  }
+  static async getVectorValidator(provider) {
+    if (this.vectorValidators[provider]) return this.vectorValidators[provider];
+    try {
+      const providerClass = await this.loadVectorProviderClass(provider);
+      if (providerClass.getValidator) {
+        this.vectorValidators[provider] = providerClass.getValidator();
+        return this.vectorValidators[provider];
+      }
+    } catch (e) {
+      console.warn(`[ProviderRegistry] Failed to load validator for ${provider}:`, e);
+    }
+    return null;
+  }
+  static async getVectorHealthChecker(provider) {
+    if (this.vectorHealthCheckers[provider]) return this.vectorHealthCheckers[provider];
+    try {
+      const providerClass = await this.loadVectorProviderClass(provider);
+      if (providerClass.getHealthChecker) {
+        this.vectorHealthCheckers[provider] = providerClass.getHealthChecker();
+        return this.vectorHealthCheckers[provider];
+      }
+    } catch (e) {
+      console.warn(`[ProviderRegistry] Failed to load health checker for ${provider}:`, e);
+    }
+    return null;
+  }
+  static async loadVectorProviderClass(provider) {
+    if (this.vectorProviders[provider]) return this.vectorProviders[provider];
+    switch (provider) {
+      case "pinecone": {
+        const { PineconeProvider: PineconeProvider2 } = await Promise.resolve().then(() => (init_PineconeProvider(), PineconeProvider_exports));
+        return PineconeProvider2;
+      }
+      case "pgvector":
+      case "postgresql": {
+        const { PostgreSQLProvider: PostgreSQLProvider2 } = await Promise.resolve().then(() => (init_PostgreSQLProvider(), PostgreSQLProvider_exports));
+        return PostgreSQLProvider2;
+      }
+      case "mongodb": {
+        const { MongoDBProvider: MongoDBProvider2 } = await Promise.resolve().then(() => (init_MongoDBProvider(), MongoDBProvider_exports));
+        return MongoDBProvider2;
+      }
+      case "milvus": {
+        const { MilvusProvider: MilvusProvider2 } = await Promise.resolve().then(() => (init_MilvusProvider(), MilvusProvider_exports));
+        return MilvusProvider2;
+      }
+      case "qdrant": {
+        const { QdrantProvider: QdrantProvider2 } = await Promise.resolve().then(() => (init_QdrantProvider(), QdrantProvider_exports));
+        return QdrantProvider2;
+      }
+      case "chromadb": {
+        const { ChromaDBProvider: ChromaDBProvider2 } = await Promise.resolve().then(() => (init_ChromaDBProvider(), ChromaDBProvider_exports));
+        return ChromaDBProvider2;
+      }
+      case "redis": {
+        const { RedisProvider: RedisProvider2 } = await Promise.resolve().then(() => (init_RedisProvider(), RedisProvider_exports));
+        return RedisProvider2;
+      }
+      case "weaviate": {
+        const { WeaviateProvider: WeaviateProvider2 } = await Promise.resolve().then(() => (init_WeaviateProvider(), WeaviateProvider_exports));
+        return WeaviateProvider2;
+      }
+      case "universal_rest":
+      case "rest": {
+        const { UniversalVectorProvider: UniversalVectorProvider2 } = await Promise.resolve().then(() => (init_UniversalVectorProvider(), UniversalVectorProvider_exports));
+        return UniversalVectorProvider2;
+      }
+      default:
+        throw new Error(`Unsupported vector provider: ${provider}`);
+    }
+  }
+  static async createVectorProvider(config) {
+    const providerClass = await this.loadVectorProviderClass(config.provider);
+    return new providerClass(config);
+  }
+  static async createGraphProvider(config) {
+    const { provider } = config;
+    if (this.graphProviders[provider]) {
+      return new this.graphProviders[provider](config);
+    }
+    switch (provider) {
+      case "simple": {
+        const { SimpleGraphProvider: SimpleGraphProvider2 } = await Promise.resolve().then(() => (init_SimpleGraphProvider(), SimpleGraphProvider_exports));
+        return new SimpleGraphProvider2(config);
+      }
+      default:
+        throw new Error(`Unsupported graph provider: ${provider}`);
+    }
+  }
+  static createLLMProvider(llmConfig, embeddingConfig) {
+    return LLMFactory.create(llmConfig, embeddingConfig);
+  }
+};
+ProviderRegistry.vectorProviders = {};
+ProviderRegistry.graphProviders = {};
+ProviderRegistry.vectorValidators = {};
+ProviderRegistry.vectorHealthCheckers = {};
+ProviderRegistry.llmValidators = {};
+ProviderRegistry.llmHealthCheckers = {};
+
+// src/core/ConfigValidator.ts
+var ConfigValidator = class {
+  /**
+   * Validates the entire RagConfig object.
+   */
+  static async validate(config) {
+    const errors = [];
+    if (!config.projectId) {
+      errors.push({
+        field: "projectId",
+        message: "projectId is required",
+        severity: "error"
+      });
+    }
+    errors.push(...await this.validateVectorDbConfig(config.vectorDb));
+    errors.push(...await this.validateLLMConfig(config.llm));
+    if (config.embedding) {
+      errors.push(...await this.validateEmbeddingConfig(config.embedding));
+    } else if (config.llm.provider === "anthropic") {
+      errors.push({
+        field: "embedding",
+        message: "Embedding config is required when using Anthropic LLM",
+        suggestion: 'Provide embedding config with provider (e.g., "openai" or "ollama")',
+        severity: "error"
+      });
+    }
+    if (config.ui) {
+      errors.push(...this.validateUIConfig(config.ui));
+    }
+    if (config.rag) {
+      errors.push(...this.validateRAGConfig(config.rag));
+    }
+    return errors;
+  }
+  static async validateVectorDbConfig(config) {
+    const errors = [];
+    if (!config.provider) {
+      errors.push({ field: "vectorDb.provider", message: "Vector database provider is required", severity: "error" });
+      return errors;
+    }
+    if (!config.indexName) {
+      errors.push({ field: "vectorDb.indexName", message: "Vector database index name is required", severity: "error" });
+    }
+    const validator = await ProviderRegistry.getVectorValidator(config.provider);
+    if (validator) {
+      errors.push(...validator.validate(config));
+    } else {
+      this.fallbackVectorValidation(config, errors);
+    }
+    return errors;
+  }
+  static async validateLLMConfig(config) {
+    const errors = [];
+    if (!config.provider) {
+      errors.push({ field: "llm.provider", message: "LLM provider is required", severity: "error" });
+      return errors;
+    }
+    const validator = LLMFactory.getValidator(config.provider);
+    if (validator) {
+      errors.push(...validator.validate(config));
+    } else {
+      this.fallbackLLMValidation(config, errors);
+    }
+    if (config.temperature !== void 0 && (config.temperature < 0 || config.temperature > 2)) {
+      errors.push({ field: "llm.temperature", message: "Temperature must be between 0 and 2", severity: "error" });
+    }
+    return errors;
+  }
+  static async validateEmbeddingConfig(config) {
+    const errors = [];
+    if (!config.provider) {
+      errors.push({ field: "embedding.provider", message: "Embedding provider is required", severity: "error" });
+      return errors;
+    }
+    const validator = LLMFactory.getValidator(config.provider);
+    if (validator) {
+      errors.push(...validator.validate(config));
+    } else {
+      this.fallbackEmbeddingValidation(config, errors);
+    }
+    return errors;
+  }
+  /**
+   * Temporary fallbacks for providers not yet migrated to the pluggable architecture.
+   */
+  static fallbackVectorValidation(config, errors) {
+    const opts = config.options || {};
+    switch (config.provider) {
+      case "milvus":
+        if (!opts.baseUrl && !opts.uri && !(opts.host && opts.port)) {
+          errors.push({ field: "vectorDb.options.baseUrl", message: "Milvus connection info required", severity: "error" });
+        }
+        break;
+      case "qdrant":
+        if (!opts.baseUrl && !opts.url) {
+          errors.push({ field: "vectorDb.options.baseUrl", message: "Qdrant URL required", severity: "error" });
+        }
+        break;
+    }
+  }
+  static fallbackLLMValidation(config, errors) {
+    if (!config.model) {
+      errors.push({ field: "llm.model", message: "LLM model name is required", severity: "error" });
+    }
+  }
+  static fallbackEmbeddingValidation(config, errors) {
+    if (!config.model) {
+      errors.push({ field: "embedding.model", message: "Embedding model name is required", severity: "error" });
+    }
+  }
+  static validateUIConfig(config) {
+    const errors = [];
+    if (config.primaryColor && !this.isValidCSSColor(config.primaryColor)) {
+      errors.push({ field: "ui.primaryColor", message: "Invalid CSS color format", severity: "warning" });
+    }
+    if (config.borderRadius && !UI_BORDER_RADIUS_OPTIONS.includes(config.borderRadius)) {
+      errors.push({ field: "ui.borderRadius", message: `borderRadius must be one of: ${UI_BORDER_RADIUS_OPTIONS.join(", ")}`, severity: "warning" });
+    }
+    return errors;
+  }
+  static validateRAGConfig(config) {
+    const errors = [];
+    if (config.topK !== void 0 && (typeof config.topK !== "number" || config.topK <= 0)) {
+      errors.push({ field: "rag.topK", message: "topK must be a positive integer", severity: "error" });
+    }
+    return errors;
+  }
+  static isValidCSSColor(color) {
+    const hexRegex = /^#([0-9a-f]{3}){1,2}$/i;
+    const rgbRegex = /^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?\)$/i;
+    const namedColors = ["red", "blue", "green", "black", "white", "transparent"];
+    return hexRegex.test(color) || rgbRegex.test(color) || namedColors.includes(color.toLowerCase());
+  }
+  static async validateAndThrow(config) {
+    const errors = await this.validate(config);
+    const errorItems = errors.filter((e) => e.severity === "error");
+    if (errorItems.length > 0) {
+      const message = errorItems.map((e) => `${e.field}: ${e.message}${e.suggestion ? ` (${e.suggestion})` : ""}`).join("\n  ");
+      throw new Error(`[ConfigValidator] Configuration validation failed:
+  ${message}`);
+    }
+  }
+};
+
+// src/rag/DocumentChunker.ts
+var DocumentChunker = class {
+  constructor(chunkSize = 1e3, chunkOverlap = 200, separators = ["\n# ", "\n## ", "\n### ", "\n#### ", "\n\n", "\n", " ", ""]) {
+    this.chunkSize = chunkSize;
+    this.chunkOverlap = chunkOverlap;
+    this.separators = separators;
+  }
+  /**
+   * Split a single text string into overlapping chunks using a recursive strategy.
+   * Preserves structural boundaries (Markdown headers) where possible.
+   */
+  chunk(text, options = {}) {
+    const {
+      chunkSize = this.chunkSize,
+      chunkOverlap = this.chunkOverlap,
+      docId = `doc_${Date.now()}`,
+      metadata = {},
+      separators = this.separators
+    } = options;
+    const finalChunks = [];
+    const splits = this.recursiveSplit(text, separators, chunkSize);
+    let currentChunk = [];
+    let currentLength = 0;
+    let chunkIndex = 0;
+    for (const split of splits) {
+      if (currentLength + split.length > chunkSize && currentChunk.length > 0) {
+        finalChunks.push({
+          id: `${docId}_chunk_${chunkIndex++}`,
+          content: currentChunk.join("").trim(),
+          metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex: chunkIndex - 1 })
+        });
+        const overlapItems = [];
+        let overlapLen = 0;
+        for (let i = currentChunk.length - 1; i >= 0; i--) {
+          if (overlapLen + currentChunk[i].length <= chunkOverlap) {
+            overlapItems.unshift(currentChunk[i]);
+            overlapLen += currentChunk[i].length;
+          } else {
+            break;
+          }
+        }
+        currentChunk = overlapItems;
+        currentLength = overlapLen;
+      }
+      currentChunk.push(split);
+      currentLength += split.length;
+    }
+    if (currentChunk.length > 0) {
+      finalChunks.push({
+        id: `${docId}_chunk_${chunkIndex}`,
+        content: currentChunk.join("").trim(),
+        metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex })
       });
-    } else {
-      payload = {
-        model: this.model,
-        input: text
-      };
-    }
-    const { data } = await this.http.post(path, payload);
-    const extractPath = (_b = this.opts.embedExtractPath) != null ? _b : "data[0].embedding";
-    const vector = resolvePath(data, extractPath);
-    if (!Array.isArray(vector)) {
-      throw new Error(`[UniversalLLMAdapter] Expected a number array at '${extractPath}' for embeddings.`);
     }
-    return vector;
+    return finalChunks;
   }
-  async batchEmbed(texts) {
-    const vectors = [];
-    for (const text of texts) {
-      vectors.push(await this.embed(text));
+  recursiveSplit(text, separators, chunkSize) {
+    const finalSplits = [];
+    let separator = separators[separators.length - 1];
+    let nextSeparators = [];
+    for (let i = 0; i < separators.length; i++) {
+      const sep = separators[i];
+      if (text.includes(sep)) {
+        separator = sep;
+        nextSeparators = separators.slice(i + 1);
+        break;
+      }
     }
-    return vectors;
-  }
-  async ping() {
-    try {
-      if (this.opts.pingPath) {
-        await this.http.get(this.opts.pingPath);
+    const parts = text.split(separator);
+    for (const part of parts) {
+      if (part.length <= chunkSize) {
+        finalSplits.push(part + (part === parts[parts.length - 1] ? "" : separator));
+      } else if (nextSeparators.length > 0) {
+        finalSplits.push(...this.recursiveSplit(part, nextSeparators, chunkSize));
+      } else {
+        finalSplits.push(part);
       }
-      return true;
-    } catch (err) {
-      console.error("[UniversalLLMAdapter] Ping failed:", err);
-      return false;
     }
+    return finalSplits;
+  }
+  chunkMany(documents) {
+    return documents.flatMap(
+      (doc) => this.chunk(doc.content, { docId: doc.docId, metadata: doc.metadata })
+    );
   }
 };
 
-// src/llm/LLMFactory.ts
-var LLMFactory = class _LLMFactory {
-  static create(llmConfig, embeddingConfig) {
-    var _a;
-    switch (llmConfig.provider) {
-      case "openai":
-        return new OpenAIProvider(llmConfig, embeddingConfig);
-      case "anthropic":
-        return new AnthropicProvider(llmConfig, embeddingConfig);
-      case "ollama":
-        return new OllamaProvider(llmConfig, embeddingConfig);
-      case "gemini":
-        return new GeminiProvider(llmConfig, embeddingConfig);
-      case "rest":
-      case "universal_rest":
-      case "custom":
-        return new UniversalLLMAdapter(llmConfig);
-      default:
-        if (llmConfig.baseUrl || ((_a = llmConfig.options) == null ? void 0 : _a.baseUrl)) {
-          return new UniversalLLMAdapter(llmConfig);
-        }
-        throw new Error(
-          `[LLMFactory] Unknown provider "${llmConfig.provider}". Supported: openai | anthropic | ollama | rest | custom`
-        );
-    }
+// src/rag/EntityExtractor.ts
+var EntityExtractor = class {
+  constructor(llm) {
+    this.llm = llm;
   }
   /**
-   * Creates a dedicated embedding-only provider.
-   * Useful when the LLM provider (e.g. Anthropic) doesn't support embeddings.
+   * Extract nodes and edges from a text chunk.
    */
-  static createEmbeddingProvider(embeddingConfig) {
-    const fakeLLMConfig = {
-      provider: embeddingConfig.provider,
-      model: embeddingConfig.model,
-      apiKey: embeddingConfig.apiKey,
-      baseUrl: embeddingConfig.baseUrl,
-      options: embeddingConfig.options
-    };
-    return _LLMFactory.create(fakeLLMConfig, embeddingConfig);
+  async extract(text) {
+    const prompt = `
+Extract entities and relationships from the following text.
+Format the output as JSON with two keys: "nodes" (array of {id, label, properties}) and "edges" (array of {source, target, type, properties}).
+Use the same ID for the same entity.
+
+Text:
+"${text}"
+
+Output JSON:
+`;
+    const response = await this.llm.chat([
+      { role: "system", content: "You are an expert at knowledge graph extraction. Respond only with valid JSON." },
+      { role: "user", content: prompt }
+    ], "");
+    try {
+      const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
+      return JSON.parse(cleanJson);
+    } catch (e) {
+      console.warn("[EntityExtractor] Failed to parse LLM response as JSON:", response);
+      return { nodes: [], edges: [] };
+    }
   }
 };
 
-// src/core/ProviderRegistry.ts
-var ProviderRegistry = class {
-  static registerVectorProvider(name, providerClass) {
-    this.vectorProviders[name] = providerClass;
-  }
+// src/rag/Reranker.ts
+var Reranker = class {
   /**
-   * Register a custom graph provider class by name.
+   * Re-ranks matches based on a secondary relevance score.
+   * In a production environment, this would call a Cross-Encoder model.
+   * Here we implement a placeholder that filters by score and limits count.
    */
-  static registerGraphProvider(name, providerClass) {
-    this.graphProviders[name] = providerClass;
+  async rerank(matches, query, limit = 5) {
+    return matches.sort((a, b) => b.score - a.score).slice(0, limit);
   }
+};
+
+// src/rag/LlamaIndexIngestor.ts
+var LlamaIndexIngestor = class {
   /**
-   * Creates a vector database provider based on the configuration.
-   * Built-in providers are dynamically imported to avoid bundling all SDKs.
+   * Chunks document content using LlamaIndex SentenceSplitter.
+   * This respects sentence and paragraph boundaries much more effectively
+   * than standard character-count splitting.
    */
-  static async createVectorProvider(config) {
-    const { provider } = config;
-    if (this.vectorProviders[provider]) {
-      return new this.vectorProviders[provider](config);
-    }
-    switch (provider) {
-      case "pinecone": {
-        const { PineconeProvider: PineconeProvider2 } = await Promise.resolve().then(() => (init_PineconeProvider(), PineconeProvider_exports));
-        return new PineconeProvider2(config);
-      }
-      case "pgvector":
-      case "postgresql": {
-        const { PostgreSQLProvider: PostgreSQLProvider2 } = await Promise.resolve().then(() => (init_PostgreSQLProvider(), PostgreSQLProvider_exports));
-        return new PostgreSQLProvider2(config);
-      }
-      case "mongodb": {
-        const { MongoDBProvider: MongoDBProvider2 } = await Promise.resolve().then(() => (init_MongoDBProvider(), MongoDBProvider_exports));
-        return new MongoDBProvider2(config);
-      }
-      case "milvus": {
-        const { MilvusProvider: MilvusProvider2 } = await Promise.resolve().then(() => (init_MilvusProvider(), MilvusProvider_exports));
-        return new MilvusProvider2(config);
-      }
-      case "qdrant": {
-        const { QdrantProvider: QdrantProvider2 } = await Promise.resolve().then(() => (init_QdrantProvider(), QdrantProvider_exports));
-        return new QdrantProvider2(config);
-      }
-      case "chromadb": {
-        const { ChromaDBProvider: ChromaDBProvider2 } = await Promise.resolve().then(() => (init_ChromaDBProvider(), ChromaDBProvider_exports));
-        return new ChromaDBProvider2(config);
-      }
-      case "redis": {
-        const { RedisProvider: RedisProvider2 } = await Promise.resolve().then(() => (init_RedisProvider(), RedisProvider_exports));
-        return new RedisProvider2(config);
-      }
-      case "weaviate": {
-        const { WeaviateProvider: WeaviateProvider2 } = await Promise.resolve().then(() => (init_WeaviateProvider(), WeaviateProvider_exports));
-        return new WeaviateProvider2(config);
-      }
-      case "universal_rest":
-      case "rest": {
-        const { UniversalVectorProvider: UniversalVectorProvider2 } = await Promise.resolve().then(() => (init_UniversalVectorProvider(), UniversalVectorProvider_exports));
-        return new UniversalVectorProvider2(config);
-      }
-      default:
-        throw new Error(
-          `[ProviderRegistry] Unsupported vector provider: "${provider}". Built-in providers: pinecone | pgvector | postgresql | mongodb | milvus | qdrant | chromadb | redis | weaviate | universal_rest. For custom providers, call ProviderRegistry.registerVectorProvider("${provider}", YourClass).`
-        );
+  async chunk(text, options = {}) {
+    var _a, _b;
+    try {
+      const { Document, SentenceSplitter, MetadataMode } = await import(`${"llamaindex"}`);
+      const splitter = new SentenceSplitter({
+        chunkSize: (_a = options.chunkSize) != null ? _a : 1e3,
+        chunkOverlap: (_b = options.chunkOverlap) != null ? _b : 200
+      });
+      const doc = new Document({ text, metadata: options.metadata || {} });
+      const nodes = splitter.getNodesFromDocuments([doc]);
+      return nodes.map((node, index) => ({
+        id: `${options.docId || "doc"}_node_${index}`,
+        content: node.getContent(MetadataMode.ALL),
+        metadata: __spreadProps(__spreadValues(__spreadValues({}, options.metadata), node.metadata), {
+          nodeId: node.id_,
+          chunkIndex: index
+        })
+      }));
+    } catch (error) {
+      console.warn("[LlamaIndexIngestor] LlamaIndex package not found or failed. Falling back to default chunker.");
+      throw error;
     }
   }
   /**
-   * Creates a graph database provider based on the configuration.
+   * Batch processing for multiple documents.
    */
-  static async createGraphProvider(config) {
-    const { provider } = config;
-    if (this.graphProviders[provider]) {
-      return new this.graphProviders[provider](config);
+  async chunkMany(documents, options = {}) {
+    const allChunks = [];
+    for (const doc of documents) {
+      const chunks = await this.chunk(doc.content, __spreadProps(__spreadValues({}, options), { docId: doc.docId, metadata: doc.metadata }));
+      allChunks.push(...chunks);
     }
-    switch (provider) {
-      case "neo4j": {
-        throw new Error("[ProviderRegistry] Neo4j provider not implemented yet.");
-      }
-      case "simple": {
-        const { SimpleGraphProvider: SimpleGraphProvider2 } = await Promise.resolve().then(() => (init_SimpleGraphProvider(), SimpleGraphProvider_exports));
-        return new SimpleGraphProvider2(config);
-      }
-      default:
-        throw new Error(
-          `[ProviderRegistry] Unsupported graph provider: "${provider}". Built-in providers: simple. For custom providers, call ProviderRegistry.registerGraphProvider("${provider}", YourClass).`
-        );
+    return allChunks;
+  }
+};
+
+// src/core/LangChainAgent.ts
+var LangChainAgent = class {
+  constructor(pipeline, config) {
+    this.pipeline = pipeline;
+    this.config = config;
+  }
+  /**
+   * Initializes the agent with the RAG pipeline as a primary tool.
+   * Dynamically imports LangChain dependencies to avoid build errors if missing.
+   */
+  async initialize(chatModel) {
+    try {
+      const { DynamicTool } = await import(`${"@langchain/core/tools"}`);
+      const { ChatPromptTemplate, MessagesPlaceholder } = await import(`${"@langchain/core/prompts"}`);
+      const { AgentExecutor, createOpenAIFunctionsAgent } = await import(`${"langchain/agents"}`);
+      const searchTool = new DynamicTool({
+        name: "document_search",
+        description: "Use this tool to search through the knowledge base and document repository. Input should be a specific search query.",
+        func: async (query) => {
+          const response = await this.pipeline.ask(query);
+          return `Search Results:
+${response.reply}
+
+Sources Used: ${JSON.stringify(response.sources.map((s) => s.id))}`;
+        }
+      });
+      const tools = [searchTool];
+      const prompt = ChatPromptTemplate.fromMessages([
+        ["system", this.config.llm.systemPrompt || "You are a helpful AI assistant with access to a document search tool."],
+        new MessagesPlaceholder("chat_history"),
+        ["human", "{input}"],
+        new MessagesPlaceholder("agent_scratchpad")
+      ]);
+      const agent = await createOpenAIFunctionsAgent({
+        llm: chatModel,
+        tools,
+        prompt
+      });
+      this.executor = new AgentExecutor({
+        agent,
+        tools
+      });
+    } catch (error) {
+      console.error("[LangChainAgent] Failed to initialize. Ensure 'langchain' and '@langchain/core' are installed.");
+      throw error;
     }
   }
   /**
-   * Creates an LLM provider based on the configuration.
+   * Run the agentic flow.
    */
-  static createLLMProvider(llmConfig, embeddingConfig) {
-    return LLMFactory.create(llmConfig, embeddingConfig);
+  async run(input, chatHistory = []) {
+    if (!this.executor) {
+      throw new Error("[LangChainAgent] Agent not initialized. Call initialize() first.");
+    }
+    const response = await this.executor.invoke({
+      input,
+      chat_history: chatHistory
+    });
+    return response.output;
   }
 };
-ProviderRegistry.vectorProviders = {};
-ProviderRegistry.graphProviders = {};
 
 // src/core/BatchProcessor.ts
 function isTransientError(error) {
@@ -3042,122 +3261,143 @@ var EmbeddingStrategyResolver = class {
   }
 };
 
-// src/core/Pipeline.ts
-function normalizeHintValue(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
-function isLikelyPromptPhrase(value) {
-  return /^(what|which|who|where|when|why|how)\b/i.test(value.trim());
-}
-function extractQueryFieldHints(question) {
-  var _a, _b, _c, _d;
-  if (!question.trim()) return [];
-  const hints = /* @__PURE__ */ new Map();
-  const addHint = (value, field) => {
-    const normalizedValue = normalizeHintValue(value);
-    if (!normalizedValue) return;
-    const normalizedField = field ? field.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() : void 0;
-    const key = `${normalizedField != null ? normalizedField : "*"}::${normalizedValue.toLowerCase()}`;
-    if (!hints.has(key)) {
-      hints.set(key, __spreadValues({
-        value: normalizedValue
-      }, normalizedField ? { field: normalizedField } : {}));
+// src/core/QueryProcessor.ts
+var QueryProcessor = class {
+  /**
+   * Normalizes a string value by collapsing whitespace and trimming.
+   */
+  static normalizeHintValue(value) {
+    return value.replace(/\s+/g, " ").trim();
+  }
+  /**
+   * Checks if a string is likely a question word or common prompt phrase.
+   */
+  static isLikelyPromptPhrase(value) {
+    return /^(what|which|who|where|when|why|how)\b/i.test(value.trim());
+  }
+  /**
+   * Scans a natural language question for potential metadata hints and keywords.
+   */
+  static extractQueryFieldHints(question) {
+    var _a, _b, _c, _d;
+    if (!question.trim()) return [];
+    const hints = /* @__PURE__ */ new Map();
+    const addHint = (value, field) => {
+      const normalizedValue = this.normalizeHintValue(value);
+      if (!normalizedValue) return;
+      const normalizedField = field ? field.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() : void 0;
+      const key = `${normalizedField != null ? normalizedField : "*"}::${normalizedValue.toLowerCase()}`;
+      if (!hints.has(key)) {
+        hints.set(key, __spreadValues({
+          value: normalizedValue
+        }, normalizedField ? { field: normalizedField } : {}));
+      }
+    };
+    for (const match of question.matchAll(/["']([^"']{2,100})["']/g)) {
+      addHint(match[1]);
     }
-  };
-  for (const match of question.matchAll(/["']([^"']{2,100})["']/g)) {
-    addHint(match[1]);
-  }
-  const naturalQuestionPatterns = [
-    /\b(?:what|which)\s+(?:is|are|was|were)\s+(?:the\s+)?([^?.!,]{1,60}?)\s+of\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
-    /\b(?:who|what)\s+(?:is|are|was|were)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
-    /\b(?:about|for|regarding)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi
-  ];
-  const personCompanyPatterns = [
-    /\bcompany(?:\s+name)?\s+(?:of|for)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
-    /\b(?:which|what)\s+company\s+does\s+["']?([^"'\n?.!,]{2,120})["']?\s+work(?:\s+for|\s+at)?(?=[?.!,]|$)/gi,
-    /\bwhere\s+does\s+["']?([^"'\n?.!,]{2,120})["']?\s+work(?:\s+for|\s+at)?(?=[?.!,]|$)/gi
-  ];
-  for (const pattern of personCompanyPatterns) {
-    for (const match of question.matchAll(pattern)) {
-      const name = match[1];
-      if (name) addHint(name, "name");
-    }
-  }
-  const universalPatterns = [
-    { regex: /([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/gi, field: "email", group: 1 },
-    { regex: /(\+?\d[\d\-\.\s\(\)]{6,}\d)/g, field: "phone", group: 1 },
-    { regex: /(\b\d{4}-\d{2}-\d{2}\b|\b\d{1,2}\/\d{1,2}\/\d{2,4}\b)/g, field: "date", group: 1 },
-    { regex: /(\$\s?\d{1,3}(?:,\d{3})*(?:\.\d+)?)/g, field: "amount", group: 1 },
-    { regex: /\b(ID|id|identifier)[: ]\s*([A-Za-z0-9\-]{3,})\b/gi, field: "id", group: 2 },
-    // Generic quoted phrase / proper-noun sequences as keywords (already partially handled above)
-    { regex: /"([^"]{2,120})"/g, group: 1 },
-    { regex: /'([^']{2,120})'/g, group: 1 }
-  ];
-  for (const p of universalPatterns) {
-    for (const match of question.matchAll(p.regex)) {
-      const val = p.group ? (_a = match[p.group]) != null ? _a : match[0] : match[0];
-      if (!val) continue;
-      if (p.field) addHint(val, p.field);
-      else addHint(val);
-    }
-  }
-  for (const pattern of naturalQuestionPatterns) {
-    for (const match of question.matchAll(pattern)) {
-      const value = (_b = match[2]) != null ? _b : match[1];
-      if (value) addHint(value);
-    }
-  }
-  const fieldPattern = `([^\\n:=?.!,]{1,60}?)`;
-  const valuePattern = `([^\\n?.!,]{1,120}?)`;
-  const fieldValuePatterns = [
-    new RegExp(`\\b${fieldPattern}\\s*(?:=|:)\\s*["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi"),
-    new RegExp(`\\b${fieldPattern}\\s+(?:is|are|was|were|equals?|equal to|named|called)\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi"),
-    new RegExp(`\\bwith\\s+${fieldPattern}\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi")
-  ];
-  for (const pattern of fieldValuePatterns) {
-    for (const match of question.matchAll(pattern)) {
-      const field = normalizeHintValue((_c = match[1]) != null ? _c : "");
-      const value = (_d = match[2]) != null ? _d : "";
-      if (field && !isLikelyPromptPhrase(field)) {
-        addHint(value, field);
+    const naturalQuestionPatterns = [
+      /\b(?:what|which)\s+(?:is|are|was|were)\s+(?:the\s+)?([^?.!,]{1,60}?)\s+of\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
+      /\b(?:who|what)\s+(?:is|are|was|were)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
+      /\b(?:about|for|regarding)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi
+    ];
+    const personCompanyPatterns = [
+      /\bcompany(?:\s+name)?\s+(?:of|for)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
+      /\b(?:which|what)\s+company\s+does\s+["']?([^"'\n?.!,]{2,120})["']?\s+work(?:\s+for|\s+at)?(?=[?.!,]|$)/gi,
+      /\bwhere\s+does\s+["']?([^"'\n?.!,]{2,120})["']?\s+work(?:\s+for|\s+at)?(?=[?.!,]|$)/gi
+    ];
+    for (const pattern of personCompanyPatterns) {
+      for (const match of question.matchAll(pattern)) {
+        const name = match[1];
+        if (name) addHint(name, "name");
+      }
+    }
+    const universalPatterns = [
+      { regex: /([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/gi, field: "email", group: 1 },
+      { regex: /(\+?\d[\d\-\.\s\(\)]{6,}\d)/g, field: "phone", group: 1 },
+      { regex: /(\b\d{4}-\d{2}-\d{2}\b|\b\d{1,2}\/\d{1,2}\/\d{2,4}\b)/g, field: "date", group: 1 },
+      { regex: /(\$\s?\d{1,3}(?:,\d{3})*(?:\.\d+)?)/g, field: "amount", group: 1 },
+      { regex: /\b(ID|id|identifier)[: ]\s*([A-Za-z0-9\-]{3,})\b/gi, field: "id", group: 2 },
+      { regex: /"([^"]{2,120})"/g, group: 1 },
+      { regex: /'([^']{2,120})'/g, group: 1 }
+    ];
+    for (const p of universalPatterns) {
+      for (const match of question.matchAll(p.regex)) {
+        const val = p.group ? (_a = match[p.group]) != null ? _a : match[0] : match[0];
+        if (!val) continue;
+        if (p.field) addHint(val, p.field);
+        else addHint(val);
+      }
+    }
+    for (const pattern of naturalQuestionPatterns) {
+      for (const match of question.matchAll(pattern)) {
+        const value = (_b = match[2]) != null ? _b : match[1];
+        if (value) addHint(value);
+      }
+    }
+    const fieldPattern = `([^\\n:=?.!,]{1,60}?)`;
+    const valuePattern = `([^\\n?.!,]{1,120}?)`;
+    const fieldValuePatterns = [
+      new RegExp(`\\b${fieldPattern}\\s*(?:=|:)\\s*["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi"),
+      new RegExp(`\\b${fieldPattern}\\s+(?:is|are|was|were|equals?|equal to|named|called)\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi"),
+      new RegExp(`\\bwith\\s+${fieldPattern}\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi")
+    ];
+    for (const pattern of fieldValuePatterns) {
+      for (const match of question.matchAll(pattern)) {
+        const field = this.normalizeHintValue((_c = match[1]) != null ? _c : "");
+        const value = (_d = match[2]) != null ? _d : "";
+        if (field && !this.isLikelyPromptPhrase(field)) {
+          addHint(value, field);
+        } else {
+          addHint(value);
+        }
+      }
+    }
+    for (const match of question.matchAll(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/g)) {
+      addHint(match[0]);
+    }
+    return [...hints.values()];
+  }
+  /**
+   * Constructs a QueryFilter object from extracted hints.
+   */
+  static buildQueryFilter(question, hints) {
+    const filter = { metadata: {}, keywords: [], queryText: question };
+    for (const hint of hints) {
+      if (hint.field) {
+        filter.metadata[hint.field] = hint.value;
       } else {
-        addHint(value);
+        filter.keywords.push(hint.value);
       }
     }
-  }
-  for (const match of question.matchAll(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/g)) {
-    addHint(match[0]);
-  }
-  return [...hints.values()];
-}
-function buildQueryFilter(question, hints) {
-  const filter = { metadata: {}, keywords: [], queryText: question };
-  for (const hint of hints) {
-    if (hint.field) {
-      filter.metadata[hint.field] = hint.value;
-    } else {
-      filter.keywords.push(hint.value);
+    for (const match of question.matchAll(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/g)) {
+      const term = this.normalizeHintValue(match[0]);
+      if (term && !filter.keywords.includes(term)) filter.keywords.push(term);
     }
+    if (Object.keys(filter.metadata || {}).length === 0) delete filter.metadata;
+    if (filter.keywords && filter.keywords.length === 0) delete filter.keywords;
+    return filter;
   }
-  for (const match of question.matchAll(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/g)) {
-    const term = normalizeHintValue(match[0]);
-    if (term && !filter.keywords.includes(term)) filter.keywords.push(term);
-  }
-  if (Object.keys(filter.metadata || {}).length === 0) delete filter.metadata;
-  if (filter.keywords && filter.keywords.length === 0) delete filter.keywords;
-  return filter;
-}
+};
+
+// src/core/Pipeline.ts
 var Pipeline = class {
   constructor(config) {
-    this.initialised = false;
-    var _a, _b, _c, _d;
     this.config = config;
+    this.embeddingCache = /* @__PURE__ */ new Map();
+    this.initialised = false;
+    var _a, _b, _c, _d, _e;
     this.chunker = new DocumentChunker(
       (_b = (_a = config.rag) == null ? void 0 : _a.chunkSize) != null ? _b : 1e3,
       (_d = (_c = config.rag) == null ? void 0 : _c.chunkOverlap) != null ? _d : 200
     );
+    if (((_e = config.rag) == null ? void 0 : _e.chunkingStrategy) === "llamaindex") {
+      this.llamaIngestor = new LlamaIndexIngestor();
+    }
+    this.reranker = new Reranker();
   }
   async initialize() {
+    var _a;
     if (this.initialised) return;
     this.vectorDB = await ProviderRegistry.createVectorProvider(this.config.vectorDb);
     const { llmProvider, embeddingProvider } = await EmbeddingStrategyResolver.resolve(
@@ -3172,6 +3412,10 @@ var Pipeline = class {
       this.entityExtractor = new EntityExtractor(this.llmProvider);
     }
     await this.vectorDB.initialize();
+    if (((_a = this.config.rag) == null ? void 0 : _a.architecture) === "agentic") {
+      this.agent = new LangChainAgent(this, this.config);
+      await this.agent.initialize(this.llmProvider);
+    }
     this.initialised = true;
   }
   /**
@@ -3184,69 +3428,21 @@ var Pipeline = class {
     const results = [];
     for (const doc of documents) {
       try {
-        const chunks = this.chunker.chunk(doc.content, {
-          docId: doc.docId,
-          metadata: doc.metadata
-        });
-        const embedBatchOptions = {
-          batchSize: 50,
-          maxRetries: 3,
-          initialDelayMs: 100
-        };
-        const vectors = await BatchProcessor.mapWithRetry(
-          chunks.map((c) => c.content),
-          (text) => this.embeddingProvider.embed(text, { taskType: "document" }),
-          embedBatchOptions
-        );
-        if (vectors.length !== chunks.length) {
-          throw new Error(`Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks`);
-        }
+        const chunks = await this.prepareChunks(doc);
+        const vectors = await this.processEmbeddings(chunks);
         const upsertDocs = chunks.map((chunk, i) => ({
           id: chunk.id,
           vector: vectors[i],
           content: chunk.content,
           metadata: chunk.metadata
         }));
-        const upsertBatchOptions = {
-          batchSize: 100,
-          maxRetries: 3,
-          initialDelayMs: 100
-        };
-        const upsertResult = await BatchProcessor.processBatch(
-          upsertDocs,
-          (batch) => this.vectorDB.batchUpsert(batch, ns),
-          upsertBatchOptions
-        );
-        if (upsertResult.errors.length > 0) {
-          console.warn(`[Pipeline] Ingestion: ${upsertResult.errors.length} batches failed for doc ${doc.docId}`);
-        }
+        const totalProcessed = await this.processUpserts(upsertDocs, ns);
         results.push({
           docId: doc.docId,
-          chunksIngested: upsertResult.totalProcessed
+          chunksIngested: totalProcessed
         });
         if (this.graphDB && this.entityExtractor) {
-          console.log(`[Pipeline] Extracting entities for doc ${doc.docId} (${chunks.length} chunks)...`);
-          const extractionOptions = {
-            batchSize: 2,
-            // Low concurrency for LLM extraction
-            maxRetries: 1,
-            initialDelayMs: 500
-          };
-          await BatchProcessor.processBatch(
-            chunks,
-            async (batch) => {
-              for (const chunk of batch) {
-                try {
-                  const { nodes, edges } = await this.entityExtractor.extract(chunk.content);
-                  if (nodes.length > 0) await this.graphDB.addNodes(nodes);
-                  if (edges.length > 0) await this.graphDB.addEdges(edges);
-                } catch (err) {
-                  console.warn(`[Pipeline] Entity extraction failed for chunk:`, err);
-                }
-              }
-            },
-            extractionOptions
-          );
+          await this.processGraphIngestion(doc.docId, chunks);
         }
       } catch (error) {
         console.error(`[Pipeline] Failed to ingest document ${doc.docId}:`, error);
@@ -3255,45 +3451,210 @@ var Pipeline = class {
     }
     return results;
   }
+  /**
+   * Step 1: Chunk the document content.
+   */
+  async prepareChunks(doc) {
+    var _a, _b;
+    if (this.llamaIngestor) {
+      return await this.llamaIngestor.chunk(doc.content, {
+        docId: doc.docId,
+        metadata: doc.metadata,
+        chunkSize: (_a = this.config.rag) == null ? void 0 : _a.chunkSize,
+        chunkOverlap: (_b = this.config.rag) == null ? void 0 : _b.chunkOverlap
+      });
+    }
+    return this.chunker.chunk(doc.content, {
+      docId: doc.docId,
+      metadata: doc.metadata
+    });
+  }
+  /**
+   * Step 2: Generate embeddings for chunks with retry logic.
+   */
+  async processEmbeddings(chunks) {
+    const embedBatchOptions = {
+      batchSize: 50,
+      maxRetries: 3,
+      initialDelayMs: 100
+    };
+    const vectors = await BatchProcessor.mapWithRetry(
+      chunks.map((c) => c.content),
+      (text) => this.embeddingProvider.embed(text, { taskType: "document" }),
+      embedBatchOptions
+    );
+    if (vectors.length !== chunks.length) {
+      throw new Error(`Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks`);
+    }
+    return vectors;
+  }
+  /**
+   * Step 3: Upsert chunks to vector database with retry logic.
+   */
+  async processUpserts(upsertDocs, namespace) {
+    const upsertBatchOptions = {
+      batchSize: 100,
+      maxRetries: 3,
+      initialDelayMs: 100
+    };
+    const upsertResult = await BatchProcessor.processBatch(
+      upsertDocs,
+      (batch) => this.vectorDB.batchUpsert(batch, namespace),
+      upsertBatchOptions
+    );
+    if (upsertResult.errors.length > 0) {
+      console.warn(`[Pipeline] Ingestion: ${upsertResult.errors.length} batches failed`);
+    }
+    return upsertResult.totalProcessed;
+  }
+  /**
+   * Step 4: Optional graph-based entity extraction and ingestion.
+   */
+  async processGraphIngestion(docId, chunks) {
+    console.log(`[Pipeline] Extracting entities for doc ${docId} (${chunks.length} chunks)...`);
+    const extractionOptions = {
+      batchSize: 2,
+      // Low concurrency for LLM extraction
+      maxRetries: 1,
+      initialDelayMs: 500
+    };
+    await BatchProcessor.processBatch(
+      chunks,
+      async (batch) => {
+        for (const chunk of batch) {
+          try {
+            const { nodes, edges } = await this.entityExtractor.extract(chunk.content);
+            if (nodes.length > 0) await this.graphDB.addNodes(nodes);
+            if (edges.length > 0) await this.graphDB.addEdges(edges);
+          } catch (err) {
+            console.warn(`[Pipeline] Entity extraction failed for chunk:`, err);
+          }
+        }
+      },
+      extractionOptions
+    );
+  }
   async ask(question, history = [], namespace) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a;
     await this.initialize();
-    const ns = namespace != null ? namespace : this.config.projectId;
-    const topK = (_b = (_a = this.config.rag) == null ? void 0 : _a.topK) != null ? _b : 5;
-    const scoreThreshold = (_d = (_c = this.config.rag) == null ? void 0 : _c.scoreThreshold) != null ? _d : 0;
+    if (((_a = this.config.rag) == null ? void 0 : _a.architecture) === "agentic" && this.agent) {
+      console.log("[Pipeline] \u{1F916} Executing in Agentic Mode...");
+      const agentReply = await this.agent.run(question, history);
+      return { reply: agentReply, sources: [] };
+    }
+    const stream = this.askStream(question, history, namespace);
+    let reply = "";
+    let sources = [];
+    let graphData;
     try {
-      let searchQuery = question;
-      if ((_e = this.config.rag) == null ? void 0 : _e.useQueryTransformation) {
-        searchQuery = await this.rewriteQuery(question, history);
-      }
-      const queryVector = await this.embeddingProvider.embed(searchQuery, { taskType: "query" });
-      const fieldHints = extractQueryFieldHints(question);
-      const filter = buildQueryFilter(question, fieldHints);
-      filter.__entityHints = fieldHints;
-      const rawMatches = await this.vectorDB.query(queryVector, topK, ns, filter);
-      const sources = rawMatches.filter((m) => m.score >= scoreThreshold);
-      let graphData;
-      if (this.graphDB && ((_f = this.config.rag) == null ? void 0 : _f.useGraphRetrieval)) {
-        graphData = await this.graphDB.query(searchQuery);
-      }
-      let context = sources.length ? sources.map((m, i) => `[Source ${i + 1}]
+      for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const chunk = temp.value;
+        if (typeof chunk === "string") {
+          reply += chunk;
+        } else if ("sources" in chunk) {
+          sources = chunk.sources;
+          graphData = chunk.graphData;
+        }
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    return { reply, sources, graphData };
+  }
+  /**
+   * High-performance streaming RAG flow.
+   * Yields text chunks first, then the retrieval metadata at the end.
+   */
+  askStream(_0) {
+    return __asyncGenerator(this, arguments, function* (question, history = [], namespace) {
+      var _a, _b, _c, _d, _e, _f;
+      yield new __await(this.initialize());
+      const ns = namespace != null ? namespace : this.config.projectId;
+      const topK = (_b = (_a = this.config.rag) == null ? void 0 : _a.topK) != null ? _b : 5;
+      const scoreThreshold = (_d = (_c = this.config.rag) == null ? void 0 : _c.scoreThreshold) != null ? _d : 0;
+      try {
+        let searchQuery = question;
+        if ((_e = this.config.rag) == null ? void 0 : _e.useQueryTransformation) {
+          searchQuery = yield new __await(this.rewriteQuery(question, history));
+        }
+        const hints = QueryProcessor.extractQueryFieldHints(question);
+        const filter = QueryProcessor.buildQueryFilter(question, hints);
+        const { sources: rawSources, graphData } = yield new __await(this.retrieve(searchQuery, {
+          namespace: ns,
+          topK: topK * 2,
+          filter
+        }));
+        let sources = rawSources.filter((m) => m.score >= scoreThreshold);
+        if ((_f = this.config.rag) == null ? void 0 : _f.useReranking) {
+          sources = yield new __await(this.reranker.rerank(sources, question, topK));
+        } else {
+          sources = sources.slice(0, topK);
+        }
+        let context = sources.length ? sources.map((m, i) => `[Source ${i + 1}]
 ${m.content}`).join("\n\n---\n\n") : "No relevant context found.";
-      if (graphData && graphData.nodes.length > 0) {
-        const graphContext = graphData.nodes.map(
-          (n) => `Entity: ${n.label} (${n.id})${n.properties ? " - " + JSON.stringify(n.properties) : ""}`
-        ).join("\n");
-        context = `GRAPH KNOWLEDGE:
+        if (graphData && graphData.nodes.length > 0) {
+          const graphContext = graphData.nodes.map(
+            (n) => `Entity: ${n.label} (${n.id})${n.properties ? " - " + JSON.stringify(n.properties) : ""}`
+          ).join("\n");
+          context = `GRAPH KNOWLEDGE:
 ${graphContext}
 
 VECTOR CONTEXT:
 ${context}`;
+        }
+        const messages = [...history, { role: "user", content: question }];
+        if (this.llmProvider.chatStream) {
+          try {
+            for (var iter = __forAwait(this.llmProvider.chatStream(messages, context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+              const chunk = temp.value;
+              yield chunk;
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+        } else {
+          const reply = yield new __await(this.llmProvider.chat(messages, context));
+          yield reply;
+        }
+        yield { reply: "", sources, graphData };
+      } catch (error2) {
+        throw new Error(`[Pipeline] Stream failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
       }
-      const messages = [...history, { role: "user", content: question }];
-      const reply = await this.llmProvider.chat(messages, context);
-      return { reply, sources, graphData };
-    } catch (error) {
-      throw new Error(`[Pipeline] Chat failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  }
+  /**
+   * Universal retrieval method combining all enabled providers.
+   */
+  async retrieve(query, options) {
+    var _a, _b, _c;
+    const ns = (_a = options.namespace) != null ? _a : this.config.projectId;
+    const topK = (_b = options.topK) != null ? _b : 5;
+    const cacheKey = `${ns}::${query}`;
+    let queryVector = this.embeddingCache.get(cacheKey);
+    const [retrievedVector, graphData] = await Promise.all([
+      queryVector ? Promise.resolve(queryVector) : this.embeddingProvider.embed(query, { taskType: "query" }),
+      this.graphDB && ((_c = this.config.rag) == null ? void 0 : _c.useGraphRetrieval) ? this.graphDB.query(query) : Promise.resolve(void 0)
+    ]);
+    if (!queryVector) {
+      this.embeddingCache.set(cacheKey, retrievedVector);
+      queryVector = retrievedVector;
     }
+    const sources = await this.vectorDB.query(queryVector, topK, ns, options.filter);
+    return { sources, graphData };
   }
   /**
    * Rewrite the user query for better retrieval performance.
@@ -3324,11 +3685,11 @@ var ProviderHealthCheck = class {
    */
   static async checkVectorProvider(config) {
     const timestamp = Date.now();
-    const configErrors = ConfigValidator.validate({
+    const configErrors = await ConfigValidator.validate({
       projectId: "health-check",
       vectorDb: config,
-      llm: { provider: "openai", model: "gpt-4o" },
-      embedding: { provider: "openai", model: "text-embedding-3-small" }
+      llm: { provider: "openai", model: "gpt-4o", apiKey: "none" },
+      embedding: { provider: "openai", model: "text-embedding-3-small", apiKey: "none" }
     });
     const vectorDbErrors = configErrors.filter((e) => e.field.startsWith("vectorDb"));
     if (vectorDbErrors.length > 0) {
@@ -3340,35 +3701,11 @@ var ProviderHealthCheck = class {
       };
     }
     try {
-      switch (config.provider) {
-        case "pinecone":
-          return await this.checkPinecone(config, timestamp);
-        case "pgvector":
-        case "postgresql":
-          return await this.checkPostgres(config, timestamp);
-        case "mongodb":
-          return await this.checkMongoDB(config, timestamp);
-        case "milvus":
-          return await this.checkMilvus(config, timestamp);
-        case "qdrant":
-          return await this.checkQdrant(config, timestamp);
-        case "chromadb":
-          return await this.checkChromaDB(config, timestamp);
-        case "redis":
-          return await this.checkRedis(config, timestamp);
-        case "weaviate":
-          return await this.checkWeaviate(config, timestamp);
-        case "rest":
-        case "universal_rest":
-          return await this.checkRestAPI(config, timestamp);
-        default:
-          return {
-            healthy: false,
-            provider: config.provider,
-            error: `Unsupported provider: ${config.provider}`,
-            timestamp
-          };
+      const checker = await ProviderRegistry.getVectorHealthChecker(config.provider);
+      if (checker) {
+        return await checker.check(config);
       }
+      return await this.fallbackVectorHealthCheck(config, timestamp);
     } catch (error) {
       return {
         healthy: false,
@@ -3378,363 +3715,50 @@ var ProviderHealthCheck = class {
       };
     }
   }
-  static async checkPinecone(config, timestamp) {
-    var _a, _b;
-    const opts = config.options;
-    try {
-      const { Pinecone: Pinecone2 } = await import("@pinecone-database/pinecone");
-      const client = new Pinecone2({ apiKey: opts.apiKey });
-      const indexes = await client.listIndexes();
-      const indexNames = (_b = (_a = indexes.indexes) == null ? void 0 : _a.map((i) => i.name)) != null ? _b : [];
-      if (!indexNames.includes(config.indexName)) {
+  static async fallbackVectorHealthCheck(config, timestamp) {
+    const opts = config.options || {};
+    const baseUrl = opts.baseUrl || opts.uri;
+    if (baseUrl && baseUrl.startsWith("http")) {
+      try {
+        const response = await fetch(`${baseUrl.replace(/\/$/, "")}/health`);
         return {
-          healthy: false,
-          provider: "pinecone",
-          error: `Index "${config.indexName}" not found. Available: ${indexNames.join(", ")}`,
+          healthy: response.ok,
+          provider: config.provider,
+          error: response.ok ? void 0 : `Health check failed: ${response.status}`,
           timestamp
         };
-      }
-      return {
-        healthy: true,
-        provider: "pinecone",
-        capabilities: { indexes: indexNames.length, targetIndex: config.indexName },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "pinecone",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  static async checkPostgres(config, timestamp) {
-    const opts = config.options;
-    try {
-      const { Client } = await import("pg");
-      const client = new Client({ connectionString: opts.connectionString });
-      await client.connect();
-      const result = await client.query(`
-        SELECT EXISTS(SELECT 1 FROM pg_extension WHERE extname = 'vector');
-      `);
-      const hasVector = result.rows[0].exists;
-      await client.end();
-      return {
-        healthy: true,
-        provider: "postgresql",
-        capabilities: { pgvectorInstalled: hasVector },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "postgresql",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  static async checkMongoDB(config, timestamp) {
-    const opts = config.options;
-    try {
-      const { MongoClient: MongoClient2 } = await import("mongodb");
-      const client = new MongoClient2(opts.uri);
-      await client.connect();
-      const db = client.db(opts.database);
-      const collections = await db.listCollections().toArray();
-      const collectionNames = collections.map((c) => c.name);
-      const hasCollection = collectionNames.includes(opts.collection);
-      await client.close();
-      return {
-        healthy: true,
-        provider: "mongodb",
-        capabilities: {
-          collections: collectionNames.length,
-          targetCollection: hasCollection ? opts.collection : "NOT FOUND (will be created on first insert)"
-        },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "mongodb",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  /**
-   * Milvus health check — uses baseUrl/uri (matching MilvusProvider constructor).
-   */
-  static async checkMilvus(config, timestamp) {
-    const opts = config.options;
-    const baseUrl = opts.baseUrl || opts.uri || (opts.host ? `http://${opts.host}:${opts.port || 19530}` : "http://localhost:19530");
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 5e3);
-      const response = await fetch(`${baseUrl}/v1/health`, { signal: controller.signal });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        throw new Error(`Health check returned ${response.status}`);
-      }
-      return {
-        healthy: true,
-        provider: "milvus",
-        capabilities: { endpoint: baseUrl },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "milvus",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  /**
-   * Qdrant health check — uses baseUrl (matching QdrantProvider constructor).
-   */
-  static async checkQdrant(config, timestamp) {
-    const opts = config.options;
-    const baseUrl = (opts.baseUrl || opts.url || "http://localhost:6333").replace(/\/$/, "");
-    try {
-      const apiKey = opts.apiKey;
-      const response = await fetch(`${baseUrl}/`, {
-        headers: apiKey ? { "api-key": apiKey } : {}
-      });
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      const health = await response.json();
-      return {
-        healthy: true,
-        provider: "qdrant",
-        capabilities: health,
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "qdrant",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  /**
-   * ChromaDB health check — uses baseUrl/host (matching ChromaDBProvider constructor).
-   */
-  static async checkChromaDB(config, timestamp) {
-    const opts = config.options;
-    const baseUrl = opts.baseUrl || (opts.host ? `http://${opts.host}:${opts.port || 8e3}` : "http://localhost:8000");
-    try {
-      const response = await fetch(`${baseUrl}/api/v1/heartbeat`);
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      return {
-        healthy: true,
-        provider: "chromadb",
-        capabilities: { endpoint: baseUrl },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "chromadb",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  /**
-   * Redis health check — Redis is TCP-only (no HTTP endpoint).
-   * We report healthy=true with a note; actual connectivity is validated at first operation.
-   */
-  static async checkRedis(config, timestamp) {
-    const opts = config.options;
-    const url = opts.baseUrl || opts.url || (opts.host && opts.port ? `redis://${opts.host}:${opts.port}` : "redis://localhost:6379");
-    if (url.startsWith("http")) {
-      try {
-        await fetch(url);
-        return { healthy: true, provider: "redis", capabilities: { endpoint: url }, timestamp };
       } catch (e) {
+        return { healthy: false, provider: config.provider, error: "Provider unreachable", timestamp };
       }
     }
     return {
       healthy: true,
-      provider: "redis",
-      capabilities: {
-        endpoint: url,
-        note: "Redis uses TCP; connectivity is validated on first operation."
-      },
+      provider: config.provider,
+      error: "Pluggable health check not implemented; basic reachability assumed.",
       timestamp
     };
   }
-  /**
-   * Weaviate health check — uses baseUrl/url (matching WeaviateProvider constructor).
-   */
-  static async checkWeaviate(config, timestamp) {
-    const opts = config.options;
-    const baseUrl = (opts.baseUrl || opts.url || "http://localhost:8080").replace(/\/$/, "");
-    try {
-      const response = await fetch(`${baseUrl}/v1/.well-known/ready`);
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      return {
-        healthy: true,
-        provider: "weaviate",
-        capabilities: { endpoint: baseUrl },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "weaviate",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  static async checkRestAPI(config, timestamp) {
-    const opts = config.options;
-    const baseUrl = (opts.baseUrl || "").replace(/\/$/, "");
-    if (!baseUrl) {
-      return { healthy: false, provider: "rest", error: "baseUrl is required", timestamp };
-    }
-    try {
-      const response = await fetch(`${baseUrl}/health`, {
-        headers: opts.headers ? JSON.parse(opts.headers) : {}
-      });
-      return {
-        healthy: response.ok,
-        provider: "rest",
-        error: response.ok ? void 0 : `Health check returned ${response.status}`,
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "rest",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
   /**
    * Validates LLM provider configuration.
    */
   static async checkLLMProvider(config) {
     const timestamp = Date.now();
     try {
-      switch (config.provider) {
-        case "openai":
-          return await this.checkOpenAI(config, timestamp);
-        case "anthropic":
-          return await this.checkAnthropic(config, timestamp);
-        case "ollama":
-          return await this.checkOllama(config, timestamp);
-        case "rest":
-        case "universal_rest":
-          return await this.checkLLMRestAPI(config, timestamp);
-        default:
-          return {
-            healthy: false,
-            provider: config.provider,
-            error: `Unsupported provider: ${config.provider}`,
-            timestamp
-          };
+      const checker = LLMFactory.getHealthChecker(config.provider);
+      if (checker) {
+        return await checker.check(config);
       }
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: config.provider,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp
-      };
-    }
-  }
-  static async checkOpenAI(config, timestamp) {
-    try {
-      const OpenAI2 = await import("openai");
-      const client = new OpenAI2.default({ apiKey: config.apiKey });
-      const models = await client.models.list();
-      const hasModel = models.data.some((m) => m.id === config.model);
-      return {
-        healthy: true,
-        provider: "openai",
-        capabilities: { model: config.model, available: hasModel, totalModels: models.data.length },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "openai",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  static async checkAnthropic(config, timestamp) {
-    try {
-      const { default: Anthropic2 } = await import("@anthropic-ai/sdk");
-      const client = new Anthropic2({ apiKey: config.apiKey });
-      await client.messages.create({
-        model: config.model,
-        max_tokens: 10,
-        messages: [{ role: "user", content: "ping" }]
-      });
-      return { healthy: true, provider: "anthropic", capabilities: { model: config.model }, timestamp };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "anthropic",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  static async checkOllama(config, timestamp) {
-    const baseUrl = (config.baseUrl || "http://localhost:11434").replace(/\/$/, "");
-    try {
-      const response = await fetch(`${baseUrl}/api/tags`);
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      const data = await response.json();
-      const models = data.models || [];
-      const hasModel = models.some((m) => m.name === config.model);
       return {
         healthy: true,
-        provider: "ollama",
-        capabilities: { model: config.model, available: hasModel, totalModels: models.length },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "ollama",
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp
-      };
-    }
-  }
-  static async checkLLMRestAPI(config, timestamp) {
-    var _a, _b;
-    const baseUrlRaw = config.baseUrl || ((_a = config.options) == null ? void 0 : _a.baseUrl);
-    const baseUrl = (typeof baseUrlRaw === "string" ? baseUrlRaw : "").replace(/\/$/, "");
-    if (!baseUrl) {
-      return { healthy: false, provider: config.provider, error: "baseUrl is required", timestamp };
-    }
-    try {
-      const headers = (_b = config.options) == null ? void 0 : _b.headers;
-      const response = await fetch(`${baseUrl}/health`, { headers: headers || void 0 });
-      return {
-        healthy: response.ok,
         provider: config.provider,
-        error: response.ok ? void 0 : `Health check returned ${response.status}`,
+        error: "Pluggable health check not implemented; basic reachability assumed.",
         timestamp
       };
     } catch (error) {
       return {
         healthy: false,
         provider: config.provider,
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error),
         timestamp
       };
     }