@retrivora-ai/rag-engine 0.1.7 → 0.1.8

package/dist/{chunk-7YQWGERZ.mjs → chunk-YIYDJQJM.mjs}

@@ -1,8 +1,7 @@
 import {
-  LLMFactory
-} from "./chunk-JI6VD5TJ.mjs";
-import {
-  mergeDefined
+  buildPayload,
+  mergeDefined,
+  resolvePath
 } from "./chunk-UKDXCXW7.mjs";
 import {
   __spreadProps,
@@ -13,7 +12,20 @@ import {
 import { NextResponse } from "next/server";
 
 // src/config/serverConfig.ts
-var VECTOR_DB_PROVIDERS = ["pinecone", "pgvector", "postgresql", "mongodb", "milvus", "qdrant", "chromadb", "redis", "weaviate", "rest", "universal_rest", "custom"];
+var VECTOR_DB_PROVIDERS = [
+  "pinecone",
+  "pgvector",
+  "postgresql",
+  "mongodb",
+  "milvus",
+  "qdrant",
+  "chromadb",
+  "redis",
+  "weaviate",
+  "rest",
+  "universal_rest",
+  "custom"
+];
 var LLM_PROVIDERS = ["openai", "anthropic", "ollama", "rest", "universal_rest", "custom"];
 var EMBEDDING_PROVIDERS = ["openai", "ollama", "rest", "universal_rest", "custom"];
 function readString(env, name) {
@@ -39,7 +51,7 @@ function readEnum(env, name, fallback, allowed) {
   throw new Error(`[getRagConfig] ${name} must be one of: ${allowed.join(", ")}`);
 }
 function getRagConfig(env = process.env) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O;
   const projectId = (_b = (_a = readString(env, "RAG_PROJECT_ID")) != null ? _a : readString(env, "NEXT_PUBLIC_PROJECT_ID")) != null ? _b : "__default__";
   const vectorProvider = readEnum(env, "VECTOR_DB_PROVIDER", "pinecone", VECTOR_DB_PROVIDERS);
   const llmProvider = readEnum(env, "LLM_PROVIDER", "openai", LLM_PROVIDERS);
@@ -48,49 +60,62 @@ function getRagConfig(env = process.env) {
   const vectorDbOptions = {};
   if (vectorProvider === "pinecone") {
     vectorDbOptions.apiKey = (_c = readString(env, "PINECONE_API_KEY")) != null ? _c : "";
-    vectorDbOptions.environment = (_d = readString(env, "PINECONE_ENVIRONMENT")) != null ? _d : "";
-  } else if (vectorProvider === "pgvector") {
-    vectorDbOptions.connectionString = (_e = readString(env, "PGVECTOR_CONNECTION_STRING")) != null ? _e : "";
+  } else if (vectorProvider === "pgvector" || vectorProvider === "postgresql") {
+    vectorDbOptions.connectionString = (_d = readString(env, "PGVECTOR_CONNECTION_STRING")) != null ? _d : "";
+    vectorDbOptions.dimensions = embeddingDimensions;
+  } else if (vectorProvider === "mongodb") {
+    vectorDbOptions.uri = (_e = readString(env, "MONGODB_URI")) != null ? _e : "";
+    vectorDbOptions.database = (_f = readString(env, "MONGODB_DB")) != null ? _f : "";
+    vectorDbOptions.collection = (_g = readString(env, "MONGODB_COLLECTION")) != null ? _g : "";
+    vectorDbOptions.indexName = (_h = readString(env, "MONGODB_INDEX_NAME")) != null ? _h : "vector_index";
+  } else if (vectorProvider === "qdrant") {
+    vectorDbOptions.baseUrl = (_i = readString(env, "QDRANT_URL")) != null ? _i : "http://localhost:6333";
+    vectorDbOptions.apiKey = readString(env, "QDRANT_API_KEY");
     vectorDbOptions.dimensions = embeddingDimensions;
+  } else if (vectorProvider === "milvus") {
+    vectorDbOptions.baseUrl = (_j = readString(env, "MILVUS_URL")) != null ? _j : "http://localhost:19530";
+    vectorDbOptions.apiKey = readString(env, "MILVUS_API_KEY");
+  } else if (vectorProvider === "chromadb") {
+    vectorDbOptions.baseUrl = (_k = readString(env, "CHROMADB_URL")) != null ? _k : "http://localhost:8000";
+  } else if (vectorProvider === "weaviate") {
+    vectorDbOptions.baseUrl = (_l = readString(env, "WEAVIATE_URL")) != null ? _l : "http://localhost:8080";
+    vectorDbOptions.apiKey = readString(env, "WEAVIATE_API_KEY");
+  } else if (vectorProvider === "redis") {
+    vectorDbOptions.baseUrl = (_m = readString(env, "REDIS_URL")) != null ? _m : "";
+    vectorDbOptions.apiKey = readString(env, "REDIS_API_KEY");
   } else if (vectorProvider === "rest") {
-    vectorDbOptions.baseUrl = (_f = readString(env, "VECTOR_DB_REST_URL")) != null ? _f : "";
+    vectorDbOptions.baseUrl = (_n = readString(env, "VECTOR_DB_REST_URL")) != null ? _n : "";
     vectorDbOptions.headers = readString(env, "VECTOR_DB_REST_API_KEY") ? { "api-key": readString(env, "VECTOR_DB_REST_API_KEY") } : {};
   } else if (vectorProvider === "universal_rest") {
-    vectorDbOptions.baseUrl = (_h = (_g = readString(env, "VECTOR_BASE_URL")) != null ? _g : readString(env, "VECTOR_DB_REST_URL")) != null ? _h : "";
+    vectorDbOptions.baseUrl = (_p = (_o = readString(env, "VECTOR_BASE_URL")) != null ? _o : readString(env, "VECTOR_DB_REST_URL")) != null ? _p : "";
     vectorDbOptions.profile = readString(env, "VECTOR_UNIVERSAL_PROFILE");
     vectorDbOptions.headers = readString(env, "VECTOR_DB_REST_API_KEY") ? { Authorization: `Bearer ${readString(env, "VECTOR_DB_REST_API_KEY")}` } : {};
-  } else if (vectorProvider === "mongodb") {
-    vectorDbOptions.uri = (_i = readString(env, "MONGODB_URI")) != null ? _i : "";
-    vectorDbOptions.database = (_j = readString(env, "MONGODB_DB")) != null ? _j : "";
-    vectorDbOptions.collection = (_k = readString(env, "MONGODB_COLLECTION")) != null ? _k : "";
-    vectorDbOptions.indexName = (_l = readString(env, "MONGODB_INDEX_NAME")) != null ? _l : "vector_index";
-  } else if (vectorProvider === "qdrant") {
-    vectorDbOptions.baseUrl = (_m = readString(env, "QDRANT_URL")) != null ? _m : "http://localhost:6333";
-    vectorDbOptions.apiKey = readString(env, "QDRANT_API_KEY");
-    vectorDbOptions.dimensions = embeddingDimensions;
   }
   const llmApiKeyByProvider = {
     openai: readString(env, "OPENAI_API_KEY"),
     anthropic: readString(env, "ANTHROPIC_API_KEY"),
     ollama: void 0,
-    universal_rest: readString(env, "LLM_API_KEY")
+    universal_rest: readString(env, "LLM_API_KEY"),
+    rest: readString(env, "LLM_API_KEY"),
+    custom: readString(env, "LLM_API_KEY")
   };
   const embeddingApiKeyByProvider = {
     openai: readString(env, "OPENAI_API_KEY"),
     ollama: void 0,
-    custom: (_n = readString(env, "EMBEDDING_API_KEY")) != null ? _n : readString(env, "OPENAI_API_KEY")
+    universal_rest: (_q = readString(env, "EMBEDDING_API_KEY")) != null ? _q : readString(env, "OPENAI_API_KEY"),
+    custom: (_r = readString(env, "EMBEDDING_API_KEY")) != null ? _r : readString(env, "OPENAI_API_KEY")
   };
   return {
     projectId,
     vectorDb: {
       provider: vectorProvider,
-      indexName: (_o = readString(env, "VECTOR_DB_INDEX")) != null ? _o : "rag-index",
+      indexName: (_s = readString(env, "VECTOR_DB_INDEX")) != null ? _s : "rag-index",
       options: vectorDbOptions
     },
     llm: {
       provider: llmProvider,
-      model: (_p = readString(env, "LLM_MODEL")) != null ? _p : "gpt-4o",
-      apiKey: (_q = llmApiKeyByProvider[llmProvider]) != null ? _q : "",
+      model: (_t = readString(env, "LLM_MODEL")) != null ? _t : "gpt-4o",
+      apiKey: (_u = llmApiKeyByProvider[llmProvider]) != null ? _u : "",
       baseUrl: readString(env, "LLM_BASE_URL"),
       systemPrompt: readString(env, "LLM_SYSTEM_PROMPT"),
       maxTokens: readNumber(env, "LLM_MAX_TOKENS", 1024),
@@ -101,7 +126,7 @@ function getRagConfig(env = process.env) {
     },
     embedding: {
       provider: embeddingProvider,
-      model: (_r = readString(env, "EMBEDDING_MODEL")) != null ? _r : "text-embedding-3-small",
+      model: (_v = readString(env, "EMBEDDING_MODEL")) != null ? _v : "text-embedding-3-small",
       apiKey: embeddingApiKeyByProvider[embeddingProvider],
       baseUrl: readString(env, "EMBEDDING_BASE_URL"),
       dimensions: embeddingDimensions,
@@ -110,16 +135,16 @@ function getRagConfig(env = process.env) {
       }
     },
     ui: {
-      title: (_t = (_s = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _s : readString(env, "UI_TITLE")) != null ? _t : "AI Assistant",
-      subtitle: (_v = (_u = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _u : readString(env, "UI_SUBTITLE")) != null ? _v : "Powered by RAG",
-      primaryColor: (_x = (_w = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _w : readString(env, "UI_PRIMARY_COLOR")) != null ? _x : "#10b981",
-      accentColor: (_z = (_y = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _y : readString(env, "UI_ACCENT_COLOR")) != null ? _z : "#3b82f6",
-      logoUrl: (_A = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _A : readString(env, "UI_LOGO_URL"),
-      placeholder: (_C = (_B = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _B : readString(env, "UI_PLACEHOLDER")) != null ? _C : "Ask me anything\u2026",
-      showSources: ((_E = (_D = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _D : readString(env, "UI_SHOW_SOURCES")) != null ? _E : "true") !== "false",
-      welcomeMessage: (_G = (_F = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _F : readString(env, "UI_WELCOME_MESSAGE")) != null ? _G : "Hello! I'm your AI assistant. Ask me anything about your documents.",
-      visualStyle: (_I = (_H = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _H : readString(env, "UI_VISUAL_STYLE")) != null ? _I : "glass",
-      borderRadius: (_K = (_J = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _J : readString(env, "UI_BORDER_RADIUS")) != null ? _K : "xl"
+      title: (_x = (_w = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _w : readString(env, "UI_TITLE")) != null ? _x : "AI Assistant",
+      subtitle: (_z = (_y = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _y : readString(env, "UI_SUBTITLE")) != null ? _z : "Powered by RAG",
+      primaryColor: (_B = (_A = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _A : readString(env, "UI_PRIMARY_COLOR")) != null ? _B : "#10b981",
+      accentColor: (_D = (_C = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _C : readString(env, "UI_ACCENT_COLOR")) != null ? _D : "#3b82f6",
+      logoUrl: (_E = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _E : readString(env, "UI_LOGO_URL"),
+      placeholder: (_G = (_F = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _F : readString(env, "UI_PLACEHOLDER")) != null ? _G : "Ask me anything\u2026",
+      showSources: ((_I = (_H = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _H : readString(env, "UI_SHOW_SOURCES")) != null ? _I : "true") !== "false",
+      welcomeMessage: (_K = (_J = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _J : readString(env, "UI_WELCOME_MESSAGE")) != null ? _K : "Hello! I'm your AI assistant. Ask me anything about your documents.",
+      visualStyle: (_M = (_L = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _L : readString(env, "UI_VISUAL_STYLE")) != null ? _M : "glass",
+      borderRadius: (_O = (_N = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _N : readString(env, "UI_BORDER_RADIUS")) != null ? _O : "xl"
     },
     rag: {
       topK: readNumber(env, "RAG_TOP_K", 5),
@@ -195,7 +220,7 @@ var ConfigValidator = class {
       errors.push({
         field: "embedding",
         message: "Embedding config is required when using Anthropic LLM",
-        suggestion: 'Provide embedding config with provider (e.g., "openai")',
+        suggestion: 'Provide embedding config with provider (e.g., "openai" or "ollama")',
         severity: "error"
       });
     }
@@ -257,6 +282,10 @@ var ConfigValidator = class {
     }
     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;
@@ -268,16 +297,12 @@ var ConfigValidator = class {
         severity: "error"
       });
     }
-    if (!opts.environment) {
-      errors.push({
-        field: "vectorDb.options.environment",
-        message: "Pinecone environment is required",
-        suggestion: 'Set PINECONE_ENVIRONMENT environment variable (e.g., "gcp-starter")',
-        severity: "error"
-      });
-    }
     return errors;
   }
+  /**
+   * PostgreSQL / pgvector — needs a connection string.
+   * Options key: { connectionString: string }
+   */
   static validatePostgresConfig(config) {
     const errors = [];
     const opts = config.options;
@@ -291,6 +316,10 @@ var ConfigValidator = class {
     }
     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;
@@ -320,27 +349,30 @@ var ConfigValidator = class {
     }
     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;
-    if (!opts.host) {
-      errors.push({
-        field: "vectorDb.options.host",
-        message: "Milvus host is required",
-        suggestion: "Set MILVUS_HOST environment variable",
-        severity: "error"
-      });
-    }
-    if (!opts.port) {
+    const hasBaseUrl = Boolean(opts.baseUrl || opts.uri);
+    const hasHostPort = Boolean(opts.host && opts.port);
+    if (!hasBaseUrl && !hasHostPort) {
       errors.push({
-        field: "vectorDb.options.port",
-        message: "Milvus port is required",
-        suggestion: "Set MILVUS_PORT environment variable (default: 19530)",
+        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;
@@ -354,38 +386,55 @@ var ConfigValidator = class {
     }
     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.host && !opts.path) {
+    if (!opts.baseUrl && !opts.host) {
       errors.push({
-        field: "vectorDb.options.host",
-        message: "ChromaDB host or path is required",
-        suggestion: "Set CHROMADB_HOST or CHROMADB_PATH environment variable",
+        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;
-    if (!opts.url && (!opts.host || !opts.port)) {
+    const hasUrl = Boolean(opts.baseUrl || opts.url);
+    const hasHostPort = Boolean(opts.host && opts.port);
+    if (!hasUrl && !hasHostPort) {
       errors.push({
-        field: "vectorDb.options.url",
-        message: "Redis connection URL or host:port is required",
-        suggestion: "Set REDIS_URL or REDIS_HOST/REDIS_PORT environment variables",
+        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.url) {
+    if (!opts.baseUrl && !opts.url) {
       errors.push({
-        field: "vectorDb.options.url",
+        field: "vectorDb.options.baseUrl",
         message: "Weaviate instance URL is required",
         suggestion: "Set WEAVIATE_URL environment variable",
         severity: "error"
@@ -393,6 +442,10 @@ var ConfigValidator = class {
     }
     return errors;
   }
+  /**
+   * Universal REST / custom REST adapter.
+   * Options key: { baseUrl: string }
+   */
   static validateRestConfig(config) {
     const errors = [];
     const opts = config.options;
@@ -500,7 +553,7 @@ var ConfigValidator = class {
       errors.push({
         field: "embedding.model",
         message: "Embedding model name is required",
-        suggestion: 'e.g., "text-embedding-3-small" for OpenAI',
+        suggestion: 'e.g., "text-embedding-3-small" for OpenAI, "nomic-embed-text" for Ollama',
         severity: "error"
       });
     }
@@ -515,7 +568,7 @@ var ConfigValidator = class {
     if (config.provider === "ollama" && !config.baseUrl) {
       errors.push({
         field: "embedding.baseUrl",
-        message: "Ollama base URL is required",
+        message: "Ollama base URL is required for embedding",
         suggestion: "Set EMBEDDING_BASE_URL environment variable",
         severity: "error"
       });
@@ -692,16 +745,432 @@ var DocumentChunker = class {
   }
 };
 
+// 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;
+    const systemContent = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Answer questions based on the provided context.
+
+Context:
+${context}`;
+    const systemMessage = {
+      role: "system",
+      content: systemContent.includes("{{context}}") ? systemContent.replace("{{context}}", context) : `${systemContent}
+
+Context:
+${context}`
+    };
+    const formattedMessages = [
+      systemMessage,
+      ...messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }))
+    ];
+    const completion = await this.client.chat.completions.create({
+      model: this.llmConfig.model,
+      messages: formattedMessages,
+      max_tokens: (_c = (_b = options == null ? void 0 : options.maxTokens) != null ? _b : this.llmConfig.maxTokens) != null ? _c : 1024,
+      temperature: (_e = (_d = options == null ? void 0 : options.temperature) != null ? _d : this.llmConfig.temperature) != null ? _e : 0.7,
+      stop: options == null ? void 0 : options.stop
+    });
+    return (_h = (_g = (_f = completion.choices[0]) == null ? void 0 : _f.message) == null ? void 0 : _g.content) != null ? _h : "";
+  }
+  async embed(text, options) {
+    const results = await this.batchEmbed([text], options);
+    return results[0];
+  }
+  async batchEmbed(texts, options) {
+    var _a, _b, _c, _d, _e;
+    const model = (_c = (_b = options == null ? void 0 : options.model) != null ? _b : (_a = this.embeddingConfig) == null ? void 0 : _a.model) != null ? _c : "text-embedding-3-small";
+    const apiKey = (_e = (_d = this.embeddingConfig) == null ? void 0 : _d.apiKey) != null ? _e : this.llmConfig.apiKey;
+    const client = apiKey !== this.llmConfig.apiKey ? new OpenAI({ apiKey }) : this.client;
+    const response = await client.embeddings.create({ model, input: texts });
+    return response.data.map((d) => d.embedding);
+  }
+  async ping() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch (err) {
+      console.error("[OpenAIProvider] Ping failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/llm/providers/AnthropicProvider.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    if (!llmConfig.apiKey) throw new Error("[AnthropicProvider] llmConfig.apiKey is required");
+    this.client = new Anthropic({ apiKey: llmConfig.apiKey });
+    this.llmConfig = llmConfig;
+    this.embeddingConfig = embeddingConfig;
+  }
+  async chat(messages, context, options) {
+    var _a, _b, _c;
+    const systemPrompt = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Use the context below to answer the user's question accurately.
+
+Context:
+${context}`;
+    const system = systemPrompt.includes("{{context}}") ? systemPrompt.replace("{{context}}", context) : `${systemPrompt}
+
+Context:
+${context}`;
+    const anthropicMessages = messages.map((m) => ({
+      role: m.role === "assistant" ? "assistant" : "user",
+      content: m.content
+    }));
+    const response = await this.client.messages.create({
+      model: this.llmConfig.model,
+      max_tokens: (_c = (_b = options == null ? void 0 : options.maxTokens) != null ? _b : this.llmConfig.maxTokens) != null ? _c : 1024,
+      system,
+      messages: anthropicMessages
+    });
+    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;
+    throw new Error(
+      '[AnthropicProvider] Anthropic does not provide an embedding API. Set embedding.provider to "openai" or "ollama" in your RagConfig.'
+    );
+  }
+  async batchEmbed(texts, options) {
+    void texts;
+    void options;
+    throw new Error(
+      "[AnthropicProvider] Anthropic does not provide an embedding API."
+    );
+  }
+  async ping() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch (err) {
+      console.error("[AnthropicProvider] Ping failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/llm/providers/OllamaProvider.ts
+import axios from "axios";
+var OllamaProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    var _a;
+    const baseURL = (_a = llmConfig.baseUrl) != null ? _a : "http://localhost:11434";
+    this.http = axios.create({ baseURL, timeout: 12e4 });
+    this.llmConfig = llmConfig;
+    this.embeddingConfig = embeddingConfig;
+  }
+  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}`;
+    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
+      },
+      messages: [
+        { role: "system", content: system },
+        ...messages.map((m) => ({ role: m.role, content: m.content }))
+      ]
+    });
+    return data.message.content;
+  }
+  async embed(text, options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    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;
+    const { data } = await client.post("/api/embeddings", {
+      model,
+      prompt: text
+    });
+    return data.embedding;
+  }
+  async batchEmbed(texts, options) {
+    const vectors = [];
+    for (const text of texts) {
+      vectors.push(await this.embed(text, options));
+    }
+    return vectors;
+  }
+  async ping() {
+    try {
+      await this.http.get("/api/tags");
+      return true;
+    } catch (err) {
+      console.error("[OllamaProvider] Ping failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/llm/providers/UniversalLLMAdapter.ts
+import axios2 from "axios";
+
+// src/config/UniversalProfiles.ts
+var OPENAI_BASE = {
+  chatPath: "/chat/completions",
+  embedPath: "/embeddings",
+  responseExtractPath: "choices[0].message.content",
+  embedExtractPath: "data[0].embedding",
+  chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"max_tokens":{{maxTokens}},"temperature":{{temperature}}}'
+};
+var LLM_PROFILES = {
+  "openai-compatible": OPENAI_BASE,
+  "litellm": __spreadProps(__spreadValues({}, OPENAI_BASE), {
+    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"max_tokens":{{maxTokens}},"temperature":{{temperature}},"stream":false}'
+  }),
+  "anthropic-claude": {
+    chatPath: "/v1/messages",
+    responseExtractPath: "content[0].text",
+    headers: { "anthropic-version": "2023-06-01" },
+    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"max_tokens":{{maxTokens}}}'
+  },
+  "google-gemini": {
+    chatPath: "/v1beta/models/{{model}}:generateContent",
+    responseExtractPath: "candidates[0].content.parts[0].text",
+    chatPayloadTemplate: '{"contents":[{"parts":[{"text":"{{messages}}"}]}]}'
+  },
+  "github-copilot": __spreadProps(__spreadValues({}, OPENAI_BASE), {
+    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"temperature":{{temperature}}}'
+  }),
+  "ollama-standard": {
+    chatPath: "/api/chat",
+    embedPath: "/api/embeddings",
+    responseExtractPath: "message.content",
+    embedExtractPath: "embedding",
+    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"stream":false}',
+    embedPayloadTemplate: '{"model":"{{model}}","prompt":"{{input}}"}'
+  }
+};
+var VECTOR_PROFILES = {
+  "pinecone-rest": {
+    queryPath: "/query",
+    upsertPath: "/vectors/upsert",
+    responseExtractPath: "matches",
+    idPath: "id",
+    scorePath: "score",
+    contentPath: "metadata.content",
+    metadataPath: "metadata",
+    queryPayloadTemplate: '{"vector":{{vector}},"topK":{{topK}},"includeMetadata":true,"namespace":"{{namespace}}"}'
+  },
+  "mongodb-atlas": {
+    queryPath: "/action/aggregate",
+    responseExtractPath: "documents",
+    idPath: "_id",
+    scorePath: "score",
+    contentPath: "content",
+    metadataPath: "metadata",
+    queryPayloadTemplate: '{"collection":"{{index}}","database":"ai_db","dataSource":"Cluster0","pipeline":[{"$vectorSearch":{"index":"vector_index","path":"embedding","queryVector":{{vector}},"numCandidates":100,"limit":{{topK}}}},{"$project":{"_id":1,"content":1,"metadata":1,"score":{"$meta":"vectorSearchScore"}}}]}'
+  },
+  "chromadb": {
+    queryPath: "/api/v1/collections/{{index}}/query",
+    upsertPath: "/api/v1/collections/{{index}}/add",
+    responseExtractPath: "matches",
+    idPath: "id",
+    scorePath: "distance",
+    contentPath: "document",
+    metadataPath: "metadata"
+  },
+  "qdrant": {
+    queryPath: "/collections/{{index}}/points/search",
+    upsertPath: "/collections/{{index}}/points",
+    responseExtractPath: "result",
+    idPath: "id",
+    scorePath: "score",
+    contentPath: "payload.content",
+    metadataPath: "payload"
+  }
+};
+
+// src/llm/providers/UniversalLLMAdapter.ts
+var UniversalLLMAdapter = class {
+  constructor(config) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.model = config.model;
+    const llmConfig = config;
+    const options = (_a = llmConfig.options) != null ? _a : {};
+    let profile = {};
+    if (typeof options.profile === "string") {
+      profile = LLM_PROFILES[options.profile] || {};
+    } else if (typeof options.profile === "object" && options.profile !== null) {
+      profile = options.profile;
+    }
+    this.opts = __spreadValues(__spreadValues({}, profile), (_b = llmConfig.options) != null ? _b : {});
+    this.systemPrompt = (_c = llmConfig.systemPrompt) != null ? _c : "You are a helpful AI assistant. Use the provided context to answer the user.";
+    this.maxTokens = (_d = llmConfig.maxTokens) != null ? _d : 1024;
+    this.temperature = (_e = llmConfig.temperature) != null ? _e : 0;
+    const baseUrl = (_f = llmConfig.baseUrl) != null ? _f : this.opts.baseUrl;
+    if (!baseUrl) {
+      throw new Error("[UniversalLLMAdapter] baseUrl is required in config or config.options");
+    }
+    this.http = axios2.create({
+      baseURL: baseUrl,
+      headers: __spreadValues(__spreadValues({
+        "Content-Type": "application/json"
+      }, config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}), this.opts.headers || {}),
+      timeout: (_g = this.opts.timeout) != null ? _g : 6e4
+    });
+  }
+  async chat(messages, context) {
+    var _a, _b;
+    const path = (_a = this.opts.chatPath) != null ? _a : "/chat/completions";
+    const formattedMessages = [
+      { role: "system", content: `${this.systemPrompt}
+
+Context:
+${context != null ? context : "None"}` },
+      ...messages
+    ];
+    let payload;
+    if (this.opts.chatPayloadTemplate) {
+      payload = buildPayload(this.opts.chatPayloadTemplate, {
+        model: this.model,
+        messages: formattedMessages,
+        maxTokens: this.maxTokens,
+        temperature: this.temperature
+      });
+    } else {
+      payload = {
+        model: this.model,
+        messages: formattedMessages,
+        max_tokens: this.maxTokens,
+        temperature: this.temperature
+      };
+    }
+    const { data } = await this.http.post(path, payload);
+    const extractPath = (_b = this.opts.responseExtractPath) != null ? _b : "choices[0].message.content";
+    const result = resolvePath(data, extractPath);
+    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
+      });
+    } 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 "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`
+        );
+    }
+  }
+  /**
+   * Creates a dedicated embedding-only provider.
+   * Useful when the LLM provider (e.g. Anthropic) doesn't support embeddings.
+   */
+  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 {
   /**
-   * Register a custom vector provider.
+   * Register a custom vector provider class by name.
+   * The name must match the provider value used in VectorDBConfig.provider.
+   *
+   * @example
+   * ProviderRegistry.registerVectorProvider('my-db', MyCustomProvider);
    */
   static registerVectorProvider(name, providerClass) {
     this.vectorProviders[name] = providerClass;
   }
   /**
    * Creates a vector database provider based on the configuration.
+   * Built-in providers are dynamically imported to avoid bundling all SDKs.
    */
   static async createVectorProvider(config) {
     const { provider } = config;
@@ -709,33 +1178,48 @@ var ProviderRegistry = class {
       return new this.vectorProviders[provider](config);
     }
     switch (provider) {
-      case "pinecone":
-        const { PineconeProvider } = await import("./PineconeProvider-ZRAFNFEC.mjs");
+      case "pinecone": {
+        const { PineconeProvider } = await import("./PineconeProvider-E6L5Z2FO.mjs");
         return new PineconeProvider(config);
+      }
       case "pgvector":
-      case "postgresql":
+      case "postgresql": {
         const { PostgreSQLProvider } = await import("./PostgreSQLProvider-ZNXA67IM.mjs");
         return new PostgreSQLProvider(config);
-      case "mongodb":
+      }
+      case "mongodb": {
         const { MongoDBProvider } = await import("./MongoDBProvider-WWVJG3WT.mjs");
         return new MongoDBProvider(config);
-      case "milvus":
-        const { MilvusProvider } = await import("./MilvusProvider-OO6QGZDZ.mjs");
+      }
+      case "milvus": {
+        const { MilvusProvider } = await import("./MilvusProvider-CJDBCBVI.mjs");
         return new MilvusProvider(config);
-      case "qdrant":
-        const { QdrantProvider } = await import("./QdrantProvider-VAED5VA7.mjs");
+      }
+      case "qdrant": {
+        const { QdrantProvider } = await import("./QdrantProvider-JITRNJQN.mjs");
         return new QdrantProvider(config);
-      case "chromadb":
-        const { ChromaDBProvider } = await import("./ChromaDBProvider-QNI7UCX4.mjs");
+      }
+      case "chromadb": {
+        const { ChromaDBProvider } = await import("./ChromaDBProvider-2JZSBOQX.mjs");
         return new ChromaDBProvider(config);
-      case "redis":
-        const { RedisProvider } = await import("./RedisProvider-ASONNYBI.mjs");
+      }
+      case "redis": {
+        const { RedisProvider } = await import("./RedisProvider-3VKFQXXD.mjs");
         return new RedisProvider(config);
-      case "weaviate":
-        const { WeaviateProvider } = await import("./WeaviateProvider-PSDCUGC7.mjs");
+      }
+      case "weaviate": {
+        const { WeaviateProvider } = await import("./WeaviateProvider-MXIPP44J.mjs");
         return new WeaviateProvider(config);
+      }
+      case "universal_rest":
+      case "rest": {
+        const { UniversalVectorProvider } = await import("./UniversalVectorProvider-E6L4U4OX.mjs");
+        return new UniversalVectorProvider(config);
+      }
       default:
-        throw new Error(`[ProviderRegistry] Unsupported vector provider: ${provider}`);
+        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).`
+        );
     }
   }
   /**
@@ -971,6 +1455,89 @@ ${errorMessages}`
   }
 };
 
+// src/config/EmbeddingStrategy.ts
+var EmbeddingStrategy = /* @__PURE__ */ ((EmbeddingStrategy2) => {
+  EmbeddingStrategy2["INTEGRATED"] = "integrated";
+  EmbeddingStrategy2["SEPARATE"] = "separate";
+  EmbeddingStrategy2["EXTERNAL"] = "external";
+  return EmbeddingStrategy2;
+})(EmbeddingStrategy || {});
+var EmbeddingStrategyResolver = class {
+  /**
+   * Determine strategy based on LLM and embedding configs
+   */
+  static determineStrategy(llmConfig, embeddingConfig) {
+    if (!embeddingConfig) {
+      return this.supportsEmbedding(llmConfig.provider) ? "integrated" /* INTEGRATED */ : "separate" /* SEPARATE */;
+    }
+    if (embeddingConfig.provider !== llmConfig.provider) {
+      return "separate" /* SEPARATE */;
+    }
+    if (embeddingConfig.model !== llmConfig.model) {
+      return "external" /* EXTERNAL */;
+    }
+    return "integrated" /* INTEGRATED */;
+  }
+  /**
+   * Resolve and initialize providers according to the strategy
+   */
+  static async resolve(llmConfig, embeddingConfig) {
+    const strategy = this.determineStrategy(llmConfig, embeddingConfig);
+    const llmProvider = LLMFactory.create(llmConfig, embeddingConfig);
+    let embeddingProvider;
+    switch (strategy) {
+      case "integrated" /* INTEGRATED */:
+        embeddingProvider = llmProvider;
+        break;
+      case "separate" /* SEPARATE */:
+        if (!embeddingConfig) {
+          throw new Error(
+            "[EmbeddingStrategyResolver] SEPARATE strategy requires embeddingConfig"
+          );
+        }
+        embeddingProvider = LLMFactory.createEmbeddingProvider(embeddingConfig);
+        break;
+      case "external" /* EXTERNAL */:
+        if (!embeddingConfig) {
+          throw new Error(
+            "[EmbeddingStrategyResolver] EXTERNAL strategy requires embeddingConfig"
+          );
+        }
+        embeddingProvider = LLMFactory.createEmbeddingProvider(embeddingConfig);
+        break;
+      default:
+        throw new Error(`[EmbeddingStrategyResolver] Unknown strategy: ${strategy}`);
+    }
+    return {
+      strategy,
+      embeddingProvider,
+      llmProvider
+    };
+  }
+  /**
+   * Check if an LLM provider natively supports embeddings
+   */
+  static supportsEmbedding(provider) {
+    const providersWithEmbedding = ["openai", "ollama", "rest", "universal_rest"];
+    return providersWithEmbedding.includes(provider);
+  }
+  /**
+   * Get a human-readable description of the strategy
+   */
+  static getDescription(strategy) {
+    switch (strategy) {
+      case "integrated" /* INTEGRATED */:
+        return "Using LLM provider for both chat and embeddings";
+      case "separate" /* SEPARATE */:
+        return "Using separate embedding provider";
+      case "external" /* EXTERNAL */:
+        return "Using external embedding service";
+      default:
+        return "Unknown strategy";
+    }
+  }
+};
+
 // src/core/Pipeline.ts
 var Pipeline = class {
   constructor(config) {
@@ -985,18 +1552,17 @@ var Pipeline = class {
   async initialize() {
     if (this.initialised) return;
     this.vectorDB = await ProviderRegistry.createVectorProvider(this.config.vectorDb);
-    this.llmProvider = ProviderRegistry.createLLMProvider(this.config.llm, this.config.embedding);
-    if (this.config.llm.provider === "anthropic") {
-      const { LLMFactory: LLMFactory2 } = await import("./LLMFactory-JFOY2V4X.mjs");
-      this.embeddingProvider = LLMFactory2.createEmbeddingProvider(this.config.embedding);
-    } else {
-      this.embeddingProvider = this.llmProvider;
-    }
+    const { llmProvider, embeddingProvider } = await EmbeddingStrategyResolver.resolve(
+      this.config.llm,
+      this.config.embedding
+    );
+    this.llmProvider = llmProvider;
+    this.embeddingProvider = embeddingProvider;
     await this.vectorDB.initialize();
     this.initialised = true;
   }
   /**
-   * Ingest documents with automatic chunking, embedding, and batch processing.
+   * Ingest documents with automatic chunking, embedding, and batch upsert.
    * Handles retries for transient failures.
    */
   async ingest(documents, namespace) {
@@ -1009,19 +1575,18 @@ var Pipeline = class {
           docId: doc.docId,
           metadata: doc.metadata
         });
-        const batchOptions = {
+        const embedBatchOptions = {
           batchSize: 50,
-          // Embedding batch size
           maxRetries: 3,
           initialDelayMs: 100
         };
         const vectors = await BatchProcessor.mapWithRetry(
           chunks.map((c) => c.content),
           (text) => this.embeddingProvider.embed(text),
-          batchOptions
+          embedBatchOptions
         );
         if (vectors.length !== chunks.length) {
-          throw new Error(`Embedding failed: got ${vectors.length} vectors for ${chunks.length} chunks`);
+          throw new Error(`Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks`);
         }
         const upsertDocs = chunks.map((chunk, i) => ({
           id: chunk.id,
@@ -1048,10 +1613,7 @@ var Pipeline = class {
         });
       } catch (error) {
         console.error(`[Pipeline] Failed to ingest document ${doc.docId}:`, error);
-        results.push({
-          docId: doc.docId,
-          chunksIngested: 0
-        });
+        results.push({ docId: doc.docId, chunksIngested: 0 });
       }
     }
     return results;
@@ -1081,7 +1643,6 @@ ${m.content}`).join("\n\n---\n\n") : "No relevant context found.";
 var ProviderHealthCheck = class {
   /**
    * Validates vector database configuration before initialization.
-   * Performs connectivity checks and verifies required resources exist.
    */
   static async checkVectorProvider(config) {
     const timestamp = Date.now();
@@ -1089,7 +1650,6 @@ var ProviderHealthCheck = class {
       projectId: "health-check",
       vectorDb: config,
       llm: { provider: "openai", model: "gpt-4o" },
-      // dummy
       embedding: { provider: "openai", model: "text-embedding-3-small" }
     });
     const vectorDbErrors = configErrors.filter((e) => e.field.startsWith("vectorDb"));
@@ -1159,10 +1719,7 @@ var ProviderHealthCheck = class {
       return {
         healthy: true,
         provider: "pinecone",
-        capabilities: {
-          indexes: indexNames.length,
-          targetIndex: config.indexName
-        },
+        capabilities: { indexes: indexNames.length, targetIndex: config.indexName },
         timestamp
       };
     } catch (error) {
@@ -1181,9 +1738,7 @@ var ProviderHealthCheck = class {
       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'
-        );
+        SELECT EXISTS(SELECT 1 FROM pg_extension WHERE extname = 'vector');
       `);
       const hasVector = result.rows[0].exists;
       await client.end();
@@ -1218,7 +1773,7 @@ var ProviderHealthCheck = class {
         provider: "mongodb",
         capabilities: {
           collections: collectionNames.length,
-          targetCollection: hasCollection ? opts.collection : "NOT FOUND"
+          targetCollection: hasCollection ? opts.collection : "NOT FOUND (will be created on first insert)"
         },
         timestamp
       };
@@ -1231,16 +1786,16 @@ var ProviderHealthCheck = class {
       };
     }
   }
+  /**
+   * Milvus health check — uses baseUrl/uri (matching MilvusProvider constructor).
+   */
   static async checkMilvus(config, timestamp) {
     const opts = config.options;
-    const host = opts.host || "localhost";
-    const port = opts.port || 19530;
+    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(`http://${host}:${port}/healthz`, {
-        signal: controller.signal
-      });
+      const response = await fetch(`${baseUrl}/v1/health`, { signal: controller.signal });
       clearTimeout(timeoutId);
       if (!response.ok) {
         throw new Error(`Health check returned ${response.status}`);
@@ -1248,7 +1803,7 @@ var ProviderHealthCheck = class {
       return {
         healthy: true,
         provider: "milvus",
-        capabilities: { endpoint: `${host}:${port}` },
+        capabilities: { endpoint: baseUrl },
         timestamp
       };
     } catch (error) {
@@ -1260,17 +1815,18 @@ var ProviderHealthCheck = class {
       };
     }
   }
+  /**
+   * 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";
+    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}`);
-      }
+      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
       const health = await response.json();
       return {
         healthy: true,
@@ -1287,19 +1843,19 @@ var ProviderHealthCheck = class {
       };
     }
   }
+  /**
+   * ChromaDB health check — uses baseUrl/host (matching ChromaDBProvider constructor).
+   */
   static async checkChromaDB(config, timestamp) {
     const opts = config.options;
-    const host = opts.host || "localhost";
-    const port = opts.port || 8e3;
+    const baseUrl = opts.baseUrl || (opts.host ? `http://${opts.host}:${opts.port || 8e3}` : "http://localhost:8000");
     try {
-      const response = await fetch(`http://${host}:${port}/api/v1/heartbeat`);
-      if (!response.ok) {
-        throw new Error(`Health check returned ${response.status}`);
-      }
+      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: `${host}:${port}` },
+        capabilities: { endpoint: baseUrl },
         timestamp
       };
     } catch (error) {
@@ -1311,38 +1867,43 @@ var ProviderHealthCheck = class {
       };
     }
   }
+  /**
+   * 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.url || `redis://${opts.host}:${opts.port}`;
-    try {
-      await fetch(url);
-      return {
-        healthy: true,
-        provider: "redis",
-        capabilities: { endpoint: url },
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: "redis",
-        error: `Connection check failed: ${error instanceof Error ? error.message : String(error)}. Ensure Redis is running at ${url}`,
-        timestamp
-      };
+    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: true,
+      provider: "redis",
+      capabilities: {
+        endpoint: url,
+        note: "Redis uses TCP; connectivity is validated on first operation."
+      },
+      timestamp
+    };
   }
+  /**
+   * Weaviate health check — uses baseUrl/url (matching WeaviateProvider constructor).
+   */
   static async checkWeaviate(config, timestamp) {
     const opts = config.options;
-    const url = (opts.url || "http://localhost:8080").replace(/\/$/, "");
+    const baseUrl = (opts.baseUrl || opts.url || "http://localhost:8080").replace(/\/$/, "");
     try {
-      const response = await fetch(`${url}/.well-known/ready`);
-      if (!response.ok) {
-        throw new Error(`Health check returned ${response.status}`);
-      }
+      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: url },
+        capabilities: { endpoint: baseUrl },
         timestamp
       };
     } catch (error) {
@@ -1358,12 +1919,7 @@ var ProviderHealthCheck = class {
     const opts = config.options;
     const baseUrl = (opts.baseUrl || "").replace(/\/$/, "");
     if (!baseUrl) {
-      return {
-        healthy: false,
-        provider: "rest",
-        error: "baseUrl is required",
-        timestamp
-      };
+      return { healthy: false, provider: "rest", error: "baseUrl is required", timestamp };
     }
     try {
       const response = await fetch(`${baseUrl}/health`, {
@@ -1419,18 +1975,14 @@ var ProviderHealthCheck = class {
   }
   static async checkOpenAI(config, timestamp) {
     try {
-      const OpenAI = await import("openai");
-      const client = new OpenAI.default({ apiKey: config.apiKey });
+      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
-        },
+        capabilities: { model: config.model, available: hasModel, totalModels: models.data.length },
         timestamp
       };
     } catch (error) {
@@ -1444,19 +1996,14 @@ var ProviderHealthCheck = class {
   }
   static async checkAnthropic(config, timestamp) {
     try {
-      const { default: Anthropic } = await import("@anthropic-ai/sdk");
-      const client = new Anthropic({ apiKey: config.apiKey });
+      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
-      };
+      return { healthy: true, provider: "anthropic", capabilities: { model: config.model }, timestamp };
     } catch (error) {
       return {
         healthy: false,
@@ -1470,20 +2017,14 @@ var ProviderHealthCheck = class {
     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}`);
-      }
+      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
-        },
+        capabilities: { model: config.model, available: hasModel, totalModels: models.length },
         timestamp
       };
     } catch (error) {
@@ -1500,18 +2041,11 @@ var ProviderHealthCheck = class {
     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
-      };
+      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
-      });
+      const response = await fetch(`${baseUrl}/health`, { headers: headers || void 0 });
       return {
         healthy: response.ok,
         provider: config.provider,
@@ -1528,7 +2062,7 @@ var ProviderHealthCheck = class {
     }
   }
   /**
-   * Runs comprehensive health checks on all configured providers.
+   * Runs comprehensive health checks on all configured providers in parallel.
    */
   static async checkAll(vectorDbConfig, llmConfig, embeddingConfig) {
     const [vectorDb, llm, embedding] = await Promise.all([
@@ -1753,10 +2287,23 @@ function createUploadHandler(config) {
 export {
   getRagConfig,
   ConfigResolver,
+  ConfigValidator,
   DocumentChunker,
+  OpenAIProvider,
+  AnthropicProvider,
+  OllamaProvider,
+  LLM_PROFILES,
+  VECTOR_PROFILES,
+  UniversalLLMAdapter,
+  LLMFactory,
   ProviderRegistry,
+  BatchProcessor,
+  EmbeddingStrategy,
+  EmbeddingStrategyResolver,
   Pipeline,
+  ProviderHealthCheck,
   VectorPlugin,
+  DocumentParser,
   createChatHandler,
   createIngestHandler,
   createHealthHandler,