@nocobase/ai 2.1.0-beta.2 → 2.1.0-beta.21

package/src/ai-employee-manager/index.ts

@@ -0,0 +1,148 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { Op } from '@nocobase/database';
+import { SequelizeCollectionManager } from '@nocobase/data-source-manager';
+import { Registry } from '@nocobase/utils';
+import _ from 'lodash';
+import { AIEmployeeEntry, AIEmployeeFilter, AIEmployeeManager, AIEmployeeOptions } from './types';
+
+const DEFAULT_KNOWLEDGE_BASE = {
+  topK: 3,
+  score: '0.6',
+  knowledgeBaseIds: [],
+};
+const DEFAULT_KNOWLEDGE_BASE_PROMPT =
+  "From knowledge base:\n{knowledgeBaseData}\nanswer user's question using this information.";
+
+export class DefaultAIEmployeeManager implements AIEmployeeManager {
+  private readonly employees = new Registry<AIEmployeeOptions>();
+  private readonly provideCollectionManager: () => { collectionManager: SequelizeCollectionManager };
+  private mode = 'memory';
+
+  constructor(private readonly app: any) {
+    this.provideCollectionManager = () => app.mainDataSource;
+  }
+
+  async init() {
+    if (this.mode === 'memory') {
+      await this.persistence();
+      this.mode = 'database';
+    }
+  }
+
+  async getEmployee(username: string): Promise<AIEmployeeEntry> {
+    return (await this.aiEmployeesModel.findOne({ where: { username } }))?.toJSON() as AIEmployeeEntry;
+  }
+
+  async listEmployees(filter: AIEmployeeFilter = {}): Promise<AIEmployeeEntry[]> {
+    const where = {};
+    if (filter.builtIn != null) {
+      where['builtIn'] = filter.builtIn;
+    }
+    if (filter.username) {
+      where['username'] = {
+        [Op.substring]: filter.username,
+      };
+    }
+    return (await this.aiEmployeesModel.findAll({ where })).map((it) => it.toJSON() as AIEmployeeEntry);
+  }
+
+  async registerEmployee(options: AIEmployeeOptions): Promise<void> {
+    if (this.mode === 'memory') {
+      return this.registerEmployeeInMemory(options);
+    }
+    return this.registerEmployeeInDatabase(options);
+  }
+
+  async persistence(): Promise<void> {
+    const employees = [...this.employees.getValues()];
+    for (const employee of employees) {
+      await this.registerEmployeeInDatabase(employee);
+    }
+  }
+
+  private registerEmployeeInMemory(options: AIEmployeeOptions): void {
+    this.employees.register(options.username, options);
+  }
+
+  private async registerEmployeeInDatabase(options: AIEmployeeOptions): Promise<void> {
+    const employee = options;
+    await this.sequelize.transaction(async (transaction) => {
+      const existed = await this.aiEmployeesModel.findOne({ where: { username: employee.username }, transaction });
+      if (!existed) {
+        await this.aiEmployeesModel.create(
+          {
+            username: employee.username,
+            nickname: employee.nickname,
+            position: employee.position,
+            avatar: employee.avatar,
+            bio: employee.bio,
+            greeting: employee.greeting,
+            about: null,
+            defaultPrompt: employee.systemPrompt,
+            skillSettings: {
+              skills: employee.skills,
+              tools: employee.tools,
+            },
+            enableKnowledgeBase: false,
+            knowledgeBase: DEFAULT_KNOWLEDGE_BASE,
+            knowledgeBasePrompt: DEFAULT_KNOWLEDGE_BASE_PROMPT,
+            enabled: true,
+            builtIn: true,
+            sort: employee.sort,
+          },
+          { transaction },
+        );
+        return;
+      }
+
+      const current = existed.toJSON() as AIEmployeeEntry;
+      let { tools } = current?.skillSettings ?? { tools: [] };
+      tools = tools?.length ? tools.filter((s) => s.name?.startsWith('workflowCaller-')) : [];
+      const mergedTools = new Set([...tools, ...employee.tools]);
+      const values: Record<string, unknown> = {
+        nickname: employee.nickname ?? current.nickname,
+        position: employee.position ?? current.position,
+        avatar: employee.avatar ?? current.avatar,
+        bio: employee.bio ?? current.bio,
+        greeting: employee.greeting ?? current.greeting,
+        defaultPrompt: employee.systemPrompt,
+        skillSettings: {
+          skills: [...employee.skills],
+          tools: [...mergedTools],
+        },
+        sort: employee.sort,
+      };
+      await existed.update(values, { transaction });
+    });
+  }
+
+  private get aiEmployeesCollection() {
+    return this.collectionManager.getCollection('aiEmployees');
+  }
+
+  private get aiEmployeesModel() {
+    return this.aiEmployeesCollection?.model;
+  }
+
+  private get sequelize() {
+    return this.collectionManager.db.sequelize;
+  }
+
+  private get collectionManager() {
+    return this.provideCollectionManager().collectionManager;
+  }
+}
+
+export function defineAIEmployee(options: AIEmployeeOptions) {
+  return options;
+}
+
+export * from './types';

