totem-llm 0.1.0

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

@@ -0,0 +1,321 @@
+const { v4: uuidv4 } = require("uuid");
+const { Document } = require("../../../models/documents");
+const { Workspace } = require("../../../models/workspace");
+const { getEmbeddingEngineSelection } = require("../../../utils/helpers");
+const { reqBody } = require("../../../utils/http");
+const { validApiKey } = require("../../../utils/middleware/validApiKey");
+const { EventLogs } = require("../../../models/eventLogs");
+const {
+  OpenAICompatibleChat,
+} = require("../../../utils/chats/openaiCompatible");
+const { getModelTag } = require("../../utils");
+const { extractTextContent, extractAttachments } = require("./helpers");
+
+function apiOpenAICompatibleEndpoints(app) {
+  if (!app) return;
+
+  app.get("/v1/openai/models", [validApiKey], async (_, response) => {
+    /*
+    #swagger.tags = ['OpenAI Compatible Endpoints']
+    #swagger.description = 'Get all available "models" which are workspaces you can use for chatting.'
+    #swagger.responses[200] = {
+      content: {
+        "application/json": {
+          "schema": {
+            "type": "object",
+            "example": {
+              "object": "list",
+              "data": [
+                {
+                  "id": "model-id-0",
+                  "object": "model",
+                  "created": 1686935002,
+                  "owned_by": "organization-owner"
+                },
+                {
+                  "id": "model-id-1",
+                  "object": "model",
+                  "created": 1686935002,
+                  "owned_by": "organization-owner"
+                }
+              ]
+            }
+          }
+        }
+      }
+    }
+    #swagger.responses[403] = {
+      schema: {
+        "$ref": "#/definitions/InvalidAPIKey"
+      }
+    }
+    */
+    try {
+      const data = [];
+      const workspaces = await Workspace.where();
+      for (const workspace of workspaces) {
+        data.push({
+          id: workspace.slug,
+          object: "model",
+          created: Math.floor(Number(new Date(workspace.createdAt)) / 1000),
+          owned_by: workspace?.chatProvider || process.env.LLM_PROVIDER,
+        });
+      }
+      return response.status(200).json({
+        object: "list",
+        data,
+      });
+    } catch (e) {
+      console.error(e.message, e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  app.post(
+    "/v1/openai/chat/completions",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['OpenAI Compatible Endpoints']
+      #swagger.description = 'Execute a chat with a workspace with OpenAI compatibility. Supports streaming as well. Model must be a workspace slug from /models.'
+      #swagger.requestBody = {
+          description: 'Send a prompt to the workspace with full use of documents as if sending a chat in AnythingLLM. Only supports some values of OpenAI API. See example below.',
+          required: true,
+          content: {
+            "application/json": {
+              example: {
+                messages: [
+                {"role":"system", content: "You are a helpful assistant"},
+                {"role":"user", content: "What is AnythingLLM?"},
+                {"role":"assistant", content: "AnythingLLM is...."},
+                {"role":"user", content: "Follow up question..."}
+                ],
+                model: "sample-workspace",
+                stream: true,
+                temperature: 0.7
+              }
+            }
+          }
+        }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      */
+      try {
+        const {
+          model,
+          messages = [],
+          temperature,
+          stream = false,
+        } = reqBody(request);
+        const workspace = await Workspace.get({ slug: String(model) });
+        if (!workspace) return response.status(401).end();
+
+        const userMessage = messages.pop();
+        if (userMessage.role !== "user") {
+          return response.status(400).json({
+            id: uuidv4(),
+            type: "abort",
+            textResponse: null,
+            sources: [],
+            close: true,
+            error:
+              "No user prompt found. Must be last element in message array with 'user' role.",
+          });
+        }
+
+        const systemPrompt =
+          messages.find((chat) => chat.role === "system")?.content ?? null;
+        const history = messages.filter((chat) => chat.role !== "system") ?? [];
+
+        if (!stream) {
+          const chatResult = await OpenAICompatibleChat.chatSync({
+            workspace,
+            systemPrompt,
+            history,
+            prompt: extractTextContent(userMessage.content),
+            attachments: extractAttachments(userMessage.content),
+            temperature: Number(temperature),
+          });
+
+          await EventLogs.logEvent("api_sent_chat", {
+            workspaceName: workspace?.name,
+            chatModel: workspace?.chatModel || "System Default",
+          });
+          return response.status(200).json(chatResult);
+        }
+
+        response.setHeader("Cache-Control", "no-cache");
+        response.setHeader("Content-Type", "text/event-stream");
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("Connection", "keep-alive");
+        response.flushHeaders();
+
+        await OpenAICompatibleChat.streamChat({
+          workspace,
+          systemPrompt,
+          history,
+          prompt: extractTextContent(userMessage.content),
+          attachments: extractAttachments(userMessage.content),
+          temperature: Number(temperature),
+          response,
+        });
+        await EventLogs.logEvent("api_sent_chat", {
+          workspaceName: workspace?.name,
+          chatModel: workspace?.chatModel || "System Default",
+        });
+        response.end();
+      } catch (e) {
+        console.error(e.message, e);
+        response.status(500).end();
+      }
+    }
+  );
+
+  app.post(
+    "/v1/openai/embeddings",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['OpenAI Compatible Endpoints']
+      #swagger.description = 'Get the embeddings of any arbitrary text string. This will use the embedder provider set in the system. Please ensure the token length of each string fits within the context of your embedder model.'
+      #swagger.requestBody = {
+          description: 'The input string(s) to be embedded. If the text is too long for the embedder model context, it will fail to embed. The vector and associated chunk metadata will be returned in the array order provided',
+          required: true,
+          content: {
+            "application/json": {
+              example: {
+                input: [
+                "This is my first string to embed",
+                "This is my second string to embed",
+                ],
+                model: null,
+              }
+            }
+          }
+        }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      */
+      try {
+        const body = reqBody(request);
+        // Support input or "inputs" (for backwards compatibility) as an array of strings or a single string
+        // TODO: "inputs" key support will eventually be fully removed.
+        let input = body?.input || body?.inputs || [];
+        // if input is not an array, make it an array and force to string content
+        if (!Array.isArray(input)) input = [String(input)];
+
+        if (Array.isArray(input)) {
+          if (input.length === 0)
+            throw new Error("Input array cannot be empty.");
+          const validArray = input.every((text) => typeof text === "string");
+          if (!validArray)
+            throw new Error("All inputs to be embedded must be strings.");
+        }
+
+        const Embedder = getEmbeddingEngineSelection();
+        const embeddings = await Embedder.embedChunks(input);
+        const data = [];
+        embeddings.forEach((embedding, index) => {
+          data.push({
+            object: "embedding",
+            embedding,
+            index,
+          });
+        });
+
+        return response.status(200).json({
+          object: "list",
+          data,
+          model: Embedder.model,
+        });
+      } catch (e) {
+        console.error(e.message, e);
+        response.status(500).end();
+      }
+    }
+  );
+
+  app.get(
+    "/v1/openai/vector_stores",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['OpenAI Compatible Endpoints']
+      #swagger.description = 'List all the vector database collections connected to AnythingLLM. These are essentially workspaces but return their unique vector db identifier - this is the same as the workspace slug.'
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            "schema": {
+              "type": "object",
+              "example": {
+                "data": [
+                  {
+                    "id": "slug-here",
+                    "object": "vector_store",
+                    "name": "My workspace",
+                    "file_counts": {
+                      "total": 3
+                    },
+                    "provider": "LanceDB"
+                  }
+                ]
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      */
+      try {
+        // We dump all in the first response and despite saying there is
+        // not more data the library still checks with a query param so if
+        // we detect one - respond with nothing.
+        if (Object.keys(request?.query ?? {}).length !== 0) {
+          return response.status(200).json({
+            data: [],
+            has_more: false,
+          });
+        }
+
+        const data = [];
+        const VectorDBProvider = process.env.VECTOR_DB || "lancedb";
+        const workspaces = await Workspace.where();
+
+        for (const workspace of workspaces) {
+          data.push({
+            id: workspace.slug,
+            object: "vector_store",
+            name: workspace.name,
+            file_counts: {
+              total: await Document.count({
+                workspaceId: Number(workspace.id),
+              }),
+            },
+            provider: VectorDBProvider,
+          });
+        }
+        return response.status(200).json({
+          first_id: [...data].splice(0)?.[0]?.id,
+          last_id: [...data].splice(-1)?.[0]?.id ?? data.splice(1)?.[0]?.id,
+          data,
+          has_more: false,
+        });
+      } catch (e) {
+        console.error(e.message, e);
+        response.status(500).end();
+      }
+    }
+  );
+}
+
+module.exports = { apiOpenAICompatibleEndpoints };

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

@@ -0,0 +1,275 @@
+const { EventLogs } = require("../../../models/eventLogs");
+const { SystemSettings } = require("../../../models/systemSettings");
+const { purgeDocument } = require("../../../utils/files/purgeDocument");
+const { getVectorDbClass } = require("../../../utils/helpers");
+const { exportChatsAsType } = require("../../../utils/helpers/chat/convertTo");
+const { dumpENV, updateENV } = require("../../../utils/helpers/updateENV");
+const { reqBody } = require("../../../utils/http");
+const { validApiKey } = require("../../../utils/middleware/validApiKey");
+
+function apiSystemEndpoints(app) {
+  if (!app) return;
+
+  app.get("/v1/system/env-dump", async (_, response) => {
+    /*
+   #swagger.tags = ['System Settings']
+   #swagger.description = 'Dump all settings to file storage'
+   #swagger.responses[403] = {
+     schema: {
+       "$ref": "#/definitions/InvalidAPIKey"
+     }
+   }
+   */
+    try {
+      if (process.env.NODE_ENV !== "production")
+        return response.sendStatus(200).end();
+      dumpENV();
+      response.sendStatus(200).end();
+    } catch (e) {
+      console.error(e.message, e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  app.get("/v1/system", [validApiKey], async (_, response) => {
+    /*
+    #swagger.tags = ['System Settings']
+    #swagger.description = 'Get all current system settings that are defined.'
+    #swagger.responses[200] = {
+      content: {
+        "application/json": {
+          schema: {
+            type: 'object',
+            example: {
+             "settings": {
+                "VectorDB": "pinecone",
+                "PineConeKey": true,
+                "PineConeIndex": "my-pinecone-index",
+                "LLMProvider": "azure",
+                "[KEY_NAME]": "KEY_VALUE",
+              }
+            }
+          }
+        }
+      }
+    }
+    #swagger.responses[403] = {
+      schema: {
+        "$ref": "#/definitions/InvalidAPIKey"
+      }
+    }
+    */
+    try {
+      const settings = await SystemSettings.currentSettings();
+      response.status(200).json({ settings });
+    } catch (e) {
+      console.error(e.message, e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  app.get("/v1/system/vector-count", [validApiKey], async (_, response) => {
+    /*
+    #swagger.tags = ['System Settings']
+    #swagger.description = 'Number of all vectors in connected vector database'
+    #swagger.responses[200] = {
+      content: {
+        "application/json": {
+          schema: {
+            type: 'object',
+            example: {
+             "vectorCount": 5450
+            }
+          }
+        }
+      }
+    }
+    #swagger.responses[403] = {
+      schema: {
+        "$ref": "#/definitions/InvalidAPIKey"
+      }
+    }
+    */
+    try {
+      const VectorDb = getVectorDbClass();
+      const vectorCount = await VectorDb.totalVectors();
+      response.status(200).json({ vectorCount });
+    } catch (e) {
+      console.error(e.message, e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  app.post(
+    "/v1/system/update-env",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['System Settings']
+      #swagger.description = 'Update a system setting or preference.'
+      #swagger.requestBody = {
+        description: 'Key pair object that matches a valid setting and value. Get keys from GET /v1/system or refer to codebase.',
+        required: true,
+        content: {
+          "application/json": {
+            example: {
+              VectorDB: "lancedb",
+              AnotherKey: "updatedValue"
+            }
+          }
+        }
+      }
+      #swagger.responses[200] = {
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                newValues: {"[ENV_KEY]": 'Value'},
+                error: 'error goes here, otherwise null'
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      */
+      try {
+        const body = reqBody(request);
+        const { newValues, error } = await updateENV(body);
+        response.status(200).json({ newValues, error });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  app.get(
+    "/v1/system/export-chats",
+    [validApiKey],
+    async (request, response) => {
+      /*
+    #swagger.tags = ['System Settings']
+    #swagger.description = 'Export all of the chats from the system in a known format. Output depends on the type sent. Will be send with the correct header for the output.'
+   #swagger.parameters['type'] = {
+      in: 'query',
+      description: "Export format jsonl, json, csv, jsonAlpaca",
+      required: false,
+      type: 'string'
+    }
+    #swagger.responses[200] = {
+      content: {
+        "application/json": {
+          schema: {
+            type: 'object',
+            example: [
+              {
+                "role": "user",
+                "content": "What is AnythinglLM?"
+              },
+              {
+                "role": "assistant",
+                "content": "AnythingLLM is a knowledge graph and vector database management system built using NodeJS express server. It provides an interface for handling all interactions, including vectorDB management and LLM (Language Model) interactions."
+              },
+            ]
+          }
+        }
+      }
+    }
+    #swagger.responses[403] = {
+      schema: {
+        "$ref": "#/definitions/InvalidAPIKey"
+      }
+    }
+    */
+      try {
+        const { type = "jsonl" } = request.query;
+        const { contentType, data } = await exportChatsAsType(
+          type,
+          "workspace"
+        );
+        await EventLogs.logEvent("exported_chats", {
+          type,
+        });
+        response.setHeader("Content-Type", contentType);
+        response.status(200).send(data);
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+  app.delete(
+    "/v1/system/remove-documents",
+    [validApiKey],
+    async (request, response) => {
+      /*
+      #swagger.tags = ['System Settings']
+      #swagger.description = 'Permanently remove documents from the system.'
+      #swagger.requestBody = {
+        description: 'Array of document names to be removed permanently.',
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              properties: {
+                names: {
+                  type: 'array',
+                  items: {
+                    type: 'string'
+                  },
+                  example: [
+                    "custom-documents/file.txt-fc4beeeb-e436-454d-8bb4-e5b8979cb48f.json"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[200] = {
+        description: 'Documents removed successfully.',
+        content: {
+          "application/json": {
+            schema: {
+              type: 'object',
+              example: {
+                success: true,
+                message: 'Documents removed successfully'
+              }
+            }
+          }
+        }
+      }
+      #swagger.responses[403] = {
+        description: 'Forbidden',
+        schema: {
+          "$ref": "#/definitions/InvalidAPIKey"
+        }
+      }
+      #swagger.responses[500] = {
+        description: 'Internal Server Error'
+      }
+      */
+      try {
+        const { names } = reqBody(request);
+        for await (const name of names) await purgeDocument(name);
+        response
+          .status(200)
+          .json({ success: true, message: "Documents removed successfully" })
+          .end();
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+}
+
+module.exports = { apiSystemEndpoints };