@tiledesk/tiledesk-server 2.19.0 → 2.19.2

package/CHANGELOG.md

@@ -5,6 +5,12 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.19.2
+- Improved vLLM integration in order to support multiple servers
+- Added custom_regex option for .txt and .md file uploaded in a Knowledge Base
+- Improved extension management in order to support markdown files
+- Updated tybot-connector to 2.1.1
+
 # 2.19.0
 - Added Analytics tracking
 

package/middleware/file-type.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const TEXT_MIME_TYPES = [
   'text/plain',
   'text/csv',
+  'text/markdown',
   'image/svg+xml',
   'application/xml',
   'text/xml'
@@ -39,6 +40,9 @@ function areMimeTypesEquivalent(mimeType1, mimeType2) {
     'image/jpg': ['image/jpeg'],
     'application/x-zip-compressed': ['application/zip'],
     'application/zip': ['application/x-zip-compressed'],
+    'text/markdown': ['text/plain', 'text/x-markdown'],
+    'text/plain': ['text/markdown', 'text/x-markdown'],
+    'text/x-markdown': ['text/markdown', 'text/plain'],
   };
   
   // Check if m1 is an alias of m2 or vice versa

package/migrations/1781085026218-vllm-servers-migration.js

@@ -0,0 +1,58 @@
+const winston = require('../config/winston');
+const Integration = require('../models/integrations');
+
+function getServerName(url) {
+    if (!url) return null;
+
+    try {
+        const hostname = new URL(url).hostname;
+
+        if (hostname === 'localhost') return 'localhost';
+
+        const parts = hostname.split('.');
+
+        if (parts.length >= 2) {
+            return parts[parts.length - 2];
+        }
+
+        return hostname;
+
+    } catch (err) {
+        winston.error("Error getting server name from URL: ", err);
+        return url;
+    }
+}
+
+async function up() {
+  try {
+    let integrations = await Integration.find({ name: 'vllm' });
+
+    for (const integration of integrations) {
+        
+        if (integration.value?.servers) continue;
+
+        if (!integration.value?.url) continue;
+
+        integration.value.servers = [{
+            name: getServerName(integration.value.url) || "default",
+            url: integration.value.url,
+            apikey: integration.value.apikey || "",
+            models: integration.value.models || []
+        }];
+
+        delete integration.value.url;
+        delete integration.value.apikey;
+        delete integration.value.models;
+        delete integration.value.token;
+
+        integration.markModified('value');
+
+        await integration.save();
+        winston.info(`VLLM server ${integration.value.url} migrated to ${integration.value.servers[0].name}`);
+    }
+  } catch (err) {
+    winston.error("VLLM servers migration error: ", err);
+  }
+}
+
+module.exports = { up };

package/models/kb_setting.js

@@ -203,6 +203,10 @@ var KBSchema = new Schema({
     type: Boolean,
     default: false,
     required: false
+  },
+  chunk_regex: {
+    type: String,
+    required: false
   }
 }, {
   timestamps: true

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.19.0",
+  "version": "2.19.2",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -49,7 +49,7 @@
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-sms-connector": "^0.1.13",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^2.1.0",
+    "@tiledesk/tiledesk-tybot-connector": "^2.1.1",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.3.2",
     "@tiledesk/tiledesk-vxml-connector": "^0.1.91",
     "@tiledesk/tiledesk-whatsapp-connector": "1.0.26",

package/pubmodules/analytics-publisher/index.js

@@ -265,7 +265,7 @@ function listen() {
   //   invited_by string|null
   // TODO: check
   authEvent.on("project_user.invite", function (event) {
-    console.log("project_user.invite", event);
+    // console.log("project_user.invite", event);
     var pu = event.savedProject_userPopulated || event.updatedPuserPopulated;
     if (!pu) return;
 
@@ -294,7 +294,7 @@ function listen() {
   //   new_status      'available'|'unavailable'|'busy'
   // TODO: check
   authEvent.on("project_user.update.agent", function (event) {
-    console.log("project_user.update.agent", event);
+    // console.log("project_user.update.agent", event);
     var pu = event.updatedProject_userPopulated;
     if (!pu) return;
     if (pu.user_available === undefined) return; // not a status-change update
@@ -326,7 +326,7 @@ function listen() {
   //   assigned_by     string|null
   //   routing_type    string
   requestEvent.on("request.department.update", function (requestComplete) {
-    console.log("request.department.update", requestComplete);
+    // console.log("request.department.update", requestComplete);
     var dept = requestComplete.department;
 
     var deptId = departmentId(dept);

package/routes/filesp.js

@@ -132,6 +132,9 @@ function areMimeTypesEquivalent(mimeType1, mimeType2) {
     'image/jpg': ['image/jpeg'],
     'application/x-zip-compressed': ['application/zip'],
     'application/zip': ['application/x-zip-compressed'],
+    'text/markdown': ['text/plain', 'text/x-markdown'],
+    'text/plain': ['text/markdown', 'text/x-markdown'],
+    'text/x-markdown': ['text/markdown', 'text/plain'],
   };
   
   // Check if m1 is an alias of m2 or vice versa

package/routes/kb.js

@@ -374,7 +374,7 @@ router.post('/qa', async (req, res) => {
 
   let model;
   try {
-    model = await aiManager.resolveLLMConfig(id_project, data.llm, data.model);
+    model = await aiManager.resolveLLMConfig(id_project, data.llm, data.model, data.vllmServer);
   } catch (err) {
     let errorCode = err?.code ?? 500;
     return res.status(errorCode).send({ success: false, error: err.error });
@@ -1583,20 +1583,21 @@ router.get('/', async (req, res) => {
 
 router.get('/:kb_id', async (req, res) => {
 
+  let project_id = req.projectid;
   let kb_id = req.params.kb_id;
 
-  KB.findById(kb_id, (err, kb) => {
-    if (err) {
-      winston.error("Find kb by id error: ", err);
-      return res.status(500).send({ success: false, error: err });
+  try {
+    let content = await KB.findOne({ id_project: project_id, _id: kb_id })
+    if (!content) {
+      return res.status(404).send({ success: false, error: "Content not found with id " + kb_id + " for project " + project_id });
     }
+    return res.status(200).send(content);
 
-    if (!kb) {
-      return res.status(404).send({ success: false, error: "Content not found with id " + kb_id });
-    }
+  } catch (err) {
+    winston.error("Find kb by id error: ", err);
+    return res.status(500).send({ success: false, error: "An error occurred retrieving the content" });
+  }
 
-    return res.status(200).send(kb);
-  })
 })
 
 router.post('/', async (req, res) => {
@@ -1604,7 +1605,7 @@ router.post('/', async (req, res) => {
   const id_project = req.projectid;
   const project = req.project
 
-  const { name, type, source, content, refresh_rate, scrape_type, scrape_options, tags, situated_context } = req.body;
+  const { name, type, source, content, refresh_rate, scrape_type, scrape_options, tags, situated_context, chunk_regex } = req.body;
   const namespace_id = req.body?.namespace;
   
   if (!namespace_id) {
@@ -1651,6 +1652,9 @@ router.post('/', async (req, res) => {
       new_kb.scrape_options = aiManager.setDefaultScrapeOptions();
     }
   }
+  if (type === 'regex_custom') {
+    new_kb.chunk_regex = chunk_regex;
+  }
 
   if (tags && Array.isArray(tags) && tags.every(tag => typeof tag === "string")) {
     new_kb.tags = tags;
@@ -1694,6 +1698,7 @@ router.post('/', async (req, res) => {
         ...(saved_kb.scrape_type && { scrape_type: saved_kb.scrape_type }),
         ...(saved_kb.scrape_options && { parameters_scrape_type_4: saved_kb.scrape_options }),
         ...(saved_kb.tags && { tags: saved_kb.tags }),
+        ...(saved_kb.chunk_regex && { chunk_regex: saved_kb.chunk_regex })
       }
 
       winston.debug("json: ", json);

package/routes/llm.js

@@ -3,6 +3,7 @@ var router = express.Router();
 var winston = require('../config/winston');
 let Integration = require('../models/integrations');
 const aiService = require('../services/aiService');
+const aiManager = require('../services/aiManager');
 const multer = require('multer');
 const fileUtils = require('../utils/fileUtils');
 const { MODELS_MULTIPLIER } = require('../utils/aiUtils');
@@ -24,36 +25,47 @@ router.post('/preview', async (req, res) => {
     let body = req.body;
     let key;
     let publicKey = false;
+    let integration;
+    let vllmConfig;
 
     if (!body.llm) {
         return res.status(400).send({ success: false, error: "Missing required parameter 'llm'" });
     }
 
-    let integration = await Integration.findOne({ id_project: id_project, name: body.llm }).catch((err) => {
-        winston.error("Error finding integration with name: ", body.llm);
-        return res.status(500).send({ success: false, error: "Error finding integration for " + body.llm});
-    })
-
-    if (!integration) {
-        winston.verbose("Integration not found for " + body.llm)
-        if (body.llm === "openai") {
-            winston.verbose("Try to retrieve shared OpenAI key")
-            if (!process.env.GPTKEY) {
-                winston.error("Shared key for OpenAI not configured.");
-                return res.status(404).send({ success: false, error: "No key found for " + body.llm });
-            }
-            key = process.env.GPTKEY;
-            publicKey = true;
-            winston.verbose("Using shared OpenAI key as fallback.");
-        } else {
-            winston.verbose("Integration for " + body.llm + " not found.")
-            return res.status(404).send({ success: false, error: "Integration for " + body.llm + " not found." })
+    if (body.llm === 'vllm') {
+        try {
+            vllmConfig = await aiManager.resolveLLMConfig(id_project, body.llm, body.model, body.vllmServer);
+            key = vllmConfig.api_key;
+        } catch (err) {
+            return res.status(err.code ?? 500).send({ success: false, error: err.error });
         }
     } else {
-        if (!integration?.value?.apikey && body.llm !== "ollama") {
-            return res.status(422).send({ success: false, error: "The key provided for " + body.llm + " is not valid or undefined." });
+        integration = await Integration.findOne({ id_project: id_project, name: body.llm }).catch((err) => {
+            winston.error("Error finding integration with name: ", body.llm);
+            return res.status(500).send({ success: false, error: "Error finding integration for " + body.llm});
+        })
+
+        if (!integration) {
+            winston.verbose("Integration not found for " + body.llm)
+            if (body.llm === "openai") {
+                winston.verbose("Try to retrieve shared OpenAI key")
+                if (!process.env.GPTKEY) {
+                    winston.error("Shared key for OpenAI not configured.");
+                    return res.status(404).send({ success: false, error: "No key found for " + body.llm });
+                }
+                key = process.env.GPTKEY;
+                publicKey = true;
+                winston.verbose("Using shared OpenAI key as fallback.");
+            } else {
+                winston.verbose("Integration for " + body.llm + " not found.")
+                return res.status(404).send({ success: false, error: "Integration for " + body.llm + " not found." })
+            }
+        } else {
+            if (!integration?.value?.apikey && body.llm !== "ollama") {
+                return res.status(422).send({ success: false, error: "The key provided for " + body.llm + " is not valid or undefined." });
+            }
+            key = integration.value.apikey;
         }
-        key = integration.value.apikey;
     }
 
     let obj = { createdAt: new Date() };
@@ -89,6 +101,16 @@ router.post('/preview', async (req, res) => {
         json.stream = false;
     }
 
+    if (body.llm === 'vllm') {
+        json.llm_key = key || "";
+        json.model = {
+            name: body.model,
+            url: vllmConfig.url,
+            provider: 'vllm'
+        };
+        json.stream = false;
+    }
+
     winston.debug("Preview LLM json: ", json);
 
     aiService.askllm(json).then((response) => {

package/services/aiManager.js

@@ -250,41 +250,54 @@ class AiManager {
     })
   }
 
-  async resolveLLMConfig(id_project, provider = 'openai', model) {
+  async resolveLLMConfig(id_project, provider = 'openai', model, vllmServer = undefined) {
 
     if (provider === 'ollama' || provider === 'vllm') {
-      try {
-        const integration = await integrationService.getIntegration(id_project, provider);
-        
-        if (!integration?.value?.url) {
-          throw { code: 422, error: `Server url for ${provider} is empty or invalid`}
-        }
+      const integration = await integrationService.getIntegration(id_project, provider);
+      if (!integration?.value) {
+        throw { code: 422, error: `${provider} integration not found` };
+      }
+
+      const value = integration.value;
 
+      if (provider === 'vllm' && Array.isArray(value.servers)) {
+        if (!vllmServer) {
+          throw { code: 422, error: "vllmServer attribute is undefined" };
+        }
+        const server = value.servers.find(s => s.name === vllmServer);
+        if (!server) {
+          throw { code: 422, error: `vllm server '${vllmServer}' not found` };
+        }
+        if (!server.url) {
+          throw { code: 422, error: "Server url for vllm is empty or invalid" };
+        }
         return {
           provider,
           name: model,
-          url: integration.value.url,
-          api_key: integration.value.apikey || ""
-        }
-
-      } catch (err) {
-        throw { code: err.code, error: err.error }
+          url: server.url,
+          api_key: server.apikey || ""
+        };
       }
-    }
 
-    try {
-      let key = await integrationService.getKeyFromIntegration(id_project, provider)
+      if (!value.url) {
+        throw { code: 422, error: `Server url for ${provider} is empty or invalid` };
+      }
 
       return {
         provider,
         name: model,
-        api_key: key
-      }
-
-    } catch (err) {
-      throw { code: err.code, error: err.error }
+        url: value.url,
+        api_key: value.apikey || ""
+      };
     }
 
+    const key = await integrationService.getKeyFromIntegration(id_project, provider);
+
+    return {
+      provider,
+      name: model,
+      api_key: key
+    };
   }
 
   async checkQuotaAvailability(quoteManager, project, ncontents) {