package/src/ai-employee-manager/types.ts

@@ -0,0 +1,63 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+export type AIEmployeeLocalizedProfile = {
+  avatar?: string;
+  nickname?: string;
+  position?: string;
+  bio?: string;
+  greeting?: string;
+  about?: string;
+};
+
+export type AIEmployeeKnowledgeBase = {
+  topK: number;
+  score: string;
+  knowledgeBaseIds: string[];
+};
+
+export type AIEmployeeToolSetting = {
+  name: string;
+  autoCall?: boolean;
+};
+
+export type AIEmployeeOptions = {
+  username: string;
+  description?: string;
+  skills?: string[];
+  tools?: AIEmployeeToolSetting[];
+  avatar?: string;
+  nickname?: string;
+  position?: string;
+  bio?: string;
+  greeting?: string;
+  systemPrompt?: string | null;
+  sort?: number;
+};
+
+export type AIEmployeeEntry = Omit<AIEmployeeOptions, 'skills' | 'tools' | 'systemPrompt'> & {
+  about?: string;
+  defaultPrompt?: string;
+  skillSettings: {
+    skills: string[];
+    tools: AIEmployeeToolSetting[];
+  };
+};
+
+export type AIEmployeeFilter = {
+  builtIn?: boolean;
+  username?: string;
+};
+
+export interface AIEmployeeManager {
+  init(): Promise<void>;
+  getEmployee(username: string): Promise<AIEmployeeEntry>;
+  listEmployees(filter?: AIEmployeeFilter): Promise<AIEmployeeEntry[]>;
+  registerEmployee(options: AIEmployeeOptions): Promise<void>;
+}

package/src/ai-manager.ts

@@ -9,13 +9,25 @@
 
 import { DocumentManager } from './document-manager';
 import { DefaultToolsManager, ToolsManager } from './tools-manager';
+import { DefaultSkillsManager, SkillsManager } from './skills-manager';
+import { AIEmployeeManager, DefaultAIEmployeeManager } from './ai-employee-manager';
+import { DefaultMCPManager, MCPManager } from './mcp-manager';
+import { McpToolsManager } from './mcp-tools-manager';
 
 export class AIManager {
   documentManager: DocumentManager;
   toolsManager: ToolsManager;
+  skillsManager: SkillsManager;
+  employeeManager: AIEmployeeManager;
+  mcpManager: MCPManager;
+  mcpToolsManager: McpToolsManager;
 
   constructor(protected readonly app: any) {
     this.documentManager = new DocumentManager();
     this.toolsManager = new DefaultToolsManager();
+    this.skillsManager = new DefaultSkillsManager(app);
+    this.employeeManager = new DefaultAIEmployeeManager(app);
+    this.mcpManager = new DefaultMCPManager(app);
+    this.mcpToolsManager = new McpToolsManager();
   }
 }

package/src/document-loader/index.ts

