@nocobase/ai 2.1.0-beta.14 → 2.1.0-beta.16

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';

package/src/loader/employee.ts

@@ -0,0 +1,194 @@
+/**
+ * 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 { importModule } from '@nocobase/utils';
+import { DirectoryScanner, DirectoryScannerOptions, FileDescriptor } from './scanner';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { AIManager } from '../ai-manager';
+import { LoadAndRegister } from './types';
+import { Logger } from '@nocobase/logger';
+import path from 'path';
+import { AIEmployeeOptions, AIEmployeeToolSetting } from '../ai-employee-manager';
+
+export type AIEmployeeLoaderOptions = { pluginName: string; scan: DirectoryScannerOptions; log?: Logger };
+
+export class AIEmployeeLoader extends LoadAndRegister<AIEmployeeLoaderOptions> {
+  protected readonly scanner: DirectoryScanner;
+
+  protected files: FileDescriptor[] = [];
+  protected employeeDescriptors: AIEmployeeDescriptor[] = [];
+  protected log: Logger;
+
+  constructor(
+    protected readonly ai: AIManager,
+    protected readonly options: AIEmployeeLoaderOptions,
+  ) {
+    super(ai, options);
+    this.log = options.log;
+    this.scanner = new DirectoryScanner(this.options.scan);
+  }
+
+  protected async scan(): Promise<void> {
+    this.files = await this.scanner.scan();
+  }
+
+  protected async import(): Promise<void> {
+    if (!this.files.length) {
+      return;
+    }
+
+    const grouped = new Map<string, FileDescriptor[]>();
+    for (const fd of this.files) {
+      const employeeRoot = getEmployeeRoot(fd);
+      const group = grouped.get(employeeRoot) ?? [];
+      group.push(fd);
+      grouped.set(employeeRoot, group);
+    }
+
+    const descriptors = await Promise.all(
+      Array.from(grouped.entries()).map(async ([employeeRoot, fds]) => {
+        const file = fds.find((fd) => fd.extname === '.ts' || fd.extname === '.js');
+        if (!file || !existsSync(file.path)) {
+          return null;
+        }
+        const promptFile = fds.find((fd) => fd.basename === 'prompt.md');
+
+        const name = path.basename(employeeRoot);
+        try {
+          const imported = await importModule(file.path);
+          const mod = imported?.default ?? imported;
+          const employeeOptions = typeof mod === 'function' ? mod() : mod;
+          if (!employeeOptions || !employeeOptions.username) {
+            this.log?.warn(`ai employee [${name}] register ignored: invalid definition at ${file.path}`);
+            return null;
+          }
+          const { skills = [], tools = [] } = employeeOptions;
+
+          if (promptFile && existsSync(promptFile.path)) {
+            try {
+              employeeOptions.systemPrompt = await readFile(promptFile.path, 'utf-8');
+            } catch (e) {
+              this.log?.error(
+                `ai employee [${name}] load fail: error occur when reading prompt.md at ${promptFile.path}`,
+                e,
+              );
+              return null;
+            }
+          }
+
+          return {
+            name,
+            employeeRoot,
+            file,
+            options: {
+              ...employeeOptions,
+              skills: [...skills, ...(await discoverSkills(employeeRoot))],
+              tools: [...tools, ...(await discoverTools(employeeRoot))],
+            } as AIEmployeeOptions,
+          } satisfies AIEmployeeDescriptor;
+        } catch (e) {
+          this.log?.error(`ai employee [${name}] load fail: error occur when import ${file.path}`, e);
+          return null;
+        }
+      }),
+    );
+
+    this.employeeDescriptors = descriptors.filter((item): item is AIEmployeeDescriptor => Boolean(item));
+  }
+
+  protected async register(): Promise<void> {
+    if (!this.employeeDescriptors.length) {
+      return;
+    }
+    const { employeeManager } = this.ai;
+    for (const descriptor of this.employeeDescriptors) {
+      await employeeManager.registerEmployee(descriptor.options);
+    }
+  }
+}
+
+export type AIEmployeeDescriptor = {
+  name: string;
+  employeeRoot: string;
+  file: FileDescriptor;
+  options: AIEmployeeOptions;
+};
+
+function getEmployeeRoot(fd: FileDescriptor) {
+  if (fd.basename === 'index.ts' || fd.basename === 'index.js' || fd.basename === 'prompt.md') {
+    return path.dirname(fd.path);
+  }
+  return fd.path;
+}
+
+async function discoverSkills(employeeRoot: string): Promise<string[]> {
+  const skillsDir = path.join(employeeRoot, 'skills');
+  if (!existsSync(skillsDir)) {
+    return [];
+  }
+  const scanner = new DirectoryScanner({
+    basePath: employeeRoot,
+    pattern: ['skills/**/SKILLS.md'],
+  });
+  const skillFiles = await scanner.scan();
+  return uniq(skillFiles.map((it) => it.directory).filter(Boolean));
+}
+
+async function discoverTools(employeeRoot: string): Promise<AIEmployeeToolSetting[]> {
+  const toolsDir = path.join(employeeRoot, 'tools');
+  if (!existsSync(toolsDir)) {
+    return [];
+  }
+  const scanner = new DirectoryScanner({
+    basePath: employeeRoot,
+    pattern: ['tools/**/*.ts', 'tools/**/*.js', '!tools/**/*.d.ts'],
+  });
+  const toolFiles = await scanner.scan();
+  return uniqBy(
+    toolFiles
+      .map((it) =>
+        normalizeAIEmployeeToolSetting(
+          it.basename === 'index.ts' || it.basename === 'index.js' ? it.directory : it.name,
+        ),
+      )
+      .filter((tool): tool is AIEmployeeToolSetting => Boolean(tool?.name)),
+    'name',
+  );
+}
+
+function uniq<T>(values: T[]) {
+  return [...new Set(values)];
+}
+
+function uniqBy<T extends Record<string, unknown>>(values: T[], key: keyof T) {
+  const valueMap = new Map<unknown, T>();
+  for (const value of values) {
+    valueMap.set(value[key], value);
+  }
+  return [...valueMap.values()];
+}
+
+export function normalizeAIEmployeeToolSetting(
+  tool?: string | AIEmployeeToolSetting,
+): AIEmployeeToolSetting | undefined {
+  if (!tool) {
+    return;
+  }
+  if (typeof tool === 'string') {
+    return { name: tool };
+  }
+  if (!tool.name) {
+    return;
+  }
+  return {
+    name: tool.name,
+    ...(tool.autoCall != null ? { autoCall: tool.autoCall } : {}),
+  };
+}

package/src/loader/index.ts

@@ -10,3 +10,6 @@
 export * from './types';
 export * from './scanner';
 export * from './tools';
+export * from './skills';
+export * from './mcp';
+export * from './employee';