totem-llm 0.1.0

package/server/endpoints/api/embed/index.js

@@ -0,0 +1,409 @@
+const { EmbedConfig } = require("../../../models/embedConfig");
+const { EmbedChats } = require("../../../models/embedChats");
+const { validApiKey } = require("../../../utils/middleware/validApiKey");
+const { reqBody } = require("../../../utils/http");
+const { Workspace } = require("../../../models/workspace");
+
+function apiEmbedEndpoints(app) {
+  if (!app) return;
+
+  app.get("/v1/embed", [validApiKey], async (request, response) => {
+    /*
+      #swagger.tags = ['Embed']
+      #swagger.description = 'List all active embeds'
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                embeds: [
+                  {
+                    "id": 1,
+                    "uuid": "embed-uuid-1",
+                    "enabled": true,
+                    "chat_mode": "query",
+                    "createdAt": "2023-04-01T12:00:00Z",
+                    "workspace": {
+                      "id": 1,
+                      "name": "Workspace 1"
+                    },
+                    "chat_count": 10
+                  },
+                  {
+                    "id": 2,
+                    "uuid": "embed-uuid-2",
+                    "enabled": false,
+                    "chat_mode": "chat",
+                    "createdAt": "2023-04-02T14:30:00Z",
+                    "workspace": {
+                      "id": 1,
+                      "name": "Workspace 1"
+                    },
+                    "chat_count": 10
+                  }
+                ]
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+    */
+    try {
+      const embeds = await EmbedConfig.whereWithWorkspace();
+      const filteredEmbeds = embeds.map((embed) => ({
+        id: embed.id,
+        uuid: embed.uuid,
+        enabled: embed.enabled,
+        chat_mode: embed.chat_mode,
+        createdAt: embed.createdAt,
+        workspace: {
+          id: embed.workspace.id,
+          name: embed.workspace.name,
+        },
+        chat_count: embed._count.embed_chats,
+      }));
+      response.status(200).json({ embeds: filteredEmbeds });
+    } catch (e) {
+      console.error(e.message, e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  app.get(
+    "/v1/embed/:embedUuid/chats",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['Embed']
+      #swagger.description = 'Get all chats for a specific embed'
+      #swagger.parameters['embedUuid'] = {
+        in: 'path',
+        description: 'UUID of the embed',
+        required: true,
+        type: 'string'
+      }
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                chats: [
+                  {
+                    "id": 1,
+                    "session_id": "session-uuid-1",
+                    "prompt": "Hello",
+                    "response": "Hi there!",
+                    "createdAt": "2023-04-01T12:00:00Z"
+                  },
+                  {
+                    "id": 2,
+                    "session_id": "session-uuid-2",
+                    "prompt": "How are you?",
+                    "response": "I'm doing well, thank you!",
+                    "createdAt": "2023-04-02T14:30:00Z"
+                  }
+                ]
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      #swagger.responses[404] = {
+        description: "Embed not found",
+      }
+    */
+      try {
+        const { embedUuid } = request.params;
+        const chats = await EmbedChats.where({
+          embed_config: { uuid: String(embedUuid) },
+        });
+        response.status(200).json({ chats });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  app.get(
+    "/v1/embed/:embedUuid/chats/:sessionUuid",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['Embed']
+      #swagger.description = 'Get chats for a specific embed and session'
+      #swagger.parameters['embedUuid'] = {
+        in: 'path',
+        description: 'UUID of the embed',
+        required: true,
+        type: 'string'
+      }
+      #swagger.parameters['sessionUuid'] = {
+        in: 'path',
+        description: 'UUID of the session',
+        required: true,
+        type: 'string'
+      }
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                chats: [
+                  {
+                    "id": 1,
+                    "prompt": "Hello",
+                    "response": "Hi there!",
+                    "createdAt": "2023-04-01T12:00:00Z"
+                  }
+                ]
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      #swagger.responses[404] = {
+        description: "Embed or session not found",
+      }
+    */
+      try {
+        const { embedUuid, sessionUuid } = request.params;
+        const chats = await EmbedChats.where({
+          embed_config: { uuid: String(embedUuid) },
+          session_id: String(sessionUuid),
+        });
+        response.status(200).json({ chats });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  app.post("/v1/embed/new", [validApiKey], async (request, response) => {
+    /*
+      #swagger.tags = ['Embed']
+      #swagger.description = 'Create a new embed configuration'
+      #swagger.requestBody = {
+        description: 'JSON object containing embed configuration details',
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                "workspace_slug": "workspace-slug-1",
+                "chat_mode": "chat",
+                "allowlist_domains": ["example.com"],
+                "allow_model_override": false,
+                "allow_temperature_override": false,
+                "allow_prompt_override": false,
+                "max_chats_per_day": 100,
+                "max_chats_per_session": 10
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                "embed": {
+                  "id": 1,
+                  "uuid": "embed-uuid-1",
+                  "enabled": true,
+                  "chat_mode": "chat",
+                  "allowlist_domains": ["example.com"],
+                  "allow_model_override": false,
+                  "allow_temperature_override": false,
+                  "allow_prompt_override": false,
+                  "max_chats_per_day": 100,
+                  "max_chats_per_session": 10,
+                  "createdAt": "2023-04-01T12:00:00Z",
+                  "workspace_slug": "workspace-slug-1"
+                },
+                "error": null
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      #swagger.responses[404] = {
+        description: "Workspace not found"
+      }
+    */
+    try {
+      const data = reqBody(request);
+
+      if (!data.workspace_slug)
+        return response
+          .status(400)
+          .json({ error: "Workspace slug is required" });
+      const workspace = await Workspace.get({
+        slug: String(data.workspace_slug),
+      });
+
+      if (!workspace)
+        return response.status(404).json({ error: "Workspace not found" });
+
+      const { embed, message: error } = await EmbedConfig.new({
+        ...data,
+        workspace_id: workspace.id,
+      });
+
+      response.status(200).json({ embed, error });
+    } catch (e) {
+      console.error(e.message, e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  app.post("/v1/embed/:embedUuid", [validApiKey], async (request, response) => {
+    /*
+      #swagger.tags = ['Embed']
+      #swagger.description = 'Update an existing embed configuration'
+      #swagger.parameters['embedUuid'] = {
+        in: 'path',
+        description: 'UUID of the embed to update',
+        required: true,
+        type: 'string'
+      }
+      #swagger.requestBody = {
+        description: 'JSON object containing embed configuration updates',
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                "enabled": true,
+                "chat_mode": "chat",
+                "allowlist_domains": ["example.com"],
+                "allow_model_override": false,
+                "allow_temperature_override": false,
+                "allow_prompt_override": false,
+                "max_chats_per_day": 100,
+                "max_chats_per_session": 10
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                "success": true,
+                "error": null
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      #swagger.responses[404] = {
+        description: "Embed not found"
+      }
+    */
+    try {
+      const { embedUuid } = request.params;
+      const data = reqBody(request);
+
+      const embed = await EmbedConfig.get({ uuid: String(embedUuid) });
+      if (!embed) {
+        return response.status(404).json({ error: "Embed not found" });
+      }
+
+      const { success, error } = await EmbedConfig.update(embed.id, data);
+      response.status(200).json({ success, error });
+    } catch (e) {
+      console.error(e.message, e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  app.delete(
+    "/v1/embed/:embedUuid",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['Embed']
+      #swagger.description = 'Delete an existing embed configuration'
+      #swagger.parameters['embedUuid'] = {
+        in: 'path',
+        description: 'UUID of the embed to delete',
+        required: true,
+        type: 'string'
+      }
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                "success": true,
+                "error": null
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      #swagger.responses[404] = {
+        description: "Embed not found"
+      }
+    */
+      try {
+        const { embedUuid } = request.params;
+        const embed = await EmbedConfig.get({ uuid: String(embedUuid) });
+        if (!embed)
+          return response.status(404).json({ error: "Embed not found" });
+        const success = await EmbedConfig.delete({ id: embed.id });
+        response
+          .status(200)
+          .json({ success, error: success ? null : "Failed to delete embed" });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+}
+
+module.exports = { apiEmbedEndpoints };

package/server/endpoints/api/index.js

@@ -0,0 +1,29 @@
+const { useSwagger } = require("../../swagger/utils");
+const { apiAdminEndpoints } = require("./admin");
+const { apiAuthEndpoints } = require("./auth");
+const { apiDocumentEndpoints } = require("./document");
+const { apiSystemEndpoints } = require("./system");
+const { apiWorkspaceEndpoints } = require("./workspace");
+const { apiWorkspaceThreadEndpoints } = require("./workspaceThread");
+const { apiUserManagementEndpoints } = require("./userManagement");
+const { apiOpenAICompatibleEndpoints } = require("./openai");
+const { apiEmbedEndpoints } = require("./embed");
+
+// All endpoints must be documented and pass through the validApiKey Middleware.
+// How to JSDoc an endpoint
+// https://www.npmjs.com/package/swagger-autogen#openapi-3x
+function developerEndpoints(app, router) {
+  if (!router) return;
+  useSwagger(app);
+  apiAuthEndpoints(router);
+  apiAdminEndpoints(router);
+  apiSystemEndpoints(router);
+  apiWorkspaceEndpoints(router);
+  apiDocumentEndpoints(router);
+  apiWorkspaceThreadEndpoints(router);
+  apiUserManagementEndpoints(router);
+  apiOpenAICompatibleEndpoints(router);
+  apiEmbedEndpoints(router);
+}
+
+module.exports = { developerEndpoints };

package/server/endpoints/api/openai/compatibility-test-script.cjs

@@ -0,0 +1,79 @@
+const OpenAI = require("openai");
+
+/**
+ * @type {import("openai").OpenAI}
+ */
+const client = new OpenAI({
+  baseURL: "http://localhost:3001/api/v1/openai",
+  apiKey: "ENTER_ANYTHINGLLM_API_KEY_HERE",
+});
+
+(async () => {
+  // Models endpoint testing.
+  console.log("Fetching /models");
+  const modelList = await client.models.list();
+  for await (const model of modelList) {
+    console.log({ model });
+  }
+
+  // Test sync chat completion
+  console.log("Running synchronous chat message");
+  const syncCompletion = await client.chat.completions.create({
+    messages: [
+      {
+        role: "system",
+        content: "You are a helpful assistant who only speaks like a pirate.",
+      },
+      { role: "user", content: "What is AnythingLLM?" },
+      // {
+      //   role: 'assistant',
+      //   content: "Arrr, matey! AnythingLLM be a fine tool fer sailin' the treacherous sea o' information with a powerful language model at yer helm. It's a potent instrument to handle all manner o' tasks involvin' text, like answerin' questions, generating prose, or even havin' a chat with digital scallywags like meself. Be there any specific treasure ye seek in the realm o' AnythingLLM?"
+      // },
+      // { role: "user", content: "Why are you talking like a pirate?" },
+    ],
+    model: "anythingllm", // must be workspace-slug
+  });
+  console.log(syncCompletion.choices[0]);
+
+  // Test sync chat streaming completion
+  console.log("Running asynchronous chat message");
+  const asyncCompletion = await client.chat.completions.create({
+    messages: [
+      {
+        role: "system",
+        content: "You are a helpful assistant who only speaks like a pirate.",
+      },
+      { role: "user", content: "What is AnythingLLM?" },
+    ],
+    model: "anythingllm", // must be workspace-slug
+    stream: true,
+  });
+
+  let message = "";
+  for await (const chunk of asyncCompletion) {
+    message += chunk.choices[0].delta.content;
+    console.log({ message });
+  }
+
+  // Test embeddings creation
+  console.log("Creating embeddings");
+  const embedding = await client.embeddings.create({
+    model: null, // model is optional for AnythingLLM
+    input: "This is a test string for embedding",
+    encoding_format: "float",
+  });
+  console.log("Embedding created successfully:");
+  console.log(`Dimensions: ${embedding.data[0].embedding.length}`);
+  console.log(
+    `First few values:`,
+    embedding.data[0].embedding.slice(0, 5),
+    `+ ${embedding.data[0].embedding.length - 5} more`
+  );
+
+  // Vector DB functionality
+  console.log("Fetching /vector_stores");
+  const vectorDBList = await client.beta.vectorStores.list();
+  for await (const db of vectorDBList) {
+    console.log(db);
+  }
+})();

package/server/endpoints/api/openai/helpers.js

@@ -0,0 +1,50 @@
+/**
+ * Extracts text content from a multimodal message
+ * If the content has multiple text items, it will join them together with a newline.
+ * @param {string|Array} content - Message content that could be string or array of content objects
+ * @returns {string} - The text content
+ */
+function extractTextContent(content) {
+  if (!Array.isArray(content)) return content;
+  return content
+    .filter((item) => item.type === "text")
+    .map((item) => item.text)
+    .join("\n");
+}
+
+/**
+ * Detects mime type from a base64 data URL string, defaults to PNG if not detected
+ * @param {string} dataUrl - The data URL string (e.g. data:image/jpeg;base64,...)
+ * @returns {string} - The mime type or 'image/png' if not detected
+ */
+function getMimeTypeFromDataUrl(dataUrl) {
+  try {
+    const matches = dataUrl.match(/^data:([^;]+);base64,/);
+    return matches ? matches[1].toLowerCase() : "image/png";
+  } catch {
+    return "image/png";
+  }
+}
+
+/**
+ * Extracts attachments from a multimodal message
+ * The attachments provided are in OpenAI format since this util is used in the OpenAI compatible chat.
+ * However, our backend internal chat uses the Attachment type we use elsewhere in the app so we have to convert it.
+ * @param {Array} content - Message content that could be string or array of content objects
+ * @returns {import("../../../utils/helpers").Attachment[]} - The attachments
+ */
+function extractAttachments(content) {
+  if (!Array.isArray(content)) return [];
+  return content
+    .filter((item) => item.type === "image_url")
+    .map((item, index) => ({
+      name: `uploaded_image_${index}`,
+      mime: getMimeTypeFromDataUrl(item.image_url.url),
+      contentString: item.image_url.url,
+    }));
+}
+
+module.exports = {
+  extractTextContent,
+  extractAttachments,
+};