@@ -0,0 +1,57 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { Document } from '@langchain/core/documents';
+import { Worker } from 'node:worker_threads';
+import path from 'node:path';
+
+export const loadByWorker = async (extname: string, blob: Blob): Promise<Document[]> => {
+  const buffer = Buffer.from(await blob.arrayBuffer());
+  const isTsRuntime = __filename.endsWith('.ts');
+  const workerPath = path.join(__dirname, `loader.worker.${isTsRuntime ? 'ts' : 'js'}`);
+  const worker = new Worker(workerPath, {
+    execArgv: isTsRuntime ? ['--require', 'tsx/cjs'] : undefined,
+  });
+  return new Promise<Document[]>((resolve, reject) => {
+    let settled = false;
+    const close = (error?: Error, result?: Document[]) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(result || []);
+    };
+
+    worker.once('message', (payload: { documents?: Document[]; error?: string }) => {
+      if (payload?.error) {
+        close(new Error(payload.error));
+        return;
+      }
+      close(undefined, payload?.documents || []);
+    });
+    worker.once('error', (error) => close(error));
+    worker.once('exit', (code) => {
+      if (!settled && code !== 0) {
+        close(new Error(`Document loader worker exited with code ${code}`));
+      }
+    });
+
+    worker.postMessage({
+      extname,
+      mimeType: blob.type,
+      buffer: Uint8Array.from(buffer),
+    });
+  }).finally(() => {
+    worker.terminate().catch(() => undefined);
+  });
+};

package/src/document-loader/loader.worker.ts

@@ -0,0 +1,100 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { PDFLoader } from '@langchain/community/document_loaders/fs/pdf';
+import { PPTXLoader } from '@langchain/community/document_loaders/fs/pptx';
+import { DocxLoader } from '@langchain/community/document_loaders/fs/docx';
+import type { Document } from '@langchain/core/documents';
+import { parentPort } from 'node:worker_threads';
+import { TextLoader } from './vendor/langchain/document_loaders/fs/text';
+import { CSVLoader } from '@langchain/community/document_loaders/fs/csv';
+import { loadXlsx } from './xlsx';
+
+type ParsePayload = {
+  extname: string;
+  mimeType?: string;
+  buffer: Uint8Array;
+};
+
+type WorkerResponse = {
+  documents?: Array<Pick<Document, 'pageContent' | 'metadata' | 'id'>>;
+  error?: string;
+};
+
+const loadPdf = async (blob: Blob): Promise<Document[]> => {
+  const loader = new PDFLoader(blob);
+  return loader.load();
+};
+
+const loadDoc = async (blob: Blob, type: 'docx' | 'doc'): Promise<Document[]> => {
+  const loader = new DocxLoader(blob, { type });
+  return loader.load();
+};
+
+const loadPpt = async (blob: Blob): Promise<Document[]> => {
+  const loader = new PPTXLoader(blob);
+  return loader.load();
+};
+
+const loadTxt = async (blob: Blob): Promise<Document[]> => {
+  const loader = new TextLoader(blob);
+  return loader.load();
+};
+
+const loadCsv = async (blob: Blob): Promise<Document[]> => {
+  const loader = new CSVLoader(blob);
+  return loader.load();
+};
+
+const loadByExtname = async (payload: ParsePayload): Promise<Document[]> => {
+  // @ts-ignore
+  const blob = new Blob([Buffer.from(payload.buffer)], { type: payload.mimeType ?? 'application/octet-stream' });
+
+  switch (payload.extname) {
+    case '.pdf':
+      return loadPdf(blob);
+    case '.ppt':
+    case '.pptx':
+      return loadPpt(blob);
+    case '.doc':
+      return loadDoc(blob, 'doc');
+    case '.docx':
+      return loadDoc(blob, 'docx');
+    case '.csv':
+      return loadCsv(blob);
+    case '.xls':
+    case '.xlsx':
+      return loadXlsx(blob);
+    case '.json':
+    case '.md':
+    case '.txt':
+      return loadTxt(blob);
+    default:
+      return [];
+  }
+};
+
+parentPort?.on('message', async (payload: ParsePayload) => {
+  try {
+    const documents = await loadByExtname(payload);
+    const response: WorkerResponse = {
+      documents: documents.map((doc) => ({
+        pageContent: doc.pageContent,
+        metadata: doc.metadata,
+        id: doc.id,
+      })),
+    };
+    parentPort?.postMessage(response);
+  } catch (error) {
+    const response: WorkerResponse = {
+      error: String(error?.stack || error),
+    };
+    parentPort?.postMessage(response);
+  }
+});

