@retrivora-ai/rag-engine 0.4.5 → 1.0.1

package/dist/{chunk-PRC5CZIZ.mjs → chunk-5W2YWFT3.mjs}

@@ -2,11 +2,15 @@ import {
   buildPayload,
   mergeDefined,
   resolvePath
-} from "./chunk-EDLTMSNY.mjs";
+} from "./chunk-YLTMFW4M.mjs";
 import {
+  __asyncGenerator,
+  __await,
+  __forAwait,
   __spreadProps,
-  __spreadValues
-} from "./chunk-FWCSY2DS.mjs";
+  __spreadValues,
+  __yieldStar
+} from "./chunk-X4TOT24V.mjs";
 
 // src/handlers/index.ts
 import { NextResponse } from "next/server";
@@ -50,7 +54,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
@@ -228,657 +231,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
+import OpenAI from "openai";
+var OpenAIProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
+    this.client = new OpenAI({ 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"
-          });
+        return errors;
+      }
+    };
+  }
+  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
+          };
         }
-        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;
-  }
-  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;
-          }
-        }
-        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
-import OpenAI from "openai";
-var OpenAIProvider = class {
-  constructor(llmConfig, embeddingConfig) {
-    if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
-    this.client = new OpenAI({ apiKey: llmConfig.apiKey });
-    this.llmConfig = llmConfig;
-    this.embeddingConfig = embeddingConfig;
+    };
   }
   async chat(messages, context, options) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -941,6 +355,56 @@ var AnthropicProvider = class {
     this.llmConfig = llmConfig;
     this.embeddingConfig = embeddingConfig;
   }
+  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.
@@ -964,11 +428,6 @@ ${context}`;
     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;
@@ -1004,22 +463,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 axios3 = (await import("axios")).default;
+          const { data } = await axios3.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 },
@@ -1028,13 +531,67 @@ ${context}`;
     });
     return data.message.content;
   }
-  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";
-    const baseURL = (_f = (_e = (_d = this.embeddingConfig) == null ? void 0 : _d.baseUrl) != null ? _e : this.llmConfig.baseUrl) != null ? _f : "http://localhost:11434";
-    const client = baseURL !== ((_g = this.llmConfig.baseUrl) != null ? _g : "http://localhost:11434") ? axios.create({ baseURL, timeout: 6e4 }) : this.http;
-    let prompt = text;
-    const queryPrefix = (_i = (_h = this.embeddingConfig) == null ? void 0 : _h.queryPrefix) != null ? _i : model.includes("nomic") ? "search_query: " : "";
+  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";
+    const baseURL = (_f = (_e = (_d = this.embeddingConfig) == null ? void 0 : _d.baseUrl) != null ? _e : this.llmConfig.baseUrl) != null ? _f : "http://localhost:11434";
+    const client = baseURL !== ((_g = this.llmConfig.baseUrl) != null ? _g : "http://localhost:11434") ? axios.create({ baseURL, timeout: 6e4 }) : this.http;
+    let prompt = text;
+    const queryPrefix = (_i = (_h = this.embeddingConfig) == null ? void 0 : _h.queryPrefix) != null ? _i : model.includes("nomic") ? "search_query: " : "";
     const docPrefix = (_k = (_j = this.embeddingConfig) == null ? void 0 : _j.documentPrefix) != null ? _k : model.includes("nomic") ? "search_document: " : "";
     if ((options == null ? void 0 : options.taskType) === "query" && queryPrefix) {
       if (!prompt.startsWith(queryPrefix)) {
@@ -1084,6 +641,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];
@@ -1325,189 +928,610 @@ ${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 } = await import("./PineconeProvider-QZNRKTN2.mjs");
+        return PineconeProvider;
+      }
+      case "pgvector":
+      case "postgresql": {
+        const { PostgreSQLProvider } = await import("./PostgreSQLProvider-BMOETDZA.mjs");
+        return PostgreSQLProvider;
+      }
+      case "mongodb": {
+        const { MongoDBProvider } = await import("./MongoDBProvider-Z6ALOVDN.mjs");
+        return MongoDBProvider;
+      }
+      case "milvus": {
+        const { MilvusProvider } = await import("./MilvusProvider-U7SKC27V.mjs");
+        return MilvusProvider;
+      }
+      case "qdrant": {
+        const { QdrantProvider } = await import("./QdrantProvider-YNUNEOZH.mjs");
+        return QdrantProvider;
+      }
+      case "chromadb": {
+        const { ChromaDBProvider } = await import("./ChromaDBProvider-MIDOR4FW.mjs");
+        return ChromaDBProvider;
+      }
+      case "redis": {
+        const { RedisProvider } = await import("./RedisProvider-SR65SCKV.mjs");
+        return RedisProvider;
+      }
+      case "weaviate": {
+        const { WeaviateProvider } = await import("./WeaviateProvider-5FWDFITI.mjs");
+        return WeaviateProvider;
+      }
+      case "universal_rest":
+      case "rest": {
+        const { UniversalVectorProvider } = await import("./UniversalVectorProvider-IN67OS56.mjs");
+        return UniversalVectorProvider;
+      }
+      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 } = await import("./SimpleGraphProvider-SLOXO4M7.mjs");
+        return new SimpleGraphProvider(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.
+
+IMPORTANT: Ensure all property values are valid JSON types (strings, numbers, booleans, or null). 
+DO NOT include mathematical expressions like "4.5/5" as numbers; use strings instead.
+
+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 } = await import("./PineconeProvider-BE2JWSPD.mjs");
-        return new PineconeProvider(config);
-      }
-      case "pgvector":
-      case "postgresql": {
-        const { PostgreSQLProvider } = await import("./PostgreSQLProvider-5HHTK4SU.mjs");
-        return new PostgreSQLProvider(config);
-      }
-      case "mongodb": {
-        const { MongoDBProvider } = await import("./MongoDBProvider-RE3Q5S5B.mjs");
-        return new MongoDBProvider(config);
-      }
-      case "milvus": {
-        const { MilvusProvider } = await import("./MilvusProvider-WDVTFB7D.mjs");
-        return new MilvusProvider(config);
-      }
-      case "qdrant": {
-        const { QdrantProvider } = await import("./QdrantProvider-XVDVBNIG.mjs");
-        return new QdrantProvider(config);
-      }
-      case "chromadb": {
-        const { ChromaDBProvider } = await import("./ChromaDBProvider-GI7TB7GJ.mjs");
-        return new ChromaDBProvider(config);
-      }
-      case "redis": {
-        const { RedisProvider } = await import("./RedisProvider-EK2R2PQH.mjs");
-        return new RedisProvider(config);
-      }
-      case "weaviate": {
-        const { WeaviateProvider } = await import("./WeaviateProvider-4CAPQ7UY.mjs");
-        return new WeaviateProvider(config);
-      }
-      case "universal_rest":
-      case "rest": {
-        const { UniversalVectorProvider } = await import("./UniversalVectorProvider-YIDRX6VT.mjs");
-        return new UniversalVectorProvider(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 } = await import("./SimpleGraphProvider-M6T7SE7D.mjs");
-        return new SimpleGraphProvider(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) {
@@ -1815,122 +1839,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);
-      } else {
-        addHint(value);
+    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");
       }
     }
