FastGPT源码解析 Agent 智能体应用创建流程和代码分析

FastGPT对话智能体创建流程和代码分析

结合基础功能大模型、知识库、工作流等模块，界面上创建智能体，使用基础能力，完成各种应用应用智能体的创建、配置、测试、发布、使用等流程

1. 智能体类型概述

FastGPT支持多种类型的智能体应用，定义在 AppTypeEnum 中：

export enum AppTypeEnum {
  folder = 'folder',        // 文件夹
  simple = 'simple',        // 简单对话机器人
  workflow = 'advanced',    // 工作流应用
  plugin = 'plugin',        // 插件应用
  httpPlugin = 'httpPlugin' // HTTP插件
}

2. 智能体创建流程

2.1 前端创建界面

核心文件： projects/app/src/pageComponents/app/list/CreateModal.tsx

创建流程包含以下步骤：

1. 选择应用类型：简单机器人、工作流或插件
2. 设置基本信息：名称、头像、介绍
3. 选择创建方式 ：
   • 空白模板
   • 预设模板
   • cURL导入（仅插件）

const CreateModal = ({ onClose, type, onOpenTemplateModal }) => {
  const { register, setValue, watch, handleSubmit } = useForm<FormType>({
    defaultValues: {
      avatar: typeData.avatar,
      name: '',
      curlContent: ''
    }
  });

  const { runAsync: onclickCreate, loading: isCreating } = useRequest2(
    async ({ avatar, name, curlContent }: FormType, templateId?: string) => {
      // 从空模板创建
      if (!templateId && currentCreateType !== 'curl') {
        return postCreateApp({
          parentId,
          avatar: avatar,
          name: name,
          type,
          modules: emptyTemplates[type].nodes,
          edges: emptyTemplates[type].edges,
          chatConfig: emptyTemplates[type].chatConfig
        });
      }

      // 从模板或cURL创建
      const { workflow, appAvatar } = await (async () => {
        if (templateId) {
          const templateDetail = await getTemplateMarketItemDetail(templateId);
          return {
            appAvatar: templateDetail.avatar,
            workflow: templateDetail.workflow
          };
        }
        if (curlContent) {
          return {
            appAvatar: avatar,
            workflow: parsePluginFromCurlString(curlContent)
          };
        }
        return Promise.reject('No template or curl content');
      })();

      return postCreateApp({
        parentId,
        avatar: appAvatar,
        name: name,
        type,
        modules: workflow.nodes || [],
        edges: workflow.edges || [],
        chatConfig: workflow.chatConfig || {}
      });
    }
  );
};

2.2 后端创建API

核心文件： projects/app/src/pages/api/core/app/create.ts

async function handler(req: ApiRequestProps<CreateAppBody>) {
  const { parentId, name, avatar, type, modules, edges, chatConfig } = req.body;

  if (!name || !type || !Array.isArray(modules)) {
    return Promise.reject(CommonErrEnum.inheritPermissionError);
  }

  // 权限验证
  const [{ teamId, tmbId, userId }] = await Promise.all([
    authUserPer({ req, authToken: true, per: WritePermissionVal }),
    ...(parentId
      ? [authApp({ req, appId: parentId, per: WritePermissionVal, authToken: true })]
      : [])
  ]);

  // 上限校验
  await checkTeamAppLimit(teamId);

  // 创建应用
  const appId = await onCreateApp({
    parentId,
    name,
    avatar,
    type,
    modules,
    edges,
    chatConfig,
    teamId,
    tmbId,
    userAvatar: tmb?.user?.avatar,
    username: tmb?.user?.username
  });

  return appId;
}

export const onCreateApp = async ({
  parentId,
  name,
  avatar,
  type,
  modules,
  edges,
  chatConfig,
  teamId,
  tmbId,
  pluginData,
  session
}) => {
  const create = async (session: ClientSession) => {
    // 创建应用记录
    const [{ _id: appId }] = await MongoApp.create([
      {
        ...parseParentIdInMongo(parentId),
        avatar,
        name,
        teamId,
        tmbId,
        modules,
        edges,
        chatConfig,
        type,
        version: 'v2',
        pluginData,
        'pluginData.nodeVersion': defaultNodeVersion
      }
    ], { session, ordered: true });

    // 创建版本记录
    if (!AppFolderTypeList.includes(type!)) {
      await MongoAppVersion.create([
        {
          tmbId,
          appId,
          nodes: modules,
          edges,
          chatConfig,
          versionName: name,
          username,
          avatar: userAvatar,
          isPublish: true
        }
      ], { session, ordered: true });
    }

    return appId;
  };

  return session ? create(session) : await mongoSessionRun(create);
};

