## Code Structure
### Next.js
FastGPT uses Next.js page routing. To separate frontend and backend code, directories are split into global, service, and web subdirectories for shared, backend-only, and frontend-only code respectively.
### Monorepo
FastGPT uses pnpm workspace for its monorepo structure, with two main parts:
* projects/app - FastGPT main project
* packages/ - Submodules
* global - Shared code: functions, type declarations, and constants usable on both frontend and backend
* service - Server-side code
* web - Frontend code
* plugin - Custom workflow plugin code
### Domain-Driven Design (DDD)
FastGPT's code modules follow DDD principles, divided into these domains:
* core - Core features (knowledge base, workflow, app, conversation)
* support - Supporting features (user system, billing, authentication, etc.)
* common - Base features (log management, file I/O, etc.)
Code Structure Details
``` . ├── .github // GitHub config ├── .husky // Formatting config ├── document // Documentation ├── files // External files, e.g., docker-compose, helm ├── packages // Subpackages │ ├── global // Frontend/backend shared subpackage │ ├── plugins // Workflow plugins (for custom packages) │ ├── service // Backend subpackage │ └── web // Frontend subpackage ├── projects │ └── app // FastGPT main project ├── python // Model code, unrelated to FastGPT itself └── scripts // Automation scripts ├── icon // Icon scripts: pnpm initIcon (write SVG to code), pnpm previewIcon (preview icons) └── postinstall.sh // ChakraUI custom theme TS type initialization ├── package.json // Top-level monorepo ├── pnpm-lock.yaml ├── pnpm-workspace.yaml // Monorepo declaration ├── Dockerfile ├── LICENSE ├── README.md ├── README_en.md ├── README_ja.md ├── dev.md ```
## 代码结构说明
### nextjs
FastGPT 使用了 nextjs 的 page route 作为框架。为了区分好前后端代码，在目录分配上会分成 global, service, web 3 个自目录，分别对应着 `前后端共用`、`后端专用`、`前端专用` 的代码。
### monorepo
FastGPT 采用 pnpm workspace 方式构建 monorepo 项目，主要分为两个部分：
* projects/app - FastGPT 主项目
* packages/ - 子模块
* global - 共用代码，通常是放一些前后端都能执行的函数、类型声明、常量。
* service - 服务端代码
* web - 前端代码
* plugin - 工作流自定义插件的代码
### 领域驱动模式（DDD）
FastGPT 在代码模块划分时，按 DDD 的思想进行划分，主要分为以下几个领域：
* core - 核心功能（知识库，工作流，应用，对话）
* support - 支撑功能（用户体系，计费，鉴权等）
* common - 基础功能（日志管理，文件读写等）
代码结构说明
``` . ├── .github // github 相关配置 ├── .husky // 格式化配置 ├── document // 文档 ├── files // 一些外部文件，例如 docker-compose, helm ├── packages // 子包 │ ├── global // 前后端通用子包 │ ├── plugins // 工作流插件（需要自定义包时候使用到） │ ├── service // 后端子包 │ └── web // 前端子包 ├── projects │ └── app // FastGPT 主项目 ├── python // 存放一些模型代码，和 FastGPT 本身无关 └── scripts // 一些自动化脚本 ├── icon // icon预览脚本，可以在顶层 pnpm initIcon(把svg写入到代码中), pnpm previewIcon（预览icon） └── postinstall.sh // chakraUI自定义theme初始化 ts 类型 ├── package.json // 顶层monorepo ├── pnpm-lock.yaml ├── pnpm-workspace.yaml // monorepo 声明 ├── Dockerfile ├── LICENSE ├── README.md ├── README_en.md ├── README_ja.md ├── dev.md ```| Protocol/Feature | SSO | Member Sync Support |
|---|---|---|
| Lark | Yes | Yes |
| WeCom | Yes | Yes |
| DingTalk | Yes | No |
| SAML 2.0 | Yes | No |
| OAuth 2.0 | Yes | No |
| WeCom | DingTalk | Lark |
|---|---|---|
|  |  |  |
| 协议/功能 | SSO | 成员同步支持 |
|---|---|---|
| 飞书 | 是 | 是 |
| 企业微信 | 是 | 是 |
| 钉钉 | 是 | 否 |
| Saml2.0 | 是 | 否 |
| Oauth2.0 | 是 | 否 |
| 企业微信 | 钉钉 | 飞书 |
|---|---|---|
|  |  |  |
| Team Mode | SMS/Email Registration | Admin Direct Add | SSO Registration | |||
|---|---|---|---|---|---|---|
| Creates Default Team | Joins Root Team | Creates Default Team | Joins Root Team | Creates Default Team | Joins Root Team | |
| Single-team Mode | ❌ | ✅ | ❌ | ✅ | ❌ | ✅ |
| Multi-team Mode | ✅ | ❌ | ✅ | ❌ | ✅ | ❌ |
| Sync Mode | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
| 团队模式 | 短信/邮箱 注册 | 管理员直接添加 | SSO 注册 | |||
|---|---|---|---|---|---|---|
| 是否创建默认团队 | 是否加入 Root 团队 | 是否创建默认团队 | 是否加入 Root 团队 | 是否创建默认团队 | 是否加入 Root 团队 | |
| 单团队模式 | ❌ | ✅ | ❌ | ✅ | ❌ | ✅ |
| 多团队模式 | ✅ | ❌ | ✅ | ❌ | ✅ | ❌ |
| 同步模式 | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
* 🐞 Submit any FastGPT bugs, issues, or feature requests to [GitHub Issues](https://github.com/labring/fastgpt/issues/new/choose).
file: ./content/guide/getting-started/index.mdx
meta: {
"title": "快速了解 FastGPT",
"description": "FastGPT 的能力与优势"
}
import { Alert } from '@/components/docs/Alert';
import FastGPTLink from '@/components/docs/linkFastGPT';
FastGPT 是一个基于大语言模型的 AI Agent 应用开发平台，集知识库问答、可视化工作流、Agent 编排、工具调用和技能扩展于一体，让开发者和业务人员都能快速构建专属 AI 应用。
* 🐞 请将任何 FastGPT 的 Bug、问题和需求提交到 [GitHub Issue](https://github.com/labring/fastgpt/issues/new/choose)。
file: ./content/guide/getting-started/quick-start.en.mdx
meta: {
"title": "Quick Start",
"description": "Quickly experience FastGPT through four use cases: Conversational Agent, Knowledge Base, Workflow, and Agent V2"
}
This article uses four complete use cases to help you quickly understand FastGPT's core application types and complete the basic setup from simple conversations to complex task orchestration.
This page is suitable for first-time FastGPT users, as well as pre-sales, delivery, operations, legal, and administrative roles who want to quickly experience the platform's capabilities. After completing this page, you will build the following in order:
1. Conversational Agent: Corporate email writing assistant.
2. Knowledge Base + Conversational Agent: Civil Code Q\&A assistant.
3. Workflow: Content review and automatic rewriting.
4. Agent V2: Intelligent data analysis Agent.
We recommend preparing the following in advance:
* An available AI model, such as GLM-5.1 or other configured models.
* A knowledge base test file, such as the Civil Code, company policies, product manuals, etc.
* If you want to test the Email tool, prepare an email SMTP authorization code.
* If you want to test Agent V2 data analysis, prepare a sample Excel or CSV file.
When reading, focus on three things: what kind of problems each application type is suitable for, why the key configurations are written this way, and what to observe during validation. The parameters and prompts in this article are reusable starting points; for production deployment, you can replace them with your own business materials, review rules, notification channels, and data files.
## Case 1: Conversational Agent — Corporate Email Writing Assistant
### 1.1 Use Cases
Conversational Agents are suitable for lightweight Q\&A, content generation, copy refinement, and standardized output. This case does not link a knowledge base or rely on complex workflows; it simply uses model configuration, prompts, and an Email tool to build a corporate email writing assistant.
Employees often need to handle emails for project updates, cross-departmental collaboration, customer replies, meeting minutes, and more. Using AI to standardize email formats and expression styles can improve writing efficiency and maintain the professionalism of external corporate communications.
The focus of this case is not to have the AI randomly generate an email, but to consolidate the stable requirements of corporate email writing into the prompt, such as subject lines, salutations, body structure, action items, and risk reminders. For beginners, it also serves as a minimal closed loop for understanding FastGPT application configuration: first define the role, then constrain the output, and finally extend execution actions through tools.
### 1.2 Configuration Steps
1. **Create a Conversational Agent**
Click "New" in the workspace, select "Conversational Agent", and fill in the application name as `Corporate Email Writing Assistant`.
2. **Enter the Application Configuration Page**
After creation, enter the application configuration page. The page is usually divided into left and right columns: the left is AI configuration, and the right is debug preview.
3. **Select a Model**
In the AI configuration, select the base model for the Conversational Agent. This case uses GLM-5.1, but you can replace it with other available models configured in your current environment.
When selecting a model, prioritize two aspects: first, whether the model is good at business writing, and second, whether it consistently follows the required format. Email writing is a low-risk, low-structure task, so you usually do not need the strongest model available, but you should still choose one with a natural tone and reliable instruction following.
4. **Write the Prompt**
The prompt needs to clearly describe the assistant's role, output format, and constraints. You can use the following example:
```md
You are a corporate email writing expert, helping employees write professional, clear, and appropriate work emails.
Output format:
- **Subject line**: Concise and clear
- **Salutation**: Choose "Dear Mr./Ms. XX" or "Hi XX" based on the relationship with the recipient
- **Body**: Three-part structure (Background → Core content → Action items)
- **Sign-off**: Name, Title, Department
Rules:
- Keep the body between 200-500 words
- List action items and to-dos with bullet points
- When involving sensitive content like salary, HR, or legal matters, remind the user to send with caution
- Use a neutral and polite tone when unsure of the relationship with the recipient
```
Write the prompt into the prompt module.
This prompt consists of three parts: the role definition stabilizes the assistant's identity, the output format constrains the email structure, and the rules control risk boundaries. In actual business, you can continue to add corporate tone requirements, brand terminology, banned words, signature formats, and more to make the output more aligned with internal standards.
5. **Add the Email Tool**
Tools encapsulate complex operations. This case uses the Email sending tool to give the AI assistant the ability to send emails after generating them. Click the plus sign on the right side of the tools and select "Send Email".
You can think of tools as the AI's external capabilities. Without tools, the assistant can only generate the email body; after adding the Email tool, the assistant can execute the sending action after user confirmation. In a production environment, it is recommended to have the assistant generate an email draft first, and then have the user confirm the sending, to avoid accidental sending or sending to the wrong recipient.
6. **Configure the Email Tool**
Enter the tool configuration page and fill in the parameters related to the email service.
7. **Activate the Tool**
Click "Settings" to enter the tool activation page, then click "Activate Tool".
8. **Fill in the Email SMTP Information**
This case uses QQ Mail as an example. When testing, you can fill it out as follows:
```text
SMTP Server Address: smtp.qq.com
SMTP Port: 465
Enable SSL
SMTP Username: Email address
SMTP Password: Authorization code
```
For the authorization code, please refer to the [Authorization Code Acquisition Tutorial](https://cloud.tencent.com/developer/article/2177098).
9. **Set the Conversation Opening**
The conversation opening is used to tell users what this AI assistant can do. You can fill in:
```text
Hello! I am the Email Writing Assistant 📧
Please tell me: Who is the recipient? What is the purpose of the email? What key information needs to be included?
I will help you generate a professional and appropriate email.
```
After filling it out, you can see the effect in the preview area on the right.
10. **Validate the Result**
After configuration, enter your email requirements in the debug preview to check whether the assistant can generate an email with a clear structure and appropriate tone.
If the user's information is insufficient, the assistant should proactively prompt to supplement the recipient, email purpose, key information, etc.
When verifying, it is recommended to test at least three types of inputs: an email requirement with complete information, a vague requirement missing the recipient or purpose, and an email requirement containing sensitive information. An email assistant ready for production not only needs to be able to "write", but also needs to be able to ask follow-up questions when information is insufficient, and remind users to send with caution in sensitive scenarios.
### 1.3 Business Value
* **Improve Writing Efficiency**: Transform high-frequency emails like project updates, customer follow-ups, and meeting minutes from "writing from scratch" to "generating after filling in key information", reducing repetitive labor.
* **Unify Communication Standards**: Consolidate standards for salutations, body structure, action items, and sign-offs into the Prompt, reducing the communication costs caused by differences in writing styles among employees.
* **Reduce Sending Risks**: Add sensitive information reminders, missing information follow-ups, and neutral tone constraints through the Prompt to reduce incomplete, inappropriate, or over-promising emails.
* **Expand Office Automation**: Combined with the Email tool, you can continue to integrate office workflows such as notifications, approvals, Lark, DingTalk, and WeCom, extending email writing from content generation to business action execution.
## Case 2: Knowledge Base + Conversational Agent — Civil Code Q\&A Assistant
### 2.1 Use Cases
A knowledge base is ideal for scenarios where answers must be based on provided materials, such as policy Q\&A, product manual Q\&A, legal article retrieval, and customer service knowledge support. Without a knowledge base, the AI primarily relies on its own model capabilities to answer questions. Once a knowledge base is connected, the AI first searches your materials and then organizes answers based on the search results.
In this case, we import the *Civil Code of the People's Republic of China* into the knowledge base and create a Civil Code Q\&A assistant. When users ask questions in natural language, the assistant should prioritize citing the original Civil Code text to reduce fabricated responses.
Think of the knowledge base as a "reference room" configured for the AI. The model itself has general knowledge but doesn't know your company policies, product details, internal processes, or specific regulatory versions. The knowledge base turns these materials into searchable content, allowing the AI to look up information before organizing an answer. For legal, policy, customer service, and after-sales scenarios, this is more controllable than relying solely on the model's memory.
### 2.2 Preparation
* Example file: Prepare a copy of the *Civil Code of the People's Republic of China* or another regulatory/documentation file.
* A usable conversation model and vector model.
* A legal question for testing, e.g., "My lease isn't up yet, but the landlord wants to sell the house. What should I do?"
### 2.3 Configuration Steps
1. **Create a Knowledge Base**
Click **Knowledge Base** on the left side of the homepage, then click **New** in the top right corner. Name the knowledge base `Civil Code Q&A Assistant`. Keep the other default settings for this case.
2. **Create a Text Dataset**
Click **New**, then select **Text Dataset** to import local documents.
3. **Upload a Local File**
Click **Upload Local File** and select the example file. In real use, you can upload multiple files at once; for this case, we upload only one file as a demonstration.
4. **Set Parsing Parameters**
After entering the parameter settings page, choose the parsing method based on the file type.
Recommended common settings:
* **File Parsing Settings**: Enable when uploading PDFs; for regular Word, Markdown, TXT files, start with the default configuration.
* **Processing Method**: For most scenarios, choose chunked storage — it's lower cost and faster for retrieval.
* **Chunking Conditions**: Controls how many tokens each chunk contains. Use the default values for quick testing.
* **Index Enhancement**: For plain text, usually check the first two options; if the document contains images, enable image-related enhancements.
These parameters directly affect the quality of subsequent Q\&A. If chunks are too large, search results may include too much irrelevant content, making answers verbose. If chunks are too small, key context may be split, causing answers to lack supporting evidence. For the quick-start phase, use the default configuration. When officially integrating enterprise policies, contracts, or product manuals, adjust these parameters gradually based on Q\&A performance.
5. **Preview Chunking Results**
After reaching the data preview step, check whether the chunks are complete and readable. If chunks are too long or too short, go back and adjust the parameters.
When previewing chunks, focus on three things: whether paragraphs are abnormally cut off, whether titles and body text remain within the same semantic range, and whether tables, clauses, or numbering are still readable. If the quality of these knowledge fragments is unstable, even a well-written Prompt in the application will struggle to consistently produce accurate answers.
6. **Wait for the Knowledge Base to Be Ready**
Once the data status changes to "Ready," the knowledge base can be referenced by applications.
7. **Create and Link a Conversational Agent**
Create a new Conversational Agent, also named `Civil Code Q&A Assistant`. After creation, link the knowledge base you just created in the application configuration.
After linking the knowledge base, the application's response flow changes from simple conversation to "user question → knowledge base search → model summarizes answer." This is the key difference between Case 1 and Case 2: Case 1 emphasizes content generation, while Case 2 emphasizes answering based on provided materials.
8. **Configure the Q\&A Prompt**
The Civil Code Q\&A assistant needs to emphasize "answer based on the knowledge base" and "cite the original text." You can use the following Prompt:
```md
You are a professional Civil Code Q&A assistant, answering legal questions based on the original text of the _Civil Code of the People's Republic of China_.
Rules:
- Strictly answer based on the Civil Code articles retrieved from the knowledge base; do not fabricate legal provisions.
- Every answer must cite the original Civil Code text (book, chapter, article).
- If there is no directly corresponding provision in the Civil Code, state this honestly and do not give legal advice.
- When applying the law to specific cases, remind the user: "This answer is for reference only; please consult a professional lawyer."
- Provide plain-language explanations of legal terms so that users without a legal background can understand.
Output format:
1. **Legal Conclusion** (1–3 sentence summary)
2. **Relevant Article Citation** (original excerpt + book/chapter/article number)
3. **Plain-Language Explanation** (explain the meaning of the article in everyday language)
4. **Practical Advice** (2–3 actionable suggestions)
5. **Disclaimer** ("This answer is based on the original Civil Code text and does not constitute legal advice. For specific cases, please consult a professional lawyer.")
```
For legal Q\&A scenarios, it's especially important to define boundaries: what can be answered is a general explanation based on the materials; the model's output should never be packaged as formal legal advice. Requiring article citations, stating uncertainty, and adding disclaimers in the Prompt all aim to make the output more traceable and compliant with high-risk knowledge Q\&A usage norms.
9. **Configure the Opening Message**
The opening greeting can include a few example questions to help users quickly understand how to use this assistant:
```text
Hello! I'm the Civil Code Q&A Assistant ⚖️
I answer legal questions based on the original text of the *Civil Code of the People's Republic of China*.
You can ask me:
["My lease isn't up yet, but the landlord wants to sell the house. What should I do?"]
["I received a product I bought online and it was broken, but the seller won't accept a return. What does the law say?"]
["The upstairs neighbor's leak soaked my ceiling. Can I claim compensation?"]
⚠️ Note: My answers are for reference only. For specific legal issues, please consult a professional lawyer.
```
If you add `[question content]` in the opening greeting, users can click the question to ask it directly — useful for demonstrations and guidance.
10. **Verify Q\&A Performance**
Ask a question related to the Civil Code and check whether the answer includes a legal conclusion, article citation, plain-language explanation, and disclaimer.
When verifying, don't just check whether the answer "looks like a legal answer" — also check whether it actually references the knowledge base content. It's recommended to test with questions inside the materials, outside the materials, and ambiguous questions: questions inside the materials should cite the original text; questions outside the materials should state that a direct confirmation is not possible; ambiguous questions should proactively prompt the user to provide more facts.
### 2.4 Business Value
* **Lower the barrier to material retrieval**: Turn lengthy regulations, policies, and manuals into a natural language Q\&A entry point, allowing business users to quickly find relevant content without needing to know keywords or directory locations first.
* **Improve answer credibility**: Through knowledge base retrieval and original text citations, answers have a source basis, reducing the risk of the model fabricating or giving vague responses based on experience.
* **Accumulate organizational knowledge**: Internal company policies, product FAQs, after-sales SOPs, contract templates, and other materials can be continuously added to the knowledge base, forming maintainable and reusable knowledge assets.
* **Adapt to high-frequency support scenarios**: Legal, HR, administrative, customer service, and delivery teams can all use a similar model to turn repetitive inquiries into self-service Q\&A, improving response efficiency.
## Case 3: Workflow — Content Review and Automatic Rewriting
### 3.1 Use Cases
Workflows are ideal for tasks with fixed steps, clear logic, and the need for branching decisions or human confirmation. This case breaks down content compliance review into several stages: knowledge base retrieval, AI classification, conditional branching, automatic rewriting, rejection explanation, and human confirmation, simulating the review process before enterprise content is published.
Its core value lies in two aspects:
1. **Automation**: Once triggered, the system automatically executes multiple steps according to the preset workflow.
2. **Standardization**: The same input goes through the same judgment and processing, reducing human variability.
To determine whether a task is suitable for a workflow, check if it has three characteristics: "stable steps, clear rules, and repeatable execution." Content review is a typical scenario: the input is content to be published, the rules come from a compliance knowledge base, and the output is usually pass, rewrite, or reject, with the option to add human confirmation in between. This improves processing efficiency while retaining risk control.
### 3.2 Preparation
First, create a "Content Compliance Rules" knowledge base and upload a simple text file. You can directly use the following rule template:
```text
Content Compliance Rules
Safe Content (can be published directly)
- Objective factual statements
- Normal event notifications, meeting arrangements
- Product feature descriptions (based on real data)
- Industry knowledge sharing
Sensitive Wording (needs rewriting)
- Absolute language: "best," "first," "100%," "absolute," "only"
- Exaggerated claims: "disrupting the industry," "unprecedented," "unmatched"
- Unverified data: conversion rates, satisfaction rates, growth rates without sources
- Comparative disparagement: directly naming competitors and belittling them
Prohibited Content (must not be published)
- Illegal information: involving pornography, gambling, drugs, fraud, pyramid schemes
- Personal attacks: insults, defamation against individuals or groups
- False information: fabricated data, forged qualifications, impersonating official sources
- Sensitive topics: political sensitivity, religious discrimination, regional attacks
```
The rule base does not need to be complex at the start. For quick validation, split the rules into three categories: "safe, needs rewriting, prohibited." For formal use, you can continue adding rules by industry, brand, channel, or region, such as advertising-sensitive terms, medical compliance requirements, prohibited financial marketing claims, brand tone guidelines, and so on.
### 3.3 Workflow Design
Before configuring nodes, it's recommended to confirm the complete workflow. This case can be designed as follows:
1. **User Input**: As the workflow starting point, receives the content to be reviewed.
2. **Knowledge Base Retrieval**: Recalls relevant rules from the content compliance rules base. It is recommended to set the citation limit to 1-2 entries.
3. **AI Content Compliance Classification**: Combines user input and retrieval results to classify the content as "Safe / Sensitive but Rewritable / Prohibited."
4. **Conditional Branching**: Enters different branches based on the classification result.
5. **Safe Branch**: Directly outputs the original text, indicating it can be published.
6. **Sensitive but Rewritable Branch**: Calls AI to rewrite the content, then submits it for user confirmation.
7. **Prohibited Branch**: Outputs a rejection explanation and provides revision suggestions.
8. **Final Output**: Returns the original text, rewritten version, or rejection explanation.
When designing a workflow, first determine the responsibility of each node to avoid having a single AI node simultaneously handle "retrieving rules, judging classification, rewriting content, explaining reasons," etc. Once responsibilities are clearly separated, each node's prompt will be shorter and more stable, making it easier to locate issues later: whether the knowledge base failed to recall rules, the review node misclassified, or the condition in the decision node didn't match.
### 3.4 Configuration Steps
1. **Create a Workflow**
Go to the workflow homepage, click "New Workflow," and name it `Content Review and Automatic Rewriting`.
After creation, enter the workflow editing page.
The complete workflow diagram for this case is as follows:
2. **Configure the Opening Message**
In the system configuration, fill in the opening statement to explain the assistant's review rules and usage.
```md
Hello! I am the Content Compliance Review Assistant 🛡️
Please send me the content you need reviewed, and I will automatically judge it according to the rules:
- **✅ Safe** — Content has no sensitive information and can be published directly
- **⚠️ Sensitive but Rewritable** — Contains correctable wording; I will rewrite it and send it back for your confirmation
- **🚫 Prohibited** — Contains red-line content and is rejected with an explanation
Supports single text review or batch submission (multiple items separated by line breaks).
**Let's get started.**
```
3. **Call the Knowledge Base**
Add a knowledge base retrieval node in the workflow, select the previously created content compliance rules base. The input for this node uses the user input, and the output is referenced by subsequent AI nodes.
The purpose of this node is not to have the model read the entire rule base, but to retrieve the rule fragments most relevant to the current content for the subsequent review node. You can initially set the citation limit to 1-2 entries to keep the prompt context focused; if the rule base is larger or the categories are more detailed, gradually increase the citation count.
4. **Configure the Content Review Node**
Add an AI dialogue node and rename it to "Content Review Node." This node is responsible for outputting the classification result based on the user input and knowledge base rules.
```md
You are a content compliance review expert. Based on the compliance rules retrieved from the knowledge base, determine the compliance level of the user's input content.
Classification criteria:
- Safe: Content has no sensitive information and can be published directly
- Sensitive but Rewritable: Contains correctable sensitive wording; can be published after rewriting
- Prohibited: Contains red-line content and cannot be published
Output format:
Output only one of three labels: Safe / Sensitive but Rewritable / Prohibited
```
Note: The knowledge base reference must select the previously created knowledge base, otherwise the AI cannot read the rule content.
The output of the review node should be as stable as possible, because it directly affects the decision node's branching. For a quick demo, you can output only the three labels "Safe / Sensitive but Rewritable / Prohibited"; if you need stricter automation integration later, you can switch to structured output, such as returning the classification, reason, and matched rules together, making it easier for downstream nodes to perform precise matching and logging.
5. **Test the Review Node**
Click "Run" in the top right corner, input a piece of content to be reviewed, and confirm that the review node returns a stable classification result.
Test this node individually instead of waiting until the entire workflow is built. Input a normal event announcement, marketing copy containing absolute language, and clearly prohibited text, and observe whether the classification meets expectations. If the classification is unstable, first adjust the rule base wording and the review prompt before continuing to configure subsequent branches.
6. **Hide Intermediate Output**
Click the settings button on the right side of the model to adjust the node's basic settings. Since the user only needs the final result, it is recommended to hide the intermediate output of the content review node.
7. **Configure the Decision Node**
Add a decision node to branch based on the "Safe / Sensitive but Rewritable / Prohibited" output from the content review node.
The decision node acts as a switch in the workflow. The more stable the output from the previous step, the easier it is to configure the decision node; if the review node's output contains explanatory text, the condition may fail to match. Therefore, in branching workflows, it is common to first constrain the output format of the upstream node before configuring the decision node conditions.
8. **Configure the Safe Branch**
When the review result is "Safe," directly output the original text. In a production scenario, you could also add spot-checking or human confirmation.
The output effect is as follows:
9. **Configure the Sensitive but Rewritable Branch**
When the review result is "Sensitive but Rewritable," add an AI dialogue node to automatically rewrite the content. You can use the following prompt:
```md
You are a content rewriting expert. Rewrite the user's input content into a compliant version.
Rewriting principles:
- Preserve the original meaning and information, do not change the core expression
- Replace absolute language with objective statements, e.g., "best" → "industry-leading"
- Replace unverified data statements with reasonable speculation, e.g., "100% effective" → "most users report it effective"
- Replace sensitive wording with neutral expressions
- Maintain the original style and tone
```
After rewriting, you can add a user choice node to let the user accept the rewrite, continue rewriting, or abandon it.
The human confirmation node is suitable for paths that are risky but correctable. AI can propose rewrite suggestions, but whether to publish is still left to the business personnel to confirm. This reduces the time spent on initial screening and repeated revisions while not handing over the final publishing decision entirely to the automated workflow.
If the user accepts the rewrite, output the rewritten result; if the user chooses to continue rewriting, it can be connected back to the content rewriting node; if the user abandons it, output the original text.
10. **Configure the Prohibited Branch**
When the review result is "Prohibited," add an AI dialogue node to output a rejection explanation. You can use the following prompt:
```md
The content submitted by the user cannot be published because it contains prohibited information. Please explain the reason in a polite and professional tone.
Output format:
1. One sentence stating that the content cannot be published
2. List specific violation points (1-3 items)
3. Provide alternative suggestions (e.g., suggest which aspects to modify before resubmitting)
```
11. **Verify the Complete Workflow**
Input safe content, sensitive content, and prohibited content separately, and confirm that all three branches return the expected results.
When verifying the complete workflow, it is recommended to record the input, review classification, branch entered, and final output for each test case. If the output does not meet expectations, troubleshoot node by node: first check whether the knowledge base recalled the correct rules, then whether the review node classified accurately, and finally whether the decision node conditions and branch output are configured correctly.
### 3.5 Business Value
* **Standardize review rules into a workflow**: Embed the judgment criteria for pre-publication content review into a knowledge base and node configuration, reducing reliance on personal experience passed down verbally.
* **Improve processing efficiency**: Safe content can pass quickly, sensitive content is automatically rewritten, and prohibited content receives a direct explanation, allowing reviewers to focus on content that requires judgment.
* **Retain human control points**: Add user confirmation for gray-area scenarios like "sensitive but rewritable," preventing the automated workflow from making publishing decisions directly for business personnel.
* **Easy to reuse and extend**: The same workflow can be applied to marketing copy, customer service scripts, announcements, event pages, short video scripts, and other content review scenarios by replacing the rule base and a few prompts.
* **Reduce compliance risk**: Through fixed branches and rejection explanations, high-risk content has a clear interception path, reducing the risk of accidental publication, exaggerated claims, or non-compliant expressions.
## Case 4: Agent V2 — Intelligent Data Analysis Agent
### 4.1 Use Cases
Agent V2 is ideal for open-ended, multi-step tasks that require dynamic planning. Unlike workflows, where every step must be predefined, Agent V2 is better suited for tasks with “unfixed steps,” such as data analysis, file processing, multi-tool collaboration, and complex problems that require follow-up clarification.
This case simulates the daily data analysis needs of operations, product, or sales teams: upload an Excel file, ask questions in natural language, and let the Agent autonomously read the file, formulate an analysis plan, and execute the analysis in a virtual machine.
In Case 3, the workflow required you to design a fixed path of “retrieval rules → classification → branching → rewriting or rejection.” Agent V2, on the other hand, acts more like an autonomous executor. You don’t need to define every step in advance; just provide the goal and the file. The Agent decides whether to read the file first, perform statistics, ask follow-up questions, or run code based on the data structure and problem complexity.
Data analysis is a great way to experience Agent V2 because it naturally has three characteristics: the analysis path is not fixed, it often requires multi-step reasoning, and the requirements may need clarification. With the same Excel file, different users might care about product sales, channel ROI, regional trends, or anomalous orders. A fixed workflow can hardly cover all paths in advance, but Agent V2 can dynamically plan based on the question.
### 4.2 Preparation
* Sample file: Prepare a sales data Excel or CSV table.
* A conversation model that supports Agent V2.
* Virtual machine capability is available in the current environment.
### 4.3 Configuration Steps
1. **Create an Agent V2 Application**
In the workspace, click “Create Application,” select `Conversational Agent V2 (Beta)`, and name it `Intelligent Data Analysis Agent`.
2. **Configure Model and Prompt**
Continue using the GLM-5.1 model for AI configuration. The system prompt can refer to:
```md
You are a senior data analyst Agent. You can read data files uploaded by users, run Python analysis code in the sandbox, and proactively ask users for clarification.
Tools:
- 📄 **Read File** — Read Excel/CSV data uploaded by the user
- 💻 **Sandbox Execution** — Run Python scripts (pandas/matplotlib/numpy)
- ❓ **Proactive Follow-up** — Confirm with the user when analysis requirements are unclear
Workflow:
1. After receiving data and a question, first read the file to understand the data structure and content
2. Formulate an analysis plan and present it to the user as a list of steps
3. Execute step by step according to the plan, showing key findings at each step
4. Proactively ask follow-up questions when encountering ambiguous requirements, such as unclear metric definitions or missing comparison baselines
5. Dynamically update the plan based on follow-up results
6. Output an analysis report containing data overview, core findings, visual charts, and business recommendations
Security Rules:
- Only data analysis is allowed in the sandbox; no network access, no writing files to the host machine
- Data is used only for this analysis; do not expose raw sensitive data in the report
- Mark confidence levels for uncertain conclusions
Output Format:
1. 📋 Analysis Plan (automatically generated based on data)
2. 📊 Data Overview (row count, column names, missing values, basic statistics)
3. 🔍 Core Findings (3-5 key insights, supported by charts)
4. 💡 Business Recommendations (actionable suggestions based on data)
```
The key point of this prompt is to have the Agent plan before executing, rather than jumping straight to conclusions. For data analysis tasks, first reading the data structure, confirming field meanings, and formulating an analysis plan can significantly reduce the risk of misunderstanding requirements or misusing metrics. In production use, you can continue to supplement internal metric definitions, such as GMV, ROI, conversion rate, active customers, repurchase rate, etc.
3. **Configure the Opening Message**
The opening remarks guide the user to upload a data file and ask analysis questions:
```text
Hello! I am the Intelligent Data Analysis Agent 📊
Just drag and drop your Excel or CSV file here and tell me what you want to analyze.
For example:
- "Analyze this sales data and find the best-selling products and trends"
- "Help me look at changes in user activity and find the reasons for the decline"
- "Compare the conversion rates of three channels, which one has the highest ROI?"
I will first understand your data, formulate an analysis plan, and then run the analysis code in the sandbox.
I will proactively ask you for clarification when needed.
```
4. **Enable Virtual Machine Capability**
Data analysis usually requires reading files and executing code, so the virtual machine configuration needs to be enabled.
The virtual machine capability is used to isolate the code execution environment. The Agent can run data analysis scripts, read uploaded files, and generate statistical results within it, without directly affecting the local host environment. For scenarios that require running Python, processing Excel, drawing charts, or performing batch calculations, this is an important capability that distinguishes Agent V2 from ordinary conversation applications.
5. **Upload File and Test**
Upload the sample sales data file and enter the question:
```text
Help me analyze this sales data to see which products sell well and which channel has the highest ROI
```
The Agent will first break down the task and then execute the analysis step by step.
During execution, you can see the task running in the virtual machine without affecting the local environment.
When testing, focus on whether the Agent has a complete analysis process: does it first identify the table fields, explain the analysis plan, run code when needed, and give business recommendations based on the results? If the problem description is unclear, the ideal behavior is not to force an analysis but to first ask the user for key definitions.
### 4.4 Verification of Results
The final result should include the analysis plan, data overview, core findings, and business recommendations.
When verifying results, it is recommended to focus on four dimensions: whether the conclusions come from actual data, whether the metric definitions are clear, whether the charts or statistics support the conclusions, and whether the business recommendations are actionable. The value of a data analysis Agent is not just to output a summary, but to connect the process of “reading data, calculating metrics, explaining results, and proposing recommendations.”
### 4.5 Business Value
* **Lower the barrier to data analysis**: Business users can directly upload Excel or CSV files and ask questions in natural language, without needing to write SQL, Python, or complex formulas first.
* **Support open-ended exploration**: The same data can be repeatedly queried around sales, channels, regions, customers, trends, outliers, etc., suitable for scenarios without a fixed analysis path.
* **Increase analysis transparency**: The Agent shows the analysis plan and key steps, so users can see how it understands the data, calculates metrics, and draws conclusions.
* **Isolate code execution risk**: By executing analysis scripts in a virtual machine, risks of local environment contamination, dependency conflicts, and permission misuse are reduced.
* **Consolidate business analysis capabilities**: Scenarios such as sales reviews, weekly operations reports, campaign attribution, and product metric diagnostics can all reuse this type of Agent, turning data analysis from an expert task into a daily workflow.
## Choosing Between the Four Types
After completing the four cases, you can understand the common application types of FastGPT as a progression from simple to complex capabilities: Conversational Agent solves "how to answer and generate content," Knowledge Base solves "what materials to base answers on," Workflow solves "what fixed process to follow," and Agent V2 solves "how to autonomously plan and execute open-ended tasks."
| Application Type | Suitable Scenarios | Core Capabilities |
| ------------------------------------- | --------------------------------------------------------------------- | ------------------------------------------------------------ |
| Conversational Agent | Lightweight Q\&A, copywriting, standardized output | Prompt, model configuration, tool calling |
| Knowledge Base + Conversational Agent | Q\&A based on documents, policies, regulations, product manuals | File import, knowledge base retrieval, citing sources |
| Workflow | Fixed steps, conditional branches, review flows, automated processing | Node orchestration, decision nodes, human confirmation |
| Agent V2 | Data analysis, complex tasks, multi-step reasoning, dynamic planning | Autonomous planning, tool calling, virtual machine execution |
When selecting, you can judge based on task complexity:
1. If it's just lightweight conversation or standardized copy generation, prioritize the Conversational Agent.
2. If answers must be based on existing materials, choose Knowledge Base + Conversational Agent.
3. If the process is fixed and requires conditional branches, human confirmation, or automated processing, choose Workflow.
4. If the task is open-ended with unfixed steps and requires autonomous analysis, tool calling, or code execution, choose Agent V2.
In real projects, you can also combine these capabilities. For example, a customer service assistant can use a Knowledge Base to answer product questions and then query orders via tools; content review can use a Workflow to fix the review path while maintaining rules with a Knowledge Base; data analysis scenarios can first use Agent V2 for exploration, then solidify stable analysis steps into a Workflow.
file: ./content/guide/getting-started/quick-start.mdx
meta: {
"title": "快速上手",
"description": "通过对话 Agent、知识库、工作流和 Agent V2 四个案例快速体验 FastGPT"
}
本文通过四个完整案例，帮助你快速理解 FastGPT 的核心应用类型，并完成从简单对话到复杂任务编排的基础搭建。
本页适合第一次接触 FastGPT 的用户，也适合售前、交付、运营、法务、行政等角色快速体验平台能力。完成本页后，你将依次搭建：
1. 对话 Agent：企业邮件撰写助手。
2. 知识库 + 对话 Agent：民法典问答助手。
3. 工作流：内容审核与自动改写。
4. Agent V2：智能数据分析 Agent。
建议提前准备以下内容：
* 可用的 AI 模型，例如 GLM-5.1 或其他已配置模型。
* 一个知识库测试文件，例如民法典、公司制度、产品手册等。
* 如果要测试 Email 工具，准备邮箱 SMTP 授权码。
* 如果要测试 Agent V2 数据分析，准备一个 Excel 或 CSV 示例文件。
阅读时建议重点关注三件事：每种应用类型适合解决什么问题、关键配置为什么这样写、验证时应该观察哪些效果。本文中的参数和 Prompt 都是可复用的起点，正式落地时可以替换为你自己的业务资料、审核规则、通知渠道和数据文件。
## 案例一：对话 Agent—企业邮件撰写助手
### 1.1 适用场景
对话 Agent 适合轻量问答、内容生成、文案润色、标准化输出等场景。本案例不关联知识库，也不依赖复杂流程，只通过模型配置、Prompt 和 Email 工具完成一个企业邮件撰写助手。
企业员工经常需要处理项目同步、跨部门协作、客户回复、会议纪要等邮件。通过 AI 统一邮件格式和表达风格，可以提升写作效率，也能保持企业对外沟通的专业性。
这个案例的重点不是让 AI 随意生成一封邮件，而是把企业邮件写作中的稳定要求沉淀到 Prompt 中，例如主题行、称呼、正文结构、行动项和风险提醒。对于新手来说，它也是理解 FastGPT 应用配置的最小闭环：先定义角色，再约束输出，最后通过工具扩展执行动作。
### 1.2 配置步骤
1. **创建对话 Agent**
在工作台点击新建，选择对话 Agent，应用名称填写为 `企业邮件撰写助手`。
2. **进入应用配置页**
创建完成后进入应用配置页。页面通常分为左右两栏：左侧是 AI 配置，右侧是调试预览。
3. **选择模型**
在 AI 配置中选择对话 Agent 使用的基础模型。本案例使用 GLM-5.1，你也可以替换为当前环境中已配置的其他可用模型。
选择模型时优先关注两点：一是模型是否擅长中文商务表达，二是输出是否稳定遵守格式。邮件撰写属于低风险、低结构复杂度任务，通常不需要过度追求最强模型，但要确保语气自然、指令遵循能力较好。
4. **编写 Prompt**
Prompt 需要清晰描述助手的角色、输出格式和约束。可以使用以下示例：
```md
你是一个企业邮件撰写专家，帮助员工撰写专业、清晰、得体的工作邮件。
输出格式：
- **主题行**：简洁明确
- **称呼**：根据收件人关系选择“尊敬的 XX 总”或“Hi XX”
- **正文**：三段式（背景 → 核心内容 → 行动项）
- **落款**：署名、职位、部门
规则：
- 正文控制在 200-500 字
- 行动项和待办用项目符号列出
- 涉及薪资、人事、法律等敏感内容时，提醒用户谨慎发送
- 不确定收件人关系时使用中性礼貌语气
```
将 Prompt 写入提示词模块。
这段 Prompt 由三部分组成：角色定义用于稳定助手身份，输出格式用于约束邮件结构，规则用于控制风险边界。实际业务中可以继续补充企业语气要求、品牌用语、禁用词、签名格式等内容，让输出更贴合内部规范。
5. **添加 Email 工具**
工具是对复杂操作的封装。本案例使用 Email 邮件发送工具，让 AI 助手在生成邮件后具备发送能力。点击工具右侧的加号，选择 Email 邮件发送。
可以把工具理解为 AI 的外部能力。没有工具时，助手只能生成邮件正文；添加 Email 工具后，助手可以在用户确认后执行发送动作。正式环境中建议先让助手生成邮件草稿，再由用户确认发送，避免误发或发送给错误收件人。
6. **配置 Email 工具**
进入工具配置页，填写邮件服务相关参数。
7. **激活工具**
点击设置后进入工具激活页面，再点击工具激活。
8. **填写邮箱 SMTP 信息**
本案例以 QQ 邮箱为例。测试时可以按以下方式填写：
```text
SMTP 服务器地址：smtp.qq.com
SMTP 端口：465
启用 SSL
SMTP 用户名：邮箱地址
SMTP 密码：授权码
```
授权码可参考 [授权码获取教程](https://cloud.tencent.com/developer/article/2177098)。
9. **设置对话开场白**
对话开场白用于告诉用户这个 AI 助手可以做什么。可以填写：
```text
你好！我是邮件撰写助手 📧
请告诉我：收件人是谁？邮件目的是什么？需要包含哪些关键信息？
我会帮你生成一封专业、得体的邮件。
```
填写后，可以在右侧预览区域看到效果。
10. **验证运行效果**
配置完成后，在调试预览中输入邮件需求，检查助手是否能生成结构清晰、语气得体的邮件。
如果用户信息不足，助手应主动提示补充收件人、邮件目的、关键信息等内容。
验证时建议至少测试三类输入：信息完整的邮件需求、缺少收件人或目的的模糊需求、包含敏感信息的邮件需求。一个可上线的邮件助手不只要“能写”，还要能在信息不足时追问，在敏感场景下提醒用户谨慎发送。
### 1.3 业务价值
* **提升写作效率**：将项目同步、客户跟进、会议纪要等高频邮件从“从零写”变成“填写关键信息后生成”，减少重复劳动。
* **统一沟通标准**：把称呼、正文结构、行动项、落款等规范固化到 Prompt 中，降低不同员工写作风格差异带来的沟通成本。
* **降低发送风险**：通过 Prompt 增加敏感信息提醒、信息缺失追问和中性语气约束，减少不完整、不恰当或过度承诺的邮件。
* **扩展办公自动化**：配合 Email 工具后，可以继续接入通知、审批、飞书、钉钉、企业微信等办公流程，将邮件撰写从内容生成延伸到业务动作执行。
## 案例二：知识库 + 对话 Agent—民法典问答助手
### 2.1 适用场景
知识库适合“回答必须基于资料”的场景，例如制度问答、产品手册问答、法律条文检索、客服知识支持等。没有知识库时，AI 主要依赖模型自身能力回答；接入知识库后，AI 会先检索你的资料，再基于检索结果组织答案。
本案例将《中华人民共和国民法典》导入知识库，并创建一个民法典问答助手。用户用自然语言提问时，助手需要优先引用民法典原文，减少凭空生成。
可以把知识库理解为给 AI 配置的“资料室”。模型本身具备通用知识，但不了解你的公司制度、产品细节、内部流程或指定法规版本；知识库把这些资料变成可检索内容，让 AI 在回答前先查资料，再组织答案。对于法律、制度、客服、售后等场景，这比单纯依赖模型记忆更可控。
### 2.2 准备内容
* 示例文件：准备一份《中华人民共和国民法典》或其他法规制度类文档。
* 一个可用的对话模型和向量模型。
* 一个用于测试的法律问题，例如“租房合同没到期，房东要卖房，我该怎么办？”。
### 2.3 配置步骤
1. **创建知识库**
在主页点击左侧的知识库，进入后点击右上角的新建。知识库名称填写为 `民法典问答助手`，案例阶段其他配置保持默认即可。
2. **创建文本数据集**
点击新建，再选择文本数据集，用于导入本地文档。
3. **上传本地文件**
点击上传本地文件，选择示例文件。实际使用时可以同时上传多个文件，本案例只上传一个文件作为演示。
4. **设置解析参数**
进入参数设置页后，根据文件类型选择解析方式。
常用配置建议：
* **文件解析设置**：上传 PDF 时建议开启；普通 Word、Markdown、TXT 等文件可先使用默认配置。
* **处理方式**：大多数场景选择分块存储，成本较低，检索速度也更快。
* **分块条件**：控制每个分块包含多少 Token，快速测试时使用默认值即可。
* **索引增强**：纯文本通常勾选前两个选项；如果文档包含图片，可勾选图片相关增强。
这些参数会直接影响后续问答质量。分块过大时，检索结果可能包含太多无关内容，回答容易变得冗长；分块过小时，关键上下文可能被拆散，回答容易缺少依据。快速上手阶段可以先使用默认配置，正式接入企业制度、合同、产品手册时，再根据问答效果逐步调整。
5. **预览分块效果**
到数据预览步骤后，检查分块是否完整、可读。如果分块过长或过短，再返回调整参数。
预览分块时重点看三点：段落是否被异常截断，标题与正文是否保留在同一语义范围内，表格、条款或编号是否仍然可读。只要这里的知识片段质量不稳定，后续应用即使 Prompt 写得很好，也很难稳定给出准确答案。
6. **等待知识库就绪**
当数据状态变为“已就绪”后，知识库即可被应用引用。
7. **创建并关联对话 Agent**
创建一个新的对话 Agent，名称同样填写为 `民法典问答助手`。创建完成后，在应用配置中关联刚刚创建的知识库。
关联知识库后，应用的回答链路会从单纯对话变成“用户问题 → 知识库检索 → 模型总结回答”。这也是案例一和案例二的关键差异：案例一强调内容生成，案例二强调基于资料回答。
8. **配置问答 Prompt**
民法典问答助手需要强调“基于知识库回答”和“引用原文”。可以使用以下 Prompt：
```md
你是一个专业的民法典问答助手，基于《中华人民共和国民法典》原文回答法律问题。
规则：
- 严格基于知识库检索到的民法典条文回答，不得臆造法条
- 每条回答必须引用民法典原文（编、章、条）
- 如果民法典中没有直接对应的规定，如实说明，不做法律建议
- 涉及具体案件的法律适用时，提醒用户“本回答仅供参考，建议咨询专业律师”
- 对法律术语做通俗解释，让非法学背景的用户也能理解
输出格式：
1. **法律结论**（1-3 句概述）
2. **相关法条引用**（原文摘录 + 编章节条号）
3. **通俗解读**（用日常语言解释法条含义）
4. **实务建议**（2-3 条可操作建议）
5. **免责声明**（“本回答基于民法典原文，不构成法律意见，具体案件请咨询专业律师”）
```
法律问答类场景尤其要强调边界：能回答的是基于资料的通用解释，不能把模型回答包装成正式法律意见。Prompt 中要求引用条文、说明不确定性、添加免责声明，目的都是让输出更可追溯，也更符合高风险知识问答的使用规范。
9. **配置开场白**
开场白可以内置几个示例问题，帮助用户快速理解这个助手的使用方式：
```text
你好！我是民法典问答助手 ⚖️
我基于《中华人民共和国民法典》原文，帮你解答法律问题。
你可以问我：
["租房合同没到期，房东要卖房，我该怎么办？"]
["网购商品收到后发现坏了，商家不给退，法律怎么规定？"]
["楼上漏水把我家的天花板泡了，能索赔吗？"]
⚠️ 提示：我的回答仅供参考，具体法律问题建议咨询专业律师。
```
如果在开场白里添加 `[问题内容]`，用户可以点击问题一键提问，适合用于演示和引导。
10. **验证问答效果**
提出一个民法典相关问题，检查回答是否包含法律结论、法条引用、通俗解读和免责声明。
验证时不要只看回答是否“像法律回答”，还要看它是否真的引用了知识库内容。建议同时测试资料内问题、资料外问题和模糊问题：资料内问题应能引用原文，资料外问题应说明无法直接确认，模糊问题应主动提示需要补充事实。
### 2.4 业务价值
* **降低资料检索门槛**：把长篇法规、制度、手册转成自然语言问答入口，让业务人员不用先知道关键词或目录位置，也能快速找到相关内容。
* **提升回答可信度**：通过知识库检索和原文引用，让答案具备来源依据，减少模型凭经验编造或泛泛而谈的风险。
* **沉淀组织知识**：企业内部制度、产品 FAQ、售后 SOP、合同模板等资料可以持续进入知识库，形成可维护、可复用的知识资产。
* **适配高频支持场景**：法务、HR、行政、客服、交付团队都可以使用类似模式，把重复咨询转成自助问答，提高响应效率。
## 案例三：工作流—内容审核与自动改写
### 3.1 适用场景
工作流适合步骤固定、逻辑清晰、需要分支判断或人工确认的任务。本案例将“内容合规审核”拆成知识库检索、AI 分类、条件判断、自动改写、拒绝说明和人工确认几个环节，用来模拟企业内容发布前的审核流程。
它的核心价值有两个：
1. **自动化**：一次触发后，系统可以按预设流程自动执行多个步骤。
2. **标准化**：同样的输入会经过同样的判断和处理，减少人工差异。
判断一个任务是否适合工作流，可以看它是否具备“步骤稳定、规则明确、可重复执行”三个特征。内容审核就是典型场景：输入是一段待发布内容，规则来自合规知识库，输出通常是通过、改写或拒绝，中间还可以加入人工确认，既提升处理效率，也保留风险控制。
### 3.2 准备内容
先创建一个“内容合规规则库”知识库，并上传一个简单的文本文件。可以直接使用以下规则模板：
```text
内容合规规则
安全内容（可直接发布）
- 客观事实陈述
- 正常的活动通知、会议安排
- 产品功能介绍（基于真实数据）
- 行业知识分享
敏感措辞（需改写）
- 绝对化用语：“最好的”“第一”“100%”“绝对”“唯一”
- 夸张宣传：“颠覆行业”“史无前例”“无人能比”
- 未证实数据：无来源的转化率、满意度、增长率
- 对比贬低：直接点名竞品并贬低
违规内容（禁止发布）
- 违法信息：涉及黄赌毒、诈骗、传销
- 人身攻击：针对个人或群体的侮辱、诽谤
- 虚假信息：伪造数据、虚构资质、冒充官方
- 敏感话题：政治敏感、宗教歧视、地域攻击
```
规则库不需要一开始就非常复杂。快速验证时，先把规则拆成“安全、需改写、禁止发布”三类即可；正式使用时，可以继续按行业、品牌、渠道、地区增加规则，例如广告法敏感词、医疗合规要求、金融营销禁用表达、品牌语气规范等。
### 3.3 流程设计
正式配置节点之前，建议先确认完整流程。这个案例可以按以下方式设计：
1. **用户输入**：作为工作流起点，接收待审核内容。
2. **知识库检索**：从内容合规规则库中召回相关规则，建议引用上限设置为 1-2 条。
3. **AI 内容合规分类**：结合用户输入和检索结果，将内容分为“安全 / 敏感可改 / 违规”。
4. **分支判断**：根据分类结果进入不同分支。
5. **安全分支**：直接输出原文，表示可发布。
6. **敏感可改分支**：调用 AI 改写内容，再交由用户确认。
7. **违规分支**：输出拒绝说明，并给出修改建议。
8. **最终输出**：返回原文、改写稿或拒绝说明。
工作流设计时要先确定每个节点的职责，避免让一个 AI 节点同时承担“检索规则、判断分类、改写内容、解释原因”等过多任务。职责拆清楚后，每个节点的 Prompt 会更短、更稳定，后续也更容易定位问题：是知识库没有召回规则，是审核节点分类不准，还是判断器条件没有匹配上。
### 3.4 配置步骤
1. **创建工作流**
进入工作流主页，点击新建工作流，名称填写为 `内容审核与自动改写`。
创建完成后进入工作流编辑页。
本案例的完整流程图如下：
2. **配置开场白**
在系统配置中填写开场白，说明助手的审核规则和使用方式。
```md
你好！我是内容合规审核助手 🛡️
请把需要审核的内容发给我，我会按规则自动判断：
- **✅ 安全** — 内容无敏感信息，可以直接发布
- **⚠️ 敏感可改** — 包含可修正的措辞，我会改写后发回你确认
- **🚫 违规** — 包含红线内容，直接拒绝并说明原因
支持单个文本审核，也可以批量发（多条用换行分隔）。
**开始吧。**
```
3. **调用知识库**
在工作流中添加知识库检索节点，选择前面创建的内容合规规则库。该节点的输入使用用户输入，输出供后续 AI 节点引用。
这个节点的目的不是让模型阅读完整规则库，而是把与当前内容最相关的规则片段召回给后续审核节点。引用上限可以先设置为 1-2 条，保证提示词上下文足够聚焦；如果规则库较大或分类较细，再逐步提高引用数量。
4. **配置内容审核节点**
添加 AI 对话节点，并重命名为“内容审核节点”。该节点负责根据用户输入和知识库规则输出分类结果。
```md
你是一个内容合规审核专家。结合知识库检索到的合规规则，判断用户输入内容的合规等级。
分类标准：
- 安全：内容无敏感信息，可以直接发布
- 敏感可改：包含可修正的敏感措辞，改写后可发布
- 违规：包含红线内容，不可发布
输出格式：
仅输出三个词之一：安全 / 敏感可改 / 违规
```
注意：知识库引用处必须选择前面创建的知识库，否则 AI 无法读取规则内容。
审核节点的输出要尽量稳定，因为它会直接影响判断器分支。快速演示时可以只输出“安全 / 敏感可改 / 违规”三个词；如果后续要做更严格的自动化集成，可以改成结构化输出，例如同时返回分类、原因和命中的规则，方便下游节点做精确匹配和日志记录。
5. **测试审核节点**
点击右上角运行，输入一段待审核内容，确认审核节点能够返回稳定的分类结果。
这一步建议单独测试节点，而不是等全部流程搭完再调试。可以分别输入正常活动通知、包含绝对化宣传的营销文案、明显违规的文本，观察分类是否符合预期。如果分类不稳定，优先调整规则库表达和审核 Prompt，再继续配置后续分支。
6. **隐藏中间输出**
点击模型右侧的设置按钮，调整节点基础设置。由于用户只需要最终结果，建议隐藏内容审核节点的中间输出。
7. **配置判断器**
添加判断器节点，根据内容审核节点输出的“安全 / 敏感可改 / 违规”进入不同分支。
判断器相当于流程中的分流开关。上一步输出越稳定，判断器越容易配置；如果审核节点输出包含解释性文字，判断条件就可能匹配失败。因此在分支类工作流中，通常要先约束上游节点的输出格式，再配置判断器条件。
8. **配置安全分支**
当审核结果为“安全”时，直接输出原文即可。生产场景中也可以增加抽样复核或人工确认。
输出效果如下：
9. **配置敏感可改分支**
当审核结果为“敏感可改”时，添加 AI 对话节点自动改写内容。可以使用以下 Prompt：
```md
你是一个内容改写专家。将用户输入的内容改写为合规版本。
改写原则：
- 保留原意和信息量，不改变核心表达
- 将绝对化用语替换为客观表述，例如“最好的”改为“行业领先的”
- 将未证实的数据表述替换为合理推测，例如“100% 有效”改为“多数用户反馈有效”
- 将敏感措辞替换为中性表达
- 保持原文风格和语气
```
改写完成后，可以添加用户选择节点，让用户选择接受改写、继续改写或放弃。
人工确认节点适合放在有风险但可修正的路径上。AI 可以负责提出改写建议，但是否发布仍交给业务人员确认。这样既能减少人工初筛和反复改稿的时间，也不会把最终发布权完全交给自动化流程。
如果用户接受改写，输出改写结果；如果用户选择继续改写，可连接回内容改写节点；如果用户放弃，则输出原文。
10. **配置违规分支**
当审核结果为“违规”时，添加 AI 对话节点输出拒绝说明。可以使用以下 Prompt：
```md
用户提交的内容因涉及违规信息无法发布。请用礼貌、专业的语气说明原因。
输出格式：
1. 一句话说明内容无法发布
2. 列举具体的违规点（1-3 条）
3. 提供替代建议（如：建议修改哪些方面后重新提交）
```
11. **验证完整流程**
分别输入安全内容、敏感内容和违规内容，确认三条分支都能返回预期结果。
完整流程验证时，建议记录每条测试内容的输入、审核分类、进入分支和最终输出。若输出不符合预期，按节点顺序排查：先看知识库是否召回正确规则，再看审核节点分类是否准确，最后看判断器条件和分支输出是否配置正确。
### 3.5 业务价值
* **把审核规则流程化**：将内容发布前的判断标准沉淀为知识库和节点配置，减少依赖个人经验口头传递。
* **提高处理效率**：安全内容可快速通过，敏感内容自动改写，违规内容直接说明原因，让审核人员把精力集中在需要判断的内容上。
* **保留人工控制点**：对“敏感可改”这类灰度场景加入用户确认，避免自动化流程直接替业务人员做发布决策。
* **便于复用和扩展**：同样的流程可以迁移到营销文案、客服话术、公告通知、活动页面、短视频脚本等内容审核场景，只需要替换规则库和部分 Prompt。
* **降低合规风险**：通过固定分支和拒绝说明，让高风险内容有明确拦截路径，减少误发、夸大宣传或不合规表达带来的风险。
## 案例四：Agent V2—智能数据分析 Agent
### 4.1 适用场景
Agent V2 适合开放式、多步骤、需要动态规划的任务。与工作流不同，工作流需要提前定义每一步；Agent V2 更适合“步骤不固定”的任务，例如数据分析、文件处理、多工具协作和需要追问澄清的复杂问题。
本案例模拟运营、产品或销售团队的日常数据分析需求：上传 Excel 文件后，直接用自然语言提出问题，让 Agent 自主读取文件、制定分析计划，并在虚拟机中执行分析。
案例三的工作流需要你先设计“检索规则 → 分类 → 分支 → 改写或拒绝”的固定路径；Agent V2 则更像一个可以自主规划的执行者。你不需要提前定义每一步，只需要提供目标和文件，Agent 会根据数据结构和问题复杂度决定先读取文件、再做统计、是否需要追问、是否需要运行代码。
数据分析很适合用来体验 Agent V2，因为它天然具备三个特点：分析路径不固定、经常需要多步推理、需求可能需要澄清。同一份 Excel，不同用户可能关心产品销量、渠道 ROI、区域趋势或异常订单，固定工作流很难提前覆盖所有路径，而 Agent V2 可以根据问题动态规划。
### 4.2 准备内容
* 示例文件：准备一份销售数据 Excel 或 CSV 表格。
* 一个支持 Agent V2 的对话模型。
* 虚拟机能力已在当前环境中可用。
### 4.3 配置步骤
1. **创建 Agent V2 应用**
工作台点击新建应用，选择 `对话 Agent V2(Beta)`，名称填写为 `智能数据分析 Agent`。
2. **配置模型与 Prompt**
AI 配置继续使用 GLM-5.1 模型。系统提示词可以参考：
```md
你是一个资深数据分析师 Agent。你可以读取用户上传的数据文件、在沙箱中运行 Python 分析代码、并主动向用户追问澄清需求。
工具：
- 📄 **读取文件** — 读取用户上传的 Excel/CSV 数据
- 💻 **沙箱执行** — 运行 Python 脚本（pandas/matplotlib/numpy）
- ❓ **主动追问** — 分析需求不明确时向用户确认
工作方式：
1. 收到数据和问题后，先读取文件了解数据结构和内容
2. 制定分析计划，以步骤列表展示给用户
3. 按计划逐步执行，每步展示关键发现
4. 遇到模糊需求时主动追问，如指标定义不明确或缺少对比基准
5. 根据追问结果动态更新计划
6. 输出分析报告，包含数据概览、核心发现、可视化图表、业务建议
安全规则：
- 沙箱中只能做数据分析，禁止访问网络，禁止写文件到宿主机
- 数据仅用于本次分析，不在报告中暴露原始敏感数据
- 不确定的结论标注置信度
输出格式：
1. 📋 分析计划（根据数据自动生成）
2. 📊 数据概览（行数、列名、缺失值、基本统计）
3. 🔍 核心发现（3-5 个关键洞察，图表辅助）
4. 💡 业务建议（基于数据的可操作建议）
```
这段 Prompt 的重点是让 Agent 先规划再执行，而不是直接给结论。对于数据分析类任务，先读取数据结构、确认字段含义、制定分析计划，可以显著减少误解需求或误用指标的风险。正式使用时，可以继续补充企业内部指标定义，例如 GMV、ROI、转化率、有效客户、复购率等口径。
3. **配置开场白**
开场白用于引导用户上传数据文件并提出分析问题：
```text
你好！我是智能数据分析 Agent 📊
直接把 Excel 或 CSV 文件拖进来，告诉我你想分析什么。
例如：
- "分析这份销售数据，找出销量最好的产品和趋势"
- "帮我看看用户活跃度的变化，找出下降的原因"
- "对比三个渠道的转化率，哪个 ROI 最高？"
我会先了解你的数据，制定分析计划，然后在沙箱中运行分析代码。
需要确认的地方我会主动问你。
```
4. **开启虚拟机能力**
数据分析通常需要读取文件并执行代码，因此需要开启虚拟机配置。
虚拟机能力用于隔离代码执行环境。Agent 可以在其中运行数据分析脚本、读取上传文件、生成统计结果，但不会直接影响本地宿主环境。对于需要运行 Python、处理 Excel、绘制图表或做批量计算的场景，这是 Agent V2 区别于普通对话应用的重要能力。
5. **上传文件并测试**
上传销售数据示例文件，并输入问题：
```text
帮我分析这份销售数据，看看哪些产品卖得好，哪个渠道 ROI 最高
```
Agent 会先拆解任务，再逐步执行分析。
执行过程中可以看到任务在虚拟机中运行，不会影响本地环境。
测试时重点观察 Agent 是否具备完整的分析过程：是否先识别表格字段，是否解释分析计划，是否在需要时运行代码，是否根据结果给出业务建议。如果问题描述不清晰，理想行为不是强行分析，而是先向用户追问关键口径。
### 4.4 验证效果
最终结果应包含分析计划、数据概览、关键发现和业务建议。
结果验证时建议关注四个维度：结论是否来自实际数据，指标口径是否清楚，图表或统计是否能支撑结论，业务建议是否可执行。数据分析 Agent 的价值不只是输出一段总结，而是把“读数据、算指标、解释结果、提出建议”的过程串起来。
### 4.5 业务价值
* **降低数据分析门槛**：业务人员可以直接上传 Excel 或 CSV，用自然语言提出问题，不必先写 SQL、Python 或复杂公式。
* **支持开放式探索**：同一份数据可以围绕销量、渠道、区域、客户、趋势、异常值等方向反复追问，适合没有固定分析路径的场景。
* **提升分析透明度**：Agent 会展示分析计划和关键步骤，用户可以看到它如何理解数据、如何计算指标、如何得出结论。
* **隔离代码执行风险**：通过虚拟机执行分析脚本，降低本地环境污染、依赖冲突和权限误用风险。
* **沉淀业务分析能力**：销售复盘、运营周报、活动归因、产品指标诊断等场景都可以复用这一类 Agent，把数据分析从专家任务变成日常工作流。
## 四种类型选型回顾
完成四个案例后，可以把 FastGPT 的常见应用类型理解为从简单到复杂的能力递进：对话 Agent 解决“怎么回答和生成内容”，知识库解决“基于什么资料回答”，工作流解决“按什么固定流程处理”，Agent V2 解决“面对开放任务如何自主规划和执行”。
| 应用类型 | 适合场景 | 核心能力 |
| -------------- | ------------------- | ---------------- |
| 对话 Agent | 轻量问答、文案生成、标准化输出 | Prompt、模型配置、工具调用 |
| 知识库 + 对话 Agent | 基于资料、制度、法条、产品手册的问答 | 文件导入、知识库检索、引用原文 |
| 工作流 | 固定步骤、条件分支、审核流、自动化处理 | 节点编排、判断器、人工确认 |
| Agent V2 | 数据分析、复杂任务、多步推理、动态规划 | 自主规划、工具调用、虚拟机执行 |
选型时可以按任务复杂度判断：
1. 如果只是做轻量对话或标准化文案生成，优先选择对话 Agent。
2. 如果回答必须基于已有资料，选择知识库 + 对话 Agent。
3. 如果流程固定且需要条件分支、人工确认或自动化处理，选择工作流。
4. 如果任务开放、步骤不固定，并且需要自主分析、工具调用或代码执行，选择 Agent V2。
实际项目中也可以组合使用这些能力。例如客服助手可以使用知识库回答产品问题，再通过工具查询订单；内容审核可以用工作流固定审核路径，同时用知识库维护规则；数据分析场景可以先用 Agent V2 完成探索，再把稳定下来的分析步骤沉淀成工作流。
file: ./content/guide/version/commercial.en.mdx
meta: {
"title": "FastGPT Commercial Edition",
"description": "FastGPT Commercial Edition overview"
}
import { Alert } from '@/components/docs/Alert';
## Overview
FastGPT Commercial Edition is an enhanced version built on top of the Community Edition with additional exclusive features. Simply install the commercial image and configure the internal network address on your existing Community Edition setup to get started.
## Feature Comparison
| | Community Edition | Commercial Edition | Cloud Service |
| ------------------------------------------------------ | ------------------------------------------------------- | ------------------ | ------------- |
| **App Building** | | | |
| Workflow orchestration | ✅ | ✅ | ✅ |
| Share links and API | ✅ | ✅ | ✅ |
| App publishing security config | ❌ | ✅ | ✅ |
| Third-party publishing (Lark, WeChat Official Account) | ❌ | ✅ | ✅ |
| Run log dashboard | ❌ | ✅ | ✅ |
| App evaluation | ❌ | ✅ | ✅ |
| Agent and Skill assisted generation | ❌ | ✅ | ✅ |
| System tool remote debugging | ❌ | ✅ | ✅ |
| **Knowledge Base** | | | |
| Knowledge base | ✅ | ✅ | ✅ |
| Third-party knowledge base scheduled sync | ❌ | ✅ | ✅ |
| Knowledge base index enhancement | ❌ | ✅ | ✅ |
| Website sync | ❌ | ✅ | ✅ |
| Image knowledge base | ❌ | ✅ | ✅ |
| **General Features** | | | |
| Multi-model configuration | ✅ | ✅ | ✅ |
| Model log dashboard | ✅ | ✅ | ✅ |
| Model content moderation | ❌ | ✅ | ✅ |
| **Enterprise Features** | | | |
| Custom branding | ❌ | ✅ | In design |
| Multi-tenancy & billing | ❌ | ✅ | ✅ |
| Team spaces & permissions | ❌ | ✅ | ✅ |
| Admin dashboard | ❌ | ✅ | Not needed |
| SSO login | ❌ | ✅ | In design |
| Commercial license | [View open source license](./opensource/license.en.mdx) | Full | Full |
## Pricing
FastGPT Commercial Edition offers 3 pricing models based on deployment type. Below are the common details for each. If you have further questions, [contact us](https://fael3z0zfze.feishu.cn/share/base/form/shrcnjJWtKqjOI9NbQTzhNyzljc?prefill_S=doc\&hide_S=1).
**Included with all plans**
1. SaaS commercial license — use for any commercial purpose during the license period.
2. Free initial deployment assistance.
3. Priority support ticket handling.
**Plan-specific features**
| Deployment Type | Included Features | Time to Launch | Starting Price |
| --------------------------------- | ------------------------------------------------------------------------------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sealos Fully Managed | 1. Free upgrades during license period.2. No ops or database management needed. | Half day | Starting at ¥10,000/month (3-month minimum)
or
Starting at ¥120,000/year
8C32G resources; additional resources billed separately. | | Sealos Fully Managed (Multi-node) | 1. Free upgrades during license period.
2. No ops or database management needed. | Half day | Starting at ¥22,000/month (3-month minimum)
or
Starting at ¥264,000/year
32C128G resources; additional resources billed separately. | | Self-hosted | 1. Free upgrade support for 6 versions. | Within 14 days | [Contact us for pricing](https://fael3z0zfze.feishu.cn/share/base/form/shrcnjJWtKqjOI9NbQTzhNyzljc?prefill_S=doc\&hide_S=1) |
2. 免运维服务&数据库。 | 半天 | 10000 元起/月（3 个月起）
或
120000 元起/年
8C32G 资源，额外资源另外收费。 | | Sealos 全托管（多节点） | 1. 有效期内免费升级。
2. 免运维服务&数据库。 | 半天 | 22000 元起/月（3 个月起）
或
264000 元起/年
32C128G 资源，额外资源另外收费。 | | 自有服务器部署 | 1. 6 个版本免费升级支持。 | 14 天内 | 具体价格和优惠可[联系咨询](https://fael3z0zfze.feishu.cn/share/base/form/shrcnjJWtKqjOI9NbQTzhNyzljc?prefill_S=doc\&hide_S=1) |
Click to view docker-compose config file download links for different databases
* **Pgvector** * China mirror (Alibaba Cloud): [docker-compose.pg.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.pg.yml) * Global mirror (dockerhub, ghcr): [docker-compose.pg.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.pg.yml) * **Oceanbase** * China mirror (Alibaba Cloud): [docker-compose.oceanbase.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.oceanbase.yml) * Global mirror (dockerhub, ghcr): [docker-compose.oceanbase.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.oceanbase.yml) * **Milvus** * China mirror (Alibaba Cloud): [docker-compose.milvus.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.milvus.yml) * Global mirror (dockerhub, ghcr): [docker-compose.milvus.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.milvus.yml) * **Zilliz** * China mirror (Alibaba Cloud): [docker-compose.zilliz.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.zilliz.yml) * Global mirror (dockerhub, ghcr): [docker-compose.zilliz.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.zilliz.yml) * **SeekDB** * China mirror (Alibaba Cloud): [docker-compose.seekdb.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.seekdb.yml) * Global mirror (dockerhub, ghcr): [docker-compose.seekdb.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.seekdb.yml)点击展开查看不同数据库的 docker-compose 配置文件下载地址
* **Pgvector** * 中国大陆地区镜像源(阿里云)：[docker-compose.pg.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.pg.yml) * 全球镜像源(dockerhub, ghcr)：[docker-compose.pg.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.pg.yml) * **Oceanbase** * 中国大陆地区镜像源(阿里云)：[docker-compose.oceanbase.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.oceanbase.yml) * 全球镜像源(dockerhub, ghcr)：[docker-compose.oceanbase.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.oceanbase.yml) * **Milvus** * 中国大陆地区镜像源(阿里云)：[docker-compose.milvus.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.milvus.yml) * 全球镜像源(dockerhub, ghcr)：[docker-compose.milvus.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.milvus.yml) * **Zilliz** * 中国大陆地区镜像源(阿里云)：[docker-compose.zilliz.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.zilliz.yml) * 全球镜像源(dockerhub, ghcr)：[docker-compose.zilliz.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.zilliz.yml) * **SeekDB** * 中国大陆地区镜像源(阿里云)：[docker-compose.seekdb.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/cn/docker-compose.seekdb.yml) * 全球镜像源(dockerhub, ghcr)：[docker-compose.seekdb.yml](https://doc.fastgpt.cn/deploy/docker/v4.15/global/docker-compose.seekdb.yml)
### Beijing Region
The Beijing region is hosted by Volcano Engine. Users in mainland China get stable access, but it can't reach OpenAI or other overseas services. Pricing is about 1/4 of the Singapore region. Click below to deploy 👇
### 1. Start Deployment
Since databases need to be deployed, wait 2–4 minutes after deployment before accessing. The default uses minimal resources, so the first access may be slow.
Follow the prompts to enter `root_password` and the `openai`/`oneapi` address and key.
After clicking deploy, you'll be redirected to the app management page. Click the details button on the right side of the `fastgpt` main app (named fastgpt-xxxx), as shown below.
After clicking details, you'll see the FastGPT deployment management page. Click the link in the external access address to open the FastGPT service.
To bind a custom domain or modify deployment parameters, click **Change** in the top right and follow Sealos' instructions.
### 2. Log In
Username: `root`
Password: the `root_password` you set during one-click deployment
### 3. Configure Models
### 4. Configure Models
You must configure at least one model set, or the system won't work properly.
[View model configuration tutorial](../config/model/intro.en.mdx)
## Pricing
Sealos uses pay-as-you-go billing based on allocated CPU, memory, and disk. For specific pricing, open the **Cost Center** in the Sealos control panel.
## Using Sealos
### Overview
FastGPT Commercial Edition includes 2 apps (fastgpt, fastgpt-plus) and 2 databases. When using multiple API keys, install OneAPI (1 app and 1 database), totaling 3 apps and 3 databases.
Click details on the right to view each app's information.
### Modifying Config Files and Environment Variables
In Sealos, open **App Launchpad** to see deployed FastGPT apps, and open **Database** to see corresponding databases.
In **App Launchpad**, select FastGPT, click **Change**, and you'll see environment variables and config files.
### 北京区
北京区服务提供商为火山云，国内用户可以稳定访问，但无法访问 OpenAI 等境外服务，价格约为新加坡区的 1/4。点击下面按键即可部署👇
### 1. 开始部署
由于需要部署数据库，部署完后需要等待 2\~4 分钟才能正常访问。默认用了最低配置，首次访问时会有些慢。
根据提示，输入 `root_password`，和 `openai` / `oneapi` 的地址和密钥。
点击部署后，会跳转到应用管理页面。可以点击 `fastgpt` 主应用右侧的详情按键（名字为 fastgpt-xxxx），如下图所示。
点击详情后，会跳转到 fastgpt 的部署管理页面，点击外网访问地址中的链接，即可打开 fastgpt 服务。
如需绑定自定义域名、修改部署参数，可以点击右上角变更，根据 sealos 的指引完成。
### 2. 登录
用户名：`root`
密码是刚刚一键部署时设置的 `root_password`
### 3. 配置模型
### 4. 配置模型
务必先配置至少一组模型，否则系统无法正常使用。
[点击查看模型配置教程](../config/model/intro.mdx)
## 收费
Sealos 采用按量计费的方式，也就是申请了多少 cpu、内存、磁盘，就按该申请量进行计费。具体的计费标准，可以打开 `sealos` 控制面板中的 `费用中心` 进行查看。
## Sealos 使用
### 简介
FastGPT 商业版共包含了 2 个应用（fastgpt, fastgpt-plus）和 2 个数据库，使用多 API Key 时候需要安装 OneAPI（一个应用和一个数据库），总计 3 个应用和 3 个数据库。
点击右侧的详情，可以查看对应应用的详细信息。
### 修改配置文件和环境变量
在 Sealos 中，你可以打开 `应用管理`（App Launchpad）看到部署的 FastGPT，可以打开 `数据库`（Database）看到对应的数据库。
在 `应用管理` 中，选中 FastGPT，点击变更，可以看到对应的环境变量和配置文件。
OpenAI-Compatible Enum and Default Budget Mapping
| FastGPT option | OpenAI-compatible value | Default budget | | -------------- | ----------------------------------------- | --------------------- | | Default | Do not explicitly send `reasoning_effort` | Use the model default | | None | `none` | `0` | | Minimal | `minimal` | `1024` | | Low | `low` | `2048` | | Medium | `medium` | `8192` | | High | `high` | `16384` | | Extra high | `xhigh` | `32768` | If an upstream provider only supports a token budget instead of discrete effort levels, ai-proxy uses the table above to convert effort to budget. When normalizing budget back to effort, `<=0` maps to `none`, `1-1024` maps to `minimal`, `1025-4096` maps to `low`, `4097-12288` maps to `medium`, `12289-24576` maps to `high`, and anything higher maps to `xhigh`.OpenAI / OpenAI Responses
| Target format | Output field | Mapping | | ------------------------- | ------------------ | ------------------------------------------------- | | OpenAI Chat / Completions | `reasoning_effort` | Writes `none/minimal/low/medium/high/xhigh` as-is | | OpenAI Responses | `reasoning.effort` | Writes `none/minimal/low/medium/high/xhigh` as-is | OpenAI Chat / Completions only parses `reasoning_effort`. When Gemini, Claude, or other request formats are converted to an OpenAI-compatible format, they are first normalized to this field.Google Gemini
Gemini native requests are parsed from `generationConfig.thinkingConfig`, including `thinkingLevel`, `thinkingBudget`, and `includeThoughts`. When writing to Gemini upstreams, ai-proxy chooses either `thinkingLevel` or `thinkingBudget` based on the model family. | OpenAI-compatible value | Gemini 3+ Pro | Gemini 3+ non-Pro | gemini-2.5-pro | gemini-2.5-flash | gemini-2.5-flash-lite | | ----------------------- | -------------------- | ----------------------- | ---------------------- | ---------------------- | ---------------------- | | `none` | `thinkingLevel=low` | `thinkingLevel=minimal` | `thinkingBudget=128` | `thinkingBudget=0` | `thinkingBudget=0` | | `minimal` | `thinkingLevel=low` | `thinkingLevel=minimal` | `thinkingBudget=1024` | `thinkingBudget=1024` | `thinkingBudget=1024` | | `low` | `thinkingLevel=low` | `thinkingLevel=low` | `thinkingBudget=2048` | `thinkingBudget=2048` | `thinkingBudget=2048` | | `medium` | `thinkingLevel=low` | `thinkingLevel=medium` | `thinkingBudget=8192` | `thinkingBudget=8192` | `thinkingBudget=8192` | | `high` | `thinkingLevel=high` | `thinkingLevel=high` | `thinkingBudget=16384` | `thinkingBudget=16384` | `thinkingBudget=16384` | | `xhigh` | `thinkingLevel=high` | `thinkingLevel=high` | `thinkingBudget=32768` | `thinkingBudget=24576` | `thinkingBudget=24576` | Gemini 2.5 models clamp the budget to the model's supported range. Some Gemini models cannot fully disable thinking, so `none` falls back to the minimum supported level or budget.Claude / Anthropic / Bedrock / Vertex AI
Claude native requests are parsed from `thinking` and `output_config`. When writing to Anthropic, AWS Bedrock Claude, or Vertex AI Claude, the payload still follows Claude's thinking format. | OpenAI-compatible value | Legacy / budget mode | Adaptive mode | | ----------------------- | ---------------------------------------------- | ---------------------------------------------------------------------- | | `none` | `thinking.type=disabled` | `thinking.type=disabled`; may be removed for some adaptive-only models | | `minimal` | `thinking.type=enabled`, `budget_tokens=1024` | `thinking.type=adaptive`, `output_config.effort=low` | | `low` | `thinking.type=enabled`, `budget_tokens=2048` | `thinking.type=adaptive`, `output_config.effort=low` | | `medium` | `thinking.type=enabled`, `budget_tokens=8192` | `thinking.type=adaptive`, `output_config.effort=medium` | | `high` | `thinking.type=enabled`, `budget_tokens=16384` | `thinking.type=adaptive`, `output_config.effort=high` | | `xhigh` | `thinking.type=enabled`, `budget_tokens=32768` | `thinking.type=adaptive`, `output_config.effort=max` | Budget mode ensures `budget_tokens < max_tokens` and raises too-small budgets to the minimum accepted by the upstream provider.Ali DashScope / Qwen / QwQ / GLM / Kimi-Compatible Models
| OpenAI-compatible value | Models with `thinking_budget` support | Models without budget support | | ----------------------- | ------------------------------------------------- | ----------------------------- | | `none` | `enable_thinking=false`; remove `thinking_budget` | `enable_thinking=false` | | `minimal` | `enable_thinking=true`, `thinking_budget=1024` | `enable_thinking=true` | | `low` | `enable_thinking=true`, `thinking_budget=2048` | `enable_thinking=true` | | `medium` | `enable_thinking=true`, `thinking_budget=8192` | `enable_thinking=true` | | `high` | `enable_thinking=true`, `thinking_budget=16384` | `enable_thinking=true` | | `xhigh` | `enable_thinking=true`, `thinking_budget=32768` | `enable_thinking=true` | ai-proxy currently treats `qwen3-*`, `qwq-*`, and Ali-compatible models whose names contain `glm` or `kimi` as supporting `thinking_budget`. Non-streaming `qwen3-*` requests are forced to disable thinking, while `qwq-*` requests are forced to streaming mode.Zhipu / DeepSeek / Doubao / Moonshot Kimi
These providers currently preserve only the on/off meaning. They do not preserve budget or fine-grained effort levels. | Provider | OpenAI-compatible value | Upstream field | | --------------------------------------------- | ------------------------------- | --------------------------------------------------- | | Zhipu / DeepSeek / Doubao | `none` | `thinking.type=disabled` | | Zhipu / DeepSeek / Doubao | `minimal/low/medium/high/xhigh` | `thinking.type=enabled` | | Moonshot / Kimi models with switch support | `none` | `thinking.type=disabled`; remove `reasoning_effort` | | Moonshot / Kimi models with switch support | `minimal/low/medium/high/xhigh` | `thinking.type=enabled`; remove `reasoning_effort` | | Moonshot / Kimi models without switch support | Any value | Remove `reasoning_effort` and omit `thinking` | For Moonshot / Kimi, whether `thinking.type` can be written depends on the actual upstream model name after channel mapping.OpenAI 兼容枚举与默认 budget 映射
| FastGPT 选项 | OpenAI 兼容值 | 默认 budget | | ---------- | ------------------------ | --------- | | 默认 | 不显式传递 `reasoning_effort` | 使用模型默认值 | | 不思考 | `none` | `0` | | 极简思考 | `minimal` | `1024` | | 轻量思考 | `low` | `2048` | | 标准思考 | `medium` | `8192` | | 深度思考 | `high` | `16384` | | 极致思考 | `xhigh` | `32768` | 如果某个平台只支持 token budget，不支持离散档位，ai-proxy 会按上表把 effort 转成 budget。反向归一化时，`<=0` 会被视为 `none`，`1~1024` 视为 `minimal`，`1025~4096` 视为 `low`，`4097~12288` 视为 `medium`，`12289~24576` 视为 `high`，更高则视为 `xhigh`。OpenAI / OpenAI Responses
| 目标格式 | 写入字段 | 映射方式 | | ------------------------- | ------------------ | ----------------------------------------- | | OpenAI Chat / Completions | `reasoning_effort` | `none/minimal/low/medium/high/xhigh` 原样写入 | | OpenAI Responses | `reasoning.effort` | `none/minimal/low/medium/high/xhigh` 原样写入 | OpenAI Chat / Completions 模式只解析 `reasoning_effort`。当 Gemini、Claude 等请求被转换为 OpenAI 兼容格式时，也会先归一化为该字段。Google Gemini
Gemini 原生请求会从 `generationConfig.thinkingConfig` 中解析 `thinkingLevel`、`thinkingBudget` 和 `includeThoughts`。写给 Gemini 上游时，ai-proxy 会根据模型系列选择 `thinkingLevel` 或 `thinkingBudget`。 | OpenAI 兼容值 | Gemini 3+ Pro | Gemini 3+ 非 Pro | gemini-2.5-pro | gemini-2.5-flash | gemini-2.5-flash-lite | | ---------- | -------------------- | ----------------------- | ---------------------- | ---------------------- | ---------------------- | | `none` | `thinkingLevel=low` | `thinkingLevel=minimal` | `thinkingBudget=128` | `thinkingBudget=0` | `thinkingBudget=0` | | `minimal` | `thinkingLevel=low` | `thinkingLevel=minimal` | `thinkingBudget=1024` | `thinkingBudget=1024` | `thinkingBudget=1024` | | `low` | `thinkingLevel=low` | `thinkingLevel=low` | `thinkingBudget=2048` | `thinkingBudget=2048` | `thinkingBudget=2048` | | `medium` | `thinkingLevel=low` | `thinkingLevel=medium` | `thinkingBudget=8192` | `thinkingBudget=8192` | `thinkingBudget=8192` | | `high` | `thinkingLevel=high` | `thinkingLevel=high` | `thinkingBudget=16384` | `thinkingBudget=16384` | `thinkingBudget=16384` | | `xhigh` | `thinkingLevel=high` | `thinkingLevel=high` | `thinkingBudget=32768` | `thinkingBudget=24576` | `thinkingBudget=24576` | Gemini 2.5 系列会按模型允许范围 clamp budget。部分 Gemini 模型不能真正关闭 thinking，`none` 会退化为模型允许的最小 level 或 budget。Claude / Anthropic / Bedrock / Vertex AI
Claude 原生请求会解析 `thinking` 和 `output_config`。写给 Anthropic 官方、AWS Bedrock Claude 或 Vertex AI Claude 时，字段形态仍遵循 Claude 的 thinking 规则。 | OpenAI 兼容值 | 旧式 / budget 模式 | adaptive 模式 | | ---------- | ----------------------------------------------- | -------------------------------------------------------- | | `none` | `thinking.type=disabled` | `thinking.type=disabled`，部分 adaptive-only 模型可能移除该字段 | | `minimal` | `thinking.type=enabled` , `budget_tokens=1024` | `thinking.type=adaptive` , `output_config.effort=low` | | `low` | `thinking.type=enabled` , `budget_tokens=2048` | `thinking.type=adaptive` , `output_config.effort=low` | | `medium` | `thinking.type=enabled` , `budget_tokens=8192` | `thinking.type=adaptive` , `output_config.effort=medium` | | `high` | `thinking.type=enabled` , `budget_tokens=16384` | `thinking.type=adaptive` , `output_config.effort=high` | | `xhigh` | `thinking.type=enabled` , `budget_tokens=32768` | `thinking.type=adaptive` , `output_config.effort=max` | budget 模式会保证 `budget_tokens < max_tokens`，并把过小的 budget 提升到上游可接受的最小值。Ali DashScope / Qwen / QwQ / GLM / Kimi 兼容模型
| OpenAI 兼容值 | 支持 `thinking_budget` 的模型 | 不支持 budget 的模型 | | ---------- | ------------------------------------------------ | ----------------------- | | `none` | `enable_thinking=false`，移除 `thinking_budget` | `enable_thinking=false` | | `minimal` | `enable_thinking=true` , `thinking_budget=1024` | `enable_thinking=true` | | `low` | `enable_thinking=true` , `thinking_budget=2048` | `enable_thinking=true` | | `medium` | `enable_thinking=true` , `thinking_budget=8192` | `enable_thinking=true` | | `high` | `enable_thinking=true` , `thinking_budget=16384` | `enable_thinking=true` | | `xhigh` | `enable_thinking=true` , `thinking_budget=32768` | `enable_thinking=true` | 当前 ai-proxy 会把 `qwen3-*`、`qwq-*`、模型名包含 `glm` 或 `kimi` 的 Ali-compatible 模型视为支持 `thinking_budget`。`qwen3-*` 非流式请求会被强制关闭 thinking，`qwq-*` 请求会被强制改为流式。Zhipu / DeepSeek / Doubao / Moonshot Kimi
这些平台当前主要保留开关语义，不保留 budget 或细粒度 effort。 | 平台 | OpenAI 兼容值 | 写给上游的字段 | | ------------------------- | ------------------------------- | ----------------------------------------------- | | Zhipu / DeepSeek / Doubao | `none` | `thinking.type=disabled` | | Zhipu / DeepSeek / Doubao | `minimal/low/medium/high/xhigh` | `thinking.type=enabled` | | Moonshot / Kimi 支持开关的模型 | `none` | `thinking.type=disabled`，并移除 `reasoning_effort` | | Moonshot / Kimi 支持开关的模型 | `minimal/low/medium/high/xhigh` | `thinking.type=enabled`，并移除 `reasoning_effort` | | Moonshot / Kimi 不支持开关的模型 | 任意值 | 移除 `reasoning_effort`，不发送 `thinking` | Moonshot / Kimi 是否能写入 `thinking.type` 取决于渠道映射后的实际上游模型名。国际版：
Notes:
- Only one speech recognition model can be active at a time, so you only need to configure one.
- The system requires at least one language model and one embedding model to function properly.
注意事项：
- 目前语音识别模型仅会生效一个，所以配置时候，只需要配置一个即可。
- 系统至少需要一个语言模型和一个索引模型才能正常使用。
| Resource | Manageable Permissions | Description |
|---|---|---|
| Team | Create Apps | Create, delete, and other basic operations |
| Create Knowledge Bases | Create, delete, and other basic operations | |
| Create Team APIKey | Create, delete, and other basic operations | |
| Manage Members | Invite/remove users, create groups, etc. | |
| App | Can Use | Allows conversation interaction |
| Can Edit | Modify basic info, workflow orchestration, etc. | |
| Can Manage | Add or remove collaborators | |
| Knowledge Base | Can Use | Can call this knowledge base in apps |
| Can Edit | Modify knowledge base content | |
| Can Manage | Add or remove collaborators |
| 资源 | 可管理权限 | 说明 |
|---|---|---|
| 团队 | 创建应用 | 创建，删除等基础操作 |
| 创建知识库 | 创建，删除等基础操作 | |
| 创建团队 APIKey | 创建，删除等基础操作 | |
| 管理成员 | 邀请、移除用户，创建群组等 | |
| 应用 | 可使用 | 允许进行对话交互 |
| 可编辑 | 修改基本信息，进行流程编排等 | |
| 可管理 | 添加或删除协作者 | |
| 知识库 | 可使用 | 可以在应用中调用该知识库 |
| 可编辑 | 修改知识库的内容 | |
| 可管理 | 添加或删除协作者 |
SANDBOX_TOKEN=
# New
CODE_SANDBOX_URL=
CODE_SANDBOX_TOKEN=
```
2. Internal-network security checks are now disabled by default. To re-enable them, set the environment variable `CHECK_INTERNAL_IP=true` (applies to fastgpt, fastgpt-pro, and fastgpt-sandbox).
### 2. Update Images
* FastGPT image tag: v4.14.9.1
* FastGPT Commercial Edition image tag: v4.14.9.1
* fastgpt-plugin image tag: v0.5.5
* mcp\_server — no update required
* sandbox image tag: v4.14.9.1
* AIProxy — no update required
## API Changes
The `/api/core/chat/getPaginationRecords` endpoint now returns a `useAgentSandbox: boolean` field indicating whether the AI sandbox tool was used in the current conversation turn. The `llmModuleAccount` and `historyPreviewLength` fields will be removed soon — please migrate away from them as soon as possible.
## New Features
1. Added AI Sandbox — attach a sandbox tool to the AI for richer operations. (Currently available on the cloud service only; a lightweight self-hosted deployment will ship in the next release.)
2. Publish channels now support WeChat personal accounts.
3. AgentV2 context now adapts to the paused state.
4. Introduced a logger SDK with Metrics tracking.
5. Updating a single Knowledge Base entry now also refreshes the collection's update timestamp.
6. Form file inputs now support opening files for preview.
## Improvements
1. API-based Knowledge Base sync now has additional fallback methods for retrieving file names.
2. Added SSRF protection to the HTTP tool.
3. Improved compatibility with more MCP JsonSchema fields — older versions could not handle mixed-type fields.
4. Optimized parts of the workflow runtime pool logic to reduce computational complexity.
5. Replaced DFS with Tarjan's SCC algorithm for edge grouping in the workflow runtime, resolving issues where complex cyclic workflows failed to run.
6. System toolsets no longer display a version number (since they have no selectable versions).
## Bug Fixes
1. When a workflow nested a plugin, plugin execution details were not properly preserved. Also cleaned up all tool-type prefixes.
2. Updating and saving an MCP toolset could prevent it from being called correctly (due to an incorrect toolId lookup).
3. The search box was missing from the API Knowledge Base file list.
4. Workflow variable values containing special characters (`$.`) caused incorrect value substitution.
5. Referencing an agent tool in a workflow caused a version retrieval error.
6. When switching from a model that supports certain parameters to one that does not, the unsupported parameters were not removed, causing model invocation failures.
7. Closing a shared link's display status caused AI responses in the chat history to render incorrectly.
8. Re-opening the preview dialog in workflow preview mode lost form input content.
9. Custom fields in subscription plans were not applied.
10. The login endpoint had an async session issue that produced error logs.
11. The condition evaluator was missing selectable conditions for the `arrayAny` type.
12. Video/audio custom file type workflows were missing file link variables at the start node.
13. User input messages were not escaped to Markdown format.
14. Fixed partial context concatenation errors in AgentV2.
## Code Improvements
1. Fixed a monorepo issue in Commercial Edition development where different React references required a full package reinstall.
file: ./content/self-host/upgrading/4-14/4149.mdx
meta: {
"title": "V4.14.9（环境变量变更）",
"description": "FastGPT V4.14.9 更新说明"
}
## 升级指南
### 1. 环境变量更新
1. 修改 FastGPT 环境变量：SANDBOX\_URL 和 SANDBOX\_TOKEN，改名成 CODE\_SANDBOX\_URL 和 CODE\_SANDBOX\_TOKEN：
```bash
# 旧的
SANDBOX_URL=代码运行沙盒的地址
SANDBOX_TOKEN=代码运行沙盒的凭证（可以为空，4.14.8 新增加了鉴权）
# 新的
CODE_SANDBOX_URL=代码运行沙盒的地址
CODE_SANDBOX_TOKEN=代码运行沙盒的凭证
```
2. 默认关闭内网安全检查，如需开启，需设置环境变量 `CHECK_INTERNAL_IP=true`（fastgpt,fastgpt-pro,fastgpt-sandbox 通用变量）
### 2. 更新镜像
* 更新 FastGPT 镜像 tag: v4.14.9.5
* 更新 FastGPT 商业版镜像 tag: v4.14.9.5
* 更新 fastgpt-plugin 镜像 tag: v0.5.5
* mcp\_server 无需更新
* 更新 sandbox 镜像 tag: v4.14.9.1
* AIProxy 无需更新
## 接口变更
`/api/core/chat/getPaginationRecords` 接口，增加返回 `useAgentSandbox:boolean` 字段，代表本轮对话，是否使用了虚拟机工具。即将移除 `llmModuleAccount` 和 `historyPreviewLength` 字段，如使用该字段，请尽快适配。
## 🚀 新增内容
1. 新增 AI 虚拟机功能，可以给 AI 挂载一个虚拟机工具进行更丰富的操作。（目前仅云服务开放使用,下个版本会推出轻量部署方案）
2. 发布渠道支持微信个人号。
3. AgentV2 上下文适配暂停态。
4. 封装 logger sdk。增加 Metrics 追踪。
5. 更新知识库单个数据时，同步更新 collection 更新时间。
6. 表单输入文件时，支持打开文件进行预览。
## ⚙️ 优化
1. API 知识库同步时，增加更多 fallback 获取文件名方式。
2. HTTP 工具，增加 SSRF 防御。
3. 兼容更多 MCP JsonSchema 字段，旧版无法适配混合类型字段。
4. 优化部分工作流运行池逻辑，减少计算复杂度
5. 调整工作流 runtime，用 Tarjan SCC 算法替代 DSC 进行 edges 分组，解决工作流复杂循环无法运行问题。
6. 系统工具集不显示版本（因为其无版本可选）。
## 🐛 修复
1. 工作流嵌套插件时，未成功保留插件运行详情。同时整理所有 tool 类型前缀。
2. 更新并保存 MCP toolset 后可能无法正常调用（由于 toolId 获取错误）。
3. API 知识库，文件列表搜索框丢失。
4. 工作流变量值，包含特殊值($.)的时候，导致值替换异常。
5. 工作流引用 agent 工具时，获取版本异常。
6. 不支持某些属性的参数的模型，从支持该参数的模型切换过来时，该模型未被去掉，导致模型调用失败。
7. 分享链接关闭状态显示后，会导致历史记录里的 AI 回复内容无法正常展示。
8. 修复工作流预览模式下，重新打开预览弹窗，会丢失表单输入内容。
9. 修复订阅套餐自定义字段未生效
10. login 接口，存在异步 session 问题，会出现报错日志。
11. 修复判断器 arrayAny 类型无判断条件可选
12. 修复视频音频自定义文件类型流程开始无文件链接变量
13. 用户输入框消息不转义成 Markdown 格式
14. 修复 AgentV2 部分上下文拼接错误。
15. login 接口安全风险。
16. 工作流工具未按预期连接到结束节点时，嵌套调用工作流工具会导致父工作流无法停止。
## 🛠️ 代码优化
1. 商业版开发时，monorepo 指向不同 react 导致需重装包。
file: ./content/guide/build/tools/system-plugins/upload_system_tool.en.mdx
meta: {
"title": "Upload System Tools Online",
"description": "FastGPT System Tool Online Upload Guide"
}
> Starting from FastGPT 4.14.0, system admins can upload and update system tools directly through the web interface for hot reloading.
## Permission Requirements
⚠️ **Important**: Only **root users** can use the online system tool upload feature.
* Make sure you are logged in with the `root` account
## Supported File Formats
* **File type**: `.pkg` files
* **File size**: Maximum 100 MB
* **File count**: Up to 15 files per upload
## Upload Steps
### 1. Access the Configuration Page
### 2. Prepare Tool Files
Before uploading, make sure your `.pkg` files are from the `dist/pkgs` folder, built by running `bun run build:pkg` in the fastgpt-plugin project.
### 3. Upload
1. Click the **"Import/Update"** button
2. In the dialog that appears, click the file selection area
3. Select your prepared `.pkg` tool files
4. After confirming the file details, click **"Confirm Import"**
### 4. Upload Process
* A success message will appear after the upload completes
* The page auto-refreshes and the new tools will appear in the tool list
## Features
### Tool Management
* **View tools**: All users can view installed system tools
* **Upload tools**: Only root users can upload new tools or update existing ones
* **Delete tools**: Only root users can delete uploaded tools
## FAQ
### Q: Can't see the "Import/Update" button
**Reason:** The current user is not a root user
**Solution:** Log in again with the root account
file: ./content/guide/build/tools/system-plugins/upload_system_tool.mdx
meta: {
"title": "如何在线上传系统工具",
"description": "FastGPT 系统工具在线上传指南"
}
> 从 FastGPT 4.14.0 版本开始，系统管理员可以通过 Web 界面直接上传和更新系统工具进行热更新
## 权限要求
⚠️ **重要提示**：只有 **root 用户** 才能使用在线上传系统工具功能。
* 确保您已使用 `root` 账户登录 FastGPT
## 支持的文件格式
* **文件类型**：`.pkg` 文件
* **文件大小**：最大 100 MB
* **文件数量**：每次最多上传 15 个文件
## 上传步骤
### 1. 进入配置页面
### 2. 准备工具文件
在上传之前，请确保您的 `.pkg` 文件是从 fastgpt-plugin 项目中通过 `bun run build:pkg` 命令打包后的 `dist/pkgs` 文件夹下得到的
### 3. 执行上传
1. 点击 **"导入/更新"** 按钮
2. 在弹出的对话框中，点击文件选择区域
3. 选择您准备好的 `.pkg` 工具文件
4. 确认文件信息无误后，点击 **"确认导入"**
### 4. 上传过程
* 上传成功后会显示成功提示
* 页面自动刷新，新工具会出现在工具列表中
## 功能特点
### 工具管理
* **查看工具**：所有用户都可以查看已安装的系统工具
* **上传工具**：仅 root 用户可以上传新工具或更新现有工具
* **删除工具**：仅 root 用户可以删除已上传的工具
## 常见问题
### Q: 无法看到"导入/更新"按钮
**原因：** 当前用户不是 root 用户
**解决方案：** 使用 root 账户重新登录
file: ./content/guide/build/workflow/nodes/ai_chat.en.mdx
meta: {
"title": "AI Chat",
"description": "FastGPT AI Chat node overview"
}
import { Alert } from '@/components/docs/Alert';
## Characteristics
* Can be added multiple times
* Trigger-based execution
* Core module
## Parameters
## AI Model
Configure available chat models via [config.json](../../../../self-host/config/model/intro.en.mdx)。
Click the AI model to configure its parameters.
For detailed parameter descriptions, see: [AI Parameter Configuration](../../general/ai_settings.en.mdx)
file: ./content/guide/build/workflow/nodes/ai_chat.mdx
meta: {
"title": "AI 对话",
"description": "FastGPT AI 对话模块介绍"
}
import { Alert } from '@/components/docs/Alert';
## 特点
* 可重复添加
* 触发执行
* 核心模块
## 参数说明
## AI模型
可以通过 [config.json](../../../../self-host/config/model/intro.mdx) 配置可选的对话模型。
点击AI模型后，可以配置模型的相关参数。
具体配置参数介绍可以参考: [AI参数配置说明](../../general/ai_settings.mdx)
file: ./content/guide/build/workflow/nodes/content_extract.en.mdx
meta: {
"title": "Text Content Extraction",
"description": "FastGPT Text Content Extraction node overview"
}
## Characteristics
* Can be added multiple times
* Requires manual configuration
* Trigger-based execution
* function\_call module
* Core module
## What It Does
Extracts structured data from text, typically used with the HTTP node for extended functionality. It can also perform direct extraction tasks such as translation.
## Parameters
### Extraction Requirement Description
Set a goal for the model describing what content needs to be extracted.
**Example 1**
> You are a lab appointment assistant. Extract the name, appointment time, and lab number from the conversation. Current time `{{cTime}}`
**Example 2**
> You are a Google search assistant. Extract search keywords from the conversation.
**Example 3**
> Translate my question directly into English without answering it.
### Chat History
Some chat history is usually needed for more complete extraction. For example, if the task requires a name, time, and lab name, the user might initially provide only the time and lab name. After being prompted for the missing info, the user provides their name. At that point, the previous record is needed to extract all 3 fields completely.
### Target Fields
Target fields correspond to extraction results. As shown above, each new field adds a corresponding output.
* **key**: Unique identifier for the field. Must not be duplicated.
* **Field description**: Describes what the field represents, e.g., name, time, search keyword, etc.
* **Required**: Whether the model is forced to extract this field. It may still return an empty string.
## Output
* **Complete extraction result**: A JSON string containing all extracted fields.
* **Target field extraction results**: All returned as string type.
file: ./content/guide/build/workflow/nodes/content_extract.mdx
meta: {
"title": "文本内容提取",
"description": "FastGPT 内容提取模块介绍"
}
## 特点
* 可重复添加
* 需要手动配置
* 触发执行
* function\_call 模块
* 核心模块
## 功能
从文本中提取结构化数据，通常是配合 HTTP 模块实现扩展。也可以做一些直接提取操作，例如：翻译。
## 参数说明
### 提取要求描述
顾名思义，给模型设置一个目标，需要提取哪些内容。
**示例 1**
> 你是实验室预约助手，从对话中提取出姓名，预约时间，实验室号。当前时间 `{{cTime}}`
**示例 2**
> 你是谷歌搜索助手，从对话中提取出搜索关键词
**示例 3**
> 将我的问题直接翻译成英文，不要回答问题
### 历史记录
通常需要一些历史记录，才能更完整的提取用户问题。例如上图中需要提供姓名、时间和实验室名，用户可能一开始只给了时间和实验室名，没有提供自己的姓名。再经过一轮缺失提示后，用户输入了姓名，此时需要结合上一次的记录才能完整的提取出 3 个内容。
### 目标字段
目标字段与提取的结果相对应，从上图可以看到，每增加一个字段，输出会增加一个对应的出口。
* **key**: 字段的唯一标识，不可重复！
* **字段描述**：描述该字段是关于什么的，例如：姓名、时间、搜索词等等。
* **必须**：是否强制模型提取该字段，可能提取出来是空字符串。
## 输出介绍
* **完整提取结果**: 一个 JSON 字符串，包含所有字段的提取结果。
* **目标字段提取结果**：类型均为字符串。
file: ./content/guide/build/workflow/nodes/coreferenceResolution.en.mdx
meta: {
"title": "Query Enhancement",
"description": "FastGPT Query Enhancement node overview and usage"
}
## Characteristics
* Can be added multiple times
* Has external input
* Trigger-based execution
## Background
In RAG, we perform embedding searches against the database based on the input query to find relevant content (Knowledge Base search).
During search -- especially in multi-turn conversations -- follow-up questions often fail to retrieve useful results. One reason is that Knowledge Base search only uses the "current" question. Consider this example:
When the user asks "What is the second point?", the system searches the Knowledge Base for exactly that phrase and finds nothing. The actual intended query is "What is the QA structure?". This is why we need a Query Enhancement node to refine the user's current question so the Knowledge Base search can return relevant results. With query enhancement applied:
## What It Does
Calls an AI model to complete and refine the user's current question. It primarily resolves coreferences (pronouns and vague references), making search queries more complete and reliable. This improves Knowledge Base search accuracy in multi-turn conversations.
The main challenge is that the model may not have a clear understanding of "completion" and often struggles to determine how to properly refine queries with long context.
file: ./content/guide/build/workflow/nodes/coreferenceResolution.mdx
meta: {
"title": "问题优化",
"description": "问题优化模块介绍和使用"
}
## 特点
* 可重复添加
* 有外部输入
* 触发执行
## 背景
在 RAG 中，我们需要根据输入的问题去数据库里执行 embedding 搜索，查找相关的内容，从而查找到相似的内容（简称知识库搜索）。
在搜索的过程中，尤其是连续对话的搜索，我们通常会发现后续的问题难以搜索到合适的内容，其中一个原因是知识库搜索只会使用“当前”的问题去执行。看下面的例子：
用户在提问“第二点是什么”的时候，只会去知识库里查找“第二点是什么”，压根查不到内容。实际上需要查询的是“QA 结构是什么”。因此我们需要引入一个【问题优化】模块，来对用户当前的问题进行补全，从而使得知识库搜索能够搜索到合适的内容。使用补全后效果如下：
## 功能
调用 AI 去对用户当前的问题进行补全。目前主要是补全“指代”词，使得检索词更加的完善可靠，从而增强上下文连续对话的知识库搜索能力。
遇到最大的难题在于：模型对于【补全】的概念可能不清晰，且对于长上下文往往无法准确的知道应该如何补全。
file: ./content/guide/build/workflow/nodes/custom_feedback.en.mdx
meta: {
"title": "Custom Feedback",
"description": "FastGPT Custom Feedback node overview"
}
This is a temporary module that will receive a more comprehensive redesign in the future.
## Characteristics
* Can be added multiple times
* No external input
* Auto-executed
| | |
| ------------------------------ | ------------------------------ |
|  |  |
|  |  |
## Overview
The Custom Feedback node adds a feedback tag to conversations, making it easier to analyze conversation data from the admin panel.
In debug mode, feedback content is not recorded. Instead it displays: `Auto feedback test: feedback content`.
In conversation mode (chat, shared window, or API calls with chatId), feedback content is recorded in the conversation log with a 60-second delay.
## Use Cases
The Custom Feedback node works like event tracking in software development, letting you observe and monitor data within conversations.
file: ./content/guide/build/workflow/nodes/custom_feedback.mdx
meta: {
"title": "自定义反馈",
"description": "自定义反馈模块介绍"
}
该模块为临时模块，后续会针对该模块进行更全面的设计。
## 特点
* 可重复添加
* 无外部输入
* 自动执行
| | |
| ------------------------------ | ------------------------------ |
|  |  |
|  |  |
## 介绍
自定义反馈模块，可以为你的对话增加一个反馈标记，从而方便在后台更好的分析对话的数据。
在调试模式下，不会记录反馈内容，而是直接提示: `自动反馈测试: 反馈内容`。
在对话模式（对话、分享窗口、带 chatId 的 API 调用）时，会将反馈内容记录到对话日志中。（会延迟60s记录）
## 作用
自定义反馈模块的功能类似于程序开发的`埋点`，便于你观测的对话中的数据。
file: ./content/guide/build/workflow/nodes/dataset_search.en.mdx
meta: {
"title": "Knowledge Base Search",
"description": "FastGPT Knowledge Base Search node overview"
}
For detailed parameters and internal logic, see: [FastGPT Knowledge Base Search](../../../dataset/rag.en.mdx)
## Characteristics
* Can be added multiple times (keeps connections tidy in complex workflows)
* Has external input
* Has static configuration
* Trigger-based execution
* Core module
## Parameters
### Input - Linked Knowledge Bases
Select one or more Knowledge Bases using the **same embedding model** for vector search.
### Input - Search Parameters
[View parameter details](../../../dataset/dataset_engine.en.mdx#搜索参数)
### Output - Referenced Content
Outputs references as an array with a possible length of 0. This means the output path will still execute even when no results are found.
file: ./content/guide/build/workflow/nodes/dataset_search.mdx
meta: {
"title": "知识库搜索",
"description": "FastGPT AI 知识库搜索模块介绍"
}
知识库搜索具体参数说明，以及内部逻辑请移步：[FastGPT知识库搜索方案](../../../dataset/rag.mdx)
## 特点
* 可重复添加（复杂编排时防止线太乱，可以更美观）
* 有外部输入
* 有静态配置
* 触发执行
* 核心模块
## 参数说明
### 输入 - 关联的知识库
可以选择一个或多个**相同向量模型**的知识库，用于向量搜索。
### 输入 - 搜索参数
[点击查看参数介绍](../../../dataset/dataset_engine.mdx#搜索参数)
### 输出 - 引用内容
以数组格式输出引用，长度可以为 0。意味着，即使没有搜索到内容，这个输出链路也会走通。
file: ./content/guide/build/workflow/nodes/document_parsing.en.mdx
meta: {
"title": "Document Parsing",
"description": "FastGPT Document Parsing node overview"
}
| | |
| --------------------------------- | --------------------------------- |
|  |  |
The Document Parsing component becomes available after enabling file upload.
## Features
## Use Cases
file: ./content/guide/build/workflow/nodes/document_parsing.mdx
meta: {
"title": "文档解析",
"description": "FastGPT 文档解析模块介绍"
}
| | |
| --------------------------------- | --------------------------------- |
|  |  |
开启文件上传后，可使用文档解析组件。
## 功能
## 作用
file: ./content/guide/build/workflow/nodes/form_input.en.mdx
meta: {
"title": "Form Input",
"description": "FastGPT Form Input node overview"
}
## Characteristics
* User interaction
* Can be added multiple times
* Trigger-based execution
## What It Does
The Form Input node is a user interaction node. When triggered, the conversation enters an "interactive" state -- the workflow state is saved and execution pauses until the user completes the interaction.
In the example above, when the Form Input node is triggered, the chat box is hidden and the conversation enters interactive mode.
After the user fills in the required fields and clicks submit, the node collects the form data and passes it to subsequent nodes.
## Use Cases
Precisely collect specific user information, then perform follow-up operations based on that data.
file: ./content/guide/build/workflow/nodes/form_input.mdx
meta: {
"title": "表单输入",
"description": "FastGPT 表单输入模块介绍"
}
## 特点
* 用户交互
* 可重复添加
* 触发执行
## 功能
「表单输入」节点属于用户交互节点，当触发这个节点时，对话会进入“交互”状态，会记录工作流的状态，等用户完成交互后，继续向下执行工作流
比如上图中的例子，当触发表单输入节点时，对话框隐藏，对话进入“交互状态”
当用户填完必填的信息并点击提交后，节点能够收集用户填写的表单信息，传递到后续的节点中使用
## 作用
能够精准收集需要的用户信息，再根据用户信息进行后续操作
file: ./content/guide/build/workflow/nodes/http.en.mdx
meta: {
"title": "HTTP Request",
"description": "FastGPT HTTP Request node overview"
}
import { Alert } from '@/components/docs/Alert';
## Characteristics
* Can be added multiple times
* Manual configuration
* Trigger-based execution
* Core of core modules
## Overview
The HTTP node sends an `HTTP` request to a specified URL. It works similarly to tools like Postman and ApiFox.
* Params are query parameters, commonly used in GET requests.
* Body is the request body, commonly used in POST/PUT requests.
* Headers are request headers for passing additional information.
* Custom variables can receive outputs from upstream nodes.
* All 3 data types support variable references via `{{}}`.
* The URL also supports `{{}}` variable references.
* Variables come from `global variables`, `system variables`, and `upstream node outputs`.
## Parameter Structure
### System Variables
Hover over the question mark next to `Request Parameters` to see available variables.
* appId: Application ID
* chatId: Current conversation ID (not available in test mode)
* responseChatItemId: Response message ID in the current conversation (not available in test mode)
* variables: Global variables for the current conversation
* cTime: Current time
* histories: Chat history (defaults to max 10 entries, length is not configurable)
### Params, Headers
Usage is the same as Postman and ApiFox.
Use `{{key}}` to reference variables. For example:
| key | value |
| ------------- | ------------------ |
| appId | `{{appId}}` |
| Authorization | Bearer `{{token}}` |
### Body
Only takes effect with certain request types.
Write a custom JSON body and use `{{key}}` to reference variables. For example:
```json
{
"string": "字符串",
"number": 123,
"boolean": true,
"array": [1, 2, 3],
"obj": {
"name": "FastGPT",
"url": "https://fastgpt.io"
}
}
```
When referencing a `string` in the Body, wrap it in quotes: `"{{string}}"`.
```json
{
"string": "{{string}}",
"token": "Bearer {{string}}",
"number": {{number}},
"boolean": {{boolean}},
"array": [{{number}}, "{{string}}"],
"array2": {{array}},
"object": {{obj}}
}
```
```json
{
"string": "字符串",
"token": "Bearer 字符串",
"number": 123,
"boolean": true,
"array": [123, "字符串"],
"array2": [1, 2, 3],
"object": {
"name": "FastGPT",
"url": "https://fastgpt.io"
}
}
```
### Extracting Return Values
As shown in the image, FastGPT lets you add multiple return values. These don't represent the raw API response -- they define `how to parse the API response`. You can use `JSON path` syntax to `extract` values from the response.
Syntax reference: [https://github.com/JSONPath-Plus/JSONPath?tab=readme-ov-file](https://github.com/JSONPath-Plus/JSONPath?tab=readme-ov-file)
```json
{
"message": "测试",
"data": {
"user": {
"name": "xxx",
"age": 12
},
"list": [
{
"name": "xxx",
"age": 50
},
[{ "test": 22 }]
],
"psw": "xxx"
}
}
```
```json
{
"$.message": "测试",
"$.data.user": { "name": "xxx", "age": 12 },
"$.data.user.name": "xxx",
"$.data.user.age": 12,
"$.data.list": [{ "name": "xxx", "age": 50 }, [{ "test": 22 }]],
"$.data.list[0]": { "name": "xxx", "age": 50 },
"$.data.list[0].name": "xxx",
"$.data.list[0].age": 50,
"$.data.list[1]": [{ "test": 22 }],
"$.data.list[1][0]": { "test": 22 },
"$.data.list[1][0].test": 22,
"$.data.psw": "xxx"
}
```
Configure the `key` to extract values from FastGPT's parsed format, following standard JavaScript object access rules. For example:
1. To get the `message` content, set the `key` to `message`.
2. To get the user's name, set the `key` to `data.user.name`.
3. To get the second element in the list, set the `key` to `data.list[1]`. If you select string as the output type, it will automatically return the JSON string `[ { "test": 22 } ]`.
### Auto-format Output
Starting from FastGPT v4.6.8, output formatting was added, primarily converting `JSON` to `string`. If you select `string` as the output type, the HTTP node will convert the corresponding key's value to a JSON string. This lets you pipe HTTP output directly into a `Text Processing` node, append appropriate prompts, and feed the result into `AI Chat`.
The HTTP node is extremely versatile. You can integrate public APIs to extend your workflow
capabilities.
## HTTP Service Integration Example
Here is a POST request service example:
```ts
type RequestType = {
appId: string;
appointment: string;
action: 'post' | 'delete' | 'put' | 'get';
};
export async function handleAppointmentRequest(body: RequestType) {
try {
const { appId, appointment, action } = body;
const parseBody = JSON.parse(appointment);
if (action === 'get') {
return await getRecord(appId, parseBody);
}
if (action === 'post') {
return await createRecord(appId, parseBody);
}
if (action === 'put') {
return await putRecord(appId, parseBody);
}
if (action === 'delete') {
return await removeRecord(appId, parseBody);
}
return {
response: 'Error'
};
} catch (err) {
return {
response: 'Error'
};
}
}
```
## Use Cases
The HTTP node enables unlimited extensibility, such as:
* Database operations
* External data source calls
* Web searches
* Sending emails
* ....
file: ./content/guide/build/workflow/nodes/http.mdx
meta: {
"title": "HTTP 请求",
"description": "FastGPT HTTP 模块介绍"
}
import { Alert } from '@/components/docs/Alert';
## 特点
* 可重复添加
* 手动配置
* 触发执行
* 核中核模块
## 介绍
HTTP 模块会向对应的地址发送一个 `HTTP` 请求，实际操作与 Postman 和 ApiFox 这类直流工具使用差不多。
* Params 为路径请求参数，GET 请求中用的居多。
* Body 为请求体，POST/PUT 请求中用的居多。
* Headers 为请求头，用于传递一些特殊的信息。
* 自定义变量中可以接收前方节点的输出作为变量
* 3 种数据中均可以通过 `{{}}` 来引用变量。
* URL 也可以通过 `{{}}` 来引用变量。
* 变量来自于 `全局变量`、`系统变量`、`前方节点输出`
## 参数结构
### 系统变量说明
你可以将鼠标放置在 `请求参数` 旁边的问号中，里面会提示你可用的变量。
* appId: 应用的 ID
* chatId: 当前对话的 ID，测试模式下不存在。
* responseChatItemId: 当前对话中，响应的消息 ID，测试模式下不存在。
* variables: 当前对话的全局变量。
* cTime: 当前时间。
* histories: 历史记录（默认最多取 10 条，无法修改长度）
### Params, Headers
不多描述，使用方法和 Postman, ApiFox 基本一致。
可通过 `{{key}}` 来引入变量。例如：
| key | value |
| ------------- | ------------------ |
| appId | `{{appId}}` |
| Authorization | Bearer `{{token}}` |
### Body
只有特定请求类型下会生效。
可以写一个 `自定义的 Json`，并通过 `{{key}}` 来引入变量。例如：
```json
{
"string": "字符串",
"number": 123,
"boolean": true,
"array": [1, 2, 3],
"obj": {
"name": "FastGPT",
"url": "https://fastgpt.io"
}
}
```
注意，在 Body 中，你如果引用 `字符串`，则需要加上 `""`，例如：`"{{string}}"`。
```json
{
"string": "{{string}}",
"token": "Bearer {{string}}",
"number": {{number}},
"boolean": {{boolean}},
"array": [{{number}}, "{{string}}"],
"array2": {{array}},
"object": {{obj}}
}
```
```json
{
"string": "字符串",
"token": "Bearer 字符串",
"number": 123,
"boolean": true,
"array": [123, "字符串"],
"array2": [1, 2, 3],
"object": {
"name": "FastGPT",
"url": "https://fastgpt.io"
}
}
```
### 如何获取返回值
从图中可以看出，FastGPT 可以添加多个返回值，这个返回值并不代表接口的返回值，而是代表 `如何解析接口返回值`，可以通过 `JSON path` 的语法，来 `提取` 接口响应的值。
语法可以参考: [https://github.com/JSONPath-Plus/JSONPath?tab=readme-ov-file](https://github.com/JSONPath-Plus/JSONPath?tab=readme-ov-file)
```json
{
"message": "测试",
"data": {
"user": {
"name": "xxx",
"age": 12
},
"list": [
{
"name": "xxx",
"age": 50
},
[{ "test": 22 }]
],
"psw": "xxx"
}
}
```
```json
{
"$.message": "测试",
"$.data.user": { "name": "xxx", "age": 12 },
"$.data.user.name": "xxx",
"$.data.user.age": 12,
"$.data.list": [{ "name": "xxx", "age": 50 }, [{ "test": 22 }]],
"$.data.list[0]": { "name": "xxx", "age": 50 },
"$.data.list[0].name": "xxx",
"$.data.list[0].age": 50,
"$.data.list[1]": [{ "test": 22 }],
"$.data.list[1][0]": { "test": 22 },
"$.data.list[1][0].test": 22,
"$.data.psw": "xxx"
}
```
你可以配置对应的 `key` 来从 `FastGPT 转化后的格式` 获取需要的值，该规则遵守 JS 的对象取值规则。例如：
1. 获取 `message` 的内容，那么你可以配置 `message` 的 `key` 为 `message`，这样就可以获取到 `message` 的内容。
2. 获取 `user的name`，则 `key` 可以为：`data.user.name`。
3. 获取 list 中第二个元素，则 `key` 可以为：`data.list[1]`，然后输出类型选择字符串，则获自动获取到 `[ { "test": 22 } ]` 的 `json` 字符串。
### 自动格式化输出
FastGPT v4.6.8 后，加入了出参格式化功能，主要以 `json` 格式化成 `字符串` 为主。如果你的输出类型选择了 `字符串`，则会将 `HTTP` 对应 `key` 的值，转成 `json` 字符串进行输出。因此，未来你可以直接从 `HTTP` 接口输出内容至 `文本加工` 中，然后拼接适当的提示词，最终输入给 `AI对话`。
HTTP 模块非常强大，你可以对接一些公开的 API，来提高编排的功能。
## HTTP 对接业务服务示例
下面是一个 POST 请求服务示例：
```ts
type RequestType = {
appId: string;
appointment: string;
action: 'post' | 'delete' | 'put' | 'get';
};
export async function handleAppointmentRequest(body: RequestType) {
try {
const { appId, appointment, action } = body;
const parseBody = JSON.parse(appointment);
if (action === 'get') {
return await getRecord(appId, parseBody);
}
if (action === 'post') {
return await createRecord(appId, parseBody);
}
if (action === 'put') {
return await putRecord(appId, parseBody);
}
if (action === 'delete') {
return await removeRecord(appId, parseBody);
}
return {
response: '异常'
};
} catch (err) {
return {
response: '异常'
};
}
}
```
## 作用
通过 HTTP 模块你可以无限扩展，比如：
* 操作数据库
* 调用外部数据源
* 执行联网搜索
* 发送邮箱
* ……
file: ./content/guide/build/workflow/nodes/knowledge_base_search_merge.en.mdx
meta: {
"title": "Knowledge Base Search Merge",
"description": "FastGPT Knowledge Base Search Merge node overview"
}
## What It Does
Merges search results from multiple Knowledge Bases into a single output, re-ranks them using RRF (Reciprocal Rank Fusion), and supports max token filtering.
## Usage
The AI Chat node can only accept one Knowledge Base reference input. If you call multiple Knowledge Bases, you cannot directly reference all of them (as shown below).
Use **Knowledge Base Search Merge** to combine results from multiple Knowledge Bases into one.
## Example Use Cases
1. After question classification, search different Knowledge Bases per category, then feed the merged results to a single AI Chat node. This avoids adding a separate AI Chat node to each branch.
file: ./content/guide/build/workflow/nodes/knowledge_base_search_merge.mdx
meta: {
"title": "知识库搜索引用合并",
"description": "FastGPT 知识库搜索引用合并模块介绍"
}
## 作用
将多个知识库搜索结果合并成一个结果进行输出，并会通过 RRF 进行重新排序（根据排名情况），并且支持最大 tokens 过滤。
## 使用方法
AI对话只能接收一个知识库引用内容。因此，如果调用了多个知识库，无法直接引用所有知识库（如下图）
使用**知识库搜索引用合并**，可以把多个知识库的搜索结果合在一起。
## 可用例子：
1. 经过问题分类后对不同知识库进行检索，然后统一给一个 AI 进行回答，此时可以用到合并，不需要每个分支都添加一个 AI 对话。
file: ./content/guide/build/workflow/nodes/loop.en.mdx
meta: {
"title": "Batch Processing",
"description": "FastGPT Batch Processing node overview and usage"
}
## Node Overview
The **Batch Processing** node was introduced in FastGPT V4.8.11. It allows workflows to iterate over array-type input data, processing one element at a time and automatically executing subsequent nodes until the entire array is processed.
This node is inspired by loop structures in programming languages, presented in a visual format.
> In programming terms, nodes are like functions or API endpoints -- each one is a **step**. By connecting multiple nodes together, you build a step-by-step process that produces the final AI output.
The **Batch Processing** node is essentially a function whose job is to automate repeated execution of a specific workflow.
## Core Features
1. **Array Batch Processing**
* Accepts array-type data input
* Automatically iterates through array elements
* Maintains processing order
* Supports parallel processing for performance optimization
2. **Automatic Iteration**
* Automatically triggers downstream nodes
* Supports conditional termination
* Supports loop counting
* Maintains execution context
3. **Works with Other Nodes**
* AI Chat nodes
* HTTP Request nodes
* Content Extraction nodes
* Conditional nodes
## Use Cases
The **Batch Processing** node extends workflow capabilities through automation, enabling FastGPT to handle batch tasks and complex data processing pipelines. It significantly improves efficiency when processing large-scale data or scenarios requiring multiple iterations.
The **Batch Processing** node is ideal for:
1. **Batch Data Processing**
* Batch text translation
* Batch document summarization
* Batch content generation
2. **Data Pipeline Processing**
* Analyzing search results one by one
* Processing Knowledge Base retrieval results individually
* Processing array data from HTTP responses item by item
3. **Recursive or Iterative Tasks**
* Long text segmented processing
* Multi-round content refinement
* Chained data processing
## Usage
### Input Parameters
The **Batch Processing** node requires two core inputs:
1. **Array (Required)**: An array-type input, which can be:
* String array (`Array`)
* Number array (`Array`)
* Boolean array (`Array`)
* Object array (`Array