@retrivora-ai/rag-engine 0.1.3 → 0.1.5

package/dist/handlers/index.js

@@ -22,6 +22,9 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -44,227 +47,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/handlers/index.ts
-var handlers_exports = {};
-__export(handlers_exports, {
-  createChatHandler: () => createChatHandler,
-  createHealthHandler: () => createHealthHandler,
-  createIngestHandler: () => createIngestHandler,
-  createUploadHandler: () => createUploadHandler
-});
-module.exports = __toCommonJS(handlers_exports);
-var import_server = require("next/server");
-
-// src/vectordb/adapters/PineconeAdapter.ts
-var import_pinecone = require("@pinecone-database/pinecone");
-var PineconeAdapter = class {
-  constructor(config) {
-    this.indexName = config.indexName;
-    const opts = config.options;
-    if (!opts.apiKey) throw new Error("[PineconeAdapter] options.apiKey is required");
-    this.apiKey = opts.apiKey;
-  }
-  async initialize() {
-    var _a, _b;
-    this.client = new import_pinecone.Pinecone({ apiKey: this.apiKey });
-    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(
-        `[PineconeAdapter] Index "${this.indexName}" not found. Available: ${names.join(", ")}`
-      );
-    }
-  }
-  index(namespace) {
-    const idx = this.client.index(this.indexName);
-    return namespace ? idx.namespace(namespace) : idx.namespace("");
-  }
-  async upsert(doc, namespace) {
-    var _a;
-    await this.index(namespace).upsert({
-      records: [
-        {
-          id: doc.id,
-          values: doc.vector,
-          metadata: __spreadValues({
-            content: doc.content
-          }, (_a = doc.metadata) != null ? _a : {})
-        }
-      ]
-    });
-  }
-  async batchUpsert(docs, namespace) {
-    const BATCH = 100;
-    for (let i = 0; i < docs.length; i += BATCH) {
-      const records = docs.slice(i, i + BATCH).map((d) => {
-        var _a;
-        return {
-          id: d.id,
-          values: d.vector,
-          metadata: __spreadValues({
-            content: d.content
-          }, (_a = d.metadata) != null ? _a : {})
-        };
-      });
-      await this.index(namespace).upsert({ records });
-    }
-  }
-  async query(vector, topK, namespace, filter) {
-    var _a;
-    const result = await this.index(namespace).query(__spreadValues({
-      vector,
-      topK,
-      includeMetadata: true
-    }, filter ? { filter } : {}));
-    return ((_a = result.matches) != null ? _a : []).map((m) => {
-      var _a2;
-      const metadata = m.metadata;
-      const content = (metadata == null ? void 0 : metadata.content) || (metadata == null ? void 0 : metadata.text) || (metadata == null ? void 0 : metadata.body) || (metadata == null ? void 0 : metadata.description) || "";
-      return {
-        id: m.id,
-        score: (_a2 = m.score) != null ? _a2 : 0,
-        content,
-        metadata
-      };
-    });
-  }
-  async delete(id, namespace) {
-    await this.index(namespace).deleteOne({ id });
-  }
-  async deleteNamespace(namespace) {
-    await this.client.index(this.indexName).namespace(namespace).deleteAll();
-  }
-  async ping() {
-    try {
-      await this.client.listIndexes();
-      return true;
-    } catch (err) {
-      console.error("[PineconeAdapter] Ping failed:", err);
-      return false;
-    }
-  }
-  async disconnect() {
-  }
-};
-
-// src/vectordb/adapters/PgVectorAdapter.ts
-var import_pg = require("pg");
-var PgVectorAdapter = class {
-  constructor(config) {
-    var _a;
-    this.tableName = config.indexName.replace(/[^a-z0-9_]/gi, "_");
-    const opts = config.options;
-    if (!opts.connectionString) {
-      throw new Error("[PgVectorAdapter] options.connectionString is required");
-    }
-    this.connectionString = opts.connectionString;
-    this.dimensions = (_a = opts.dimensions) != null ? _a : 1536;
-  }
-  async initialize() {
-    this.pool = new import_pg.Pool({ connectionString: this.connectionString });
-    const client = await this.pool.connect();
-    try {
-      await client.query("CREATE EXTENSION IF NOT EXISTS vector");
-      await client.query(`
-        CREATE TABLE IF NOT EXISTS ${this.tableName} (
-          id          TEXT PRIMARY KEY,
-          namespace   TEXT NOT NULL DEFAULT '',
-          content     TEXT NOT NULL,
-          metadata    JSONB,
-          embedding   VECTOR(${this.dimensions})
-        )
-      `);
-      await client.query(`
-        CREATE INDEX IF NOT EXISTS ${this.tableName}_embedding_idx
-        ON ${this.tableName}
-        USING hnsw (embedding vector_cosine_ops)
-      `);
-    } finally {
-      client.release();
-    }
-  }
-  async upsert(doc, namespace = "") {
-    var _a;
-    const vectorLiteral = `[${doc.vector.join(",")}]`;
-    await this.pool.query(
-      `INSERT INTO ${this.tableName} (id, namespace, content, metadata, embedding)
-       VALUES ($1, $2, $3, $4, $5::vector)
-       ON CONFLICT (id) DO UPDATE
-         SET namespace = EXCLUDED.namespace,
-             content   = EXCLUDED.content,
-             metadata  = EXCLUDED.metadata,
-             embedding = EXCLUDED.embedding`,
-      [doc.id, namespace, doc.content, JSON.stringify((_a = doc.metadata) != null ? _a : {}), vectorLiteral]
-    );
-  }
-  async batchUpsert(docs, namespace = "") {
-    for (const doc of docs) {
-      await this.upsert(doc, namespace);
-    }
-  }
-  async query(vector, topK, namespace, filter) {
-    const vectorLiteral = `[${vector.join(",")}]`;
-    let whereClause = namespace ? `WHERE namespace = $3` : "";
-    const params = [vectorLiteral, topK];
-    if (namespace) params.push(namespace);
-    if (filter && Object.keys(filter).length > 0) {
-      const filterConditions = Object.entries(filter).map(([key, val]) => {
-        const paramIdx = params.length + 1;
-        params.push(JSON.stringify(val));
-        return `metadata->>'${key}' = $${paramIdx}`;
-      }).join(" AND ");
-      whereClause = whereClause ? `${whereClause} AND ${filterConditions}` : `WHERE ${filterConditions}`;
-    }
-    const result = await this.pool.query(
-      `SELECT id,
-              content,
-              metadata,
-              1 - (embedding <=> $1::vector) AS score
-       FROM   ${this.tableName}
-       ${whereClause}
-       ORDER  BY embedding <=> $1::vector
-       LIMIT  $2`,
-      params
-    );
-    return result.rows.map((row) => ({
-      id: String(row.id),
-      score: parseFloat(String(row.score)),
-      content: String(row.content),
-      metadata: row.metadata
-    }));
-  }
-  async delete(id, namespace) {
-    const where = namespace ? "WHERE id = $1 AND namespace = $2" : "WHERE id = $1";
-    const params = namespace ? [id, namespace] : [id];
-    await this.pool.query(`DELETE FROM ${this.tableName} ${where}`, params);
-  }
-  async deleteNamespace(namespace) {
-    await this.pool.query(
-      `DELETE FROM ${this.tableName} WHERE namespace = $1`,
-      [namespace]
-    );
-  }
-  async ping() {
-    try {
-      await this.pool.query("SELECT 1");
-      return true;
-    } catch (err) {
-      console.error("[PgVectorAdapter] Ping failed:", err);
-      return false;
-    }
-  }
-  async disconnect() {
-    try {
-      await this.pool.end();
-    } catch (err) {
-      console.error("[PgVectorAdapter] Failed to disconnect:", err);
-    }
-  }
-};
-
-// src/vectordb/adapters/UniversalVectorDBAdapter.ts
-var import_axios = __toESM(require("axios"));
-
 // src/utils/templateUtils.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -292,676 +74,1394 @@ function buildPayload(template, vars) {
 Raw payload: ${raw}`);
   }
 }
-
-// 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}}"}'
+function mergeDefined(base, override) {
+  const merged = __spreadValues({}, base || {});
+  if (!override) {
+    return merged;
+  }
+  for (const [key, value] of Object.entries(override)) {
+    if (value !== void 0 && value !== null && value !== "") {
+      merged[key] = value;
+    }
   }
-};
-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"
+  return merged;
+}
+var init_templateUtils = __esm({
+  "src/utils/templateUtils.ts"() {
+    "use strict";
   }
-};
+});
 
-// src/vectordb/adapters/UniversalVectorDBAdapter.ts
-var UniversalVectorDBAdapter = class {
-  constructor(config) {
-    var _a, _b, _c;
-    this.indexName = config.indexName;
-    const options = (_a = config.options) != null ? _a : {};
-    let profile = {};
-    if (typeof options.profile === "string") {
-      profile = VECTOR_PROFILES[options.profile] || {};
-    } else if (typeof options.profile === "object" && options.profile !== null) {
-      profile = options.profile;
-    }
-    this.opts = __spreadValues(__spreadValues({}, profile), (_b = config.options) != null ? _b : {});
-    if (!this.opts.baseUrl) {
-      throw new Error("[UniversalVectorDBAdapter] options.baseUrl is required");
-    }
-    this.http = import_axios.default.create({
-      baseURL: this.opts.baseUrl,
-      headers: __spreadValues({
-        "Content-Type": "application/json"
-      }, this.opts.headers || {}),
-      timeout: (_c = this.opts.timeout) != null ? _c : 3e4
-    });
-  }
-  async initialize() {
-    if (this.opts.pingPath) {
-      const ok = await this.ping();
-      if (!ok) {
-        throw new Error(`[UniversalVectorDBAdapter] Could not reach health endpoint: ${this.opts.pingPath}`);
+// 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 upsert(doc, namespace) {
-    var _a, _b;
-    const path = (_a = this.opts.upsertPath) != null ? _a : "/upsert";
-    if (this.opts.upsertPayloadTemplate) {
-      const payload = buildPayload(this.opts.upsertPayloadTemplate, {
-        id: doc.id,
-        vector: doc.vector,
-        content: doc.content,
-        metadata: (_b = doc.metadata) != null ? _b : {},
-        namespace: namespace != null ? namespace : "",
-        index: this.indexName
-      });
-      await this.http.post(path, payload);
-    } else {
-      await this.http.post(path, __spreadValues({
-        index: this.indexName,
-        namespace
-      }, doc));
-    }
-  }
-  async batchUpsert(docs, namespace) {
-    var _a;
-    const path = (_a = this.opts.upsertPath) != null ? _a : "/upsert";
-    if (this.opts.batchUpsertPayloadTemplate) {
-      const payload = buildPayload(this.opts.batchUpsertPayloadTemplate, {
-        vectors: docs,
-        namespace: namespace != null ? namespace : "",
-        index: this.indexName
-      });
-      await this.http.post(path, payload);
-    } else {
-      await Promise.all(docs.map((doc) => this.upsert(doc, namespace)));
-    }
+      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;
+        }
+      }
+    };
   }
-  async query(vector, topK, namespace, filter) {
-    var _a, _b, _c, _d, _e, _f;
-    const path = (_a = this.opts.queryPath) != null ? _a : "/query";
-    let payload;
-    if (this.opts.queryPayloadTemplate) {
-      payload = buildPayload(this.opts.queryPayloadTemplate, {
-        vector,
-        topK,
-        namespace: namespace != null ? namespace : "",
-        index: this.indexName,
-        filter: filter != null ? filter : {}
-      });
-    } else {
-      payload = { index: this.indexName, namespace, vector, topK, filter };
-    }
-    const { data } = await this.http.post(path, payload);
-    const extractPath = (_b = this.opts.responseExtractPath) != null ? _b : "matches";
-    const matchesRaw = resolvePath(data, extractPath);
-    if (!Array.isArray(matchesRaw)) {
-      throw new Error(`[UniversalVectorDBAdapter] Expected an array at responseExtractPath '${extractPath}', but got ${typeof matchesRaw}`);
-    }
-    const idPath = (_c = this.opts.idPath) != null ? _c : "id";
-    const scorePath = (_d = this.opts.scorePath) != null ? _d : "score";
-    const contentPath = (_e = this.opts.contentPath) != null ? _e : "content";
-    const metadataPath = (_f = this.opts.metadataPath) != null ? _f : "metadata";
-    return matchesRaw.map((match) => ({
-      id: String(resolvePath(match, idPath) || ""),
-      score: Number(resolvePath(match, scorePath) || 0),
-      content: String(resolvePath(match, contentPath) || ""),
-      metadata: resolvePath(match, metadataPath) || {}
-    }));
+});
+
+// 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;
+        }
+      }
+    };
   }
-  async delete(id, namespace) {
-    var _a;
-    const path = (_a = this.opts.deletePath) != null ? _a : "/delete";
-    await this.http.post(path, { index: this.indexName, namespace, id });
+});
+
+// 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;
+        }
+      }
+    };
   }
-  async deleteNamespace(namespace) {
-    var _a;
-    const path = (_a = this.opts.deleteNamespacePath) != null ? _a : "/delete-namespace";
-    await this.http.post(path, { index: this.indexName, namespace });
+});
+
+// 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}}"}'
+      }
+    };
   }
-  async ping() {
-    try {
-      if (this.opts.pingPath) {
-        await this.http.get(this.opts.pingPath);
+});
+
+// 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
+        });
       }
-      return true;
-    } catch (err) {
-      console.error("[UniversalVectorDBAdapter] Ping failed:", err);
-      return false;
-    }
+      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;
+        }
+      }
+    };
   }
-  async disconnect() {
+});
+
+// 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/vectordb/adapters/MongoDbAdapter.ts
-var import_mongodb = require("mongodb");
-var MongoDbAdapter = class {
-  constructor(options) {
-    this.uri = options.uri;
-    this.dbName = options.database;
-    this.collectionName = options.collection;
-    this.indexName = options.indexName || "vector_index";
-    this.embeddingKey = options.embeddingKey || "embedding";
-    this.contentKey = options.contentKey || "content";
-    this.metadataKey = options.metadataKey || "metadata";
-    if (!this.uri || !this.dbName || !this.collectionName) {
-      throw new Error("MongoDbAdapter requires uri, database, and collection options.");
-    }
-    this.client = new import_mongodb.MongoClient(this.uri);
+// src/providers/vectordb/BaseVectorProvider.ts
+var BaseVectorProvider;
+var init_BaseVectorProvider = __esm({
+  "src/providers/vectordb/BaseVectorProvider.ts"() {
+    "use strict";
+    BaseVectorProvider = class {
+      constructor(config) {
+        this.config = config;
+        this.indexName = config.indexName || "default";
+      }
+    };
   }
-  async initialize() {
-    await this.client.connect();
-    this.db = this.client.db(this.dbName);
-    this.collection = this.db.collection(this.collectionName);
+});
+
+// src/providers/vectordb/PineconeProvider.ts
+var PineconeProvider_exports = {};
+__export(PineconeProvider_exports, {
+  PineconeProvider: () => PineconeProvider
+});
+var import_pinecone, PineconeProvider;
+var init_PineconeProvider = __esm({
+  "src/providers/vectordb/PineconeProvider.ts"() {
+    "use strict";
+    import_pinecone = require("@pinecone-database/pinecone");
+    init_BaseVectorProvider();
+    PineconeProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        const opts = config.options;
+        if (!opts.apiKey) throw new Error("[PineconeProvider] options.apiKey is required");
+        this.apiKey = opts.apiKey;
+      }
+      async initialize() {
+        var _a, _b;
+        this.client = new import_pinecone.Pinecone({ apiKey: this.apiKey });
+        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.`);
+        }
+      }
+      index(namespace) {
+        const idx = this.client.index(this.indexName);
+        return namespace ? idx.namespace(namespace) : idx.namespace("");
+      }
+      async upsert(doc, namespace) {
+        var _a;
+        await this.index(namespace).upsert({
+          records: [{
+            id: doc.id,
+            values: doc.vector,
+            metadata: __spreadValues({ content: doc.content }, (_a = doc.metadata) != null ? _a : {})
+          }]
+        });
+      }
+      async batchUpsert(docs, namespace) {
+        const BATCH = 100;
+        for (let i = 0; i < docs.length; i += BATCH) {
+          const records = docs.slice(i, i + BATCH).map((d) => {
+            var _a;
+            return {
+              id: d.id,
+              values: d.vector,
+              metadata: __spreadValues({ content: d.content }, (_a = d.metadata) != null ? _a : {})
+            };
+          });
+          await this.index(namespace).upsert({ records });
+        }
+      }
+      async query(vector, topK, namespace, filter) {
+        var _a;
+        const result = await this.index(namespace).query(__spreadValues({
+          vector,
+          topK,
+          includeMetadata: true
+        }, filter ? { filter } : {}));
+        return ((_a = result.matches) != null ? _a : []).map((m) => {
+          var _a2, _b;
+          return {
+            id: m.id,
+            score: (_a2 = m.score) != null ? _a2 : 0,
+            content: ((_b = m.metadata) == null ? void 0 : _b.content) || "",
+            metadata: m.metadata
+          };
+        });
+      }
+      async delete(id, namespace) {
+        await this.index(namespace).deleteOne({ id });
+      }
+      async deleteNamespace(namespace) {
+        await this.client.index(this.indexName).namespace(namespace).deleteAll();
+      }
+      async ping() {
+        try {
+          await this.client.listIndexes();
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+      }
+    };
   }