3. 数据存储结构

3.1 应用Schema

核心文件： packages/service/core/app/schema.ts

const AppSchema = new Schema({
  parentId: {
    type: Schema.Types.ObjectId,
    ref: AppCollectionName,
    default: null
  },
  teamId: {
    type: Schema.Types.ObjectId,
    ref: TeamCollectionName,
    required: true
  },
  tmbId: {
    type: Schema.Types.ObjectId,
    ref: TeamMemberCollectionName,
    required: true
  },
  name: {
    type: String,
    required: true
  },
  type: {
    type: String,
    default: AppTypeEnum.workflow,
    enum: Object.values(AppTypeEnum)
  },
  avatar: {
    type: String,
    default: '/icon/logo.svg'
  },
  intro: {
    type: String,
    default: ''
  },
  
  // 工作流节点和连线
  modules: {
    type: Array,
    default: []
  },
  edges: {
    type: Array,
    default: []
  },
  
  // 聊天配置
  chatConfig: {
    type: chatConfigType
  },
  
  // 插件配置
  pluginData: {
    type: {
      nodeVersion: String,
      pluginUniId: String,
      apiSchemaStr: String,
      customHeaders: String
    }
  },
  
  // 定时触发配置
  scheduledTriggerConfig: {
    cronString: String,
    timezone: String,
    defaultPrompt: String
  },
  
  inheritPermission: {
    type: Boolean,
    default: true
  }
});

3.2 聊天配置类型

export type AppChatConfigType = {
  welcomeText?: string;                    // 欢迎语
  variables?: VariableItemType[];          // 变量配置
  autoExecute?: AppAutoExecuteConfigType;  // 自动执行
  questionGuide?: AppQGConfigType;         // 问题引导
  ttsConfig?: AppTTSConfigType;           // 语音合成
  whisperConfig?: AppWhisperConfigType;   // 语音识别
  chatInputGuide?: ChatInputGuideConfigType; // 输入引导
  fileSelectConfig?: AppFileSelectConfigType; // 文件选择
  instruction?: string;                    // 插件说明
};

4. 预设模板系统

4.1 模板定义

核心文件： projects/app/src/web/core/app/templates.ts

FastGPT提供三种基础模板：

export const emptyTemplates: Record<
  AppTypeEnum.simple | AppTypeEnum.plugin | AppTypeEnum.workflow,
  {
    name: string;
    avatar: string;
    nodes: AppSchema['modules'];
    edges: AppSchema['edges'];
    chatConfig: AppSchema['chatConfig'];
  }
> = {
  // 简单对话机器人模板
  [AppTypeEnum.simple]: {
    avatar: 'core/workflow/template/aiChat',
    name: '简单机器人',
    nodes: [
      {
        nodeId: 'userGuide',
        name: '系统配置',
        flowNodeType: FlowNodeTypeEnum.systemConfig,
        // ... 系统配置节点
      },
      {
        nodeId: '448745',
        name: '工作流开始',
        flowNodeType: FlowNodeTypeEnum.workflowStart,
        // ... 开始节点配置
      },
      {
        nodeId: 'loOvhld2ZTKa',
        name: 'AI对话',
        flowNodeType: FlowNodeTypeEnum.chatNode,
        // ... AI对话节点配置
      }
    ],
    edges: [
      {
        source: '448745',
        target: 'loOvhld2ZTKa',
        sourceHandle: '448745-source-right',
        targetHandle: 'loOvhld2ZTKa-target-left'
      }
    ],
    chatConfig: {}
  },
  
  // 工作流模板
  [AppTypeEnum.workflow]: {
    avatar: 'core/app/type/workflowFill',
    name: '空白工作流',
    nodes: [
      // 系统配置节点
      // 工作流开始节点
    ],
    edges: [],
    chatConfig: {}
  },
  
  // 插件模板
  [AppTypeEnum.plugin]: {
    avatar: 'core/app/type/pluginFill',
    name: '空白插件',
    nodes: [
      // 插件输入节点
      // 插件输出节点
      // 插件配置节点
    ],
    edges: [],
    chatConfig: {}
  }
};

4.2 cURL解析功能

对于插件类型，支持从cURL字符串解析生成工作流：