package/src/document-loader/vendor/langchain/document_loaders/fs/text.ts

@@ -0,0 +1,72 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { Document } from '@langchain/core/documents';
+import { getEnv } from '@langchain/core/utils/env';
+import { BaseDocumentLoader } from '@langchain/core/document_loaders/base';
+
+export class TextLoader extends BaseDocumentLoader {
+  private filePathOrBlob: any;
+
+  constructor(filePathOrBlob) {
+    super();
+    this.filePathOrBlob = filePathOrBlob;
+  }
+
+  async parse(raw) {
+    return [raw];
+  }
+
+  async load() {
+    let text;
+    let metadata;
+
+    if (typeof this.filePathOrBlob === 'string') {
+      const { readFile } = await TextLoader.imports();
+      text = await readFile(this.filePathOrBlob, 'utf8');
+      metadata = { source: this.filePathOrBlob };
+    } else {
+      text = await this.filePathOrBlob.text();
+      metadata = { source: 'blob', blobType: this.filePathOrBlob.type };
+    }
+
+    const parsed = await this.parse(text);
+    parsed.forEach((pageContent, i) => {
+      if (typeof pageContent !== 'string') {
+        throw new Error(`Expected string, at position ${i} got ${typeof pageContent}`);
+      }
+    });
+
+    return parsed.map(
+      (pageContent, i) =>
+        new Document({
+          pageContent,
+          metadata:
+            parsed.length === 1
+              ? metadata
+              : {
+                  ...metadata,
+                  line: i + 1,
+                },
+        }),
+    );
+  }
+
+  static async imports() {
+    try {
+      const { readFile } = await import('node:fs/promises');
+      return { readFile };
+    } catch (e) {
+      console.error(e);
+      throw new Error(
+        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`,
+      );
+    }
+  }
+}

package/src/document-loader/xlsx.ts

@@ -0,0 +1,82 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { Document } from '@langchain/core/documents';
+import * as XLSX from 'xlsx';
+
+const normalizeCellValue = (value: unknown): string => {
+  if (value === undefined || value === null) {
+    return '';
+  }
+
+  return String(value);
+};
+
+const trimTrailingEmptyCells = (row: unknown[]): unknown[] => {
+  let end = row.length;
+
+  while (end > 0 && normalizeCellValue(row[end - 1]).trim() === '') {
+    end -= 1;
+  }
+
+  return row.slice(0, end);
+};
+
+const sheetToLines = (sheet: XLSX.WorkSheet): string[] => {
+  const rows = XLSX.utils.sheet_to_json(sheet, {
+    header: 1,
+    raw: false,
+    defval: '',
+    blankrows: false,
+  }) as unknown[][];
+
+  return rows
+    .map((row) => trimTrailingEmptyCells(Array.isArray(row) ? row : []))
+    .filter((row) => row.length > 0)
+    .map((row) => row.map((cell) => normalizeCellValue(cell)).join('\t'))
+    .filter((line) => line.trim().length > 0);
+};
+
+export const loadXlsx = async (blob: Blob): Promise<Document[]> => {
+  const buffer = await blob.arrayBuffer();
+  const workbook = XLSX.read(buffer, {
+    type: 'array',
+    cellText: true,
+  });
+
+  const documents: Document[] = [];
+
+  workbook.SheetNames.forEach((sheetName, index) => {
+    const sheet = workbook.Sheets[sheetName];
+
+    if (!sheet) {
+      return;
+    }
+
+    const lines = sheetToLines(sheet);
+
+    if (!lines.length) {
+      return;
+    }
+
+    documents.push(
+      new Document({
+        pageContent: [`Sheet: ${sheetName}`, ...lines].join('\n'),
+        metadata: {
+          source: 'blob',
+          blobType: blob.type,
+          sheetName,
+          sheetIndex: index,
+        },
+      }),
+    );
+  });
+
+  return documents;
+};

package/src/index.ts

@@ -8,6 +8,11 @@
  */
 
 export * from './ai-manager';
+export * from './ai-employee-manager';
 export * from './document-manager';
+export * from './mcp-tools-manager';
 export * from './tools-manager';
+export * from './skills-manager';
+export * from './mcp-manager';
 export * from './loader';
+export * from './document-loader';