-  async upsert(doc, namespace) {
-    if (!this.collection) await this.initialize();
-    const document = __spreadValues({
-      _id: doc.id,
-      [this.embeddingKey]: doc.vector,
-      [this.contentKey]: doc.content,
-      [this.metadataKey]: doc.metadata || {}
-    }, namespace ? { namespace } : {});
-    await this.collection.updateOne(
-      { _id: doc.id },
-      { $set: document },
-      { upsert: true }
-    );
+});
+
+// src/providers/vectordb/PostgreSQLProvider.ts
+var PostgreSQLProvider_exports = {};
+__export(PostgreSQLProvider_exports, {
+  PostgreSQLProvider: () => PostgreSQLProvider
+});
+var import_pg, PostgreSQLProvider;
+var init_PostgreSQLProvider = __esm({
+  "src/providers/vectordb/PostgreSQLProvider.ts"() {
+    "use strict";
+    import_pg = require("pg");
+    init_BaseVectorProvider();
+    PostgreSQLProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        var _a;
+        super(config);
+        this.tableName = this.indexName.replace(/[^a-z0-9_]/gi, "_");
+        const opts = config.options;
+        if (!opts.connectionString) throw new Error("[PostgreSQLProvider] options.connectionString is required");
+        this.connectionString = opts.connectionString;
+        this.dimensions = (_a = opts.dimensions) != null ? _a : 1536;
+      }
+      async initialize() {
+        this.pool = new import_pg.Pool({ connectionString: this.connectionString });
+        const client = await this.pool.connect();
+        try {
+          await client.query("CREATE EXTENSION IF NOT EXISTS vector");
+          await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          id          TEXT PRIMARY KEY,
+          namespace   TEXT NOT NULL DEFAULT '',
+          content     TEXT NOT NULL,
+          metadata    JSONB,
+          embedding   VECTOR(${this.dimensions})
+        )
+      `);
+          await client.query(`
+        CREATE INDEX IF NOT EXISTS ${this.tableName}_embedding_idx
+        ON ${this.tableName}
+        USING hnsw (embedding vector_cosine_ops)
+      `);
+        } finally {
+          client.release();
+        }
+      }
+      async upsert(doc, namespace = "") {
+        var _a;
+        const vectorLiteral = `[${doc.vector.join(",")}]`;
+        await this.pool.query(
+          `INSERT INTO ${this.tableName} (id, namespace, content, metadata, embedding)
+       VALUES ($1, $2, $3, $4, $5::vector)
+       ON CONFLICT (id) DO UPDATE
+         SET namespace = EXCLUDED.namespace,
+             content   = EXCLUDED.content,
+             metadata  = EXCLUDED.metadata,
+             embedding = EXCLUDED.embedding`,
+          [doc.id, namespace, doc.content, JSON.stringify((_a = doc.metadata) != null ? _a : {}), vectorLiteral]
+        );
+      }
+      async batchUpsert(docs, namespace = "") {
+        for (const doc of docs) {
+          await this.upsert(doc, namespace);
+        }
+      }
+      async query(vector, topK, namespace, filter) {
+        const vectorLiteral = `[${vector.join(",")}]`;
+        let whereClause = namespace ? `WHERE namespace = $3` : "";
+        const params = [vectorLiteral, topK];
+        if (namespace) params.push(namespace);
+        if (filter && Object.keys(filter).length > 0) {
+          const filterConditions = Object.entries(filter).map(([key, val]) => {
+            const paramIdx = params.length + 1;
+            params.push(JSON.stringify(val));
+            return `metadata->>'${key}' = $${paramIdx}`;
+          }).join(" AND ");
+          whereClause = whereClause ? `${whereClause} AND ${filterConditions}` : `WHERE ${filterConditions}`;
+        }
+        const result = await this.pool.query(
+          `SELECT id, content, metadata, 1 - (embedding <=> $1::vector) AS score
+       FROM ${this.tableName}
+       ${whereClause}
+       ORDER BY embedding <=> $1::vector
+       LIMIT $2`,
+          params
+        );
+        return result.rows.map((row) => ({
+          id: String(row["id"]),
+          score: parseFloat(String(row["score"])),
+          content: String(row["content"]),
+          metadata: row["metadata"]
+        }));
+      }
+      async delete(id, namespace) {
+        const where = namespace ? "WHERE id = $1 AND namespace = $2" : "WHERE id = $1";
+        const params = namespace ? [id, namespace] : [id];
+        await this.pool.query(`DELETE FROM ${this.tableName} ${where}`, params);
+      }
+      async deleteNamespace(namespace) {
+        await this.pool.query(`DELETE FROM ${this.tableName} WHERE namespace = $1`, [namespace]);
+      }
+      async ping() {
+        try {
+          await this.pool.query("SELECT 1");
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+        await this.pool.end();
+      }
+    };
   }
-  async batchUpsert(docs, namespace) {
-    if (!this.collection) await this.initialize();
-    const operations = docs.map((doc) => ({
-      updateOne: {
-        filter: { _id: doc.id },
-        update: {
-          $set: __spreadValues({
-            _id: doc.id,
-            [this.embeddingKey]: doc.vector,
-            [this.contentKey]: doc.content,
-            [this.metadataKey]: doc.metadata || {}
-          }, namespace ? { namespace } : {})
-        },
-        upsert: true
-      }
-    }));
-    await this.collection.bulkWrite(operations);
+});
+
+// src/providers/vectordb/MongoDBProvider.ts
+var MongoDBProvider_exports = {};
+__export(MongoDBProvider_exports, {
+  MongoDBProvider: () => MongoDBProvider
+});
+var import_mongodb, MongoDBProvider;
+var init_MongoDBProvider = __esm({
+  "src/providers/vectordb/MongoDBProvider.ts"() {
+    "use strict";
+    import_mongodb = require("mongodb");
+    init_BaseVectorProvider();
+    MongoDBProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        const opts = config.options;
+        if (!opts.uri || !opts.database || !opts.collection) {
+          throw new Error("[MongoDBProvider] options uri, database, and collection are required.");
+        }
+        this.client = new import_mongodb.MongoClient(opts.uri);
+        this.dbName = opts.database;
+        this.collectionName = opts.collection;
+        this.embeddingKey = opts.embeddingKey || "embedding";
+        this.contentKey = opts.contentKey || "content";
+        this.metadataKey = opts.metadataKey || "metadata";
+      }
+      async initialize() {
+        await this.client.connect();
+        this.db = this.client.db(this.dbName);
+        this.collection = this.db.collection(this.collectionName);
+      }
+      async upsert(doc, namespace) {
+        const document = __spreadValues({
+          _id: doc.id,
+          [this.embeddingKey]: doc.vector,
+          [this.contentKey]: doc.content,
+          [this.metadataKey]: doc.metadata || {}
+        }, namespace ? { namespace } : {});
+        await this.collection.updateOne({ _id: doc.id }, { $set: document }, { upsert: true });
+      }
+      async batchUpsert(docs, namespace) {
+        const operations = docs.map((doc) => ({
+          updateOne: {
+            filter: { _id: doc.id },
+            update: {
+              $set: __spreadValues({
+                [this.embeddingKey]: doc.vector,
+                [this.contentKey]: doc.content,
+                [this.metadataKey]: doc.metadata || {}
+              }, namespace ? { namespace } : {})
+            },
+            upsert: true
+          }
+        }));
+        await this.collection.bulkWrite(operations);
+      }
+      async query(vector, topK, namespace, filter) {
+        const pipeline = [
+          {
+            $vectorSearch: __spreadValues({
+              index: this.config.options.indexName || "vector_index",
+              path: this.embeddingKey,
+              queryVector: vector,
+              numCandidates: Math.max(topK * 10, 100),
+              limit: topK
+            }, filter || namespace ? { filter: __spreadValues(__spreadValues({}, filter || {}), namespace ? { namespace } : {}) } : {})
+          },
+          {
+            $project: {
+              score: { $meta: "vectorSearchScore" },
+              content: `$${this.contentKey}`,
+              metadata: `$${this.metadataKey}`
+            }
+          }
+        ];
+        const results = await this.collection.aggregate(pipeline).toArray();
+        return results.map((res) => ({
+          id: res["_id"].toString(),
+          score: res["score"],
+          content: res["content"],
+          metadata: res["metadata"]
+        }));
+      }
+      async delete(id, namespace) {
+        await this.collection.deleteOne(__spreadValues({ _id: id }, namespace ? { namespace } : {}));
+      }
+      async deleteNamespace(namespace) {
+        await this.collection.deleteMany({ namespace });
+      }
+      async ping() {
+        try {
+          await this.db.command({ ping: 1 });
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+        await this.client.close();
+      }
+    };
   }
-  async query(vector, topK, namespace, filter) {
-    if (!this.collection) await this.initialize();
-    const pipeline = [
-      {
-        $vectorSearch: __spreadValues({
-          index: this.indexName,
-          path: this.embeddingKey,
-          queryVector: vector,
-          numCandidates: Math.max(topK * 10, 100),
-          limit: topK
-        }, filter || namespace ? {
-          filter: __spreadValues(__spreadValues({}, filter || {}), namespace ? { namespace } : {})
-        } : {})
-      },
-      {
-        $project: {
-          score: { $meta: "vectorSearchScore" },
-          content: `$${this.contentKey}`,
-          metadata: `$${this.metadataKey}`
+});
+
+// src/providers/vectordb/MilvusProvider.ts
+var MilvusProvider_exports = {};
+__export(MilvusProvider_exports, {
+  MilvusProvider: () => MilvusProvider
+});
+var import_axios3, MilvusProvider;
+var init_MilvusProvider = __esm({
+  "src/providers/vectordb/MilvusProvider.ts"() {
+    "use strict";
+    import_axios3 = __toESM(require("axios"));
+    init_BaseVectorProvider();
+    MilvusProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        const opts = config.options;
+        const baseUrl = opts.baseUrl || opts.uri;
+        if (!baseUrl) throw new Error("[MilvusProvider] baseUrl/uri is required");
+        this.http = import_axios3.default.create({
+          baseURL: baseUrl,
+          headers: __spreadValues(__spreadValues({
+            "Content-Type": "application/json"
+          }, opts.headers || {}), opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {})
+        });
+      }
+      async initialize() {
+        await this.ping();
+      }
+      async upsert(doc, namespace) {
+        const payload = {
+          collectionName: this.indexName,
+          data: [__spreadValues({
+            vector: doc.vector,
+            content: doc.content,
+            metadata: doc.metadata || {}
+          }, namespace ? { namespace } : {})]
+        };
+        await this.http.post("/v1/vector/upsert", payload);
+      }
+      async batchUpsert(docs, namespace) {
+        const payload = {
+          collectionName: this.indexName,
+          data: docs.map((doc) => __spreadValues({
+            vector: doc.vector,
+            content: doc.content,
+            metadata: doc.metadata || {}
+          }, namespace ? { namespace } : {}))
+        };
+        await this.http.post("/v1/vector/upsert", payload);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async query(vector, topK, namespace, _filter) {
+        const payload = {
+          collectionName: this.indexName,
+          vector,
+          limit: topK,
+          filter: namespace ? `namespace == "${namespace}"` : void 0,
+          outputFields: ["content", "metadata"]
+        };
+        const { data } = await this.http.post("/v1/vector/search", payload);
+        return (data.data || []).map((res) => ({
+          id: String(res["id"]),
+          score: res["distance"],
+          content: res["content"],
+          metadata: res["metadata"]
+        }));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async delete(id, _namespace) {
+        await this.http.post("/v1/vector/delete", {
+          collectionName: this.indexName,
+          id
+        });
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async deleteNamespace(_namespace) {
+      }
+      async ping() {
+        try {
+          await this.http.get("/v1/health");
+          return true;
+        } catch (e) {
+          return false;
         }
       }
-    ];
-    const results = await this.collection.aggregate(pipeline).toArray();
-    return results.map((res) => ({
-      id: res._id.toString(),
-      score: res.score,
-      content: res.content,
-      metadata: res.metadata
-    }));
-  }
-  async delete(id, namespace) {
-    if (!this.collection) await this.initialize();
-    const query = __spreadValues({ _id: id }, namespace ? { namespace } : {});
-    await this.collection.deleteOne(query);
-  }
-  async deleteNamespace(namespace) {
-    if (!this.collection) await this.initialize();
-    await this.collection.deleteMany({ namespace });
-  }
-  async ping() {
-    try {
-      if (!this.collection) await this.initialize();
-      await this.db.command({ ping: 1 });
-      return true;
-    } catch (err) {
-      console.error("[MongoDbAdapter] Ping failed:", err);
-      return false;
-    }
-  }
-  async disconnect() {
-    try {
-      await this.client.close();
-      this.db = void 0;
-      this.collection = void 0;
-    } catch (err) {
-      console.error("[MongoDbAdapter] Failed to disconnect:", err);
-    }
+      async disconnect() {
+      }
+    };
   }
-};
+});
 
-// src/vectordb/VectorDBFactory.ts
-var VectorDBFactory = class {
-  static create(config) {
-    var _a;
-    switch (config.provider) {
-      case "pinecone":
-        return new PineconeAdapter(config);
-      case "pgvector":
-        return new PgVectorAdapter(config);
-      case "mongodb":
-        return new MongoDbAdapter(config.options);
-      case "rest":
-      case "universal_rest":
-      case "custom":
-        return new UniversalVectorDBAdapter(config);
-      default:
-        if ((_a = config.options) == null ? void 0 : _a.baseUrl) {
-          return new UniversalVectorDBAdapter(config);
+// src/providers/vectordb/QdrantProvider.ts
+var QdrantProvider_exports = {};
+__export(QdrantProvider_exports, {
+  QdrantProvider: () => QdrantProvider
+});
+var import_axios4, QdrantProvider;
+var init_QdrantProvider = __esm({
+  "src/providers/vectordb/QdrantProvider.ts"() {
+    "use strict";
+    import_axios4 = __toESM(require("axios"));
+    init_BaseVectorProvider();
+    QdrantProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        const opts = config.options;
+        const baseUrl = opts.baseUrl;
+        if (!baseUrl) throw new Error("[QdrantProvider] baseUrl is required");
+        this.http = import_axios4.default.create({
+          baseURL: baseUrl,
+          headers: __spreadValues({
+            "Content-Type": "application/json"
+          }, opts.apiKey ? { "api-key": opts.apiKey } : {})
+        });
+      }
+      async initialize() {
+        await this.ping();
+      }
+      async upsert(doc, namespace) {
+        await this.batchUpsert([doc], namespace);
+      }
+      async batchUpsert(docs, namespace) {
+        const payload = {
+          points: docs.map((doc) => ({
+            id: doc.id,
+            vector: doc.vector,
+            payload: __spreadValues({
+              content: doc.content,
+              metadata: doc.metadata || {}
+            }, namespace ? { namespace } : {})
+          }))
+        };
+        await this.http.put(`/collections/${this.indexName}/points`, payload);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async query(vector, topK, namespace, _filter) {
+        const payload = {
+          vector,
+          limit: topK,
+          with_payload: true,
+          filter: namespace ? {
+            must: [{ key: "namespace", match: { value: namespace } }]
+          } : void 0
+        };
+        const { data } = await this.http.post(`/collections/${this.indexName}/points/search`, payload);
+        return (data.result || []).map((res) => {
+          var _a, _b;
+          return {
+            id: res["id"],
+            score: res["score"],
+            content: ((_a = res["payload"]) == null ? void 0 : _a.content) || "",
+            metadata: ((_b = res["payload"]) == null ? void 0 : _b.metadata) || {}
+          };
+        });
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async delete(id, _namespace) {
+        await this.http.post(`/collections/${this.indexName}/points/delete`, {
+          points: [id]
+        });
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async deleteNamespace(_namespace) {
+        await this.http.post(`/collections/${this.indexName}/points/delete`, {
+          filter: {
+            must: [{ key: "namespace", match: { value: _namespace } }]
+          }
+        });
+      }
+      async ping() {
+        try {
+          await this.http.get("/healthz");
+          return true;
+        } catch (e) {
+          return false;
         }
-        throw new Error(
-          `[VectorDBFactory] Unknown provider "${config.provider}". Supported: pinecone | pgvector | mongodb | rest`
-        );
-    }
+      }
+      async disconnect() {
+      }
+    };
   }
-};
+});
 
-// 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;
+// src/providers/vectordb/ChromaDBProvider.ts
+var ChromaDBProvider_exports = {};
+__export(ChromaDBProvider_exports, {
+  ChromaDBProvider: () => ChromaDBProvider
+});
+var import_axios5, ChromaDBProvider;
+var init_ChromaDBProvider = __esm({
+  "src/providers/vectordb/ChromaDBProvider.ts"() {
+    "use strict";
+    import_axios5 = __toESM(require("axios"));
+    init_BaseVectorProvider();
+    ChromaDBProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        this.collectionId = "";
+        const opts = config.options;
+        const baseUrl = opts.baseUrl;
+        if (!baseUrl) throw new Error("[ChromaDBProvider] baseUrl is required");
+        this.http = import_axios5.default.create({
+          baseURL: baseUrl,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      async initialize() {
+        const { data } = await this.http.get(`/api/v1/collections/${this.indexName}`);
+        this.collectionId = data.id;
+      }
+      async upsert(doc, namespace) {
+        await this.batchUpsert([doc], namespace);
+      }
+      async batchUpsert(docs, namespace) {
+        const payload = {
+          ids: docs.map((d) => d.id),
+          embeddings: docs.map((d) => d.vector),
+          documents: docs.map((d) => d.content),
+          metadatas: docs.map((d) => __spreadValues(__spreadValues({}, d.metadata || {}), namespace ? { namespace } : {}))
+        };
+        await this.http.post(`/api/v1/collections/${this.collectionId}/add`, payload);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async query(vector, topK, namespace, _filter) {
+        const payload = {
+          query_embeddings: [vector],
+          n_results: topK,
+          where: namespace ? { namespace: { $eq: namespace } } : void 0
+        };
+        const { data } = await this.http.post(`/api/v1/collections/${this.collectionId}/query`, payload);
+        const matches = [];
+        if (data.ids && data.ids[0]) {
+          for (let i = 0; i < data.ids[0].length; i++) {
+            matches.push({
+              id: data.ids[0][i],
+              score: data.distances ? 1 - data.distances[0][i] : 0,
+              content: data.documents ? data.documents[0][i] : "",
+              metadata: data.metadatas ? data.metadatas[0][i] : {}
+            });
+          }
+        }
+        return matches;
+      }
+      async delete(id, _namespace) {
+        await this.http.post(`/api/v1/collections/${this.collectionId}/delete`, {
+          ids: [id],
+          where: _namespace ? { namespace: { $eq: _namespace } } : void 0
+        });
+      }
+      async deleteNamespace(_namespace) {
+        await this.http.post(`/api/v1/collections/${this.collectionId}/delete`, {
+          where: { namespace: { $eq: _namespace } }
+        });
+      }
+      async ping() {
+        try {
+          await this.http.get("/api/v1/heartbeat");
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+      }
+    };
   }
-  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}`
+// src/providers/vectordb/RedisProvider.ts
+var RedisProvider_exports = {};
+__export(RedisProvider_exports, {
+  RedisProvider: () => RedisProvider
+});
+var import_axios6, RedisProvider;
+var init_RedisProvider = __esm({
+  "src/providers/vectordb/RedisProvider.ts"() {
+    "use strict";
+    import_axios6 = __toESM(require("axios"));
+    init_BaseVectorProvider();
+    RedisProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        const opts = config.options;
+        const baseUrl = opts.baseUrl;
+        if (!baseUrl) throw new Error("[RedisProvider] baseUrl is required");
+        this.http = import_axios6.default.create({
+          baseURL: baseUrl,
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${opts.apiKey}`
+          }
+        });
+      }
+      async initialize() {
+        await this.ping();
+      }
+      async upsert(doc, namespace) {
+        const key = namespace ? `${namespace}:${doc.id}` : doc.id;
+        await this.http.post("/", ["JSON.SET", key, "$", JSON.stringify({
+          vector: doc.vector,
+          content: doc.content,
+          metadata: doc.metadata || {}
+        })]);
+      }
+      async batchUpsert(docs, namespace) {
+        for (const doc of docs) {
+          await this.upsert(doc, namespace);
+        }
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async query(vector, topK, namespace, _filter) {
+        const payload = {
+          index: this.indexName,
+          vector,
+          topK,
+          namespace
+        };
+        const { data } = await this.http.post("/search", payload);
+        return (data.results || []).map((res) => ({
+          id: res["id"],
+          score: res["score"],
+          content: res["content"],
+          metadata: res["metadata"]
+        }));
+      }
+      async delete(id, namespace) {
+        const key = namespace ? `${namespace}:${id}` : id;
+        await this.http.post("/", ["DEL", key]);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async deleteNamespace(_namespace) {
+      }
+      async ping() {
+        try {
+          await this.http.post("/", ["PING"]);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+      }
     };
-    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;
+// src/providers/vectordb/WeaviateProvider.ts
+var WeaviateProvider_exports = {};
+__export(WeaviateProvider_exports, {
+  WeaviateProvider: () => WeaviateProvider
+});
+var import_axios7, WeaviateProvider;
+var init_WeaviateProvider = __esm({
+  "src/providers/vectordb/WeaviateProvider.ts"() {
+    "use strict";
+    import_axios7 = __toESM(require("axios"));
+    init_BaseVectorProvider();
+    WeaviateProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        super(config);
+        const opts = config.options;
+        const baseUrl = opts.baseUrl;
+        if (!baseUrl) throw new Error("[WeaviateProvider] baseUrl is required");
+        this.http = import_axios7.default.create({
+          baseURL: baseUrl,
+          headers: __spreadValues({
+            "Content-Type": "application/json"
+          }, opts.apiKey ? {
+            "X-OpenAI-Api-Key": opts.apiKey,
+            "Authorization": `Bearer ${opts.apiKey}`
+          } : {})
+        });
+      }
+      async initialize() {
+        await this.ping();
+      }
+      async upsert(doc, namespace) {
+        const payload = {
+          class: this.indexName,
+          id: doc.id,
+          vector: doc.vector,
+          properties: {
+            content: doc.content,
+            metadata: JSON.stringify(doc.metadata || {}),
+            namespace: namespace || ""
+          }
+        };
+        await this.http.post("/v1/objects", payload);
+      }
+      async batchUpsert(docs, namespace) {
+        const payload = {
+          objects: docs.map((doc) => ({
+            class: this.indexName,
+            id: doc.id,
+            vector: doc.vector,
+            properties: {
+              content: doc.content,
+              metadata: JSON.stringify(doc.metadata || {}),
+              namespace: namespace || ""
+            }
+          }))
+        };
+        await this.http.post("/v1/batch/objects", payload);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async query(vector, topK, namespace, _filter) {
+        var _a, _b;
+        const graphqlQuery = {
+          query: `
+        {
+          Get {
+            ${this.indexName}(
+              nearVector: {
+                vector: ${JSON.stringify(vector)}
+              }
+              limit: ${topK}
+              ${namespace ? `where: { path: ["namespace"], operator: Equal, valueString: "${namespace}" }` : ""}
+            ) {
+              content
+              metadata
+              _additional {
+                id
+                distance
+              }
+            }
+          }
+        }
+      `
+        };
+        const { data } = await this.http.post("/v1/graphql", graphqlQuery);
+        const results = ((_b = (_a = data.data) == null ? void 0 : _a.Get) == null ? void 0 : _b[this.indexName]) || [];
+        return results.map((res) => ({
+          id: res["_additional"].id,
+          score: 1 - res["_additional"].distance,
+          content: res["content"],
+          metadata: res["metadata"] ? JSON.parse(res["metadata"]) : {}
+        }));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async delete(id, _namespace) {
+        await this.http.delete(`/v1/objects/${this.indexName}/${id}`);
+      }
+      async deleteNamespace(namespace) {
+        await this.http.post("/v1/batch/objects", {
+          match: {
+            class: this.indexName,
+            where: { path: ["namespace"], operator: "Equal", valueString: namespace }
+          }
+        });
+      }
+      async ping() {
+        try {
+          await this.http.get("/v1/.well-known/live");
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+      }
+    };
   }
-  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}
+// src/handlers/index.ts
+var handlers_exports = {};
+__export(handlers_exports, {
+  createChatHandler: () => createChatHandler,
+  createHealthHandler: () => createHealthHandler,
+  createIngestHandler: () => createIngestHandler,
+  createUploadHandler: () => createUploadHandler
+});
+module.exports = __toCommonJS(handlers_exports);
+var import_server = require("next/server");
 
-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/core/ConfigResolver.ts
+init_templateUtils();
 
-// src/llm/providers/OllamaProvider.ts
-var import_axios2 = __toESM(require("axios"));
-var OllamaProvider = class {
-  constructor(llmConfig, embeddingConfig) {
-    var _a;
-    const baseURL = (_a = llmConfig.baseUrl) != null ? _a : "http://localhost:11434";
-    this.http = import_axios2.default.create({ baseURL, timeout: 12e4 });
-    this.llmConfig = llmConfig;
-    this.embeddingConfig = embeddingConfig;
+// src/config/serverConfig.ts
+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) {
+  var _a;
+  const value = (_a = env[name]) == null ? void 0 : _a.trim();
+  return value ? value : void 0;
+}
+function readNumber(env, name, fallback) {
+  const value = env[name];
+  if (!value) return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`[getRagConfig] ${name} must be a valid number`);
+  }
+  return parsed;
+}
+function readEnum(env, name, fallback, allowed) {
+  var _a;
+  const value = (_a = readString(env, name)) != null ? _a : fallback;
+  if (allowed.includes(value)) {
+    return value;
   }
-  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,
+  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;
+  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);
+  const embeddingProvider = readEnum(env, "EMBEDDING_PROVIDER", "openai", EMBEDDING_PROVIDERS);
+  const embeddingDimensions = readNumber(env, "EMBEDDING_DIMENSIONS", 1536);
+  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 : "";
+    vectorDbOptions.dimensions = embeddingDimensions;
+  } else if (vectorProvider === "rest") {
+    vectorDbOptions.baseUrl = (_f = readString(env, "VECTOR_DB_REST_URL")) != null ? _f : "";
+    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.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";
+  }
+  const llmApiKeyByProvider = {
+    openai: readString(env, "OPENAI_API_KEY"),
+    anthropic: readString(env, "ANTHROPIC_API_KEY"),
+    ollama: void 0,
+    universal_rest: readString(env, "LLM_API_KEY")
+  };
+  const embeddingApiKeyByProvider = {
+    openai: readString(env, "OPENAI_API_KEY"),
+    ollama: void 0,
+    custom: (_m = readString(env, "EMBEDDING_API_KEY")) != null ? _m : readString(env, "OPENAI_API_KEY")
+  };
+  return {
+    projectId,
+    vectorDb: {
+      provider: vectorProvider,
+      indexName: (_n = readString(env, "VECTOR_DB_INDEX")) != null ? _n : "rag-index",
+      options: vectorDbOptions
+    },
+    llm: {
+      provider: llmProvider,
+      model: (_o = readString(env, "LLM_MODEL")) != null ? _o : "gpt-4o",
+      apiKey: (_p = llmApiKeyByProvider[llmProvider]) != null ? _p : "",
+      baseUrl: readString(env, "LLM_BASE_URL"),
+      systemPrompt: readString(env, "LLM_SYSTEM_PROMPT"),
+      maxTokens: readNumber(env, "LLM_MAX_TOKENS", 1024),
+      temperature: readNumber(env, "LLM_TEMPERATURE", 0.7),
       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_axios2.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;
+        profile: readString(env, "LLM_UNIVERSAL_PROFILE")
+      }
+    },
+    embedding: {
+      provider: embeddingProvider,
+      model: (_q = readString(env, "EMBEDDING_MODEL")) != null ? _q : "text-embedding-3-small",
+      apiKey: embeddingApiKeyByProvider[embeddingProvider],
+      baseUrl: readString(env, "EMBEDDING_BASE_URL"),
+      dimensions: embeddingDimensions,
+      options: {
+        profile: readString(env, "EMBEDDING_UNIVERSAL_PROFILE")
+      }
+    },
+    ui: {
+      title: (_s = (_r = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _r : readString(env, "UI_TITLE")) != null ? _s : "AI Assistant",
+      subtitle: (_u = (_t = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _t : readString(env, "UI_SUBTITLE")) != null ? _u : "Powered by RAG",
+      primaryColor: (_w = (_v = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _v : readString(env, "UI_PRIMARY_COLOR")) != null ? _w : "#10b981",
+      accentColor: (_y = (_x = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _x : readString(env, "UI_ACCENT_COLOR")) != null ? _y : "#3b82f6",
+      logoUrl: (_z = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _z : readString(env, "UI_LOGO_URL"),
+      placeholder: (_B = (_A = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _A : readString(env, "UI_PLACEHOLDER")) != null ? _B : "Ask me anything\u2026",
+      showSources: ((_D = (_C = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _C : readString(env, "UI_SHOW_SOURCES")) != null ? _D : "true") !== "false",
+      welcomeMessage: (_F = (_E = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _E : readString(env, "UI_WELCOME_MESSAGE")) != null ? _F : "Hello! I'm your AI assistant. Ask me anything about your documents.",
+      visualStyle: (_H = (_G = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _G : readString(env, "UI_VISUAL_STYLE")) != null ? _H : "glass",
+      borderRadius: (_J = (_I = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _I : readString(env, "UI_BORDER_RADIUS")) != null ? _J : "xl"
+    },
+    rag: {
+      topK: readNumber(env, "RAG_TOP_K", 5),
+      scoreThreshold: readNumber(env, "RAG_SCORE_THRESHOLD", 0),
+      chunkSize: readNumber(env, "RAG_CHUNK_SIZE", 1e3),
+      chunkOverlap: readNumber(env, "RAG_CHUNK_OVERLAP", 200)
     }
-  }
-};
+  };
+}
 
-// src/llm/providers/UniversalLLMAdapter.ts
-var import_axios3 = __toESM(require("axios"));
-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");
+// src/core/ConfigResolver.ts
+var ConfigResolver = class {
+  /**
+   * Resolves the final configuration by merging host-provided config with defaults.
+   * @param hostConfig - Partial configuration passed from the host application.
+   */
+  static resolve(hostConfig) {
+    const envConfig = getRagConfig();
+    if (!hostConfig) {
+      return envConfig;
     }
-    this.http = import_axios3.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
+    return __spreadProps(__spreadValues(__spreadValues({}, envConfig), hostConfig), {
+      projectId: hostConfig.projectId || envConfig.projectId,
+      vectorDb: hostConfig.vectorDb ? __spreadProps(__spreadValues(__spreadValues({}, envConfig.vectorDb), hostConfig.vectorDb), {
+        options: __spreadValues(__spreadValues({}, envConfig.vectorDb.options), hostConfig.vectorDb.options || {})
+      }) : envConfig.vectorDb,
+      llm: hostConfig.llm ? __spreadProps(__spreadValues(__spreadValues({}, envConfig.llm), hostConfig.llm), {
+        options: __spreadValues(__spreadValues({}, envConfig.llm.options || {}), hostConfig.llm.options || {})
+      }) : envConfig.llm,
+      embedding: hostConfig.embedding ? __spreadProps(__spreadValues(__spreadValues({}, envConfig.embedding), hostConfig.embedding), {
+        options: __spreadValues(__spreadValues({}, envConfig.embedding.options || {}), hostConfig.embedding.options || {})
+      }) : envConfig.embedding,
+      ui: hostConfig.ui ? mergeDefined(envConfig.ui, hostConfig.ui) : envConfig.ui,
+      rag: hostConfig.rag ? __spreadValues(__spreadValues({}, envConfig.rag), hostConfig.rag) : envConfig.rag
     });
   }
-  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));
+  /**
+   * Validates the configuration for required fields.
+   */
+  static validate(config) {
+    if (!config.projectId) {
+      throw new Error("[ConfigResolver] projectId is required");
     }
-    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;
+    if (!config.vectorDb.provider) {
+      throw new Error("[ConfigResolver] vectorDb.provider is required");
     }
-  }
-};
-
-// 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`
-        );
+    if (!config.llm.provider) {
+      throw new Error("[ConfigResolver] llm.provider is required");
     }
   }
-  /**
-   * 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/rag/DocumentChunker.ts
@@ -1023,42 +1523,88 @@ var DocumentChunker = class {
   }
 };
 
-// src/rag/RAGPipeline.ts
-var RAGPipeline = class {
-  constructor(config, adapters) {
+// src/core/ProviderRegistry.ts
+init_LLMFactory();
+var ProviderRegistry = class {
+  /**
+   * Register a custom vector provider.
+   */
+  static registerVectorProvider(name, providerClass) {
+    this.vectorProviders[name] = providerClass;
+  }
+  /**
+   * Creates a vector database provider based on the configuration.
+   */
+  static async createVectorProvider(config) {
+    const { provider } = config;
+    if (this.vectorProviders[provider]) {
+      return new this.vectorProviders[provider](config);
+    }
+    switch (provider) {
+      case "pinecone":
+        const { PineconeProvider: PineconeProvider2 } = await Promise.resolve().then(() => (init_PineconeProvider(), PineconeProvider_exports));
+        return new PineconeProvider2(config);
+      case "pgvector":
+      case "postgresql":
+        const { PostgreSQLProvider: PostgreSQLProvider2 } = await Promise.resolve().then(() => (init_PostgreSQLProvider(), PostgreSQLProvider_exports));
+        return new PostgreSQLProvider2(config);
+      case "mongodb":
+        const { MongoDBProvider: MongoDBProvider2 } = await Promise.resolve().then(() => (init_MongoDBProvider(), MongoDBProvider_exports));
+        return new MongoDBProvider2(config);
+      case "milvus":
+        const { MilvusProvider: MilvusProvider2 } = await Promise.resolve().then(() => (init_MilvusProvider(), MilvusProvider_exports));
+        return new MilvusProvider2(config);
+      case "qdrant":
+        const { QdrantProvider: QdrantProvider2 } = await Promise.resolve().then(() => (init_QdrantProvider(), QdrantProvider_exports));
+        return new QdrantProvider2(config);
+      case "chromadb":
+        const { ChromaDBProvider: ChromaDBProvider2 } = await Promise.resolve().then(() => (init_ChromaDBProvider(), ChromaDBProvider_exports));
+        return new ChromaDBProvider2(config);
+      case "redis":
+        const { RedisProvider: RedisProvider2 } = await Promise.resolve().then(() => (init_RedisProvider(), RedisProvider_exports));
+        return new RedisProvider2(config);
+      case "weaviate":
+        const { WeaviateProvider: WeaviateProvider2 } = await Promise.resolve().then(() => (init_WeaviateProvider(), WeaviateProvider_exports));
+        return new WeaviateProvider2(config);
+      default:
+        throw new Error(`[ProviderRegistry] Unsupported vector provider: ${provider}`);
+    }
+  }
+  /**
+   * Creates an LLM provider based on the configuration.
+   */
+  static createLLMProvider(llmConfig, embeddingConfig) {
+    return LLMFactory.create(llmConfig, embeddingConfig);
+  }
+};
+ProviderRegistry.vectorProviders = {};
+
+// src/core/Pipeline.ts
+var Pipeline = class {
+  constructor(config) {
     this.initialised = false;
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d;
     this.config = config;
-    this.vectorDB = (_a = adapters == null ? void 0 : adapters.vectorDB) != null ? _a : VectorDBFactory.create(config.vectorDb);
-    this.llmProvider = (_b = adapters == null ? void 0 : adapters.llmProvider) != null ? _b : LLMFactory.create(config.llm, config.embedding);
-    if (adapters == null ? void 0 : adapters.embeddingProvider) {
-      this.embeddingProvider = adapters.embeddingProvider;
-    } else if (config.llm.provider === "anthropic") {
-      this.embeddingProvider = LLMFactory.createEmbeddingProvider(config.embedding);
-    } else {
-      this.embeddingProvider = this.llmProvider;
-    }
     this.chunker = new DocumentChunker(
-      (_d = (_c = config.rag) == null ? void 0 : _c.chunkSize) != null ? _d : 1e3,
-      (_f = (_e = config.rag) == null ? void 0 : _e.chunkOverlap) != null ? _f : 200
+      (_b = (_a = config.rag) == null ? void 0 : _a.chunkSize) != null ? _b : 1e3,
+      (_d = (_c = config.rag) == null ? void 0 : _c.chunkOverlap) != null ? _d : 200
     );
   }
-  /** Lazily initialise the vector DB connection */
-  async init() {
-    if (!this.initialised) {
-      await this.vectorDB.initialize();
-      this.initialised = true;
+  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;
     }
+    await this.vectorDB.initialize();
+    this.initialised = true;
   }
-  // ---------------------------------------------------------------------------
-  // INGEST
-  // ---------------------------------------------------------------------------
-  /**
-   * Ingest one or more documents into the vector DB.
-   * Automatically chunks, embeds, and upserts each chunk.
-   */
   async ingest(documents, namespace) {
-    await this.init();
+    await this.initialize();
     const ns = namespace != null ? namespace : this.config.projectId;
     const results = [];
     for (const doc of documents) {
@@ -1066,8 +1612,7 @@ var RAGPipeline = class {
         docId: doc.docId,
         metadata: doc.metadata
       });
-      const chunkTexts = chunks.map((c) => c.content);
-      const vectors = await this.embeddingProvider.batchEmbed(chunkTexts);
+      const vectors = await this.embeddingProvider.batchEmbed(chunks.map((c) => c.content));
       const upsertDocs = chunks.map((chunk, i) => ({
         id: chunk.id,
         vector: vectors[i],
@@ -1076,64 +1621,68 @@ var RAGPipeline = class {
       }));
       await this.vectorDB.batchUpsert(upsertDocs, ns);
       results.push({ docId: doc.docId, chunksIngested: chunks.length });
-      console.log(`[RAGPipeline] Ingested ${chunks.length} chunks for doc: ${doc.docId}`);
     }
     return results;
   }
-  // ---------------------------------------------------------------------------
-  // ASK
-  // ---------------------------------------------------------------------------
-  /**
-   * Run a full RAG query:
-   *  1. Embed the user question
-   *  2. Retrieve top-K relevant chunks from the vector DB
-   *  3. Filter by score threshold
-   *  4. Build context string
-   *  5. Call the LLM with chat history + context
-   */
   async ask(question, history = [], namespace) {
     var _a, _b, _c, _d;
-    await this.init();
+    await this.initialize();
     const ns = namespace != null ? namespace : this.config.projectId;
     const topK = (_b = (_a = this.config.rag) == null ? void 0 : _a.topK) != null ? _b : 5;
     const scoreThreshold = (_d = (_c = this.config.rag) == null ? void 0 : _c.scoreThreshold) != null ? _d : 0;
-    console.log(`[RAGPipeline] Searching Pinecone (Namespace: "${ns}", TopK: ${topK})...`);
     const queryVector = await this.embeddingProvider.embed(question);
     const rawMatches = await this.vectorDB.query(queryVector, topK, ns);
-    console.log(`[RAGPipeline] Found ${rawMatches.length} raw matches in Pinecone.`);
     const sources = rawMatches.filter((m) => m.score >= scoreThreshold);
-    console.log(`[RAGPipeline] ${sources.length} sources remaining after threshold filter (min: ${scoreThreshold}).`);
     const context = sources.length ? sources.map((m, i) => `[Source ${i + 1}]
 ${m.content}`).join("\n\n---\n\n") : "No relevant context found.";
-    const messages = [
-      ...history,
-      { role: "user", content: question }
-    ];
+    const messages = [...history, { role: "user", content: question }];
     const reply = await this.llmProvider.chat(messages, context);
     return { reply, sources };
   }
-  // ---------------------------------------------------------------------------
-  // HEALTH
-  // ---------------------------------------------------------------------------
   async health() {
+    await this.initialize();
     const [vectorDB, llm] = await Promise.all([
       this.vectorDB.ping().catch(() => false),
       this.llmProvider.ping().catch(() => false)
     ]);
     return { vectorDB, llm };
   }
-  // ---------------------------------------------------------------------------
-  // DATA MANAGEMENT
-  // ---------------------------------------------------------------------------
-  async deleteDocument(docId, namespace) {
-    await this.init();
-    const ns = namespace != null ? namespace : this.config.projectId;
-    await this.vectorDB.delete(docId, ns);
+};
+
+// src/core/VectorPlugin.ts
+var VectorPlugin = class {
+  /**
+   * Initializes the plugin with the host configuration.
+   * @param hostConfig - Configuration object passed from the host application.
+   */
+  constructor(hostConfig) {
+    this.config = ConfigResolver.resolve(hostConfig);
+    ConfigResolver.validate(this.config);
+    this.pipeline = new Pipeline(this.config);
   }
-  async deleteProject(namespace) {
-    await this.init();
-    const ns = namespace != null ? namespace : this.config.projectId;
-    await this.vectorDB.deleteNamespace(ns);
+  /**
+   * Get the current resolved configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Run a chat query.
+   */
+  async chat(message, history = [], namespace) {
+    return this.pipeline.ask(message, history, namespace);
+  }
+  /**
+   * Ingest documents into the vector database.
+   */
+  async ingest(documents, namespace) {
+    return this.pipeline.ingest(documents, namespace);
+  }
+  /**
+   * Check the health of the connected providers.
+   */
+  async health() {
+    return this.pipeline.health();
   }
 };
 
@@ -1197,12 +1746,8 @@ var DocumentParser = class {
 };
 
 // src/handlers/index.ts
-function createChatHandler(config, adapters) {
-  let pipeline = null;
-  function getPipeline() {
-    if (!pipeline) pipeline = new RAGPipeline(config, adapters);
-    return pipeline;
-  }
+function createChatHandler(config) {
+  const plugin = new VectorPlugin(config);
   return async function POST(req) {
     try {
       const body = await req.json();
@@ -1210,8 +1755,7 @@ function createChatHandler(config, adapters) {
       if (!(message == null ? void 0 : message.trim())) {
         return import_server.NextResponse.json({ error: "message is required" }, { status: 400 });
       }
-      const rag = getPipeline();
-      const result = await rag.ask(message, history, namespace);
+      const result = await plugin.chat(message, history, namespace);
       return import_server.NextResponse.json(result);
     } catch (err) {
       const message = err instanceof Error ? err.message : "Internal server error";
@@ -1219,64 +1763,42 @@ function createChatHandler(config, adapters) {
     }
   };
 }
-function createIngestHandler(config, adapters) {
-  let pipeline = null;
-  function getPipeline() {
-    if (!pipeline) pipeline = new RAGPipeline(config, adapters);
-    return pipeline;
-  }
+function createIngestHandler(config) {
+  const plugin = new VectorPlugin(config);
   return async function POST(req) {
     try {
       const body = await req.json();
       const { documents, namespace } = body;
       if (!Array.isArray(documents) || documents.length === 0) {
-        return import_server.NextResponse.json(
-          { error: "documents array is required and must not be empty" },
-          { status: 400 }
-        );
+        return import_server.NextResponse.json({ error: "documents array is required" }, { status: 400 });
       }
-      const rag = getPipeline();
-      const results = await rag.ingest(documents, namespace);
-      const totalChunks = results.reduce((sum, r) => sum + r.chunksIngested, 0);
-      return import_server.NextResponse.json({ results, totalChunks });
+      const results = await plugin.ingest(documents, namespace);
+      return import_server.NextResponse.json({ results });
     } catch (err) {
       const message = err instanceof Error ? err.message : "Internal server error";
       return import_server.NextResponse.json({ error: message }, { status: 500 });
     }
   };
 }
-function createHealthHandler(config, adapters) {
-  let pipeline = null;
-  function getPipeline() {
-    if (!pipeline) pipeline = new RAGPipeline(config, adapters);
-    return pipeline;
-  }
+function createHealthHandler(config) {
+  const plugin = new VectorPlugin(config);
   return async function GET() {
     try {
-      const rag = getPipeline();
-      const health = await rag.health();
+      const health = await plugin.health();
       const status = health.vectorDB && health.llm ? "ok" : "degraded";
       return import_server.NextResponse.json(__spreadProps(__spreadValues({
         status
       }, health), {
-        project: config.projectId,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
-      return import_server.NextResponse.json(
-        { status: "error", error: message, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
-        { status: 500 }
-      );
+      return import_server.NextResponse.json({ status: "error", error: message }, { status: 500 });
     }
   };
 }
-function createUploadHandler(config, adapters) {
-  let pipeline = null;
-  function getPipeline() {
-    if (!pipeline) pipeline = new RAGPipeline(config, adapters);
-    return pipeline;
-  }
+function createUploadHandler(config) {
+  const plugin = new VectorPlugin(config);
   return async function POST(req) {
     try {
       const formData = await req.formData();
@@ -1300,15 +1822,8 @@ function createUploadHandler(config, adapters) {
           };
         })
       );
-      const rag = getPipeline();
-      const results = await rag.ingest(documents, namespace);
-      const totalChunks = results.reduce((sum, r) => sum + r.chunksIngested, 0);
-      return import_server.NextResponse.json({
-        message: "Upload successful",
-        filesProcessed: files.length,
-        totalChunks,
-        results
-      });
+      const results = await plugin.ingest(documents, namespace);
+      return import_server.NextResponse.json({ message: "Upload successful", results });
     } catch (err) {
       const message = err instanceof Error ? err.message : "Upload failed";
       return import_server.NextResponse.json({ error: message }, { status: 500 });