export const parsePluginFromCurlString = (curl: string) => {
  const { url, method, headers, body, params, bodyArray } = parseCurl(curl);

  // 解析参数生成插件输入
  const allInputs = Array.from(
    new Map([...params, ...bodyArray].map((item) => [item.key, item])).values()
  );
  
  const formatPluginStartInputs = allInputs.map((item) => {
    const valueType = item.value === null ? 'string' : typeof item.value;
    // 根据值类型生成对应的输入配置
    return {
      renderTypeList: valueTypeItem.renderTypeList,
      valueType: valueTypeItem.valueType,
      key: item.key,
      label: item.key,
      required: false,
      toolDescription: item.key
    };
  });

  // 生成HTTP请求节点
  return {
    nodes: [
      // 插件输入节点
      // HTTP请求节点
      // 插件输出节点
      // 插件配置节点
    ],
    edges: [
      // 连接各节点
    ],
    chatConfig: {}
  };
};

5. 工作流执行引擎

5.1 工作流调度器

核心文件： packages/service/core/workflow/dispatch/index.ts

// 节点类型与处理函数映射
const callbackMap: Record<FlowNodeTypeEnum, Function> = {
  [FlowNodeTypeEnum.workflowStart]: dispatchWorkflowStart,
  [FlowNodeTypeEnum.answerNode]: dispatchAnswer,
  [FlowNodeTypeEnum.chatNode]: dispatchChatCompletion,
  [FlowNodeTypeEnum.datasetSearchNode]: dispatchDatasetSearch,
  [FlowNodeTypeEnum.datasetConcatNode]: dispatchDatasetConcat,
  [FlowNodeTypeEnum.classifyQuestion]: dispatchClassifyQuestion,
  [FlowNodeTypeEnum.contentExtract]: dispatchContentExtract,
  [FlowNodeTypeEnum.httpRequest468]: dispatchHttp468Request,
  [FlowNodeTypeEnum.tools]: dispatchRunTools,
  [FlowNodeTypeEnum.pluginModule]: dispatchRunPlugin,
  // ... 更多节点类型
};

export async function dispatchWorkFlow(data: Props): Promise<DispatchFlowResponse> {
  let {
    runtimeNodes = [],
    runtimeEdges = [],
    histories = [],
    variables = {},
    stream = false,
    ...props
  } = data;

  // 初始化系统变量
  variables = {
    ...getSystemVariable(data),
    ...externalProvider.externalWorkflowVariables,
    ...variables
  };

  // 节点执行状态检查
  async function checkNodeCanRun(
    node: RuntimeNodeItemType,
    skippedNodeIdList = new Set<string>()
  ): Promise<RuntimeNodeItemType[]> {
    // 获取节点运行状态
    const status = checkNodeRunStatus({
      node,
      runtimeEdges
    });

    if (status === 'run') {
      return nodeRunWithActive(node);
    }
    if (status === 'skip') {
      return nodeRunWithSkip(node);
    }
  }

  // 执行节点
  async function nodeRunWithActive(node: RuntimeNodeItemType) {
    // 获取节点运行参数
    const params = getNodeRunParams(node);

    const dispatchData: ModuleDispatchProps = {
      ...props,
      variables,
      histories,
      node,
      runtimeNodes,
      runtimeEdges,
      params
    };

    // 执行节点处理函数
    const dispatchRes = await callbackMap[node.flowNodeType](dispatchData);

    // 更新节点输出
    node.outputs.forEach((outputItem) => {
      if (dispatchRes[outputItem.key] !== undefined) {
        outputItem.value = dispatchRes[outputItem.key];
      }
    });

    return dispatchRes;
  }

  // 开始执行工作流
  const entryNodes = runtimeNodes.filter((item) => item.isEntry);
  await Promise.all(entryNodes.map((node) => checkNodeCanRun(node)));

  return {
    flowResponses: chatResponses,
    flowUsages: chatNodeUsages,
    assistantResponses: chatAssistantResponse,
    newVariables: variables
  };
}

5.2 AI模型管理

核心文件： packages/service/core/ai/model.ts

export const getDefaultLLMModel = () => global?.systemDefaultModel.llm!;

export const getLLMModel = (model?: string) => {
  if (!model) return getDefaultLLMModel();
  return global.llmModelMap.get(model) || getDefaultLLMModel();
};

export const getEmbeddingModel = (model?: string) => {
  if (!model) return getDefaultEmbeddingModel();
  return global.embeddingModelMap.get(model) || getDefaultEmbeddingModel();
};

export const findAIModel = (model: string): SystemModelItemType | undefined => {
  return (
    global.llmModelMap.get(model) ||
    global.embeddingModelMap.get(model) ||
    global.ttsModelMap.get(model) ||
    global.sttModelMap.get(model) ||
    global.reRankModelMap.get(model)
  );
};

6. 节点类型系统