-  }
-  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);
+    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()];
   }
-  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);
+  /**
+   * 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 {
+        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;
   }
-  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(
@@ -1945,6 +1990,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;
   }
   /**
@@ -1957,69 +2006,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);
@@ -2028,45 +2029,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);
+      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;
+        }
       }
-      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);
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
       }
-      let context = sources.length ? sources.map((m, i) => `[Source ${i + 1}]
+    }
+    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.
@@ -2097,11 +2263,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) {
@@ -2113,35 +2279,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,
@@ -2151,363 +2293,50 @@ var ProviderHealthCheck = class {
       };
     }
   }
-  static async checkPinecone(config, timestamp) {
-    var _a, _b;
-    const opts = config.options;
-    try {
-      const { Pinecone } = await import("@pinecone-database/pinecone");
-      const client = new Pinecone({ 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 } = await import("mongodb");
-      const client = new MongoClient(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
       };
     }
@@ -2582,6 +2411,14 @@ var VectorPlugin = class {
   async chat(message, history = [], namespace) {
     return this.pipeline.ask(message, history, namespace);
   }
+  /**
+   * Run a streaming chat query.
+   */
+  chatStream(_0) {
+    return __asyncGenerator(this, arguments, function* (message, history = [], namespace) {
+      yield* __yieldStar(this.pipeline.askStream(message, history, namespace));
+    });
+  }
   /**
    * Ingest documents into the vector database.
    */
@@ -2667,6 +2504,55 @@ function createChatHandler(config) {
     }
   };
 }
+function createStreamHandler(config) {
+  const plugin = new VectorPlugin(config);
+  return async function POST(req) {
+    try {
+      const { message, history = [], namespace } = await req.json();
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        async start(controller) {
+          const pipelineStream = plugin.chatStream(message, history, namespace);
+          try {
+            for (var iter = __forAwait(pipelineStream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+              const chunk = temp.value;
+              if (typeof chunk === "string") {
+                controller.enqueue(encoder.encode(chunk));
+              } else {
+                controller.enqueue(encoder.encode(`
+
+__METADATA__${JSON.stringify(chunk)}`));
+              }
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && await temp.call(iter);
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+          controller.close();
+        }
+      });
+      return new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive"
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      return new Response(JSON.stringify({ error: message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+}
 function createIngestHandler(config) {
   const plugin = new VectorPlugin(config);
   return async function POST(req) {
@@ -2738,8 +2624,6 @@ function createUploadHandler(config) {
 export {
   getRagConfig,
   ConfigResolver,
-  ConfigValidator,
-  DocumentChunker,
   OpenAIProvider,
   AnthropicProvider,
   OllamaProvider,
@@ -2748,6 +2632,8 @@ export {
   UniversalLLMAdapter,
   LLMFactory,
   ProviderRegistry,
+  ConfigValidator,
+  DocumentChunker,
   BatchProcessor,
   EmbeddingStrategy,
   EmbeddingStrategyResolver,
@@ -2756,6 +2642,7 @@ export {
   VectorPlugin,
   DocumentParser,
   createChatHandler,
+  createStreamHandler,
   createIngestHandler,
   createHealthHandler,
   createUploadHandler