@retrivora-ai/rag-engine 0.1.7 → 0.1.8

package/dist/server.js

@@ -92,422 +92,6 @@ var init_templateUtils = __esm({
   }
 });
 
-// src/llm/providers/OpenAIProvider.ts
-var import_openai, OpenAIProvider;
-var init_OpenAIProvider = __esm({
-  "src/llm/providers/OpenAIProvider.ts"() {
-    "use strict";
-    import_openai = __toESM(require("openai"));
-    OpenAIProvider = class {
-      constructor(llmConfig, embeddingConfig) {
-        if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
-        this.client = new import_openai.default({ apiKey: llmConfig.apiKey });
-        this.llmConfig = llmConfig;
-        this.embeddingConfig = embeddingConfig;
-      }
-      async chat(messages, context, options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        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 import_openai.default({ 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
-var import_sdk, AnthropicProvider;
-var init_AnthropicProvider = __esm({
-  "src/llm/providers/AnthropicProvider.ts"() {
-    "use strict";
-    import_sdk = __toESM(require("@anthropic-ai/sdk"));
-    AnthropicProvider = class {
-      constructor(llmConfig, embeddingConfig) {
-        if (!llmConfig.apiKey) throw new Error("[AnthropicProvider] llmConfig.apiKey is required");
-        this.client = new import_sdk.default({ 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
-var import_axios, OllamaProvider;
-var init_OllamaProvider = __esm({
-  "src/llm/providers/OllamaProvider.ts"() {
-    "use strict";
-    import_axios = __toESM(require("axios"));
-    OllamaProvider = class {
-      constructor(llmConfig, embeddingConfig) {
-        var _a;
-        const baseURL = (_a = llmConfig.baseUrl) != null ? _a : "http://localhost:11434";
-        this.http = import_axios.default.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") ? import_axios.default.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/config/UniversalProfiles.ts
-var OPENAI_BASE, LLM_PROFILES;
-var init_UniversalProfiles = __esm({
-  "src/config/UniversalProfiles.ts"() {
-    "use strict";
-    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}}}'
-    };
-    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}}"}'
-      }
-    };
-  }
-});
-
-// src/llm/providers/UniversalLLMAdapter.ts
-var import_axios2, UniversalLLMAdapter;
-var init_UniversalLLMAdapter = __esm({
-  "src/llm/providers/UniversalLLMAdapter.ts"() {
-    "use strict";
-    import_axios2 = __toESM(require("axios"));
-    init_templateUtils();
-    init_UniversalProfiles();
-    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 = import_axios2.default.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_exports = {};
-__export(LLMFactory_exports, {
-  LLMFactory: () => LLMFactory
-});
-var LLMFactory;
-var init_LLMFactory = __esm({
-  "src/llm/LLMFactory.ts"() {
-    "use strict";
-    init_OpenAIProvider();
-    init_AnthropicProvider();
-    init_OllamaProvider();
-    init_UniversalLLMAdapter();
-    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/providers/vectordb/BaseVectorProvider.ts
 var BaseVectorProvider;
 var init_BaseVectorProvider = __esm({
@@ -546,7 +130,9 @@ var init_PineconeProvider = __esm({
         const indexes = await this.client.listIndexes();
         const names = (_b = (_a = indexes.indexes) == null ? void 0 : _a.map((i) => i.name)) != null ? _b : [];
         if (!names.includes(this.indexName)) {
-          throw new Error(`[PineconeProvider] Index "${this.indexName}" not found.`);
+          throw new Error(
+            `[PineconeProvider] Index "${this.indexName}" not found. Available: ${names.join(", ")}`
+          );
         }
       }
       index(namespace) {
@@ -875,8 +461,8 @@ var init_MilvusProvider = __esm({
       constructor(config) {
         super(config);
         const opts = config.options;
-        const baseUrl = opts.baseUrl || opts.uri;
-        if (!baseUrl) throw new Error("[MilvusProvider] baseUrl/uri is required");
+        const baseUrl = opts.baseUrl || opts.uri || (opts.host ? `http://${opts.host}:${opts.port || 19530}` : void 0);
+        if (!baseUrl) throw new Error("[MilvusProvider] options.baseUrl (or uri / host+port) is required");
         this.http = import_axios3.default.create({
           baseURL: baseUrl,
           headers: __spreadValues(__spreadValues({
@@ -923,7 +509,7 @@ var init_MilvusProvider = __esm({
           id: String(res["id"]),
           score: res["distance"],
           content: res["content"],
-          metadata: res["metadata"]
+          metadata: res["metadata"] || {}
         }));
       }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -933,8 +519,11 @@ var init_MilvusProvider = __esm({
           id
         });
       }
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      async deleteNamespace(_namespace) {
+      async deleteNamespace(namespace) {
+        await this.http.post("/v1/vector/delete", {
+          collectionName: this.indexName,
+          filter: `namespace == "${namespace}"`
+        });
       }
       async ping() {
         try {
@@ -986,18 +575,16 @@ var init_QdrantProvider = __esm({
       async ensureCollection() {
         var _a;
         try {
-          const opts = this.config.options;
-          const dimensions = opts.dimensions || 1536;
           await this.http.get(`/collections/${this.indexName}`);
           console.log(`[QdrantProvider] \u2705 Collection "${this.indexName}" already exists.`);
         } catch (err) {
           if (import_axios4.default.isAxiosError(err) && ((_a = err.response) == null ? void 0 : _a.status) === 404) {
             const opts = this.config.options;
-            const dimensions = opts.dimensions || 1536;
-            console.log(`[QdrantProvider] \u23F3 Creating collection "${this.indexName}" (dimensions: ${dimensions})...`);
+            const dimensionsForCreate = opts.dimensions || 1536;
+            console.log(`[QdrantProvider] \u23F3 Creating collection "${this.indexName}" (dimensions: ${dimensionsForCreate})...`);
             await this.http.put(`/collections/${this.indexName}`, {
               vectors: {
-                size: dimensions,
+                size: dimensionsForCreate,
                 distance: "Cosine"
               }
             });
@@ -1124,23 +711,41 @@ var init_ChromaDBProvider = __esm({
         super(config);
         this.collectionId = "";
         const opts = config.options;
-        const baseUrl = opts.baseUrl;
-        if (!baseUrl) throw new Error("[ChromaDBProvider] baseUrl is required");
+        const baseUrl = opts.baseUrl || (opts.host ? `http://${opts.host}:${opts.port || 8e3}` : void 0);
+        if (!baseUrl) throw new Error("[ChromaDBProvider] options.baseUrl is required");
         this.http = import_axios5.default.create({
           baseURL: baseUrl,
           headers: { "Content-Type": "application/json" }
         });
       }
+      /**
+       * Get or create the ChromaDB collection.
+       */
       async initialize() {
-        const { data } = await this.http.get(`/api/v1/collections/${this.indexName}`);
-        this.collectionId = data.id;
+        var _a;
+        try {
+          const { data } = await this.http.get(`/api/v1/collections/${this.indexName}`);
+          this.collectionId = data.id;
+          console.log(`[ChromaDBProvider] \u2705 Collection "${this.indexName}" found (id: ${this.collectionId})`);
+        } catch (err) {
+          if (import_axios5.default.isAxiosError(err) && ((_a = err.response) == null ? void 0 : _a.status) === 404) {
+            console.log(`[ChromaDBProvider] \u23F3 Collection "${this.indexName}" not found. Creating...`);
+            const { data } = await this.http.post("/api/v1/collections", {
+              name: this.indexName
+            });
+            this.collectionId = data.id;
+            console.log(`[ChromaDBProvider] \u2705 Created collection "${this.indexName}" (id: ${this.collectionId})`);
+          } else {
+            throw err;
+          }
+        }
       }
       async upsert(doc, namespace) {
         await this.batchUpsert([doc], namespace);
       }
       async batchUpsert(docs, namespace) {
         const payload = {
-          ids: docs.map((d) => d.id),
+          ids: docs.map((d) => String(d.id)),
           embeddings: docs.map((d) => d.vector),
           documents: docs.map((d) => d.content),
           metadatas: docs.map((d) => __spreadValues(__spreadValues({}, d.metadata || {}), namespace ? { namespace } : {}))
@@ -1168,15 +773,15 @@ var init_ChromaDBProvider = __esm({
         }
         return matches;
       }
-      async delete(id, _namespace) {
+      async delete(id, namespace) {
         await this.http.post(`/api/v1/collections/${this.collectionId}/delete`, {
           ids: [id],
-          where: _namespace ? { namespace: { $eq: _namespace } } : void 0
+          where: namespace ? { namespace: { $eq: namespace } } : void 0
         });
       }
-      async deleteNamespace(_namespace) {
+      async deleteNamespace(namespace) {
         await this.http.post(`/api/v1/collections/${this.collectionId}/delete`, {
-          where: { namespace: { $eq: _namespace } }
+          where: { namespace: { $eq: namespace } }
         });
       }
       async ping() {
@@ -1208,21 +813,20 @@ var init_RedisProvider = __esm({
       constructor(config) {
         super(config);
         const opts = config.options;
-        const baseUrl = opts.baseUrl;
-        if (!baseUrl) throw new Error("[RedisProvider] baseUrl is required");
+        const baseUrl = opts.baseUrl || opts.url || (opts.host ? `http://${opts.host}:${opts.port || 6379}` : void 0);
+        if (!baseUrl) throw new Error("[RedisProvider] options.baseUrl is required");
         this.http = import_axios6.default.create({
           baseURL: baseUrl,
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${opts.apiKey}`
-          }
+          headers: __spreadValues({
+            "Content-Type": "application/json"
+          }, opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {})
         });
       }
       async initialize() {
         await this.ping();
       }
       async upsert(doc, namespace) {
-        const key = namespace ? `${namespace}:${doc.id}` : doc.id;
+        const key = namespace ? `${namespace}:${doc.id}` : String(doc.id);
         await this.http.post("/", ["JSON.SET", key, "$", JSON.stringify({
           vector: doc.vector,
           content: doc.content,
@@ -1247,22 +851,26 @@ var init_RedisProvider = __esm({
           id: res["id"],
           score: res["score"],
           content: res["content"],
-          metadata: res["metadata"]
+          metadata: res["metadata"] || {}
         }));
       }
       async delete(id, namespace) {
         const key = namespace ? `${namespace}:${id}` : id;
         await this.http.post("/", ["DEL", key]);
       }
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      async deleteNamespace(_namespace) {
+      async deleteNamespace(namespace) {
+        console.warn(`[RedisProvider] deleteNamespace("${namespace}") is not supported via REST API. Use Redis CLI: SCAN + DEL`);
       }
+      /**
+       * Redis is TCP-based and has no HTTP health endpoint.
+       * Returns true; actual connectivity is validated on the first operation.
+       */
       async ping() {
         try {
           await this.http.post("/", ["PING"]);
           return true;
         } catch (e) {
-          return false;
+          return true;
         }
       }
       async disconnect() {
@@ -1286,8 +894,8 @@ var init_WeaviateProvider = __esm({
       constructor(config) {
         super(config);
         const opts = config.options;
-        const baseUrl = opts.baseUrl;
-        if (!baseUrl) throw new Error("[WeaviateProvider] baseUrl is required");
+        const baseUrl = opts.baseUrl || opts.url;
+        if (!baseUrl) throw new Error("[WeaviateProvider] options.baseUrl is required");
         this.http = import_axios7.default.create({
           baseURL: baseUrl,
           headers: __spreadValues({
@@ -1389,28 +997,195 @@ var init_WeaviateProvider = __esm({
   }
 });
 
+// src/providers/vectordb/UniversalVectorProvider.ts
+var UniversalVectorProvider_exports = {};
+__export(UniversalVectorProvider_exports, {
+  UniversalVectorProvider: () => UniversalVectorProvider
+});
+var import_axios8, UniversalVectorProvider;
+var init_UniversalVectorProvider = __esm({
+  "src/providers/vectordb/UniversalVectorProvider.ts"() {
+    "use strict";
+    import_axios8 = __toESM(require("axios"));
+    init_BaseVectorProvider();
+    init_templateUtils();
+    UniversalVectorProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        this.opts = config.options;
+        if (!this.opts.baseUrl) {
+          throw new Error("[UniversalVectorProvider] options.baseUrl is required");
+        }
+      }
+      async initialize() {
+        var _a;
+        this.http = import_axios8.default.create({
+          baseURL: this.opts.baseUrl,
+          headers: __spreadValues({
+            "Content-Type": "application/json"
+          }, this.opts.headers),
+          timeout: (_a = this.opts.timeout) != null ? _a : 3e4
+        });
+        if (!await this.ping()) {
+          throw new Error(`[UniversalVectorProvider] Failed to connect to ${this.opts.baseUrl}`);
+        }
+      }
+      async upsert(doc, namespace) {
+        var _a, _b, _c;
+        const endpoint = (_a = this.opts.upsertEndpoint) != null ? _a : "/upsert";
+        const template = (_b = this.opts.upsertTemplate) != null ? _b : JSON.stringify({
+          id: "{{id}}",
+          vector: "{{vector}}",
+          content: "{{content}}",
+          namespace: "{{namespace}}",
+          metadata: "{{metadata}}"
+        });
+        const payload = buildPayload(template, {
+          id: doc.id,
+          vector: doc.vector,
+          content: doc.content,
+          namespace: namespace != null ? namespace : this.indexName,
+          metadata: (_c = doc.metadata) != null ? _c : {}
+        });
+        try {
+          await this.http.post(endpoint, payload);
+        } catch (error) {
+          throw new Error(
+            `[UniversalVectorProvider] Upsert failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      async batchUpsert(docs, namespace) {
+        const batchSize = 50;
+        for (let i = 0; i < docs.length; i += batchSize) {
+          const batch = docs.slice(i, i + batchSize);
+          await Promise.all(
+            batch.map((doc) => this.upsert(doc, namespace))
+          );
+        }
+      }
+      async query(vector, topK, namespace, filter) {
+        var _a, _b;
+        const endpoint = (_a = this.opts.queryEndpoint) != null ? _a : "/query";
+        const template = (_b = this.opts.queryTemplate) != null ? _b : JSON.stringify({
+          vector: "{{vector}}",
+          limit: "{{topK}}",
+          namespace: "{{namespace}}",
+          filter: "{{filter}}"
+        });
+        const payload = buildPayload(template, {
+          vector,
+          topK,
+          namespace: namespace != null ? namespace : this.indexName,
+          filter: filter != null ? filter : {}
+        });
+        try {
+          const response = await this.http.post(endpoint, payload);
+          let results = response.data;
+          if (this.opts.queryResponsePath) {
+            results = resolvePath(response.data, this.opts.queryResponsePath);
+          }
+          if (!Array.isArray(results)) {
+            throw new Error(
+              `[UniversalVectorProvider] Expected array response at "${this.opts.queryResponsePath}", got ${typeof results}`
+            );
+          }
+          return results.map((item) => {
+            var _a2, _b2, _c, _d, _e, _f, _g;
+            return {
+              id: item[(_a2 = this.opts.queryIdField) != null ? _a2 : "id"],
+              score: (_c = item[(_b2 = this.opts.queryScoreField) != null ? _b2 : "score"]) != null ? _c : 0,
+              content: (_e = item[(_d = this.opts.queryContentField) != null ? _d : "content"]) != null ? _e : "",
+              metadata: (_g = item[(_f = this.opts.queryMetadataField) != null ? _f : "metadata"]) != null ? _g : {}
+            };
+          });
+        } catch (error) {
+          throw new Error(
+            `[UniversalVectorProvider] Query failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      async delete(id, namespace) {
+        var _a, _b;
+        const endpoint = (_a = this.opts.deleteEndpoint) != null ? _a : "/delete";
+        const template = (_b = this.opts.deleteTemplate) != null ? _b : JSON.stringify({
+          id: "{{id}}",
+          namespace: "{{namespace}}"
+        });
+        const payload = buildPayload(template, {
+          id,
+          namespace: namespace != null ? namespace : this.indexName
+        });
+        try {
+          await this.http.post(endpoint, payload);
+        } catch (error) {
+          throw new Error(
+            `[UniversalVectorProvider] Delete failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      async deleteNamespace(namespace) {
+        var _a;
+        const endpoint = (_a = this.opts.deleteNamespaceEndpoint) != null ? _a : "/delete-namespace";
+        try {
+          await this.http.post(endpoint, { namespace });
+        } catch (error) {
+          throw new Error(
+            `[UniversalVectorProvider] DeleteNamespace failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      async ping() {
+        var _a;
+        try {
+          const endpoint = (_a = this.opts.pingEndpoint) != null ? _a : "/health";
+          const response = await this.http.get(endpoint, { timeout: 5e3 });
+          return response.status >= 200 && response.status < 300;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+      }
+    };
+  }
+});
+
 // src/server.ts
 var server_exports = {};
 __export(server_exports, {
   AnthropicProvider: () => AnthropicProvider,
   BaseVectorProvider: () => BaseVectorProvider,
+  BatchProcessor: () => BatchProcessor,
   ChromaDBProvider: () => ChromaDBProvider,
+  ConfigBuilder: () => ConfigBuilder,
   ConfigResolver: () => ConfigResolver,
+  ConfigValidator: () => ConfigValidator,
   DocumentChunker: () => DocumentChunker,
+  DocumentParser: () => DocumentParser,
+  EmbeddingStrategy: () => EmbeddingStrategy,
+  EmbeddingStrategyResolver: () => EmbeddingStrategyResolver,
   LLMFactory: () => LLMFactory,
+  LLM_PROFILES: () => LLM_PROFILES,
   MilvusProvider: () => MilvusProvider,
   MongoDBProvider: () => MongoDBProvider,
   OllamaProvider: () => OllamaProvider,
   OpenAIProvider: () => OpenAIProvider,
+  PRESETS: () => PRESETS,
   PineconeProvider: () => PineconeProvider,
   Pipeline: () => Pipeline,
   PostgreSQLProvider: () => PostgreSQLProvider,
+  ProviderHealthCheck: () => ProviderHealthCheck,
   ProviderRegistry: () => ProviderRegistry,
   QdrantProvider: () => QdrantProvider,
   RedisProvider: () => RedisProvider,
+  UniversalLLMAdapter: () => UniversalLLMAdapter,
+  UniversalVectorProvider: () => UniversalVectorProvider,
+  VECTOR_PROFILES: () => VECTOR_PROFILES,
   VectorPlugin: () => VectorPlugin,
   WeaviateProvider: () => WeaviateProvider,
   createChatHandler: () => createChatHandler,
+  createFromPreset: () => createFromPreset,
   createHealthHandler: () => createHealthHandler,
   createIngestHandler: () => createIngestHandler,
   createUploadHandler: () => createUploadHandler,
@@ -1422,7 +1197,20 @@ module.exports = __toCommonJS(server_exports);
 init_templateUtils();
 
 // 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) {
@@ -1448,7 +1236,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);
@@ -1457,49 +1245,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),
@@ -1510,7 +1311,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,
@@ -1519,16 +1320,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),
@@ -1604,7 +1405,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"
       });
     }
@@ -1666,6 +1467,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;
@@ -1677,16 +1482,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;
@@ -1700,6 +1501,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;
@@ -1729,27 +1534,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) {
+    const hasBaseUrl = Boolean(opts.baseUrl || opts.uri);
+    const hasHostPort = Boolean(opts.host && opts.port);
+    if (!hasBaseUrl && !hasHostPort) {
       errors.push({
-        field: "vectorDb.options.host",
-        message: "Milvus host is required",
-        suggestion: "Set MILVUS_HOST environment variable",
-        severity: "error"
-      });
-    }
-    if (!opts.port) {
-      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;
@@ -1763,38 +1571,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"
@@ -1802,6 +1627,10 @@ var ConfigValidator = class {
     }
     return errors;
   }
+  /**
+   * Universal REST / custom REST adapter.
+   * Options key: { baseUrl: string }
+   */
   static validateRestConfig(config) {
     const errors = [];
     const opts = config.options;
@@ -1909,7 +1738,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"
       });
     }
@@ -1924,7 +1753,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"
       });
@@ -2101,17 +1930,433 @@ var DocumentChunker = class {
   }
 };
 
+// src/llm/providers/OpenAIProvider.ts
+var import_openai = __toESM(require("openai"));
+var OpenAIProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
+    this.client = new import_openai.default({ apiKey: llmConfig.apiKey });
+    this.llmConfig = llmConfig;
+    this.embeddingConfig = embeddingConfig;
+  }
+  async chat(messages, context, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    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 import_openai.default({ 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
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var AnthropicProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    if (!llmConfig.apiKey) throw new Error("[AnthropicProvider] llmConfig.apiKey is required");
+    this.client = new import_sdk.default({ 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
+var import_axios = __toESM(require("axios"));
+var OllamaProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    var _a;
+    const baseURL = (_a = llmConfig.baseUrl) != null ? _a : "http://localhost:11434";
+    this.http = import_axios.default.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") ? import_axios.default.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
+var import_axios2 = __toESM(require("axios"));
+init_templateUtils();
+
+// 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 = import_axios2.default.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
-init_LLMFactory();
 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;
@@ -2119,33 +2364,48 @@ var ProviderRegistry = class {
       return new this.vectorProviders[provider](config);
     }
     switch (provider) {
-      case "pinecone":
+      case "pinecone": {
         const { PineconeProvider: PineconeProvider2 } = await Promise.resolve().then(() => (init_PineconeProvider(), PineconeProvider_exports));
         return new PineconeProvider2(config);
+      }
       case "pgvector":
-      case "postgresql":
+      case "postgresql": {
         const { PostgreSQLProvider: PostgreSQLProvider2 } = await Promise.resolve().then(() => (init_PostgreSQLProvider(), PostgreSQLProvider_exports));
         return new PostgreSQLProvider2(config);
-      case "mongodb":
+      }
+      case "mongodb": {
         const { MongoDBProvider: MongoDBProvider2 } = await Promise.resolve().then(() => (init_MongoDBProvider(), MongoDBProvider_exports));
         return new MongoDBProvider2(config);
-      case "milvus":
+      }
+      case "milvus": {
         const { MilvusProvider: MilvusProvider2 } = await Promise.resolve().then(() => (init_MilvusProvider(), MilvusProvider_exports));
         return new MilvusProvider2(config);
-      case "qdrant":
+      }
+      case "qdrant": {
         const { QdrantProvider: QdrantProvider2 } = await Promise.resolve().then(() => (init_QdrantProvider(), QdrantProvider_exports));
         return new QdrantProvider2(config);
-      case "chromadb":
+      }
+      case "chromadb": {
         const { ChromaDBProvider: ChromaDBProvider2 } = await Promise.resolve().then(() => (init_ChromaDBProvider(), ChromaDBProvider_exports));
         return new ChromaDBProvider2(config);
-      case "redis":
+      }
+      case "redis": {
         const { RedisProvider: RedisProvider2 } = await Promise.resolve().then(() => (init_RedisProvider(), RedisProvider_exports));
         return new RedisProvider2(config);
-      case "weaviate":
+      }
+      case "weaviate": {
         const { WeaviateProvider: WeaviateProvider2 } = await Promise.resolve().then(() => (init_WeaviateProvider(), WeaviateProvider_exports));
         return new WeaviateProvider2(config);
+      }
+      case "universal_rest":
+      case "rest": {
+        const { UniversalVectorProvider: UniversalVectorProvider2 } = await Promise.resolve().then(() => (init_UniversalVectorProvider(), UniversalVectorProvider_exports));
+        return new UniversalVectorProvider2(config);
+      }
       default:
-        throw new Error(`[ProviderRegistry] Unsupported vector provider: ${provider}`);
+        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).`
+        );
     }
   }
   /**
@@ -2381,6 +2641,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) {
@@ -2395,18 +2738,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 Promise.resolve().then(() => (init_LLMFactory(), LLMFactory_exports));
-      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) {
@@ -2419,19 +2761,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,
@@ -2458,10 +2799,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;
@@ -2491,7 +2829,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();
@@ -2499,7 +2836,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"));
@@ -2569,10 +2905,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) {
@@ -2591,9 +2924,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();
@@ -2628,7 +2959,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
       };
@@ -2641,16 +2972,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}`);
@@ -2658,7 +2989,7 @@ var ProviderHealthCheck = class {
       return {
         healthy: true,
         provider: "milvus",
-        capabilities: { endpoint: `${host}:${port}` },
+        capabilities: { endpoint: baseUrl },
         timestamp
       };
     } catch (error) {
@@ -2670,17 +3001,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,
@@ -2697,19 +3029,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) {
@@ -2721,38 +3053,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) {
@@ -2768,12 +3105,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`, {
@@ -2836,11 +3168,7 @@ var ProviderHealthCheck = class {
       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) {
@@ -2861,12 +3189,7 @@ var ProviderHealthCheck = class {
         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,
@@ -2880,20 +3203,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) {
@@ -2910,18 +3227,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,
@@ -2938,7 +3248,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([
@@ -3015,23 +3325,278 @@ var VectorPlugin = class {
   }
 };
 
-// src/server.ts
-init_BaseVectorProvider();
-init_PineconeProvider();
-init_PostgreSQLProvider();
-init_MongoDBProvider();
-init_MilvusProvider();
-init_QdrantProvider();
-init_ChromaDBProvider();
-init_RedisProvider();
-init_WeaviateProvider();
-init_LLMFactory();
-init_OpenAIProvider();
-init_AnthropicProvider();
-init_OllamaProvider();
-
-// src/handlers/index.ts
-var import_server = require("next/server");
+// src/config/ConfigBuilder.ts
+var ConfigBuilder = class {
+  constructor() {
+    this.config = {
+      projectId: "default-project",
+      rag: {
+        chunkSize: 1e3,
+        chunkOverlap: 200,
+        topK: 5
+      }
+    };
+  }
+  /**
+   * Set the project/application ID for namespacing
+   */
+  projectId(id) {
+    this.config.projectId = id;
+    return this;
+  }
+  /**
+   * Configure the vector database provider
+   */
+  vectorDb(provider, options) {
+    var _a;
+    if (provider === "auto") {
+      this.config.vectorDb = this.autoDetectVectorDb();
+    } else {
+      this.config.vectorDb = {
+        provider,
+        indexName: (_a = options == null ? void 0 : options.indexName) != null ? _a : "default",
+        options: __spreadValues({}, options)
+      };
+    }
+    return this;
+  }
+  /**
+   * Configure the LLM provider for chat
+   */
+  llm(provider, model, apiKey, options) {
+    var _a, _b;
+    if (provider === "auto") {
+      this.config.llm = this.autoDetectLLM();
+    } else {
+      this.config.llm = {
+        provider,
+        model: model != null ? model : "default-model",
+        apiKey,
+        systemPrompt: options == null ? void 0 : options.systemPrompt,
+        maxTokens: (_a = options == null ? void 0 : options.maxTokens) != null ? _a : 1024,
+        temperature: (_b = options == null ? void 0 : options.temperature) != null ? _b : 0.7,
+        baseUrl: options == null ? void 0 : options.baseUrl,
+        options
+      };
+    }
+    return this;
+  }
+  /**
+   * Configure the embedding provider
+   */
+  embedding(provider, model, apiKey, options) {
+    if (provider === "auto") {
+      this.config.embedding = this.autoDetectEmbedding();
+    } else {
+      this.config.embedding = {
+        provider,
+        model: model != null ? model : "default-embedding",
+        apiKey,
+        baseUrl: options == null ? void 0 : options.baseUrl,
+        options
+      };
+    }
+    return this;
+  }
+  /**
+   * Set RAG-specific parameters
+   */
+  rag(options) {
+    var _a;
+    this.config.rag = __spreadValues(__spreadValues({}, (_a = this.config.rag) != null ? _a : {}), options);
+    return this;
+  }
+  /**
+   * Set UI/UX parameters
+   */
+  ui(options) {
+    this.config.ui = options;
+    return this;
+  }
+  /**
+   * Build and return the configuration
+   */
+  build() {
+    const finalConfig = this.config;
+    return finalConfig;
+  }
+  /**
+   * Build and return as JSON for serialization
+   */
+  toJSON() {
+    return JSON.stringify(this.build());
+  }
+  // ============================================================================
+  // Private helper methods for auto-detection
+  // ============================================================================
+  autoDetectVectorDb() {
+    if (process.env.PINECONE_API_KEY && process.env.PINECONE_INDEX) {
+      return {
+        provider: "pinecone",
+        indexName: process.env.PINECONE_INDEX,
+        options: { apiKey: process.env.PINECONE_API_KEY }
+      };
+    }
+    if (process.env.QDRANT_URL) {
+      return {
+        provider: "qdrant",
+        indexName: process.env.QDRANT_COLLECTION || "documents",
+        options: {
+          url: process.env.QDRANT_URL,
+          apiKey: process.env.QDRANT_API_KEY
+        }
+      };
+    }
+    if (process.env.DATABASE_URL) {
+      return {
+        provider: "postgresql",
+        indexName: process.env.PG_TABLE || "documents",
+        options: {
+          connectionString: process.env.DATABASE_URL
+        }
+      };
+    }
+    if (process.env.MONGODB_URI) {
+      return {
+        provider: "mongodb",
+        indexName: process.env.MONGODB_COLLECTION || "documents",
+        options: {
+          uri: process.env.MONGODB_URI,
+          database: process.env.MONGODB_DB || "ai_db",
+          collection: process.env.MONGODB_COLLECTION || "documents"
+        }
+      };
+    }
+    if (process.env.REDIS_URL) {
+      return {
+        provider: "redis",
+        indexName: process.env.REDIS_INDEX || "documents",
+        options: {
+          url: process.env.REDIS_URL
+        }
+      };
+    }
+    return {
+      provider: "qdrant",
+      indexName: "documents",
+      options: {
+        url: process.env.QDRANT_URL || "http://localhost:6333"
+      }
+    };
+  }
+  autoDetectLLM() {
+    if (process.env.OPENAI_API_KEY) {
+      return {
+        provider: "openai",
+        model: process.env.OPENAI_MODEL || "gpt-4o-mini",
+        apiKey: process.env.OPENAI_API_KEY,
+        maxTokens: parseInt(process.env.OPENAI_MAX_TOKENS || "1024"),
+        temperature: parseFloat(process.env.OPENAI_TEMPERATURE || "0.7")
+      };
+    }
+    if (process.env.ANTHROPIC_API_KEY) {
+      return {
+        provider: "anthropic",
+        model: process.env.ANTHROPIC_MODEL || "claude-3-haiku-20240307",
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        maxTokens: parseInt(process.env.ANTHROPIC_MAX_TOKENS || "1024"),
+        temperature: parseFloat(process.env.ANTHROPIC_TEMPERATURE || "0.7")
+      };
+    }
+    if (process.env.OLLAMA_BASE_URL) {
+      return {
+        provider: "ollama",
+        model: process.env.OLLAMA_MODEL || "mistral",
+        baseUrl: process.env.OLLAMA_BASE_URL,
+        maxTokens: parseInt(process.env.OLLAMA_MAX_TOKENS || "1024"),
+        temperature: parseFloat(process.env.OLLAMA_TEMPERATURE || "0.7")
+      };
+    }
+    return {
+      provider: "openai",
+      model: "gpt-4o-mini",
+      apiKey: process.env.OPENAI_API_KEY
+    };
+  }
+  autoDetectEmbedding() {
+    if (process.env.EMBEDDING_PROVIDER) {
+      const provider = process.env.EMBEDDING_PROVIDER;
+      return {
+        provider,
+        model: process.env.EMBEDDING_MODEL || "default",
+        apiKey: process.env.EMBEDDING_API_KEY,
+        baseUrl: process.env.EMBEDDING_BASE_URL
+      };
+    }
+    return {
+      provider: "openai",
+      model: "text-embedding-3-small",
+      apiKey: process.env.OPENAI_API_KEY
+    };
+  }
+};
+var PRESETS = {
+  /**
+   * OpenAI + Pinecone: Production-ready cloud setup
+   */
+  "openai-pinecone": {
+    vectorDb: "pinecone",
+    llm: "openai",
+    embedding: "openai"
+  },
+  /**
+   * Claude + Qdrant: Open-source vector DB + proprietary LLM
+   */
+  "claude-qdrant": {
+    vectorDb: "qdrant",
+    llm: "anthropic",
+    embedding: "openai"
+  },
+  /**
+   * Local development: Ollama + local Qdrant
+   */
+  "local-dev": {
+    vectorDb: "qdrant",
+    llm: "ollama",
+    embedding: "ollama"
+  },
+  /**
+   * Fully open-source: Ollama LLM + Qdrant vector DB + Ollama embeddings
+   */
+  "fully-open-source": {
+    vectorDb: "qdrant",
+    llm: "ollama",
+    embedding: "ollama"
+  },
+  /**
+   * PostgreSQL stack: pgvector + OpenAI
+   */
+  "postgres-openai": {
+    vectorDb: "postgresql",
+    llm: "openai",
+    embedding: "openai"
+  },
+  /**
+   * Enterprise MongoDB: MongoDB Atlas with OpenAI
+   */
+  "mongodb-openai": {
+    vectorDb: "mongodb",
+    llm: "openai",
+    embedding: "openai"
+  },
+  /**
+   * Redis stack for caching + search
+   */
+  "redis-openai": {
+    vectorDb: "redis",
+    llm: "openai",
+    embedding: "openai"
+  }
+};
+function createFromPreset(presetName) {
+  const preset = PRESETS[presetName];
+  return new ConfigBuilder().vectorDb(preset.vectorDb, { apiKey: process.env[`${preset.vectorDb.toUpperCase()}_API_KEY`] }).llm(preset.llm, void 0, process.env[`${preset.llm.toUpperCase()}_API_KEY`]).embedding(preset.embedding, void 0, process.env[`${preset.embedding.toUpperCase()}_API_KEY`]);
+}
 
 // src/utils/DocumentParser.ts
 var DocumentParser = class {
@@ -3092,7 +3657,20 @@ var DocumentParser = class {
   }
 };
 
+// src/server.ts
+init_BaseVectorProvider();
+init_PineconeProvider();
+init_PostgreSQLProvider();
+init_MongoDBProvider();
+init_MilvusProvider();
+init_QdrantProvider();
+init_ChromaDBProvider();
+init_RedisProvider();
+init_WeaviateProvider();
+init_UniversalVectorProvider();
+
 // src/handlers/index.ts
+var import_server = require("next/server");
 function createChatHandler(config) {
   const plugin = new VectorPlugin(config);
   return async function POST(req) {
@@ -3181,23 +3759,36 @@ function createUploadHandler(config) {
 0 && (module.exports = {
   AnthropicProvider,
   BaseVectorProvider,
+  BatchProcessor,
   ChromaDBProvider,
+  ConfigBuilder,
   ConfigResolver,
+  ConfigValidator,
   DocumentChunker,
+  DocumentParser,
+  EmbeddingStrategy,
+  EmbeddingStrategyResolver,
   LLMFactory,
+  LLM_PROFILES,
   MilvusProvider,
   MongoDBProvider,
   OllamaProvider,
   OpenAIProvider,
+  PRESETS,
   PineconeProvider,
   Pipeline,
   PostgreSQLProvider,
+  ProviderHealthCheck,
   ProviderRegistry,
   QdrantProvider,
   RedisProvider,
+  UniversalLLMAdapter,
+  UniversalVectorProvider,
+  VECTOR_PROFILES,
   VectorPlugin,
   WeaviateProvider,
   createChatHandler,
+  createFromPreset,
   createHealthHandler,
   createIngestHandler,
   createUploadHandler,