@retrivora-ai/rag-engine 1.0.3 → 1.0.5

package/dist/server.js

@@ -1551,8 +1551,14 @@ __export(server_exports, {
   createFromPreset: () => createFromPreset,
   createHealthHandler: () => createHealthHandler,
   createIngestHandler: () => createIngestHandler,
+  createStreamHandler: () => createStreamHandler,
   createUploadHandler: () => createUploadHandler,
-  getRagConfig: () => getRagConfig
+  getRagConfig: () => getRagConfig,
+  resetConfigCache: () => resetConfigCache,
+  sseErrorFrame: () => sseErrorFrame,
+  sseFrame: () => sseFrame,
+  sseMetaFrame: () => sseMetaFrame,
+  sseTextFrame: () => sseTextFrame
 });
 module.exports = __toCommonJS(server_exports);
 
@@ -1734,13 +1740,23 @@ function getRagConfig(env = process.env) {
 }
 
 // src/core/ConfigResolver.ts
+var _cachedEnvConfig = null;
+function getCachedEnvConfig() {
+  if (!_cachedEnvConfig) {
+    _cachedEnvConfig = getRagConfig();
+  }
+  return _cachedEnvConfig;
+}
+function resetConfigCache() {
+  _cachedEnvConfig = null;
+}
 var ConfigResolver = class {
   /**
-   * Resolves the final configuration by merging host-provided config with defaults.
+   * Resolves the final configuration by merging host-provided config with environment defaults.
    * @param hostConfig - Partial configuration passed from the host application.
    */
   static resolve(hostConfig) {
-    const envConfig = getRagConfig();
+    const envConfig = getCachedEnvConfig();
     if (!hostConfig) {
       return envConfig;
     }
@@ -2953,25 +2969,42 @@ Text to extract from:
     const response = await this.llm.chat([
       { role: "system", content: "You are a precise knowledge graph extraction engine. You always output valid JSON and nothing else." },
       { role: "user", content: prompt }
-    ], "", { maxTokens: 2048, temperature: 0.1 });
+    ], "", { maxTokens: 4096, temperature: 0.1 });
     try {
       const jsonMatch = response.match(/\{[\s\S]*\}/);
       const cleanJson = jsonMatch ? jsonMatch[0] : response.trim();
       return JSON.parse(cleanJson);
     } catch (e) {
-      console.warn(`[EntityExtractor] Failed to parse LLM response. Length: ${response.length} chars.`);
-      if (response.trim().endsWith("}") === false && response.includes('"nodes"')) {
-        try {
-          const partialResponse = response.trim() + (response.includes("[") ? "]}" : "}");
-          const jsonMatch = partialResponse.match(/\{[\s\S]*\}/);
-          if (jsonMatch) return JSON.parse(jsonMatch[0]);
-        } catch (e2) {
-        }
+      try {
+        const repaired = this.repairTruncatedJson(response);
+        if (repaired) return JSON.parse(repaired);
+      } catch (e2) {
       }
-      console.warn("[EntityExtractor] Full failing response:", response.substring(0, 200) + "...");
+      console.warn(`[EntityExtractor] Failed to parse LLM response. Length: ${response.length} chars.`);
+      console.warn("[EntityExtractor] Snippet:", response.substring(0, 100) + "...");
       return { nodes: [], edges: [] };
     }
   }
+  /**
+   * Attempts to fix JSON that was cut off mid-generation.
+   * Strategy: Find the last valid element in an array and close the structure.
+   */
+  repairTruncatedJson(json) {
+    let text = json.trim();
+    const startIdx = text.indexOf("{");
+    if (startIdx === -1) return null;
+    text = text.substring(startIdx);
+    const lastCompleteObjectIdx = text.lastIndexOf("}");
+    if (lastCompleteObjectIdx === -1) return null;
+    let repaired = text.substring(0, lastCompleteObjectIdx + 1);
+    const openBrackets = (repaired.match(/\{/g) || []).length;
+    const closedBrackets = (repaired.match(/\}/g) || []).length;
+    const openSquares = (repaired.match(/\[/g) || []).length;
+    const closedSquares = (repaired.match(/\]/g) || []).length;
+    for (let i = 0; i < openSquares - closedSquares; i++) repaired += "]";
+    for (let i = 0; i < openBrackets - closedBrackets; i++) repaired += "}";
+    return repaired;
+  }
 };
 
 // src/rag/Reranker.ts