6.1 核心节点类型

export enum FlowNodeTypeEnum {
  // 基础节点
  workflowStart = 'workflowStart',      // 工作流开始
  answerNode = 'answerNode',            // 指定回复
  chatNode = 'chatNode',                // AI对话
  
  // 数据处理
  datasetSearchNode = 'datasetSearchNode', // 知识库搜索
  datasetConcatNode = 'datasetConcatNode', // 知识库拼接
  
  // 智能处理
  classifyQuestion = 'classifyQuestion',   // 问题分类
  contentExtract = 'contentExtract',       // 内容提取
  
  // 工具节点
  httpRequest468 = 'httpRequest468',       // HTTP请求
  tools = 'tools',                         // 工具调用
  code = 'code',                          // 代码执行
  
  // 插件节点
  pluginModule = 'pluginModule',          // 插件模块
  pluginInput = 'pluginInput',            // 插件输入
  pluginOutput = 'pluginOutput',          // 插件输出
  
  // 交互节点
  userSelect = 'userSelect',              // 用户选择
  formInput = 'formInput',                // 表单输入
  
  // 控制流
  ifElseNode = 'ifElseNode',              // 条件分支
  loop = 'loop',                          // 循环
  loopStart = 'loopStart',                // 循环开始
  loopEnd = 'loopEnd',                    // 循环结束
  
  // 配置节点
  systemConfig = 'systemConfig',          // 系统配置
  pluginConfig = 'pluginConfig'           // 插件配置
}

6.2 节点输入输出系统

export type FlowNodeInputItemType = {
  key: string;
  renderTypeList: FlowNodeInputTypeEnum[];
  valueType: WorkflowIOValueTypeEnum;
  label: string;
  description?: string;
  required?: boolean;
  toolDescription?: string;
  defaultValue?: any;
  value?: any;
  // ... 更多配置
};

export type FlowNodeOutputItemType = {
  id: string;
  key: string;
  label: string;
  description?: string;
  valueType: WorkflowIOValueTypeEnum;
  type: FlowNodeOutputTypeEnum;
  // ... 更多配置
};

7. 智能体配置系统

7.1 变量系统

export type VariableItemType = {
  id: string;
  key: string;
  label: string;
  type: VariableInputEnum;
  required: boolean;
  description: string;
  valueType?: WorkflowIOValueTypeEnum;
  defaultValue?: any;
  
  // 输入配置
  maxLength?: number;
  max?: number;
  min?: number;
  enums?: { value: string; label: string }[];
};

7.2 聊天功能配置

// TTS配置
export type AppTTSConfigType = {
  type: 'none' | 'web' | 'model';
  model?: string;
  voice?: string;
  speed?: number;
};

// 语音识别配置
export type AppWhisperConfigType = {
  open: boolean;
  autoSend: boolean;
  autoTTSResponse: boolean;
};

// 问题引导配置
export type AppQGConfigType = {
  open: boolean;
  model?: string;
  customPrompt?: string;
};

// 自动执行配置
export type AppAutoExecuteConfigType = {
  open: boolean;
  defaultPrompt: string;
};

8. 核心创建流程总结

1. 前端界面 → 用户选择应用类型和创建方式
2. 模板选择 → 根据类型加载对应的预设模板
3. 参数配置 → 设置应用名称、头像等基本信息
4. 权限验证 → 验证用户权限和团队限制
5. 数据创建 → 在数据库中创建应用记录和版本记录
6. 工作流初始化 → 根据模板生成初始节点和连线
7. 跳转编辑 → 创建完成后跳转到应用详情页进行进一步配置

9. 关键代码文件路径

前端核心文件

• projects/app/src/pageComponents/app/list/CreateModal.tsx - 创建弹窗
• projects/app/src/web/core/app/templates.ts - 模板定义
• projects/app/src/web/core/app/api.ts - API调用
• projects/app/src/pageComponents/app/detail/ - 应用详情页

后端核心文件

• projects/app/src/pages/api/core/app/create.ts - 创建API
• packages/service/core/app/schema.ts - 数据模型
• packages/service/core/app/controller.ts - 应用控制器
• packages/service/core/workflow/dispatch/index.ts - 工作流引擎
• packages/service/core/ai/model.ts - AI模型管理

类型定义文件

• packages/global/core/app/type.d.ts - 应用类型定义
• packages/global/core/app/constants.ts - 应用常量
• packages/global/core/workflow/node/constant.ts - 节点类型定义

这套系统提供了完整的智能体创建、配置和运行能力，支持从简单对话到复杂工作流的各种应用场景。