@retrivora-ai/rag-engine 0.1.0

package/dist/handlers/index.js

@@ -0,0 +1,1319 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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, _b, _c;
+      return {
+        id: m.id,
+        score: (_a2 = m.score) != null ? _a2 : 0,
+        content: (_c = (_b = m.metadata) == null ? void 0 : _b.content) != null ? _c : "",
+        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 (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;
+}
+function resolvePath(obj, path) {
+  if (!path || !obj) return void 0;
+  return path.replace(/\[(\w+)\]/g, ".$1").replace(/^\./, "").split(".").reduce((current, segment) => {
+    if (!isRecord(current) && !Array.isArray(current)) {
+      return void 0;
+    }
+    return current[segment];
+  }, obj);
+}
+function buildPayload(template, vars) {
+  let raw = template;
+  for (const [key, val] of Object.entries(vars)) {
+    const stringifiedVal = val === void 0 ? "null" : JSON.stringify(val);
+    raw = raw.replace(new RegExp(`"\\{\\{${key}\\}\\}"`, "g"), stringifiedVal);
+    raw = raw.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), stringifiedVal);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse payload template: ${err.message}
+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}}"}'
+  }
+};
+var VECTOR_PROFILES = {
+  "pinecone-rest": {
+    queryPath: "/query",
+    upsertPath: "/vectors/upsert",
+    responseExtractPath: "matches",
+    idPath: "id",
+    scorePath: "score",
+    contentPath: "metadata.content",
+    metadataPath: "metadata",
+    queryPayloadTemplate: '{"vector":{{vector}},"topK":{{topK}},"includeMetadata":true,"namespace":"{{namespace}}"}'
+  },
+  "mongodb-atlas": {
+    queryPath: "/action/aggregate",
+    responseExtractPath: "documents",
+    idPath: "_id",
+    scorePath: "score",
+    contentPath: "content",
+    metadataPath: "metadata",
+    queryPayloadTemplate: '{"collection":"{{index}}","database":"ai_db","dataSource":"Cluster0","pipeline":[{"$vectorSearch":{"index":"vector_index","path":"embedding","queryVector":{{vector}},"numCandidates":100,"limit":{{topK}}}},{"$project":{"_id":1,"content":1,"metadata":1,"score":{"$meta":"vectorSearchScore"}}}]}'
+  },
+  "chromadb": {
+    queryPath: "/api/v1/collections/{{index}}/query",
+    upsertPath: "/api/v1/collections/{{index}}/add",
+    responseExtractPath: "matches",
+    idPath: "id",
+    scorePath: "distance",
+    contentPath: "document",
+    metadataPath: "metadata"
+  },
+  "qdrant": {
+    queryPath: "/collections/{{index}}/points/search",
+    upsertPath: "/collections/{{index}}/points",
+    responseExtractPath: "result",
+    idPath: "id",
+    scorePath: "score",
+    contentPath: "payload.content",
+    metadataPath: "payload"
+  }
+};
+
+// src/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}`);
+      }
+    }
+  }
+  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 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) || {}
+    }));
+  }
+  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 });
+  }
+  async deleteNamespace(namespace) {
+    var _a;
+    const path = (_a = this.opts.deleteNamespacePath) != null ? _a : "/delete-namespace";
+    await this.http.post(path, { index: this.indexName, namespace });
+  }
+  async ping() {
+    try {
+      if (this.opts.pingPath) {
+        await this.http.get(this.opts.pingPath);
+      }
+      return true;
+    } catch (err) {
+      console.error("[UniversalVectorDBAdapter] Ping failed:", err);
+      return false;
+    }
+  }
+  async disconnect() {
+  }
+};
+
+// 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);
+  }
+  async initialize() {
+    await this.client.connect();
+    this.db = this.client.db(this.dbName);
+    this.collection = this.db.collection(this.collectionName);
+  }
+  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 }
+    );
+  }
+  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);
+  }
+  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}`
+        }
+      }
+    ];
+    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);
+    }
+  }
+};
+
+// 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);
+        }
+        throw new Error(
+          `[VectorDBFactory] Unknown provider "${config.provider}". Supported: pinecone | pgvector | mongodb | rest`
+        );
+    }
+  }
+};
+
+// src/llm/providers/OpenAIProvider.ts
+var import_openai = __toESM(require("openai"));
+var OpenAIProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
+    this.client = new import_openai.default({ apiKey: llmConfig.apiKey });
+    this.llmConfig = llmConfig;
+    this.embeddingConfig = embeddingConfig;
+  }
+  async chat(messages, context, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const systemContent = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Answer questions based on the provided context.
+
+Context:
+${context}`;
+    const systemMessage = {
+      role: "system",
+      content: systemContent.includes("{{context}}") ? systemContent.replace("{{context}}", context) : `${systemContent}
+
+Context:
+${context}`
+    };
+    const formattedMessages = [
+      systemMessage,
+      ...messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }))
+    ];
+    const completion = await this.client.chat.completions.create({
+      model: this.llmConfig.model,
+      messages: formattedMessages,
+      max_tokens: (_c = (_b = options == null ? void 0 : options.maxTokens) != null ? _b : this.llmConfig.maxTokens) != null ? _c : 1024,
+      temperature: (_e = (_d = options == null ? void 0 : options.temperature) != null ? _d : this.llmConfig.temperature) != null ? _e : 0.7,
+      stop: options == null ? void 0 : options.stop
+    });
+    return (_h = (_g = (_f = completion.choices[0]) == null ? void 0 : _f.message) == null ? void 0 : _g.content) != null ? _h : "";
+  }
+  async embed(text, options) {
+    const results = await this.batchEmbed([text], options);
+    return results[0];
+  }
+  async batchEmbed(texts, options) {
+    var _a, _b, _c, _d, _e;
+    const model = (_c = (_b = options == null ? void 0 : options.model) != null ? _b : (_a = this.embeddingConfig) == null ? void 0 : _a.model) != null ? _c : "text-embedding-3-small";
+    const apiKey = (_e = (_d = this.embeddingConfig) == null ? void 0 : _d.apiKey) != null ? _e : this.llmConfig.apiKey;
+    const client = apiKey !== this.llmConfig.apiKey ? new import_openai.default({ apiKey }) : this.client;
+    const response = await client.embeddings.create({ model, input: texts });
+    return response.data.map((d) => d.embedding);
+  }
+  async ping() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch (err) {
+      console.error("[OpenAIProvider] Ping failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/llm/providers/AnthropicProvider.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var AnthropicProvider = class {
+  constructor(llmConfig, embeddingConfig) {
+    if (!llmConfig.apiKey) throw new Error("[AnthropicProvider] llmConfig.apiKey is required");
+    this.client = new import_sdk.default({ apiKey: llmConfig.apiKey });
+    this.llmConfig = llmConfig;
+    this.embeddingConfig = embeddingConfig;
+  }
+  async chat(messages, context, options) {
+    var _a, _b, _c;
+    const systemPrompt = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Use the context below to answer the user's question accurately.
+
+Context:
+${context}`;
+    const system = systemPrompt.includes("{{context}}") ? systemPrompt.replace("{{context}}", context) : `${systemPrompt}
+
+Context:
+${context}`;
+    const anthropicMessages = messages.map((m) => ({
+      role: m.role === "assistant" ? "assistant" : "user",
+      content: m.content
+    }));
+    const response = await this.client.messages.create({
+      model: this.llmConfig.model,
+      max_tokens: (_c = (_b = options == null ? void 0 : options.maxTokens) != null ? _b : this.llmConfig.maxTokens) != null ? _c : 1024,
+      system,
+      messages: anthropicMessages
+    });
+    const block = response.content[0];
+    return block.type === "text" ? block.text : "";
+  }
+  /**
+   * Anthropic does not offer an embedding API.
+   * This method throws with a clear error so developers know to configure
+   * a separate embedding provider (OpenAI or Ollama).
+   */
+  async embed(text, options) {
+    void text;
+    void options;
+    throw new Error(
+      '[AnthropicProvider] Anthropic does not provide an embedding API. Set embedding.provider to "openai" or "ollama" in your RagConfig.'
+    );
+  }
+  async batchEmbed(texts, options) {
+    void texts;
+    void options;
+    throw new Error(
+      "[AnthropicProvider] Anthropic does not provide an embedding API."
+    );
+  }
+  async ping() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch (err) {
+      console.error("[AnthropicProvider] Ping failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/llm/providers/OllamaProvider.ts
+var import_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;
+  }
+  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_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;
+    }
+  }
+};
+
+// 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");
+    }
+    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
+    });
+  }
+  async chat(messages, context) {
+    var _a, _b;
+    const path = (_a = this.opts.chatPath) != null ? _a : "/chat/completions";
+    const formattedMessages = [
+      { role: "system", content: `${this.systemPrompt}
+
+Context:
+${context != null ? context : "None"}` },
+      ...messages
+    ];
+    let payload;
+    if (this.opts.chatPayloadTemplate) {
+      payload = buildPayload(this.opts.chatPayloadTemplate, {
+        model: this.model,
+        messages: formattedMessages,
+        maxTokens: this.maxTokens,
+        temperature: this.temperature
+      });
+    } else {
+      payload = {
+        model: this.model,
+        messages: formattedMessages,
+        max_tokens: this.maxTokens,
+        temperature: this.temperature
+      };
+    }
+    const { data } = await this.http.post(path, payload);
+    const extractPath = (_b = this.opts.responseExtractPath) != null ? _b : "choices[0].message.content";
+    const result = resolvePath(data, extractPath);
+    if (result === void 0) {
+      throw new Error(`[UniversalLLMAdapter] Could not extract text from path '${extractPath}' in response.`);
+    }
+    return String(result);
+  }
+  async embed(text) {
+    var _a, _b;
+    const path = (_a = this.opts.embedPath) != null ? _a : "/embeddings";
+    let payload;
+    if (this.opts.embedPayloadTemplate) {
+      payload = buildPayload(this.opts.embedPayloadTemplate, {
+        model: this.model,
+        input: text
+      });
+    } else {
+      payload = {
+        model: this.model,
+        input: text
+      };
+    }
+    const { data } = await this.http.post(path, payload);
+    const extractPath = (_b = this.opts.embedExtractPath) != null ? _b : "data[0].embedding";
+    const vector = resolvePath(data, extractPath);
+    if (!Array.isArray(vector)) {
+      throw new Error(`[UniversalLLMAdapter] Expected a number array at '${extractPath}' for embeddings.`);
+    }
+    return vector;
+  }
+  async batchEmbed(texts) {
+    const vectors = [];
+    for (const text of texts) {
+      vectors.push(await this.embed(text));
+    }
+    return vectors;
+  }
+  async ping() {
+    try {
+      if (this.opts.pingPath) {
+        await this.http.get(this.opts.pingPath);
+      }
+      return true;
+    } catch (err) {
+      console.error("[UniversalLLMAdapter] Ping failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/llm/LLMFactory.ts
+var LLMFactory = class _LLMFactory {
+  static create(llmConfig, embeddingConfig) {
+    var _a;
+    switch (llmConfig.provider) {
+      case "openai":
+        return new OpenAIProvider(llmConfig, embeddingConfig);
+      case "anthropic":
+        return new AnthropicProvider(llmConfig, embeddingConfig);
+      case "ollama":
+        return new OllamaProvider(llmConfig, embeddingConfig);
+      case "rest":
+      case "universal_rest":
+      case "custom":
+        return new UniversalLLMAdapter(llmConfig);
+      default:
+        if (llmConfig.baseUrl || ((_a = llmConfig.options) == null ? void 0 : _a.baseUrl)) {
+          return new UniversalLLMAdapter(llmConfig);
+        }
+        throw new Error(
+          `[LLMFactory] Unknown provider "${llmConfig.provider}". Supported: openai | anthropic | ollama | rest | custom`
+        );
+    }
+  }
+  /**
+   * Creates a dedicated embedding-only provider.
+   * Useful when the LLM provider (e.g. Anthropic) doesn't support embeddings.
+   */
+  static createEmbeddingProvider(embeddingConfig) {
+    const fakeLLMConfig = {
+      provider: embeddingConfig.provider,
+      model: embeddingConfig.model,
+      apiKey: embeddingConfig.apiKey,
+      baseUrl: embeddingConfig.baseUrl,
+      options: embeddingConfig.options
+    };
+    return _LLMFactory.create(fakeLLMConfig, embeddingConfig);
+  }
+};
+
+// src/rag/DocumentChunker.ts
+var DocumentChunker = class {
+  constructor(chunkSize = 1e3, chunkOverlap = 200) {
+    this.chunkSize = chunkSize;
+    this.chunkOverlap = chunkOverlap;
+  }
+  /**
+   * Split a single text string into overlapping chunks.
+   */
+  chunk(text, options = {}) {
+    const {
+      chunkSize = this.chunkSize,
+      chunkOverlap = this.chunkOverlap,
+      docId = `doc_${Date.now()}`,
+      metadata = {}
+    } = options;
+    const cleaned = text.replace(/\r\n/g, "\n").trim();
+    if (!cleaned) return [];
+    const sentences = cleaned.split(new RegExp("(?<=[.!?])\\s+|\\n{2,}")).map((s) => s.trim()).filter(Boolean);
+    const chunks = [];
+    let current = "";
+    let chunkIndex = 0;
+    for (const sentence of sentences) {
+      if ((current + " " + sentence).trim().length <= chunkSize) {
+        current = current ? `${current} ${sentence}` : sentence;
+      } else {
+        if (current) {
+          chunks.push({
+            id: `${docId}_chunk_${chunkIndex++}`,
+            content: current.trim(),
+            metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex: chunkIndex - 1 })
+          });
+        }
+        if (chunkOverlap > 0 && current.length > chunkOverlap) {
+          current = current.slice(-chunkOverlap) + " " + sentence;
+        } else {
+          current = sentence;
+        }
+      }
+    }
+    if (current.trim()) {
+      chunks.push({
+        id: `${docId}_chunk_${chunkIndex}`,
+        content: current.trim(),
+        metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex })
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Chunk multiple documents at once.
+   */
+  chunkMany(documents) {
+    return documents.flatMap(
+      (doc) => this.chunk(doc.content, { docId: doc.docId, metadata: doc.metadata })
+    );
+  }
+};
+
+// src/rag/RAGPipeline.ts
+var RAGPipeline = class {
+  constructor(config, adapters) {
+    this.initialised = false;
+    var _a, _b, _c, _d, _e, _f;
+    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
+    );
+  }
+  /** Lazily initialise the vector DB connection */
+  async init() {
+    if (!this.initialised) {
+      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();
+    const ns = namespace != null ? namespace : this.config.projectId;
+    const results = [];
+    for (const doc of documents) {
+      const chunks = this.chunker.chunk(doc.content, {
+        docId: doc.docId,
+        metadata: doc.metadata
+      });
+      const chunkTexts = chunks.map((c) => c.content);
+      const vectors = await this.embeddingProvider.batchEmbed(chunkTexts);
+      const upsertDocs = chunks.map((chunk, i) => ({
+        id: chunk.id,
+        vector: vectors[i],
+        content: chunk.content,
+        metadata: chunk.metadata
+      }));
+      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();
+    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;
+    const queryVector = await this.embeddingProvider.embed(question);
+    const rawMatches = await this.vectorDB.query(queryVector, topK, ns);
+    const sources = rawMatches.filter((m) => m.score >= 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 reply = await this.llmProvider.chat(messages, context);
+    return { reply, sources };
+  }
+  // ---------------------------------------------------------------------------
+  // HEALTH
+  // ---------------------------------------------------------------------------
+  async health() {
+    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);
+  }
+  async deleteProject(namespace) {
+    await this.init();
+    const ns = namespace != null ? namespace : this.config.projectId;
+    await this.vectorDB.deleteNamespace(ns);
+  }
+};
+
+// src/utils/DocumentParser.ts
+var DocumentParser = class {
+  /**
+   * Extract text from a File or Buffer based on its type.
+   */
+  static async parse(file, fileName, mimeType) {
+    var _a;
+    const extension = (_a = fileName.split(".").pop()) == null ? void 0 : _a.toLowerCase();
+    if (extension === "txt" || extension === "md" || mimeType === "text/plain" || mimeType === "text/markdown") {
+      return this.readAsText(file);
+    }
+    if (extension === "json" || mimeType === "application/json") {
+      const text = await this.readAsText(file);
+      try {
+        const obj = JSON.parse(text);
+        return JSON.stringify(obj, null, 2);
+      } catch (e) {
+        return text;
+      }
+    }
+    if (extension === "csv" || mimeType === "text/csv") {
+      return this.readAsText(file);
+    }
+    if (extension === "pdf" || mimeType === "application/pdf") {
+      try {
+        const pdf = await import("pdf-parse/lib/pdf-parse.js");
+        const buffer = Buffer.isBuffer(file) ? file : Buffer.from(await file.arrayBuffer());
+        const data = await pdf.default(buffer);
+        return data.text;
+      } catch (err) {
+        console.warn('[DocumentParser] PDF parsing failed. Make sure "pdf-parse" is installed.', err);
+        return `[PDF Parsing Error for ${fileName}]`;
+      }
+    }
+    if (extension === "docx" || mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
+      try {
+        const mammoth = await import("mammoth");
+        const buffer = Buffer.isBuffer(file) ? file : Buffer.from(await file.arrayBuffer());
+        const result = await mammoth.extractRawText({ buffer });
+        return result.value;
+      } catch (err) {
+        console.warn('[DocumentParser] DOCX parsing failed. Make sure "mammoth" is installed.', err);
+        return `[DOCX Parsing Error for ${fileName}]`;
+      }
+    }
+    try {
+      return await this.readAsText(file);
+    } catch (e) {
+      throw new Error(`[DocumentParser] Unsupported file format: ${fileName} (${mimeType})`);
+    }
+  }
+  static async readAsText(file) {
+    if (Buffer.isBuffer(file)) {
+      return file.toString("utf-8");
+    }
+    return await file.text();
+  }
+};
+
+// src/handlers/index.ts
+function createChatHandler(config, adapters) {
+  let pipeline = null;
+  function getPipeline() {
+    if (!pipeline) pipeline = new RAGPipeline(config, adapters);
+    return pipeline;
+  }
+  return async function POST(req) {
+    try {
+      const body = await req.json();
+      const { message, history = [], namespace } = body;
+      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);
+      return import_server.NextResponse.json(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      return import_server.NextResponse.json({ error: message }, { status: 500 });
+    }
+  };
+}
+function createIngestHandler(config, adapters) {
+  let pipeline = null;
+  function getPipeline() {
+    if (!pipeline) pipeline = new RAGPipeline(config, adapters);
+    return pipeline;
+  }
+  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 }
+        );
+      }
+      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 });
+    } 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;
+  }
+  return async function GET() {
+    try {
+      const rag = getPipeline();
+      const health = await rag.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 }
+      );
+    }
+  };
+}
+function createUploadHandler(config, adapters) {
+  let pipeline = null;
+  function getPipeline() {
+    if (!pipeline) pipeline = new RAGPipeline(config, adapters);
+    return pipeline;
+  }
+  return async function POST(req) {
+    try {
+      const formData = await req.formData();
+      const files = formData.getAll("files");
+      const namespace = formData.get("namespace") || void 0;
+      if (!files || files.length === 0) {
+        return import_server.NextResponse.json({ error: "No files provided" }, { status: 400 });
+      }
+      const documents = await Promise.all(
+        files.map(async (file) => {
+          const content = await DocumentParser.parse(file, file.name, file.type);
+          return {
+            docId: file.name,
+            content,
+            metadata: {
+              fileName: file.name,
+              fileSize: file.size,
+              fileType: file.type,
+              uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          };
+        })
+      );
+      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
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Upload failed";
+      return import_server.NextResponse.json({ error: message }, { status: 500 });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createChatHandler,
+  createHealthHandler,
+  createIngestHandler,
+  createUploadHandler
+});