@@ -3036,14 +3069,16 @@ var LangChainAgent = class {
     this.config = config;
   }
   /**
-   * Initializes the agent with the RAG pipeline as a primary tool.
-   * Dynamically imports LangChain dependencies to avoid build errors if missing.
+   * Initializes the LangChain ReAct agent with the RAG pipeline as a tool.
+   * Dynamically imports langchain so the package doesn't crash if it isn't installed.
    */
   async initialize(chatModel) {
     try {
-      const { DynamicTool } = await import(`${"@langchain/core/tools"}`);
-      const { ChatPromptTemplate, MessagesPlaceholder } = await import(`${"@langchain/core/prompts"}`);
-      const { AgentExecutor, createOpenAIFunctionsAgent } = await import(`${"langchain/agents"}`);
+      const [{ DynamicTool }, { HumanMessage }, { createAgent }] = await Promise.all([
+        import("@langchain/core/tools"),
+        import("@langchain/core/messages"),
+        import("langchain")
+      ]);
       const searchTool = new DynamicTool({
         name: "document_search",
         description: "Use this tool to search through the knowledge base and document repository. Input should be a specific search query.",
@@ -3052,42 +3087,53 @@ var LangChainAgent = class {
           return `Search Results:
 ${response.reply}
 
-Sources Used: ${JSON.stringify(response.sources.map((s) => s.id))}`;
+Sources Used: ${JSON.stringify(
+            response.sources.map((s) => s.id)
+          )}`;
         }
       });
-      const tools = [searchTool];
-      const prompt = ChatPromptTemplate.fromMessages([
-        ["system", this.config.llm.systemPrompt || "You are a helpful AI assistant with access to a document search tool."],
-        new MessagesPlaceholder("chat_history"),
-        ["human", "{input}"],
-        new MessagesPlaceholder("agent_scratchpad")
-      ]);
-      const agent = await createOpenAIFunctionsAgent({
-        llm: chatModel,
-        tools,
-        prompt
-      });
-      this.executor = new AgentExecutor({
-        agent,
-        tools
+      this.agent = createAgent({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        model: chatModel,
+        tools: [searchTool],
+        systemPrompt: this.config.llm.systemPrompt || "You are a helpful AI assistant with access to a document search tool."
       });
+      void HumanMessage;
     } catch (error) {
-      console.error("[LangChainAgent] Failed to initialize. Ensure 'langchain' and '@langchain/core' are installed.");
-      throw error;
+      const isMissing = error instanceof Error && error.message.includes("Cannot find module");
+      const hint = isMissing ? " Make sure 'langchain' and '@langchain/core' are installed:\n  npm install langchain @langchain/core" : "";
+      throw new Error(
+        `[LangChainAgent] Failed to initialize.${hint}
+${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
    * Run the agentic flow.
+   *
+   * LangChain v1.x: invoke takes `{ messages: [...] }` instead of `{ input, chat_history }`.
+   * The agent returns `{ messages: [...] }` — the last message is the final answer.
    */
   async run(input, chatHistory = []) {
-    if (!this.executor) {
+    var _a, _b, _c;
+    if (!this.agent) {
       throw new Error("[LangChainAgent] Agent not initialized. Call initialize() first.");
     }
-    const response = await this.executor.invoke({
-      input,
-      chat_history: chatHistory
+    const { HumanMessage, AIMessage } = await import("@langchain/core/messages");
+    const historyMessages = chatHistory.map(
+      (m) => m.role === "user" ? new HumanMessage(m.content) : new AIMessage(m.content)
+    );
+    const response = await this.agent.invoke({
+      messages: [...historyMessages, new HumanMessage(input)]
     });
-    return response.output;
+    const lastMessage = (_a = response == null ? void 0 : response.messages) == null ? void 0 : _a.at(-1);
+    if (lastMessage && typeof lastMessage.content === "string") {
+      return lastMessage.content;
+    }
+    if (Array.isArray(lastMessage == null ? void 0 : lastMessage.content)) {
+      return lastMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+    }
+    return String((_c = (_b = response == null ? void 0 : response.output) != null ? _b : response) != null ? _c : "");
   }
 };
 
@@ -3496,6 +3542,10 @@ var QueryProcessor = class {
   }
   /**
    * Constructs a QueryFilter object from extracted hints.
+   *
+   * Note: proper nouns are extracted inside `extractQueryFieldHints` and surfaced
+   * as field-less hints; `buildQueryFilter` adds them to `keywords` without
+   * re-running the proper noun regex to avoid duplication.
    */
   static buildQueryFilter(question, hints) {
     const filter = { metadata: {}, keywords: [], queryText: question };
@@ -3503,13 +3553,11 @@ var QueryProcessor = class {
       if (hint.field) {
         filter.metadata[hint.field] = hint.value;
       } else {
-        filter.keywords.push(hint.value);
+        if (!filter.keywords.includes(hint.value)) {
+          filter.keywords.push(hint.value);
+        }
       }
     }
-    for (const match of question.matchAll(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/g)) {
-      const term = this.normalizeHintValue(match[0]);
-      if (term && !filter.keywords.includes(term)) filter.keywords.push(term);
-    }
     if (Object.keys(filter.metadata || {}).length === 0) delete filter.metadata;
     if (filter.keywords && filter.keywords.length === 0) delete filter.keywords;
     return filter;
@@ -3517,10 +3565,40 @@ var QueryProcessor = class {
 };
 
 // src/core/Pipeline.ts
+var LRUEmbeddingCache = class {
+  constructor(maxSize = 500) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
 var Pipeline = class {
   constructor(config) {
     this.config = config;
-    this.embeddingCache = /* @__PURE__ */ new Map();
+    /** LRU-bounded cache: avoids re-embedding identical queries within the same process. */
+    this.embeddingCache = new LRUEmbeddingCache(500);
     this.initialised = false;
     var _a, _b, _c, _d, _e;
     this.chunker = new DocumentChunker(
@@ -3608,6 +3686,7 @@ var Pipeline = class {
   }
   /**
    * Step 2: Generate embeddings for chunks with retry logic.
+   * Uses batchEmbed when available for efficiency; falls back to sequential embedding.
    */
   async processEmbeddings(chunks) {
     const embedBatchOptions = {
@@ -3621,7 +3700,9 @@ var Pipeline = class {
       embedBatchOptions
     );
     if (vectors.length !== chunks.length) {
-      throw new Error(`Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks`);
+      throw new Error(
+        `[Pipeline] Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks. Check embedding provider logs for individual chunk failures.`
+      );
     }
     return vectors;
   }
@@ -3775,6 +3856,7 @@ ${context}`;
   }
   /**
    * Universal retrieval method combining all enabled providers.
+   * Uses an LRU-bounded embedding cache to avoid re-embedding the same query.
    */
   async retrieve(query, options) {
     var _a, _b, _c;
@@ -3807,10 +3889,13 @@ ${history.map((m) => `${m.role}: ${m.content}`).join("\n")}
 New Question: ${question}
 
 Optimized Search Query:`;
-    const rewrite = await this.llmProvider.chat([
-      { role: "system", content: "You are an assistant that optimizes search queries for RAG systems." },
-      { role: "user", content: prompt }
-    ], "");
+    const rewrite = await this.llmProvider.chat(
+      [
+        { role: "system", content: "You are an assistant that optimizes search queries for RAG systems." },
+        { role: "user", content: prompt }
+      ],
+      ""
+    );
     return rewrite.trim() || question;
   }
 };
@@ -3971,21 +4056,11 @@ var VectorPlugin = class {
 
 // src/config/ConfigBuilder.ts
 var ConfigBuilder = class {
-  constructor() {
-    this.config = {
-      projectId: "default-project",
-      rag: {
-        chunkSize: 1e3,
-        chunkOverlap: 200,
-        topK: 5
-      }
-    };
-  }
   /**
    * Set the project/application ID for namespacing
    */
   projectId(id) {
-    this.config.projectId = id;
+    this._projectId = id;
     return this;
   }
   /**
@@ -3994,9 +4069,9 @@ var ConfigBuilder = class {
   vectorDb(provider, options) {
     var _a;
     if (provider === "auto") {
-      this.config.vectorDb = this.autoDetectVectorDb();
+      this._vectorDb = this._autoDetectVectorDb();
     } else {
-      this.config.vectorDb = {
+      this._vectorDb = {
         provider,
         indexName: (_a = options == null ? void 0 : options.indexName) != null ? _a : "default",
         options: __spreadValues({}, options)
@@ -4010,9 +4085,9 @@ var ConfigBuilder = class {
   llm(provider, model, apiKey, options) {
     var _a, _b;
     if (provider === "auto") {
-      this.config.llm = this.autoDetectLLM();
+      this._llm = this._autoDetectLLM();
     } else {
-      this.config.llm = {
+      this._llm = {
         provider,
         model: model != null ? model : "default-model",
         apiKey,
@@ -4030,9 +4105,9 @@ var ConfigBuilder = class {
    */
   embedding(provider, model, apiKey, options) {
     if (provider === "auto") {
-      this.config.embedding = this.autoDetectEmbedding();
+      this._embedding = this._autoDetectEmbedding();
     } else {
-      this.config.embedding = {
+      this._embedding = {
         provider,
         model: model != null ? model : "default-embedding",
         apiKey,
@@ -4043,26 +4118,46 @@ var ConfigBuilder = class {
     return this;
   }
   /**
-   * Set RAG-specific parameters
+   * Set RAG-specific pipeline parameters
    */
   rag(options) {
     var _a;
-    this.config.rag = __spreadValues(__spreadValues({}, (_a = this.config.rag) != null ? _a : {}), options);
+    this._rag = __spreadValues(__spreadValues({}, (_a = this._rag) != null ? _a : {}), options);
     return this;
   }
   /**
-   * Set UI/UX parameters
+   * Set UI branding and appearance options.
+   * Accepts the full UIConfig interface.
    */
   ui(options) {
-    this.config.ui = options;
+    this._ui = options;
     return this;
   }
   /**
-   * Build and return the configuration
+   * Build and return the final RagConfig.
+   * Throws if required fields (projectId, vectorDb, llm, embedding) are not set.
    */
   build() {
-    const finalConfig = this.config;
-    return finalConfig;
+    var _a;
+    const missing = [];
+    if (!this._projectId) missing.push('projectId (call .projectId("my-app"))');
+    if (!this._vectorDb) missing.push('vectorDb (call .vectorDb("pinecone", { ... }))');
+    if (!this._llm) missing.push('llm (call .llm("openai", "gpt-4o", apiKey))');
+    if (!this._embedding) missing.push('embedding (call .embedding("openai", "text-embedding-3-small"))');
+    if (missing.length > 0) {
+      throw new Error(
+        `[ConfigBuilder] Cannot build \u2014 required fields are missing:
+  ${missing.join("\n  ")}`
+      );
+    }
+    return __spreadValues({
+      projectId: this._projectId,
+      vectorDb: this._vectorDb,
+      llm: this._llm,
+      embedding: this._embedding,
+      ui: this._rag ? this._ui : void 0,
+      rag: (_a = this._rag) != null ? _a : { chunkSize: 1e3, chunkOverlap: 200, topK: 5 }
+    }, this._ui ? { ui: this._ui } : {});
   }
   /**
    * Build and return as JSON for serialization
@@ -4073,169 +4168,58 @@ var ConfigBuilder = class {
   // ============================================================================
   // Private helper methods for auto-detection
   // ============================================================================
-  autoDetectVectorDb() {
+  _autoDetectVectorDb() {
     if (process.env.PINECONE_API_KEY && process.env.PINECONE_INDEX) {
-      return {
-        provider: "pinecone",
-        indexName: process.env.PINECONE_INDEX,
-        options: { apiKey: process.env.PINECONE_API_KEY }
-      };
+      return { provider: "pinecone", indexName: process.env.PINECONE_INDEX, options: { apiKey: process.env.PINECONE_API_KEY } };
     }
     if (process.env.QDRANT_URL) {
-      return {
-        provider: "qdrant",
-        indexName: process.env.QDRANT_COLLECTION || "documents",
-        options: {
-          url: process.env.QDRANT_URL,
-          apiKey: process.env.QDRANT_API_KEY
-        }
-      };
+      return { provider: "qdrant", indexName: process.env.QDRANT_COLLECTION || "documents", options: { url: process.env.QDRANT_URL, apiKey: process.env.QDRANT_API_KEY } };
     }
     if (process.env.DATABASE_URL) {
-      return {
-        provider: "postgresql",
-        indexName: process.env.PG_TABLE || "documents",
-        options: {
-          connectionString: process.env.DATABASE_URL
-        }
-      };
+      return { provider: "postgresql", indexName: process.env.PG_TABLE || "documents", options: { connectionString: process.env.DATABASE_URL } };
     }
     if (process.env.MONGODB_URI) {
-      return {
-        provider: "mongodb",
-        indexName: process.env.MONGODB_COLLECTION || "documents",
-        options: {
-          uri: process.env.MONGODB_URI,
-          database: process.env.MONGODB_DB || "ai_db",
-          collection: process.env.MONGODB_COLLECTION || "documents"
-        }
-      };
+      return { provider: "mongodb", indexName: process.env.MONGODB_COLLECTION || "documents", options: { uri: process.env.MONGODB_URI, database: process.env.MONGODB_DB || "ai_db", collection: process.env.MONGODB_COLLECTION || "documents" } };
     }
     if (process.env.REDIS_URL) {
-      return {
-        provider: "redis",
-        indexName: process.env.REDIS_INDEX || "documents",
-        options: {
-          url: process.env.REDIS_URL
-        }
-      };
+      return { provider: "redis", indexName: process.env.REDIS_INDEX || "documents", options: { url: process.env.REDIS_URL } };
     }
-    return {
-      provider: "qdrant",
-      indexName: "documents",
-      options: {
-        url: process.env.QDRANT_URL || "http://localhost:6333"
-      }
-    };
+    return { provider: "qdrant", indexName: "documents", options: { url: process.env.QDRANT_URL || "http://localhost:6333" } };
   }
-  autoDetectLLM() {
+  _autoDetectLLM() {
     if (process.env.OPENAI_API_KEY) {
-      return {
-        provider: "openai",
-        model: process.env.OPENAI_MODEL || "gpt-4o-mini",
-        apiKey: process.env.OPENAI_API_KEY,
-        maxTokens: parseInt(process.env.OPENAI_MAX_TOKENS || "1024"),
-        temperature: parseFloat(process.env.OPENAI_TEMPERATURE || "0.7")
-      };
+      return { provider: "openai", model: process.env.OPENAI_MODEL || "gpt-4o-mini", apiKey: process.env.OPENAI_API_KEY, maxTokens: parseInt(process.env.OPENAI_MAX_TOKENS || "1024"), temperature: parseFloat(process.env.OPENAI_TEMPERATURE || "0.7") };
     }
     if (process.env.ANTHROPIC_API_KEY) {
-      return {
-        provider: "anthropic",
-        model: process.env.ANTHROPIC_MODEL || "claude-3-haiku-20240307",
-        apiKey: process.env.ANTHROPIC_API_KEY,
-        maxTokens: parseInt(process.env.ANTHROPIC_MAX_TOKENS || "1024"),
-        temperature: parseFloat(process.env.ANTHROPIC_TEMPERATURE || "0.7")
-      };
+      return { provider: "anthropic", model: process.env.ANTHROPIC_MODEL || "claude-3-haiku-20240307", apiKey: process.env.ANTHROPIC_API_KEY, maxTokens: parseInt(process.env.ANTHROPIC_MAX_TOKENS || "1024"), temperature: parseFloat(process.env.ANTHROPIC_TEMPERATURE || "0.7") };
     }
     if (process.env.OLLAMA_BASE_URL) {
-      return {
-        provider: "ollama",
-        model: process.env.OLLAMA_MODEL || "mistral",
-        baseUrl: process.env.OLLAMA_BASE_URL,
-        maxTokens: parseInt(process.env.OLLAMA_MAX_TOKENS || "1024"),
-        temperature: parseFloat(process.env.OLLAMA_TEMPERATURE || "0.7")
-      };
+      return { provider: "ollama", model: process.env.OLLAMA_MODEL || "mistral", baseUrl: process.env.OLLAMA_BASE_URL, maxTokens: parseInt(process.env.OLLAMA_MAX_TOKENS || "1024"), temperature: parseFloat(process.env.OLLAMA_TEMPERATURE || "0.7") };
     }
-    return {
-      provider: "openai",
-      model: "gpt-4o-mini",
-      apiKey: process.env.OPENAI_API_KEY
-    };
+    return { provider: "openai", model: "gpt-4o-mini", apiKey: process.env.OPENAI_API_KEY };
   }
-  autoDetectEmbedding() {
+  _autoDetectEmbedding() {
     if (process.env.EMBEDDING_PROVIDER) {
-      const provider = process.env.EMBEDDING_PROVIDER;
-      return {
-        provider,
-        model: process.env.EMBEDDING_MODEL || "default",
-        apiKey: process.env.EMBEDDING_API_KEY,
-        baseUrl: process.env.EMBEDDING_BASE_URL
-      };
+      return { provider: process.env.EMBEDDING_PROVIDER, model: process.env.EMBEDDING_MODEL || "default", apiKey: process.env.EMBEDDING_API_KEY, baseUrl: process.env.EMBEDDING_BASE_URL };
     }
-    return {
-      provider: "openai",
-      model: "text-embedding-3-small",
-      apiKey: process.env.OPENAI_API_KEY
-    };
+    return { provider: "openai", model: "text-embedding-3-small", apiKey: process.env.OPENAI_API_KEY };
   }
 };
 var PRESETS = {
-  /**
-   * OpenAI + Pinecone: Production-ready cloud setup
-   */
-  "openai-pinecone": {
-    vectorDb: "pinecone",
-    llm: "openai",
-    embedding: "openai"
-  },
-  /**
-   * Claude + Qdrant: Open-source vector DB + proprietary LLM
-   */
-  "claude-qdrant": {
-    vectorDb: "qdrant",
-    llm: "anthropic",
-    embedding: "openai"
-  },
-  /**
-   * Local development: Ollama + local Qdrant
-   */
-  "local-dev": {
-    vectorDb: "qdrant",
-    llm: "ollama",
-    embedding: "ollama"
-  },
-  /**
-   * Fully open-source: Ollama LLM + Qdrant vector DB + Ollama embeddings
-   */
-  "fully-open-source": {
-    vectorDb: "qdrant",
-    llm: "ollama",
-    embedding: "ollama"
-  },
-  /**
-   * PostgreSQL stack: pgvector + OpenAI
-   */
-  "postgres-openai": {
-    vectorDb: "postgresql",
-    llm: "openai",
-    embedding: "openai"
-  },
-  /**
-   * Enterprise MongoDB: MongoDB Atlas with OpenAI
-   */
-  "mongodb-openai": {
-    vectorDb: "mongodb",
-    llm: "openai",
-    embedding: "openai"
-  },
-  /**
-   * Redis stack for caching + search
-   */
-  "redis-openai": {
-    vectorDb: "redis",
-    llm: "openai",
-    embedding: "openai"
-  }
+  /** OpenAI + Pinecone: Production-ready cloud setup */
+  "openai-pinecone": { vectorDb: "pinecone", llm: "openai", embedding: "openai" },
+  /** Claude + Qdrant: Open-source vector DB + proprietary LLM */
+  "claude-qdrant": { vectorDb: "qdrant", llm: "anthropic", embedding: "openai" },
+  /** Local development: Ollama + local Qdrant */
+  "local-dev": { vectorDb: "qdrant", llm: "ollama", embedding: "ollama" },
+  /** Fully open-source: Ollama LLM + Qdrant + Ollama embeddings */
+  "fully-open-source": { vectorDb: "qdrant", llm: "ollama", embedding: "ollama" },
+  /** PostgreSQL stack: pgvector + OpenAI */
+  "postgres-openai": { vectorDb: "postgresql", llm: "openai", embedding: "openai" },
+  /** Enterprise MongoDB: MongoDB Atlas with OpenAI */
+  "mongodb-openai": { vectorDb: "mongodb", llm: "openai", embedding: "openai" },
+  /** Redis stack for caching + search */
+  "redis-openai": { vectorDb: "redis", llm: "openai", embedding: "openai" }
 };
 function createFromPreset(presetName) {
   const preset = PRESETS[presetName];
@@ -4514,8 +4498,35 @@ init_UniversalVectorProvider();
 
 // src/handlers/index.ts
 var import_server = require("next/server");
-function createChatHandler(config) {
-  const plugin = new VectorPlugin(config);
+function sseFrame(payload) {
+  return `data: ${JSON.stringify(payload)}
+
+`;
+}
+function sseTextFrame(text) {
+  return `data: ${JSON.stringify({ type: "text", text })}
+
+`;
+}
+function sseMetaFrame(meta) {
+  return `data: ${JSON.stringify(__spreadValues({ type: "metadata" }, meta != null ? meta : {}))}
+
+`;
+}
+function sseErrorFrame(message) {
+  return `data: ${JSON.stringify({ type: "error", error: message })}
+
+`;
+}
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream; charset=utf-8",
+  "Cache-Control": "no-cache, no-transform",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+  // Disable Nginx buffering for streaming
+};
+function createChatHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function POST(req) {
     try {
       const body = await req.json();
@@ -4531,8 +4542,64 @@ function createChatHandler(config) {
     }
   };
 }
-function createIngestHandler(config) {
-  const plugin = new VectorPlugin(config);
+function createStreamHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
+  return async function POST(req) {
+    let body;
+    try {
+      body = await req.json();
+    } catch (e) {
+      return new Response(JSON.stringify({ error: "Invalid JSON body" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const { message, history = [], namespace } = body;
+    if (!(message == null ? void 0 : message.trim())) {
+      return new Response(JSON.stringify({ error: "message is required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        const enqueue = (text) => controller.enqueue(encoder.encode(text));
+        try {
+          const pipelineStream = plugin.chatStream(message, history, namespace);
+          try {
+            for (var iter = __forAwait(pipelineStream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+              const chunk = temp.value;
+              if (typeof chunk === "string") {
+                enqueue(sseTextFrame(chunk));
+              } else {
+                enqueue(sseMetaFrame(chunk));
+              }
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && await temp.call(iter);
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+        } catch (streamError) {
+          const errorMessage = streamError instanceof Error ? streamError.message : String(streamError);
+          console.error("[createStreamHandler] Stream error:", streamError);
+          enqueue(sseErrorFrame(errorMessage));
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, { headers: SSE_HEADERS });
+  };
+}
+function createIngestHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function POST(req) {
     try {
       const body = await req.json();
@@ -4548,8 +4615,8 @@ function createIngestHandler(config) {
     }
   };
 }
-function createHealthHandler(config) {
-  const plugin = new VectorPlugin(config);
+function createHealthHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function GET() {
     try {
       const health = await plugin.checkHealth();
@@ -4565,8 +4632,8 @@ function createHealthHandler(config) {
     }
   };
 }
-function createUploadHandler(config) {
-  const plugin = new VectorPlugin(config);
+function createUploadHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function POST(req) {
     try {
       const formData = await req.formData();
@@ -4635,6 +4702,12 @@ function createUploadHandler(config) {
   createFromPreset,
   createHealthHandler,
   createIngestHandler,
+  createStreamHandler,
   createUploadHandler,
-  getRagConfig
+  getRagConfig,
+  resetConfigCache,
+  sseErrorFrame,
+  sseFrame,
+  sseMetaFrame,
+  sseTextFrame
 });