fix: Component sequence adjustment

Co-authored-by: xiaoc <648844981@qq.com>

.dockerignore

@@ -1,2 +1,4 @@
 .git*
 .idea*
+*.md
+.venv/

.github/dependabot.yml

@@ -0,0 +1,9 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      timezone: "Asia/Shanghai"
+      day: "friday"
+    target-branch: "v3"

.github/workflows/build-and-push-python-pg.yml

@@ -14,33 +14,19 @@ on:
           - linux/amd64,linux/arm64
 jobs:
   build-and-push-python-pg-to-ghcr:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-      - name: Check Disk Space
-        run: df -h
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          tool-cache: true
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-      - name: Check Disk Space
-        run: df -h
       - name: Checkout
         uses: actions/checkout@v4
         with:
-          ref: main
+          ref: ${{ github.ref_name }}
       - name: Prepare
         id: prepare
         run: |
-          DOCKER_IMAGE=ghcr.io/1panel-dev/maxkb-python-pg
+          DOCKER_IMAGE=ghcr.io/1panel-dev/maxkb-base
           DOCKER_PLATFORMS=${{ github.event.inputs.architecture }}
-          TAG_NAME=python3.11-pg15.8
+          TAG_NAME=python3.11-pg17.6
-          DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME} --tag ${DOCKER_IMAGE}:latest"
+          DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME}"
           echo ::set-output name=docker_image::${DOCKER_IMAGE}
           echo ::set-output name=version::${TAG_NAME}
           echo ::set-output name=buildx_args::--platform ${DOCKER_PLATFORMS} --no-cache \
@@ -51,8 +37,7 @@ jobs:
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
         with:
-          # Until https://github.com/tonistiigi/binfmt/issues/215
+          cache-image: false
-          image: tonistiigi/binfmt:qemu-v7.0.0-28
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
       - name: Login to GitHub Container Registry
@@ -63,4 +48,4 @@ jobs:
           password: ${{ secrets.GH_TOKEN }}
       - name: Docker Buildx (build-and-push)
         run: |
-          docker buildx build --output "type=image,push=true" ${{ steps.prepare.outputs.buildx_args }} -f installer/Dockerfile-python-pg
+          docker buildx build --output "type=image,push=true" ${{ steps.prepare.outputs.buildx_args }} -f installer/Dockerfile-base

.github/workflows/build-and-push-vector-model.yml

@@ -5,7 +5,7 @@ on:
     inputs:
       dockerImageTag:
         description: 'Docker Image Tag'
-        default: 'v1.0.1'
+        default: 'v2.0.3'
         required: true
       architecture:
         description: 'Architecture'
@@ -19,26 +19,12 @@ on:
 
 jobs:
   build-and-push-vector-model-to-ghcr:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-      - name: Check Disk Space
-        run: df -h
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          tool-cache: true
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-      - name: Check Disk Space
-        run: df -h
       - name: Checkout
         uses: actions/checkout@v4
         with:
-          ref: main
+          ref: ${{ github.ref_name }}
       - name: Prepare
         id: prepare
         run: |
@@ -56,8 +42,7 @@ jobs:
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
         with:
-          # Until https://github.com/tonistiigi/binfmt/issues/215
+          cache-image: false
-          image: tonistiigi/binfmt:qemu-v7.0.0-28
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
       - name: Login to GitHub Container Registry

.github/workflows/build-and-push.yml

@@ -1,13 +1,13 @@
 name: build-and-push
 
-run-name: 构建镜像并推送仓库 ${{ github.event.inputs.dockerImageTag }} (${{ github.event.inputs.registry }})
+run-name: 构建镜像并推送仓库 ${{ github.event.inputs.dockerImageTag }} (${{ github.event.inputs.registry }}) (${{ github.event.inputs.architecture }})
 
 on:
   workflow_dispatch:
     inputs:
       dockerImageTag:
         description: 'Image Tag'
-        default: 'v1.10.3-dev'
+        default: 'v2.4.0-dev'
         required: true
       dockerImageTagWithLatest:
         description: '是否发布latest tag（正式发版时选择，测试版本切勿选择）'
@@ -36,26 +36,12 @@ on:
 jobs:
   build-and-push-to-fit2cloud-registry:
     if: ${{ contains(github.event.inputs.registry, 'fit2cloud') }}
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-      - name: Check Disk Space
+      - name: Clear Work Dir
-        run: df -h
+        run: |
-      - name: Free Disk Space (Ubuntu)
+          ls -la
-        uses: jlumbroso/free-disk-space@main
+          rm -rf -- ./* ./.??*
-        with:
-          tool-cache: true
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-      - name: Check Disk Space
-        run: df -h
-      - name: Set Swap Space
-        uses: pierotofy/set-swap-space@master
-        with:
-          swap-size-gb: 8
       - name: Checkout
         uses: actions/checkout@v4
         with:
@@ -68,24 +54,19 @@ jobs:
           TAG_NAME=${{ github.event.inputs.dockerImageTag }}
           TAG_NAME_WITH_LATEST=${{ github.event.inputs.dockerImageTagWithLatest }}
           if [[ ${TAG_NAME_WITH_LATEST} == 'true' ]]; then            
-            DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME} --tag ${DOCKER_IMAGE}:latest"
+            DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME} --tag ${DOCKER_IMAGE}:${TAG_NAME%%.*} --tag ${DOCKER_IMAGE}:latest"
           else
             DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME}"
           fi
-          echo ::set-output name=buildx_args::--platform ${DOCKER_PLATFORMS} --memory-swap -1 \
+          echo "buildx_args=--platform ${DOCKER_PLATFORMS} --memory-swap -1 \
-            --build-arg DOCKER_IMAGE_TAG=${{ github.event.inputs.dockerImageTag }} --build-arg BUILD_AT=$(TZ=Asia/Shanghai date +'%Y-%m-%dT%H:%M') --build-arg GITHUB_COMMIT=${GITHUB_SHA::8} --no-cache \
+            --build-arg DOCKER_IMAGE_TAG=${{ github.event.inputs.dockerImageTag }} --build-arg BUILD_AT=$(TZ=Asia/Shanghai date +'%Y-%m-%dT%H:%M') --build-arg GITHUB_COMMIT=`git rev-parse --short HEAD` --no-cache \
-            ${DOCKER_IMAGE_TAGS} .
+            ${DOCKER_IMAGE_TAGS} ." >> $GITHUB_OUTPUT
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
         with:
-          # Until https://github.com/tonistiigi/binfmt/issues/215
+          cache-image: false
-          image: tonistiigi/binfmt:qemu-v7.0.0-28
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
-        with:
-          buildkitd-config-inline: |
-            [worker.oci]
-              max-parallelism = 1
       - name: Login to GitHub Container Registry
         uses: docker/login-action@v3
         with:
@@ -98,32 +79,25 @@ jobs:
           registry: ${{ secrets.FIT2CLOUD_REGISTRY_HOST }}
           username: ${{ secrets.FIT2CLOUD_REGISTRY_USERNAME }}
           password: ${{ secrets.FIT2CLOUD_REGISTRY_PASSWORD }}
+      - name: Build Web
+        run: |
+          docker buildx build --no-cache --target web-build --output type=local,dest=./web-build-output . -f installer/Dockerfile
+          rm -rf ./ui
+          cp -r ./web-build-output/ui ./
+          rm -rf ./web-build-output
       - name: Docker Buildx (build-and-push)
         run: |
+          sudo sync && echo 3 | sudo tee /proc/sys/vm/drop_caches && free -m
           docker buildx build --output "type=image,push=true" ${{ steps.prepare.outputs.buildx_args }} -f installer/Dockerfile
 
   build-and-push-to-dockerhub:
     if: ${{ contains(github.event.inputs.registry, 'dockerhub') }}
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-      - name: Check Disk Space
+      - name: Clear Work Dir
-        run: df -h
+        run: |
-      - name: Free Disk Space (Ubuntu)
+          ls -la
-        uses: jlumbroso/free-disk-space@main
+          rm -rf -- ./* ./.??*
-        with:
-          tool-cache: true
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-      - name: Check Disk Space
-        run: df -h
-      - name: Set Swap Space
-        uses: pierotofy/set-swap-space@master
-        with:
-          swap-size-gb: 8
       - name: Checkout
         uses: actions/checkout@v4
         with:
@@ -136,24 +110,19 @@ jobs:
           TAG_NAME=${{ github.event.inputs.dockerImageTag }}          
           TAG_NAME_WITH_LATEST=${{ github.event.inputs.dockerImageTagWithLatest }}
           if [[ ${TAG_NAME_WITH_LATEST} == 'true' ]]; then            
-            DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME} --tag ${DOCKER_IMAGE}:latest"
+            DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME} --tag ${DOCKER_IMAGE}:${TAG_NAME%%.*} --tag ${DOCKER_IMAGE}:latest"
           else
             DOCKER_IMAGE_TAGS="--tag ${DOCKER_IMAGE}:${TAG_NAME}"
           fi
-          echo ::set-output name=buildx_args::--platform ${DOCKER_PLATFORMS} --memory-swap -1 \
+          echo "buildx_args=--platform ${DOCKER_PLATFORMS} --memory-swap -1 \
-            --build-arg DOCKER_IMAGE_TAG=${{ github.event.inputs.dockerImageTag }} --build-arg BUILD_AT=$(TZ=Asia/Shanghai date +'%Y-%m-%dT%H:%M') --build-arg GITHUB_COMMIT=${GITHUB_SHA::8} --no-cache \
+            --build-arg DOCKER_IMAGE_TAG=${{ github.event.inputs.dockerImageTag }} --build-arg BUILD_AT=$(TZ=Asia/Shanghai date +'%Y-%m-%dT%H:%M') --build-arg GITHUB_COMMIT=`git rev-parse --short HEAD` --no-cache \
-            ${DOCKER_IMAGE_TAGS} .
+            ${DOCKER_IMAGE_TAGS} ." >> $GITHUB_OUTPUT
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
         with:
-          # Until https://github.com/tonistiigi/binfmt/issues/215
+          cache-image: false
-          image: tonistiigi/binfmt:qemu-v7.0.0-28
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
-        with:
-          buildkitd-config-inline: |
-            [worker.oci]
-              max-parallelism = 1
       - name: Login to GitHub Container Registry
         uses: docker/login-action@v3
         with:
@@ -165,6 +134,13 @@ jobs:
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build Web
+        run: |
+          docker buildx build --no-cache --target web-build --output type=local,dest=./web-build-output . -f installer/Dockerfile
+          rm -rf ./ui
+          cp -r ./web-build-output/ui ./
+          rm -rf ./web-build-output
       - name: Docker Buildx (build-and-push)
         run: |
+          sudo sync && echo 3 | sudo tee /proc/sys/vm/drop_caches && free -m
           docker buildx build --output "type=image,push=true" ${{ steps.prepare.outputs.buildx_args }} -f installer/Dockerfile

.github/workflows/typos_check.yml

@@ -1,8 +1,7 @@
 name: Typos Check
 on:
+  workflow_dispatch:
   push:
-    branches:
-      - main
   pull_request:
     types: [opened, synchronize, reopened]
 
@@ -12,7 +11,21 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout Actions Repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
-
+      with:
+        ref: ${{ github.ref_name }}
+    - name: Create config file
+      run: |
+        cat <<EOF > typo-check-config.toml
+        [files]
+        extend-exclude = [
+          "**/*_svg",
+          "**/migrations/**",
+          "**/loopEdge.ts",
+          "**/edge.ts",
+        ]
+        EOF
     - name: Check spelling
       uses: crate-ci/typos@master
+      with:
+        config: ./typo-check-config.toml

.gitignore

@@ -137,9 +137,9 @@ celerybeat.pid
 # Environments
 .env
 .venv
-env/
+# env/
 venv/
-ENV/
+# ENV/
 env.bak/
 venv.bak/
 
@@ -183,5 +183,10 @@ apps/xpack
 data
 .dev
 poetry.lock
-apps/setting/models_provider/impl/*/icon/
+uv.lock
+apps/models_provider/impl/*/icon/
+apps/models_provider/impl/tencent_model_provider/credential/stt.py
+apps/models_provider/impl/tencent_model_provider/model/stt.py
 tmp/
+config.yml
+.SANDBOX_BANNED_HOSTS

.typos.toml

@@ -1,4 +0,0 @@
-[files]
-extend-exclude = [
-    'apps/setting/models_provider/impl/*/icon/*'
-]

README.md

@@ -1,5 +1,6 @@
 <p align="center"><img src= "https://github.com/1Panel-dev/maxkb/assets/52996290/c0694996-0eed-40d8-b369-322bf2a380bf" alt="MaxKB" width="300" /></p>
-<h3 align="center">Ready-to-use AI Chatbot</h3>
+<h3 align="center">Open-source platform for building enterprise-grade agents</h3>
+<h3 align="center">强大易用的企业级智能体平台</h3>
 <p align="center"><a href="https://trendshift.io/repositories/9113" target="_blank"><img src="https://trendshift.io/api/badge/repositories/9113" alt="1Panel-dev%2FMaxKB | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a></p>
 <p align="center">
   <a href="https://www.gnu.org/licenses/gpl-3.0.html#license-text"><img src="https://img.shields.io/github/license/1Panel-dev/maxkb?color=%231890FF" alt="License: GPL v3"></a>
@@ -10,10 +11,10 @@
 </p>
 <hr/>
 
-MaxKB = Max Knowledge Base, it is a ready-to-use AI chatbot that integrates Retrieval-Augmented Generation (RAG) pipelines, supports robust workflows, and provides advanced MCP tool-use capabilities. MaxKB is widely applied in scenarios such as intelligent customer service, corporate internal knowledge bases, academic research, and education.
+MaxKB = Max Knowledge Brain, it is an open-source platform for building enterprise-grade agents. MaxKB integrates Retrieval-Augmented Generation (RAG) pipelines, supports robust workflows, and provides advanced MCP tool-use capabilities. MaxKB is widely applied in scenarios such as intelligent customer service, corporate internal knowledge bases, academic research, and education.
 
-- **RAG Pipeline**: Supports direct uploading of documents / automatic crawling of online documents, with features for automatic text splitting, vectorization, and RAG (Retrieval-Augmented Generation). This effectively reduces hallucinations in large models, providing a superior smart Q&A interaction experience.
+- **RAG Pipeline**: Supports direct uploading of documents / automatic crawling of online documents, with features for automatic text splitting, vectorization. This effectively reduces hallucinations in large models, providing a superior smart Q&A interaction experience.
-- **Flexible Orchestration**: Equipped with a powerful workflow engine, function library and MCP tool-use, enabling the orchestration of AI processes to meet the needs of complex business scenarios. 
+- **Agentic Workflow**: Equipped with a powerful workflow engine, function library and MCP tool-use, enabling the orchestration of AI processes to meet the needs of complex business scenarios.
 - **Seamless Integration**: Facilitates zero-coding rapid integration into third-party business systems, quickly equipping existing systems with intelligent Q&A capabilities to enhance user satisfaction.
 - **Model-Agnostic**: Supports various large models, including private models (such as DeepSeek, Llama, Qwen, etc.) and public models (like OpenAI, Claude, Gemini, etc.).
 - **Multi Modal**: Native support for input and output text, image, audio and video.
@@ -23,7 +24,7 @@ MaxKB = Max Knowledge Base, it is a ready-to-use AI chatbot that integrates Retr
 Execute the script below to start a MaxKB container using Docker:
 
 ```bash
-docker run -d --name=maxkb --restart=always -p 8080:8080 -v ~/.maxkb:/var/lib/postgresql/data -v ~/.python-packages:/opt/maxkb/app/sandbox/python-packages 1panel/maxkb
+docker run -d --name=maxkb --restart=always -p 8080:8080 -v ~/.maxkb:/opt/maxkb 1panel/maxkb
 ```
 
 Access MaxKB web interface at `http://your_server_ip:8080` with default admin credentials:
@@ -31,18 +32,18 @@ Access MaxKB web interface at `http://your_server_ip:8080` with default admin cr
 - username: admin
 - password: MaxKB@123..
 
-中国用户如遇到 Docker 镜像 Pull 失败问题，请参照该 [离线安装文档](https://maxkb.cn/docs/installation/offline_installtion/) 进行安装。
+中国用户如遇到 Docker 镜像 Pull 失败问题，请参照该 [离线安装文档](https://maxkb.cn/docs/v2/installation/offline_installtion/) 进行安装。
 
 ## Screenshots
 
 <table style="border-collapse: collapse; border: 1px solid black;">
   <tr>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://maxkb.hk/images/overview.png" alt="MaxKB Demo1"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/eb285512-a66a-4752-8941-c65ed1592238" alt="MaxKB Demo1"   /></td>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://maxkb.hk/images/screenshot-models.png" alt="MaxKB Demo2"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/f732f1f5-472c-4fd2-93c1-a277eda83d04" alt="MaxKB Demo2"   /></td>
   </tr>
   <tr>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://maxkb.hk/images/screenshot-knowledge.png" alt="MaxKB Demo3"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/c927474a-9a23-4830-822f-5db26025c9b2" alt="MaxKB Demo3"   /></td>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://maxkb.hk/images/screenshot-function.png" alt="MaxKB Demo4"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/e6268996-a46d-4e58-9f30-31139df78ad2" alt="MaxKB Demo4"   /></td>
   </tr>
 </table>
 
@@ -53,69 +54,6 @@ Access MaxKB web interface at `http://your_server_ip:8080` with default admin cr
 - LLM Framework：[LangChain](https://www.langchain.com/)
 - Database：[PostgreSQL + pgvector](https://www.postgresql.org/)
 
-## Feature Comparison
-
-MaxKB is positioned as an Ready-to-use RAG (Retrieval-Augmented Generation) intelligent Q&A application, rather than a middleware platform for building large model applications. The following table is merely a comparison from a functional perspective.
-
-<table style="width: 100%;">
-  <tr>
-    <th align="center">Feature</th>
-    <th align="center">LangChain</th>
-    <th align="center">Dify.AI</th>
-    <th align="center">Flowise</th>
-    <th align="center">MaxKB <br>（Built upon LangChain）</th>
-  </tr>
-  <tr>
-    <td align="center">Supported LLMs</td>
-    <td align="center">Rich Variety</td>
-    <td align="center">Rich Variety</td>
-    <td align="center">Rich Variety</td>
-    <td align="center">Rich Variety</td>
-  </tr>
-  <tr>
-    <td align="center">RAG Engine</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-  </tr>
-  <tr>
-    <td align="center">Agent</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-    <td align="center">✅</td>
-  </tr>
-  <tr>
-    <td align="center">Workflow</td>
-    <td align="center">❌</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-  </tr>
-  <tr>
-    <td align="center">Observability</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-    <td align="center">✅</td>
-  </tr>
-  <tr>
-    <td align="center">SSO/Access control</td>
-    <td align="center">❌</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-    <td align="center">✅ (Pro)</td>
-  </tr>
-  <tr>
-    <td align="center">On-premise Deployment</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-  </tr>
-</table>
-
 ## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=1Panel-dev/MaxKB&type=Date)](https://star-history.com/#1Panel-dev/MaxKB&Date)

README_CN.md

@@ -1,25 +1,25 @@
 <p align="center"><img src= "https://github.com/1Panel-dev/maxkb/assets/52996290/c0694996-0eed-40d8-b369-322bf2a380bf" alt="MaxKB" width="300" /></p>
-<h3 align="center">基于大模型和 RAG 的知识库问答系统</h3>
+<h3 align="center">强大易用的企业级智能体平台</h3>
-<h4 align="center">Ready-to-use, flexible RAG Chatbot</h4>
 <p align="center">
     <a href="https://trendshift.io/repositories/9113" target="_blank"><img src="https://trendshift.io/api/badge/repositories/9113" alt="1Panel-dev%2FMaxKB | Trendshift" style="width: 250px; height: auto;" /></a>
-    <a href="https://market.aliyun.com/products/53690006/cmjj00067609.html?userCode=kmemb8jp" target="_blank"><img src="https://img.alicdn.com/imgextra/i2/O1CN01H5JIwY1rZ0OobDjnJ_!!6000000005644-2-tps-1000-216.png" alt="1Panel-dev%2FMaxKB | Aliyun" style="width: 250px; height: auto;" /></a>
 </p>
 <p align="center">
   <a href="README_EN.md"><img src="https://img.shields.io/badge/English_README-blue" alt="English README"></a>
-  <a href="https://www.gnu.org/licenses/gpl-3.0.html#license-text"><img src="https://img.shields.io/github/license/1Panel-dev/maxkb" alt="License: GPL v3"></a>
+  <a href="https://www.gnu.org/licenses/gpl-3.0.html#license-text"><img src="https://img.shields.io/github/license/1Panel-dev/maxkb?color=%231890FF" alt="License: GPL v3"></a>
   <a href="https://github.com/1Panel-dev/maxkb/releases/latest"><img src="https://img.shields.io/github/v/release/1Panel-dev/maxkb" alt="Latest release"></a>
   <a href="https://github.com/1Panel-dev/maxkb"><img src="https://img.shields.io/github/stars/1Panel-dev/maxkb?style=flat-square" alt="Stars"></a>
   <a href="https://hub.docker.com/r/1panel/maxkb"><img src="https://img.shields.io/docker/pulls/1panel/maxkb?label=downloads" alt="Download"></a>
+  <a href="https://gitee.com/fit2cloud-feizhiyun/MaxKB"><img src="https://gitee.com/fit2cloud-feizhiyun/MaxKB/badge/star.svg?theme=gvp" alt="Gitee Stars"></a>
+  <a href="https://gitcode.com/feizhiyun/MaxKB"><img src="https://gitcode.com/feizhiyun/MaxKB/star/badge.svg" alt="GitCode Stars"></a>
 </p>
 <hr/>
 
-MaxKB = Max Knowledge Base，是一款开箱即用的 RAG Chatbot，具备强大的工作流和 MCP 工具调用能力。它支持对接各种主流大语言模型（LLMs），广泛应用于智能客服、企业内部知识库、学术研究与教育等场景。
+MaxKB = Max Knowledge Brain，是一个强大易用的企业级智能体平台，致力于解决企业 AI 落地面临的技术门槛高、部署成本高、迭代周期长等问题，助力企业在人工智能时代赢得先机。秉承“开箱即用，伴随成长”的设计理念，MaxKB 支持企业快速接入主流大模型，高效构建专属知识库，并提供从基础问答（RAG）、复杂流程自动化（工作流）到智能体（Agent）的渐进式升级路径，全面赋能智能客服、智能办公助手等多种应用场景。
 
-- **开箱即用**：支持直接上传文档 / 自动爬取在线文档，支持文本自动拆分、向量化和 RAG（检索增强生成），有效减少大模型幻觉，智能问答交互体验好；
+- **RAG 检索增强生成**：高效搭建本地 AI 知识库，支持直接上传文档 / 自动爬取在线文档，支持文本自动拆分、向量化，有效减少大模型幻觉，提升问答效果；
-- **模型中立**：支持对接各种大模型，包括本地私有大模型（DeepSeek R1 / Llama 3 / Qwen 2 等）、国内公共大模型（通义千问 / 腾讯混元 / 字节豆包 / 百度千帆 / 智谱 AI / Kimi 等）和国外公共大模型（OpenAI / Claude / Gemini 等）；
 - **灵活编排**：内置强大的工作流引擎、函数库和 MCP 工具调用能力，支持编排 AI 工作过程，满足复杂业务场景下的需求；
-- **无缝嵌入**：支持零编码快速嵌入到第三方业务系统，让已有系统快速拥有智能问答能力，提高用户满意度。
+- **无缝嵌入**：支持零编码快速嵌入到第三方业务系统，让已有系统快速拥有智能问答能力，提高用户满意度；
+- **模型中立**：支持对接各种大模型，包括本地私有大模型（DeepSeek R1 / Qwen 3 等）、国内公共大模型（通义千问 / 腾讯混元 / 字节豆包 / 百度千帆 / 智谱 AI / Kimi 等）和国外公共大模型（OpenAI / Claude / Gemini 等）。
 
 MaxKB 三分钟视频介绍：https://www.bilibili.com/video/BV18JypYeEkj/
 
@@ -27,10 +27,10 @@ MaxKB 三分钟视频介绍：https://www.bilibili.com/video/BV18JypYeEkj/
 
 ```
 # Linux 机器
-docker run -d --name=maxkb --restart=always -p 8080:8080 -v ~/.maxkb:/var/lib/postgresql/data -v ~/.python-packages:/opt/maxkb/app/sandbox/python-packages registry.fit2cloud.com/maxkb/maxkb
+docker run -d --name=maxkb --restart=always -p 8080:8080 -v ~/.maxkb:/opt/maxkb registry.fit2cloud.com/maxkb/maxkb
 
 # Windows 机器
-docker run -d --name=maxkb --restart=always -p 8080:8080 -v C:/maxkb:/var/lib/postgresql/data -v C:/python-packages:/opt/maxkb/app/sandbox/python-packages registry.fit2cloud.com/maxkb/maxkb
+docker run -d --name=maxkb --restart=always -p 8080:8080 -v C:/maxkb:/opt/maxkb registry.fit2cloud.com/maxkb/maxkb
 
 # 用户名: admin
 # 密码: MaxKB@123..
@@ -38,8 +38,8 @@ docker run -d --name=maxkb --restart=always -p 8080:8080 -v C:/maxkb:/var/lib/po
 
 - 你也可以通过 [1Panel 应用商店](https://apps.fit2cloud.com/1panel) 快速部署 MaxKB；
 - 如果是内网环境，推荐使用 [离线安装包](https://community.fit2cloud.com/#/products/maxkb/downloads) 进行安装部署；
-- MaxKB 产品版本分为社区版和专业版，详情请参见：[MaxKB 产品版本对比](https://maxkb.cn/pricing.html)；
+- MaxKB 不同产品产品版本的对比请参见：[MaxKB 产品版本对比](https://maxkb.cn/price)；
-- 如果您需要向团队介绍 MaxKB，可以使用这个 [官方 PPT 材料](https://maxkb.cn/download/introduce-maxkb_202503.pdf)。
+- 如果您需要向团队介绍 MaxKB，可以使用这个 [官方 PPT 材料](https://fit2cloud.com/maxkb/download/introduce-maxkb_202507.pdf)。
 
 如你有更多问题，可以查看使用手册，或者通过论坛与我们交流。
 
@@ -54,12 +54,12 @@ docker run -d --name=maxkb --restart=always -p 8080:8080 -v C:/maxkb:/var/lib/po
 
 <table style="border-collapse: collapse; border: 1px solid black;">
   <tr>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/1Panel-dev/MaxKB/assets/52996290/d87395fa-a8d7-401c-82bf-c6e475d10ae9" alt="MaxKB Demo1"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/eb285512-a66a-4752-8941-c65ed1592238" alt="MaxKB Demo1"   /></td>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/1Panel-dev/MaxKB/assets/52996290/47c35ee4-3a3b-4bd4-9f4f-ee20788b2b9a" alt="MaxKB Demo2"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/f732f1f5-472c-4fd2-93c1-a277eda83d04" alt="MaxKB Demo2"   /></td>
   </tr>
   <tr>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/9a1043cb-fa62-4f71-b9a3-0b46fa59a70e" alt="MaxKB Demo3"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/c927474a-9a23-4830-822f-5db26025c9b2" alt="MaxKB Demo3"   /></td>
-    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/3407ce9a-779c-4eb4-858e-9441a2ddc664" alt="MaxKB Demo4"   /></td>
+    <td style="padding: 5px;background-color:#fff;"><img src= "https://github.com/user-attachments/assets/e6268996-a46d-4e58-9f30-31139df78ad2" alt="MaxKB Demo4"   /></td>
   </tr>
 </table>
 

apps/application/api/application_access_token.py

@@ -0,0 +1,35 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： application_access_token.py
+    @date：2025/6/9 17:46
+    @desc:
+"""
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter
+
+from application.serializers.application_access_token import AccessTokenEditSerializer
+from common.mixins.api_mixin import APIMixin
+
+
+class ApplicationAccessTokenAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [OpenApiParameter(
+            name="workspace_id",
+            description="工作空间id",
+            type=OpenApiTypes.STR,
+            location='path',
+            required=True,
+        ), OpenApiParameter(
+            name="application_id",
+            description="应用id",
+            type=OpenApiTypes.STR,
+            location='path',
+            required=True,
+        )]
+
+    @staticmethod
+    def get_request():
+        return AccessTokenEditSerializer

apps/application/api/application_api.py

@@ -0,0 +1,218 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： application.py
+    @date：2025/5/26 16:59
+    @desc:
+"""
+from django.utils.translation import gettext_lazy as _
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter
+from rest_framework import serializers
+
+from application.serializers.application import ApplicationCreateSerializer, ApplicationListResponse, \
+    ApplicationImportRequest, ApplicationEditSerializer, TextToSpeechRequest, SpeechToTextRequest, PlayDemoTextRequest
+from common.mixins.api_mixin import APIMixin
+from common.result import ResultSerializer, ResultPageSerializer, DefaultResultSerializer
+
+
+class ApplicationCreateRequest(ApplicationCreateSerializer.SimplateRequest):
+    work_flow = serializers.DictField(required=True, label=_("Workflow Objects"))
+
+
+class ApplicationCreateResponse(ResultSerializer):
+    def get_data(self):
+        return ApplicationCreateSerializer.ApplicationResponse()
+
+
+class ApplicationListResult(ResultSerializer):
+    def get_data(self):
+        return ApplicationListResponse(many=True)
+
+
+class ApplicationPageResult(ResultPageSerializer):
+    def get_data(self):
+        return ApplicationListResponse(many=True)
+
+
+class ApplicationQueryAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="current_page",
+                description=_("Current page"),
+                type=OpenApiTypes.INT,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="page_size",
+                description=_("Page size"),
+                type=OpenApiTypes.INT,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="folder_id",
+                description=_("folder id"),
+                type=OpenApiTypes.STR,
+                location='query',
+                required=False,
+            ),
+            OpenApiParameter(
+                name="name",
+                description=_("Application Name"),
+                type=OpenApiTypes.STR,
+                location='query',
+                required=False,
+            ),
+            OpenApiParameter(
+                name="desc",
+                description=_("Application Description"),
+                type=OpenApiTypes.STR,
+                location='query',
+                required=False,
+            ),
+            OpenApiParameter(
+                name="user_id",
+                description=_("User ID"),
+                type=OpenApiTypes.STR,
+                location='query',
+                required=False,
+            ),
+            OpenApiParameter(
+                name="publish_status",
+                description=_("Publish status") + '(published|unpublished)',
+                type=OpenApiTypes.STR,
+                location='query',
+                required=False,
+            )
+        ]
+
+    @staticmethod
+    def get_response():
+        return ApplicationListResult
+
+    @staticmethod
+    def get_page_response():
+        return ApplicationPageResult
+
+
+class ApplicationCreateAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )
+        ]
+
+    @staticmethod
+    def get_request():
+        return ApplicationCreateRequest
+
+    @staticmethod
+    def get_response():
+        return ApplicationCreateResponse
+
+
+class ApplicationImportAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        ApplicationCreateAPI.get_parameters()
+
+    @staticmethod
+    def get_request():
+        return ApplicationImportRequest
+
+
+class ApplicationOperateAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="application_id",
+                description="应用id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )
+        ]
+
+
+class ApplicationExportAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return ApplicationOperateAPI.get_parameters()
+
+    @staticmethod
+    def get_response():
+        return DefaultResultSerializer
+
+
+class ApplicationEditAPI(APIMixin):
+    @staticmethod
+    def get_request():
+        return ApplicationEditSerializer
+
+
+class TextToSpeechAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return ApplicationOperateAPI.get_parameters()
+
+    @staticmethod
+    def get_request():
+        return TextToSpeechRequest
+
+    @staticmethod
+    def get_response():
+        return DefaultResultSerializer
+
+
+class SpeechToTextAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return ApplicationOperateAPI.get_parameters()
+
+    @staticmethod
+    def get_request():
+        return SpeechToTextRequest
+
+    @staticmethod
+    def get_response():
+        return DefaultResultSerializer
+
+
+class PlayDemoTextAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return ApplicationOperateAPI.get_parameters()
+
+    @staticmethod
+    def get_request():
+        return PlayDemoTextRequest
+
+    @staticmethod
+    def get_response():
+        return DefaultResultSerializer

apps/application/api/application_api_key.py

@@ -0,0 +1,61 @@
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter
+
+from application.serializers.application_api_key import EditApplicationKeySerializer, ApplicationKeySerializerModel
+from common.mixins.api_mixin import APIMixin
+from common.result import ResultSerializer
+
+
+class ApplicationKeyListResult(ResultSerializer):
+    def get_data(self):
+        return ApplicationKeySerializerModel(many=True)
+
+
+class ApplicationKeyResult(ResultSerializer):
+    def get_data(self):
+        return ApplicationKeySerializerModel()
+
+
+class ApplicationKeyAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="application_id",
+                description="application ID",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )
+        ]
+
+    @staticmethod
+    def get_response():
+        return ApplicationKeyResult
+
+    class List(APIMixin):
+        @staticmethod
+        def get_response():
+            return ApplicationKeyListResult
+
+    class Operate(APIMixin):
+        @staticmethod
+        def get_parameters():
+            return [*ApplicationKeyAPI.get_parameters(), OpenApiParameter(
+                name="api_key_id",
+                description="ApiKeyId",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )]
+
+        @staticmethod
+        def get_request():
+            return EditApplicationKeySerializer

apps/application/api/application_chat.py

@@ -0,0 +1,141 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： application_chat.py
+    @date：2025/6/10 13:54
+    @desc:
+"""
+from django.utils.translation import gettext_lazy as _
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter
+
+from application.serializers.application_chat import ApplicationChatQuerySerializers, \
+    ApplicationChatResponseSerializers, ApplicationChatRecordExportRequest
+from common.mixins.api_mixin import APIMixin
+from common.result import ResultSerializer, ResultPageSerializer
+
+
+class ApplicationChatListResponseSerializers(ResultSerializer):
+    def get_data(self):
+        return ApplicationChatResponseSerializers(many=True)
+
+
+class ApplicationChatPageResponseSerializers(ResultPageSerializer):
+    def get_data(self):
+        return ApplicationChatResponseSerializers(many=True)
+
+
+class ApplicationChatQueryAPI(APIMixin):
+    @staticmethod
+    def get_request():
+        return ApplicationChatQuerySerializers
+
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="application_id",
+                description="application ID",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ), OpenApiParameter(
+                name="start_time",
+                description="start Time",
+                type=OpenApiTypes.STR,
+                required=True,
+            ),
+            OpenApiParameter(
+                name="end_time",
+                description="end Time",
+                type=OpenApiTypes.STR,
+                required=True,
+            ),
+            OpenApiParameter(
+                name="abstract",
+                description="summary",
+                type=OpenApiTypes.STR,
+                required=False,
+            ),
+            OpenApiParameter(
+                name="username",
+                description="username",
+                type=OpenApiTypes.STR,
+                required=False,
+            ),
+            OpenApiParameter(
+                name="min_star",
+                description=_("Minimum number of likes"),
+                type=OpenApiTypes.INT,
+                required=False,
+            ),
+            OpenApiParameter(
+                name="min_trample",
+                description=_("Minimum number of clicks"),
+                type=OpenApiTypes.INT,
+                required=False,
+            ),
+            OpenApiParameter(
+                name="comparer",
+                description=_("Comparator"),
+                type=OpenApiTypes.STR,
+                required=False,
+            ),
+        ]
+
+    @staticmethod
+    def get_response():
+        return ApplicationChatListResponseSerializers
+
+
+class ApplicationChatQueryPageAPI(APIMixin):
+    @staticmethod
+    def get_request():
+        return ApplicationChatQueryAPI.get_request()
+
+    @staticmethod
+    def get_parameters():
+        return [
+            *ApplicationChatQueryAPI.get_parameters(),
+            OpenApiParameter(
+                name="current_page",
+                description=_("Current page"),
+                type=OpenApiTypes.INT,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="page_size",
+                description=_("Page size"),
+                type=OpenApiTypes.INT,
+                location='path',
+                required=True,
+            ),
+
+        ]
+
+    @staticmethod
+    def get_response():
+        return ApplicationChatPageResponseSerializers
+
+
+class ApplicationChatExportAPI(APIMixin):
+    @staticmethod
+    def get_request():
+        return ApplicationChatRecordExportRequest
+
+    @staticmethod
+    def get_parameters():
+        return ApplicationChatQueryAPI.get_parameters()
+
+    @staticmethod
+    def get_response():
+        return None

apps/application/api/application_chat_record.py

@@ -0,0 +1,180 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： application_chat_record.py
+    @date：2025/6/10 15:19
+    @desc:
+"""
+from django.utils.translation import gettext_lazy as _
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter
+
+from application.serializers.application_chat_record import ApplicationChatRecordAddKnowledgeSerializer, \
+    ApplicationChatRecordImproveInstanceSerializer
+from common.mixins.api_mixin import APIMixin
+
+
+class ApplicationChatRecordQueryAPI(APIMixin):
+    @staticmethod
+    def get_response():
+        pass
+
+    @staticmethod
+    def get_request():
+        pass
+
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="application_id",
+                description="Application ID",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="chat_id",
+                description=_("Chat ID"),
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="order_asc",
+                description=_("Is it in order"),
+                type=OpenApiTypes.BOOL,
+                required=True,
+            )
+        ]
+
+
+class ApplicationChatRecordPageQueryAPI(APIMixin):
+    @staticmethod
+    def get_response():
+        pass
+
+    @staticmethod
+    def get_request():
+        pass
+
+    @staticmethod
+    def get_parameters():
+        return [*ApplicationChatRecordQueryAPI.get_parameters(),
+                OpenApiParameter(
+                    name="current_page",
+                    description=_("Current page"),
+                    type=OpenApiTypes.INT,
+                    location='path',
+                    required=True,
+                ),
+                OpenApiParameter(
+                    name="page_size",
+                    description=_("Page size"),
+                    type=OpenApiTypes.INT,
+                    location='path',
+                    required=True,
+                )]
+
+
+class ApplicationChatRecordImproveParagraphAPI(APIMixin):
+    @staticmethod
+    def get_response():
+        pass
+
+    @staticmethod
+    def get_request():
+        return ApplicationChatRecordImproveInstanceSerializer
+
+    @staticmethod
+    def get_parameters():
+        return [OpenApiParameter(
+            name="workspace_id",
+            description="工作空间id",
+            type=OpenApiTypes.STR,
+            location='path',
+            required=True,
+        ),
+            OpenApiParameter(
+                name="application_id",
+                description="Application ID",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="chat_id",
+                description=_("Chat ID"),
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="chat_record_id",
+                description=_("Chat Record ID"),
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="knowledge_id",
+                description=_("Knowledge ID"),
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="document_id",
+                description=_("Document ID"),
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )
+        ]
+
+    class Operate(APIMixin):
+        @staticmethod
+        def get_parameters():
+            return [*ApplicationChatRecordImproveParagraphAPI.get_parameters(), OpenApiParameter(
+                name="paragraph_id",
+                description=_("Paragraph ID"),
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )]
+
+
+class ApplicationChatRecordAddKnowledgeAPI(APIMixin):
+    @staticmethod
+    def get_request():
+        return ApplicationChatRecordAddKnowledgeSerializer
+
+    @staticmethod
+    def get_response():
+        return None
+
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="application_id",
+                description="Application ID",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )]

apps/application/api/application_stats.py

@@ -0,0 +1,55 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： application_stats.py
+    @date：2025/6/9 20:45
+    @desc:
+"""
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter
+
+from application.serializers.application_stats import ApplicationStatsSerializer
+from common.mixins.api_mixin import APIMixin
+from common.result import ResultSerializer
+
+
+class ApplicationStatsResult(ResultSerializer):
+    def get_data(self):
+        return ApplicationStatsSerializer(many=True)
+
+
+class ApplicationStatsAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [OpenApiParameter(
+            name="workspace_id",
+            description="工作空间id",
+            type=OpenApiTypes.STR,
+            location='path',
+            required=True,
+        ),
+            OpenApiParameter(
+                name="application_id",
+                description="application ID",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="start_time",
+                description="start Time",
+                type=OpenApiTypes.STR,
+                required=True,
+            ),
+            OpenApiParameter(
+                name="end_time",
+                description="end Time",
+                type=OpenApiTypes.STR,
+                required=True,
+            ),
+        ]
+
+    @staticmethod
+    def get_response():
+        return ApplicationStatsResult

apps/application/api/application_version.py

@@ -0,0 +1,96 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： application_version.py
+    @date：2025/6/4 17:33
+    @desc:
+"""
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter
+
+from application.serializers.application_version import ApplicationVersionModelSerializer
+from common.mixins.api_mixin import APIMixin
+from common.result import ResultSerializer, PageDataResponse, ResultPageSerializer
+
+
+class ApplicationListVersionResult(ResultSerializer):
+    def get_data(self):
+        return ApplicationVersionModelSerializer(many=True)
+
+
+class ApplicationPageVersionResult(ResultPageSerializer):
+    def get_data(self):
+        return ApplicationVersionModelSerializer(many=True)
+
+
+class ApplicationWorkflowVersionResult(ResultSerializer):
+    def get_data(self):
+        return ApplicationVersionModelSerializer()
+
+
+class ApplicationVersionAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="application_id",
+                description="application ID",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )
+        ]
+
+
+class ApplicationVersionOperateAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="application_version_id",
+                description="工作流版本id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            )
+            , *ApplicationVersionAPI.get_parameters()
+        ]
+
+    @staticmethod
+    def get_response():
+        return ApplicationWorkflowVersionResult
+
+
+class ApplicationVersionListAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="name",
+                description="Version Name",
+                type=OpenApiTypes.STR,
+                required=False,
+            )
+            , *ApplicationVersionAPI.get_parameters()]
+
+    @staticmethod
+    def get_response():
+        return ApplicationListVersionResult
+
+
+class ApplicationVersionPageAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return ApplicationVersionListAPI.get_parameters()
+
+    @staticmethod
+    def get_response():
+        return ApplicationPageVersionResult

apps/application/chat_pipeline/I_base_chat_pipeline.py

@@ -12,42 +12,45 @@ from typing import Type
 
 from rest_framework import serializers
 
-from dataset.models import Paragraph
+from knowledge.models import Paragraph
 
 
 class ParagraphPipelineModel:
 
-    def __init__(self, _id: str, document_id: str, dataset_id: str, content: str, title: str, status: str,
+    def __init__(self, _id: str, document_id: str, knowledge_id: str, content: str, title: str, status: str,
-                 is_active: bool, comprehensive_score: float, similarity: float, dataset_name: str, document_name: str,
+                 is_active: bool, comprehensive_score: float, similarity: float, knowledge_name: str,
-                 hit_handling_method: str, directly_return_similarity: float, meta: dict = None):
+                 document_name: str,
+                 hit_handling_method: str, directly_return_similarity: float, knowledge_type, meta: dict = None):
         self.id = _id
         self.document_id = document_id
-        self.dataset_id = dataset_id
+        self.knowledge_id = knowledge_id
         self.content = content
         self.title = title
         self.status = status,
         self.is_active = is_active
         self.comprehensive_score = comprehensive_score
         self.similarity = similarity
-        self.dataset_name = dataset_name
+        self.knowledge_name = knowledge_name
         self.document_name = document_name
         self.hit_handling_method = hit_handling_method
         self.directly_return_similarity = directly_return_similarity
         self.meta = meta
+        self.knowledge_type = knowledge_type
 
     def to_dict(self):
         return {
             'id': self.id,
             'document_id': self.document_id,
-            'dataset_id': self.dataset_id,
+            'knowledge_id': self.knowledge_id,
             'content': self.content,
             'title': self.title,
             'status': self.status,
             'is_active': self.is_active,
             'comprehensive_score': self.comprehensive_score,
             'similarity': self.similarity,
-            'dataset_name': self.dataset_name,
+            'knowledge_name': self.knowledge_name,
             'document_name': self.document_name,
+            'knowledge_type': self.knowledge_type,
             'meta': self.meta,
         }
 
@@ -57,7 +60,8 @@ class ParagraphPipelineModel:
             self.paragraph = {}
             self.comprehensive_score = None
             self.document_name = None
-            self.dataset_name = None
+            self.knowledge_name = None
+            self.knowledge_type = None
             self.hit_handling_method = None
             self.directly_return_similarity = 0.9
             self.meta = {}
@@ -66,7 +70,7 @@ class ParagraphPipelineModel:
             if isinstance(paragraph, Paragraph):
                 self.paragraph = {'id': paragraph.id,
                                   'document_id': paragraph.document_id,
-                                  'dataset_id': paragraph.dataset_id,
+                                  'knowledge_id': paragraph.knowledge_id,
                                   'content': paragraph.content,
                                   'title': paragraph.title,
                                   'status': paragraph.status,
@@ -76,8 +80,12 @@ class ParagraphPipelineModel:
                 self.paragraph = paragraph
             return self
 
-        def add_dataset_name(self, dataset_name):
+        def add_knowledge_name(self, knowledge_name):
-            self.dataset_name = dataset_name
+            self.knowledge_name = knowledge_name
+            return self
+
+        def add_knowledge_type(self, knowledge_type):
+            self.knowledge_type = knowledge_type
             return self
 
         def add_document_name(self, document_name):
@@ -106,12 +114,13 @@ class ParagraphPipelineModel:
 
         def build(self):
             return ParagraphPipelineModel(str(self.paragraph.get('id')), str(self.paragraph.get('document_id')),
-                                          str(self.paragraph.get('dataset_id')),
+                                          str(self.paragraph.get('knowledge_id')),
                                           self.paragraph.get('content'), self.paragraph.get('title'),
                                           self.paragraph.get('status'),
                                           self.paragraph.get('is_active'),
-                                          self.comprehensive_score, self.similarity, self.dataset_name,
+                                          self.comprehensive_score, self.similarity, self.knowledge_name,
                                           self.document_name, self.hit_handling_method, self.directly_return_similarity,
+                                          self.knowledge_type,
                                           self.meta)
 
 

apps/application/chat_pipeline/pipeline_manage.py

@@ -17,12 +17,14 @@ from common.handle.impl.response.system_to_response import SystemToResponse
 
 class PipelineManage:
     def __init__(self, step_list: List[Type[IBaseChatPipelineStep]],
-                 base_to_response: BaseToResponse = SystemToResponse()):
+                 base_to_response: BaseToResponse = SystemToResponse(),
+                 debug=False):
         # 步骤执行器
         self.step_list = [step() for step in step_list]
         # 上下文
         self.context = {'message_tokens': 0, 'answer_tokens': 0}
         self.base_to_response = base_to_response
+        self.debug = debug
 
     def run(self, context: Dict = None):
         self.context['start_time'] = time.time()
@@ -44,6 +46,7 @@ class PipelineManage:
         def __init__(self):
             self.step_list: List[Type[IBaseChatPipelineStep]] = []
             self.base_to_response = SystemToResponse()
+            self.debug = False
 
         def append_step(self, step: Type[IBaseChatPipelineStep]):
             self.step_list.append(step)
@@ -53,5 +56,9 @@ class PipelineManage:
             self.base_to_response = base_to_response
             return self
 
+        def add_debug(self, debug):
+            self.debug = debug
+            return self
+
         def build(self):
-            return PipelineManage(step_list=self.step_list, base_to_response=self.base_to_response)
+            return PipelineManage(step_list=self.step_list, base_to_response=self.base_to_response, debug=self.debug)

apps/application/chat_pipeline/step/chat_step/i_chat_step.py

@@ -16,9 +16,8 @@ from rest_framework import serializers
 
 from application.chat_pipeline.I_base_chat_pipeline import IBaseChatPipelineStep, ParagraphPipelineModel
 from application.chat_pipeline.pipeline_manage import PipelineManage
-from application.serializers.application_serializers import NoReferencesSetting
+from application.serializers.application import NoReferencesSetting
 from common.field.common import InstanceField
-from common.util.field_message import ErrMessage
 
 
 class ModelField(serializers.Field):
@@ -45,7 +44,7 @@ class PostResponseHandler:
     @abstractmethod
     def handler(self, chat_id, chat_record_id, paragraph_list: List[ParagraphPipelineModel], problem_text: str,
                 answer_text,
-                manage, step, padding_problem_text: str = None, client_id=None, **kwargs):
+                manage, step, padding_problem_text: str = None, **kwargs):
         pass
 
 
@@ -53,35 +52,43 @@ class IChatStep(IBaseChatPipelineStep):
     class InstanceSerializer(serializers.Serializer):
         # 对话列表
         message_list = serializers.ListField(required=True, child=MessageField(required=True),
-                                             error_messages=ErrMessage.list(_("Conversation list")))
+                                             label=_("Conversation list"))
-        model_id = serializers.UUIDField(required=False, allow_null=True, error_messages=ErrMessage.uuid(_("Model id")))
+        model_id = serializers.UUIDField(required=False, allow_null=True, label=_("Model id"))
         # 段落列表
-        paragraph_list = serializers.ListField(error_messages=ErrMessage.list(_("Paragraph List")))
+        paragraph_list = serializers.ListField(label=_("Paragraph List"))
         # 对话id
-        chat_id = serializers.UUIDField(required=True, error_messages=ErrMessage.uuid(_("Conversation ID")))
+        chat_id = serializers.UUIDField(required=True, label=_("Conversation ID"))
         # 用户问题
-        problem_text = serializers.CharField(required=True, error_messages=ErrMessage.uuid(_("User Questions")))
+        problem_text = serializers.CharField(required=True, label=_("User Questions"))
         # 后置处理器
         post_response_handler = InstanceField(model_type=PostResponseHandler,
-                                              error_messages=ErrMessage.base(_("Post-processor")))
+                                              label=_("Post-processor"))
         # 补全问题
         padding_problem_text = serializers.CharField(required=False,
-                                                     error_messages=ErrMessage.base(_("Completion Question")))
+                                                     label=_("Completion Question"))
         # 是否使用流的形式输出
-        stream = serializers.BooleanField(required=False, error_messages=ErrMessage.base(_("Streaming Output")))
+        stream = serializers.BooleanField(required=False, label=_("Streaming Output"))
-        client_id = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Client id")))
+        chat_user_id = serializers.CharField(required=True, label=_("Chat user id"))
-        client_type = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Client Type")))
+
+        chat_user_type = serializers.CharField(required=True, label=_("Chat user Type"))
         # 未查询到引用分段
         no_references_setting = NoReferencesSetting(required=True,
-                                                    error_messages=ErrMessage.base(_("No reference segment settings")))
+                                                    label=_("No reference segment settings"))
 
-        user_id = serializers.UUIDField(required=True, error_messages=ErrMessage.uuid(_("User ID")))
+        workspace_id = serializers.CharField(required=True, label=_("Workspace ID"))
 
         model_setting = serializers.DictField(required=True, allow_null=True,
-                                              error_messages=ErrMessage.dict(_("Model settings")))
+                                              label=_("Model settings"))
 
         model_params_setting = serializers.DictField(required=False, allow_null=True,
-                                                     error_messages=ErrMessage.dict(_("Model parameter settings")))
+                                                     label=_("Model parameter settings"))
+        mcp_enable = serializers.BooleanField(label="MCP否启用", required=False, default=False)
+        mcp_tool_ids = serializers.JSONField(label="MCP工具ID列表", required=False, default=list)
+        mcp_servers = serializers.JSONField(label="MCP服务列表", required=False, default=dict)
+        mcp_source = serializers.CharField(label="MCP Source", required=False, default="referencing")
+        tool_enable = serializers.BooleanField(label="工具是否启用", required=False, default=False)
+        tool_ids = serializers.JSONField(label="工具ID列表", required=False, default=list)
+        mcp_output_enable = serializers.BooleanField(label="MCP输出是否启用", required=False, default=True)
 
         def is_valid(self, *, raise_exception=False):
             super().is_valid(raise_exception=True)
@@ -102,9 +109,12 @@ class IChatStep(IBaseChatPipelineStep):
                 chat_id, problem_text,
                 post_response_handler: PostResponseHandler,
                 model_id: str = None,
-                user_id: str = None,
+                workspace_id: str = None,
                 paragraph_list=None,
                 manage: PipelineManage = None,
-                padding_problem_text: str = None, stream: bool = True, client_id=None, client_type=None,
+                padding_problem_text: str = None, stream: bool = True, chat_user_id=None, chat_user_type=None,
-                no_references_setting=None, model_params_setting=None, model_setting=None, **kwargs):
+                no_references_setting=None, model_params_setting=None, model_setting=None,
+                mcp_enable=False, mcp_tool_ids=None, mcp_servers='', mcp_source="referencing",
+                tool_enable=False, tool_ids=None, mcp_output_enable=True,
+                **kwargs):
         pass

apps/application/chat_pipeline/step/chat_step/impl/base_chat_step.py

@@ -6,10 +6,11 @@
     @date：2024/1/9 18:25
     @desc: 对话step Base实现
 """
-import logging
+import json
+import os
 import time
 import traceback
-import uuid
+import uuid_utils.compat as uuid
 from typing import List
 
 from django.db.models import QuerySet
@@ -18,22 +19,28 @@ from django.utils.translation import gettext as _
 from langchain.chat_models.base import BaseChatModel
 from langchain.schema import BaseMessage
 from langchain.schema.messages import HumanMessage, AIMessage
-from langchain_core.messages import AIMessageChunk
+from langchain_core.messages import AIMessageChunk, SystemMessage
 from rest_framework import status
 
 from application.chat_pipeline.I_base_chat_pipeline import ParagraphPipelineModel
 from application.chat_pipeline.pipeline_manage import PipelineManage
 from application.chat_pipeline.step.chat_step.i_chat_step import IChatStep, PostResponseHandler
-from application.flow.tools import Reasoning
+from application.flow.tools import Reasoning, mcp_response_generator
-from application.models.api_key_model import ApplicationPublicAccessClient
+from application.models import ApplicationChatUserStats, ChatUserType
-from common.constants.authentication_type import AuthenticationType
+from common.utils.logger import maxkb_logger
-from setting.models_provider.tools import get_model_instance_by_model_user_id
+from common.utils.rsa_util import rsa_long_decrypt
+from common.utils.tool_code import ToolExecutor
+from maxkb.const import CONFIG
+from models_provider.tools import get_model_instance_by_model_workspace_id
+from tools.models import Tool
 
 
-def add_access_num(client_id=None, client_type=None, application_id=None):
+def add_access_num(chat_user_id=None, chat_user_type=None, application_id=None):
-    if client_type == AuthenticationType.APPLICATION_ACCESS_TOKEN.value and application_id is not None:
+    if [ChatUserType.ANONYMOUS_USER.value, ChatUserType.CHAT_USER.value].__contains__(
-        application_public_access_client = (QuerySet(ApplicationPublicAccessClient).filter(client_id=client_id,
+            chat_user_type) and application_id is not None:
-                                                                                           application_id=application_id)
+        application_public_access_client = (QuerySet(ApplicationChatUserStats).filter(chat_user_id=chat_user_id,
+                                                                                      chat_user_type=chat_user_type,
+                                                                                      application_id=application_id)
                                             .first())
         if application_public_access_client is not None:
             application_public_access_client.access_num = application_public_access_client.access_num + 1
@@ -52,6 +59,7 @@ def write_context(step, manage, request_token, response_token, all_text):
     manage.context['answer_tokens'] = manage.context['answer_tokens'] + response_token
 
 
+
 def event_content(response,
                   chat_id,
                   chat_record_id,
@@ -63,7 +71,7 @@ def event_content(response,
                   message_list: List[BaseMessage],
                   problem_text: str,
                   padding_problem_text: str = None,
-                  client_id=None, client_type=None,
+                  chat_user_id=None, chat_user_type=None,
                   is_ai_chat: bool = None,
                   model_setting=None):
     if model_setting is None:
@@ -85,6 +93,7 @@ def event_content(response,
                 reasoning_content_chunk = chunk.additional_kwargs.get('reasoning_content', '')
             else:
                 reasoning_content_chunk = reasoning_chunk.get('reasoning_content')
+            content_chunk = reasoning._normalize_content(content_chunk)
             all_text += content_chunk
             if reasoning_content_chunk is None:
                 reasoning_content_chunk = ''
@@ -124,26 +133,24 @@ def event_content(response,
             request_token = 0
             response_token = 0
         write_context(step, manage, request_token, response_token, all_text)
-        asker = manage.context.get('form_data', {}).get('asker', None)
         post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
-                                      all_text, manage, step, padding_problem_text, client_id,
+                                      all_text, manage, step, padding_problem_text,
-                                      reasoning_content=reasoning_content if reasoning_content_enable else ''
+                                      reasoning_content=reasoning_content if reasoning_content_enable else '')
-                                      , asker=asker)
         yield manage.get_base_to_response().to_stream_chunk_response(chat_id, str(chat_record_id), 'ai-chat-node',
                                                                      [], '', True,
                                                                      request_token, response_token,
                                                                      {'node_is_end': True, 'view_type': 'many_view',
                                                                       'node_type': 'ai-chat-node'})
-        add_access_num(client_id, client_type, manage.context.get('application_id'))
+        if not manage.debug:
+            add_access_num(chat_user_id, chat_user_type, manage.context.get('application_id'))
     except Exception as e:
-        logging.getLogger("max_kb_error").error(f'{str(e)}:{traceback.format_exc()}')
+        maxkb_logger.error(f'{str(e)}:{traceback.format_exc()}')
         all_text = 'Exception:' + str(e)
         write_context(step, manage, 0, 0, all_text)
-        asker = manage.context.get('form_data', {}).get('asker', None)
         post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
-                                      all_text, manage, step, padding_problem_text, client_id, reasoning_content='',
+                                      all_text, manage, step, padding_problem_text, reasoning_content='')
-                                      asker=asker)
+        if not manage.debug:
-        add_access_num(client_id, client_type, manage.context.get('application_id'))
+            add_access_num(chat_user_id, chat_user_type, manage.context.get('application_id'))
         yield manage.get_base_to_response().to_stream_chunk_response(chat_id, str(chat_record_id), 'ai-chat-node',
                                                                      [], all_text,
                                                                      False,
@@ -160,28 +167,40 @@ class BaseChatStep(IChatStep):
                 problem_text,
                 post_response_handler: PostResponseHandler,
                 model_id: str = None,
-                user_id: str = None,
+                workspace_id: str = None,
                 paragraph_list=None,
                 manage: PipelineManage = None,
                 padding_problem_text: str = None,
                 stream: bool = True,
-                client_id=None, client_type=None,
+                chat_user_id=None, chat_user_type=None,
                 no_references_setting=None,
                 model_params_setting=None,
                 model_setting=None,
+                mcp_enable=False,
+                mcp_tool_ids=None,
+                mcp_servers='',
+                mcp_source="referencing",
+                tool_enable=False,
+                tool_ids=None,
+                mcp_output_enable=True,
                 **kwargs):
-        chat_model = get_model_instance_by_model_user_id(model_id, user_id,
+        chat_model = get_model_instance_by_model_workspace_id(model_id, workspace_id,
-                                                         **model_params_setting) if model_id is not None else None
+                                                              **model_params_setting) if model_id is not None else None
         if stream:
             return self.execute_stream(message_list, chat_id, problem_text, post_response_handler, chat_model,
                                        paragraph_list,
-                                       manage, padding_problem_text, client_id, client_type, no_references_setting,
+                                       manage, padding_problem_text, chat_user_id, chat_user_type,
-                                       model_setting)
+                                       no_references_setting,
+                                       model_setting,
+                                       mcp_enable, mcp_tool_ids, mcp_servers, mcp_source, tool_enable, tool_ids,
+                                       mcp_output_enable)
         else:
             return self.execute_block(message_list, chat_id, problem_text, post_response_handler, chat_model,
                                       paragraph_list,
-                                      manage, padding_problem_text, client_id, client_type, no_references_setting,
+                                      manage, padding_problem_text, chat_user_id, chat_user_type, no_references_setting,
-                                      model_setting)
+                                      model_setting,
+                                      mcp_enable, mcp_tool_ids, mcp_servers, mcp_source, tool_enable, tool_ids,
+                                      mcp_output_enable)
 
     def get_details(self, manage, **kwargs):
         return {
@@ -197,19 +216,69 @@ class BaseChatStep(IChatStep):
 
     @staticmethod
     def reset_message_list(message_list: List[BaseMessage], answer_text):
-        result = [{'role': 'user' if isinstance(message, HumanMessage) else 'ai', 'content': message.content} for
+        result = [{'role': 'user' if isinstance(message, HumanMessage) else (
+            'system' if isinstance(message, SystemMessage) else 'ai'), 'content': message.content} for
                   message
                   in
                   message_list]
         result.append({'role': 'ai', 'content': answer_text})
         return result
 
-    @staticmethod
+    def _handle_mcp_request(self, mcp_enable, tool_enable, mcp_source, mcp_servers, mcp_tool_ids, tool_ids,
-    def get_stream_result(message_list: List[BaseMessage],
+                            mcp_output_enable, chat_model, message_list):
+        if not mcp_enable and not tool_enable:
+            return None
+
+        mcp_servers_config = {}
+
+        # 迁移过来mcp_source是None
+        if mcp_source is None:
+            mcp_source = 'custom'
+        if mcp_enable:
+            # 兼容老数据
+            if not mcp_tool_ids:
+                mcp_tool_ids = []
+            if mcp_source == 'custom' and mcp_servers is not None and '"stdio"' not in mcp_servers:
+                mcp_servers_config = json.loads(mcp_servers)
+            elif mcp_tool_ids:
+                mcp_tools = QuerySet(Tool).filter(id__in=mcp_tool_ids).values()
+                for mcp_tool in mcp_tools:
+                    if mcp_tool and mcp_tool['is_active']:
+                        mcp_servers_config = {**mcp_servers_config, **json.loads(mcp_tool['code'])}
+
+        if tool_enable:
+            if tool_ids and len(tool_ids) > 0:  # 如果有工具ID，则将其转换为MCP
+                self.context['tool_ids'] = tool_ids
+                for tool_id in tool_ids:
+                    tool = QuerySet(Tool).filter(id=tool_id).first()
+                    if tool is None or tool.is_active is False:
+                        continue
+                    executor = ToolExecutor()
+                    if tool.init_params is not None:
+                        params = json.loads(rsa_long_decrypt(tool.init_params))
+                    else:
+                        params = {}
+                    tool_config = executor.get_tool_mcp_config(tool.code, params)
+
+                    mcp_servers_config[str(tool.id)] = tool_config
+
+        if len(mcp_servers_config) > 0:
+            return mcp_response_generator(chat_model, message_list, json.dumps(mcp_servers_config), mcp_output_enable)
+
+        return None
+
+    def get_stream_result(self, message_list: List[BaseMessage],
                           chat_model: BaseChatModel = None,
                           paragraph_list=None,
                           no_references_setting=None,
-                          problem_text=None):
+                          problem_text=None,
+                          mcp_enable=False,
+                          mcp_tool_ids=None,
+                          mcp_servers='',
+                          mcp_source="referencing",
+                          tool_enable=False,
+                          tool_ids=None,
+                          mcp_output_enable=True):
         if paragraph_list is None:
             paragraph_list = []
         directly_return_chunk_list = [AIMessageChunk(content=paragraph.content)
@@ -225,6 +294,13 @@ class BaseChatStep(IChatStep):
             return iter([AIMessageChunk(
                 _('Sorry, the AI model is not configured. Please go to the application to set up the AI model first.'))]), False
         else:
+            # 处理 MCP 请求
+            mcp_result = self._handle_mcp_request(
+                mcp_enable, tool_enable, mcp_source, mcp_servers, mcp_tool_ids, tool_ids, mcp_output_enable, chat_model,
+                message_list,
+            )
+            if mcp_result:
+                return mcp_result, True
             return chat_model.stream(message_list), True
 
     def execute_stream(self, message_list: List[BaseMessage],
@@ -235,27 +311,44 @@ class BaseChatStep(IChatStep):
                        paragraph_list=None,
                        manage: PipelineManage = None,
                        padding_problem_text: str = None,
-                       client_id=None, client_type=None,
+                       chat_user_id=None, chat_user_type=None,
                        no_references_setting=None,
-                       model_setting=None):
+                       model_setting=None,
+                       mcp_enable=False,
+                       mcp_tool_ids=None,
+                       mcp_servers='',
+                       mcp_source="referencing",
+                       tool_enable=False,
+                       tool_ids=None,
+                       mcp_output_enable=True):
         chat_result, is_ai_chat = self.get_stream_result(message_list, chat_model, paragraph_list,
-                                                         no_references_setting, problem_text)
+                                                         no_references_setting, problem_text, mcp_enable, mcp_tool_ids,
-        chat_record_id = uuid.uuid1()
+                                                         mcp_servers, mcp_source, tool_enable, tool_ids,
+                                                         mcp_output_enable)
+        chat_record_id = uuid.uuid7()
         r = StreamingHttpResponse(
             streaming_content=event_content(chat_result, chat_id, chat_record_id, paragraph_list,
                                             post_response_handler, manage, self, chat_model, message_list, problem_text,
-                                            padding_problem_text, client_id, client_type, is_ai_chat, model_setting),
+                                            padding_problem_text, chat_user_id, chat_user_type, is_ai_chat,
+                                            model_setting),
             content_type='text/event-stream;charset=utf-8')
 
         r['Cache-Control'] = 'no-cache'
         return r
 
-    @staticmethod
+    def get_block_result(self, message_list: List[BaseMessage],
-    def get_block_result(message_list: List[BaseMessage],
                          chat_model: BaseChatModel = None,
                          paragraph_list=None,
                          no_references_setting=None,
-                         problem_text=None):
+                         problem_text=None,
+                         mcp_enable=False,
+                         mcp_tool_ids=None,
+                         mcp_servers='',
+                         mcp_source="referencing",
+                         tool_enable=False,
+                         tool_ids=None,
+                         mcp_output_enable=True
+                         ):
         if paragraph_list is None:
             paragraph_list = []
         directly_return_chunk_list = [AIMessageChunk(content=paragraph.content)
@@ -270,6 +363,13 @@ class BaseChatStep(IChatStep):
             return AIMessage(
                 _('Sorry, the AI model is not configured. Please go to the application to set up the AI model first.')), False
         else:
+            # 处理 MCP 请求
+            mcp_result = self._handle_mcp_request(
+                mcp_enable, tool_enable, mcp_source, mcp_servers, mcp_tool_ids, tool_ids, mcp_output_enable,
+                chat_model, message_list,
+            )
+            if mcp_result:
+                return mcp_result, True
             return chat_model.invoke(message_list), True
 
     def execute_block(self, message_list: List[BaseMessage],
@@ -280,18 +380,27 @@ class BaseChatStep(IChatStep):
                       paragraph_list=None,
                       manage: PipelineManage = None,
                       padding_problem_text: str = None,
-                      client_id=None, client_type=None, no_references_setting=None,
+                      chat_user_id=None, chat_user_type=None, no_references_setting=None,
-                      model_setting=None):
+                      model_setting=None,
+                      mcp_enable=False,
+                      mcp_tool_ids=None,
+                      mcp_servers='',
+                      mcp_source="referencing",
+                      tool_enable=False,
+                      tool_ids=None,
+                      mcp_output_enable=True):
         reasoning_content_enable = model_setting.get('reasoning_content_enable', False)
         reasoning_content_start = model_setting.get('reasoning_content_start', '<think>')
         reasoning_content_end = model_setting.get('reasoning_content_end', '</think>')
         reasoning = Reasoning(reasoning_content_start,
                               reasoning_content_end)
-        chat_record_id = uuid.uuid1()
+        chat_record_id = uuid.uuid7()
         # 调用模型
         try:
             chat_result, is_ai_chat = self.get_block_result(message_list, chat_model, paragraph_list,
-                                                            no_references_setting, problem_text)
+                                                            no_references_setting, problem_text, mcp_enable,
+                                                            mcp_tool_ids, mcp_servers, mcp_source, tool_enable,
+                                                            tool_ids, mcp_output_enable)
             if is_ai_chat:
                 request_token = chat_model.get_num_tokens_from_messages(message_list)
                 response_token = chat_model.get_num_tokens(chat_result.content)
@@ -303,16 +412,15 @@ class BaseChatStep(IChatStep):
             reasoning_result_end = reasoning.get_end_reasoning_content()
             content = reasoning_result.get('content') + reasoning_result_end.get('content')
             if 'reasoning_content' in chat_result.response_metadata:
-                reasoning_content = chat_result.response_metadata.get('reasoning_content', '')
+                reasoning_content = (chat_result.response_metadata.get('reasoning_content', '') or '')
             else:
-                reasoning_content = reasoning_result.get('reasoning_content') + reasoning_result_end.get(
+                reasoning_content = (reasoning_result.get('reasoning_content') or "") + (reasoning_result_end.get(
-                    'reasoning_content')
+                    'reasoning_content') or "")
-            asker = manage.context.get('form_data', {}).get('asker', None)
             post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
-                                          content, manage, self, padding_problem_text, client_id,
+                                          content, manage, self, padding_problem_text,
-                                          reasoning_content=reasoning_content if reasoning_content_enable else '',
+                                          reasoning_content=reasoning_content)
-                                          asker=asker)
+            if not manage.debug:
-            add_access_num(client_id, client_type, manage.context.get('application_id'))
+                add_access_num(chat_user_id, chat_user_type, manage.context.get('application_id'))
             return manage.get_base_to_response().to_block_response(str(chat_id), str(chat_record_id),
                                                                    content, True,
                                                                    request_token, response_token,
@@ -325,10 +433,9 @@ class BaseChatStep(IChatStep):
         except Exception as e:
             all_text = 'Exception:' + str(e)
             write_context(self, manage, 0, 0, all_text)
-            asker = manage.context.get('form_data', {}).get('asker', None)
             post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
-                                          all_text, manage, self, padding_problem_text, client_id, reasoning_content='',
+                                          all_text, manage, self, padding_problem_text, reasoning_content='')
-                                          asker=asker)
+            if not manage.debug:
-            add_access_num(client_id, client_type, manage.context.get('application_id'))
+                add_access_num(chat_user_id, chat_user_type, manage.context.get('application_id'))
             return manage.get_base_to_response().to_block_response(str(chat_id), str(chat_record_id), all_text, True, 0,
                                                                    0, _status=status.HTTP_500_INTERNAL_SERVER_ERROR)

apps/application/chat_pipeline/step/generate_human_message_step/i_generate_human_message_step.py

@@ -16,34 +16,35 @@ from rest_framework import serializers
 from application.chat_pipeline.I_base_chat_pipeline import IBaseChatPipelineStep, ParagraphPipelineModel
 from application.chat_pipeline.pipeline_manage import PipelineManage
 from application.models import ChatRecord
-from application.serializers.application_serializers import NoReferencesSetting
+from application.serializers.application import NoReferencesSetting
 from common.field.common import InstanceField
-from common.util.field_message import ErrMessage
 
 
 class IGenerateHumanMessageStep(IBaseChatPipelineStep):
     class InstanceSerializer(serializers.Serializer):
         # 问题
-        problem_text = serializers.CharField(required=True, error_messages=ErrMessage.char(_("question")))
+        problem_text = serializers.CharField(required=True, label=_("question"))
         # 段落列表
         paragraph_list = serializers.ListField(child=InstanceField(model_type=ParagraphPipelineModel, required=True),
-                                               error_messages=ErrMessage.list(_("Paragraph List")))
+                                               label=_("Paragraph List"))
         # 历史对答
         history_chat_record = serializers.ListField(child=InstanceField(model_type=ChatRecord, required=True),
-                                                    error_messages=ErrMessage.list(_("History Questions")))
+                                                    label=_("History Questions"))
         # 多轮对话数量
-        dialogue_number = serializers.IntegerField(required=True, error_messages=ErrMessage.integer(_("Number of multi-round conversations")))
+        dialogue_number = serializers.IntegerField(required=True, label=_("Number of multi-round conversations"))
         # 最大携带知识库段落长度
-        max_paragraph_char_number = serializers.IntegerField(required=True, error_messages=ErrMessage.integer(
+        max_paragraph_char_number = serializers.IntegerField(required=True,
-            _("Maximum length of the knowledge base paragraph")))
+                                                             label=_("Maximum length of the knowledge base paragraph"))
         # 模板
-        prompt = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Prompt word")))
+        prompt = serializers.CharField(required=True, label=_("Prompt word"))
         system = serializers.CharField(required=False, allow_null=True, allow_blank=True,
-                                       error_messages=ErrMessage.char(_("System prompt words (role)")))
+                                       label=_("System prompt words (role)"))
         # 补齐问题
-        padding_problem_text = serializers.CharField(required=False, error_messages=ErrMessage.char(_("Completion problem")))
+        padding_problem_text = serializers.CharField(required=False,
+                                                     label=_("Completion problem"))
         # 未查询到引用分段
-        no_references_setting = NoReferencesSetting(required=True, error_messages=ErrMessage.base(_("No reference segment settings")))
+        no_references_setting = NoReferencesSetting(required=True,
+                                                    label=_("No reference segment settings"))
 
     def get_step_serializer(self, manage: PipelineManage) -> Type[serializers.Serializer]:
         return self.InstanceSerializer

apps/application/chat_pipeline/step/generate_human_message_step/impl/base_generate_human_message_step.py

@@ -15,7 +15,7 @@ from application.chat_pipeline.I_base_chat_pipeline import ParagraphPipelineMode
 from application.chat_pipeline.step.generate_human_message_step.i_generate_human_message_step import \
     IGenerateHumanMessageStep
 from application.models import ChatRecord
-from common.util.split_model import flat_map
+from common.utils.common import flat_map
 
 
 class BaseGenerateHumanMessageStep(IGenerateHumanMessageStep):

apps/application/chat_pipeline/step/reset_problem_step/i_reset_problem_step.py

@@ -16,22 +16,20 @@ from application.chat_pipeline.I_base_chat_pipeline import IBaseChatPipelineStep
 from application.chat_pipeline.pipeline_manage import PipelineManage
 from application.models import ChatRecord
 from common.field.common import InstanceField
-from common.util.field_message import ErrMessage
 
 
 class IResetProblemStep(IBaseChatPipelineStep):
     class InstanceSerializer(serializers.Serializer):
         # 问题文本
-        problem_text = serializers.CharField(required=True, error_messages=ErrMessage.float(_("question")))
+        problem_text = serializers.CharField(required=True, label=_("question"))
         # 历史对答
         history_chat_record = serializers.ListField(child=InstanceField(model_type=ChatRecord, required=True),
-                                                    error_messages=ErrMessage.list(_("History Questions")))
+                                                    label=_("History Questions"))
         # 大语言模型
-        model_id = serializers.UUIDField(required=False, allow_null=True, error_messages=ErrMessage.uuid(_("Model id")))
+        model_id = serializers.UUIDField(required=False, allow_null=True, label=_("Model id"))
-        user_id = serializers.UUIDField(required=True, error_messages=ErrMessage.uuid(_("User ID")))
+        workspace_id = serializers.CharField(required=True, label=_("User ID"))
         problem_optimization_prompt = serializers.CharField(required=False, max_length=102400,
-                                                            error_messages=ErrMessage.char(
+                                                            label=_("Question completion prompt"))
-                                                                _("Question completion prompt")))
 
     def get_step_serializer(self, manage: PipelineManage) -> Type[serializers.Serializer]:
         return self.InstanceSerializer
@@ -52,6 +50,6 @@ class IResetProblemStep(IBaseChatPipelineStep):
     @abstractmethod
     def execute(self, problem_text: str, history_chat_record: List[ChatRecord] = None, model_id: str = None,
                 problem_optimization_prompt=None,
-                user_id=None,
+                workspace_id=None,
                 **kwargs):
         pass

apps/application/chat_pipeline/step/reset_problem_step/impl/base_reset_problem_step.py

@@ -13,8 +13,8 @@ from langchain.schema import HumanMessage
 
 from application.chat_pipeline.step.reset_problem_step.i_reset_problem_step import IResetProblemStep
 from application.models import ChatRecord
-from common.util.split_model import flat_map
+from common.utils.split_model import flat_map
-from setting.models_provider.tools import get_model_instance_by_model_user_id
+from models_provider.tools import get_model_instance_by_model_workspace_id
 
 prompt = _(
     "() contains the user's question. Answer the guessed user's question based on the context ({question}) Requirement: Output a complete question and put it in the <data></data> tag")
@@ -23,9 +23,9 @@ prompt = _(
 class BaseResetProblemStep(IResetProblemStep):
     def execute(self, problem_text: str, history_chat_record: List[ChatRecord] = None, model_id: str = None,
                 problem_optimization_prompt=None,
-                user_id=None,
+                workspace_id=None,
                 **kwargs) -> str:
-        chat_model = get_model_instance_by_model_user_id(model_id, user_id) if model_id is not None else None
+        chat_model = get_model_instance_by_model_workspace_id(model_id, workspace_id) if model_id is not None else None
         if chat_model is None:
             return problem_text
         start_index = len(history_chat_record) - 3

apps/application/chat_pipeline/step/search_dataset_step/i_search_dataset_step.py

@@ -16,62 +16,62 @@ from rest_framework import serializers
 
 from application.chat_pipeline.I_base_chat_pipeline import IBaseChatPipelineStep, ParagraphPipelineModel
 from application.chat_pipeline.pipeline_manage import PipelineManage
-from common.util.field_message import ErrMessage
 
 
 class ISearchDatasetStep(IBaseChatPipelineStep):
     class InstanceSerializer(serializers.Serializer):
         # 原始问题文本
-        problem_text = serializers.CharField(required=True, error_messages=ErrMessage.char(_("question")))
+        problem_text = serializers.CharField(required=True, label=_("question"))
         # 系统补全问题文本
         padding_problem_text = serializers.CharField(required=False,
-                                                     error_messages=ErrMessage.char(_("System completes question text")))
+                                                     label=_("System completes question text"))
         # 需要查询的数据集id列表
-        dataset_id_list = serializers.ListField(required=True, child=serializers.UUIDField(required=True),
+        knowledge_id_list = serializers.ListField(required=True, child=serializers.UUIDField(required=True),
-                                                error_messages=ErrMessage.list(_("Dataset id list")))
+                                                  label=_("Dataset id list"))
         # 需要排除的文档id
         exclude_document_id_list = serializers.ListField(required=True, child=serializers.UUIDField(required=True),
-                                                         error_messages=ErrMessage.list(_("List of document ids to exclude")))
+                                                         label=_("List of document ids to exclude"))
         # 需要排除向量id
         exclude_paragraph_id_list = serializers.ListField(required=True, child=serializers.UUIDField(required=True),
-                                                          error_messages=ErrMessage.list(_("List of exclusion vector ids")))
+                                                          label=_("List of exclusion vector ids"))
         # 需要查询的条数
         top_n = serializers.IntegerField(required=True,
-                                         error_messages=ErrMessage.integer(_("Reference segment number")))
+                                         label=_("Reference segment number"))
         # 相似度 0-1之间
         similarity = serializers.FloatField(required=True, max_value=1, min_value=0,
-                                            error_messages=ErrMessage.float(_("Similarity")))
+                                            label=_("Similarity"))
         search_mode = serializers.CharField(required=True, validators=[
             validators.RegexValidator(regex=re.compile("^embedding|keywords|blend$"),
                                       message=_("The type only supports embedding|keywords|blend"), code=500)
-        ], error_messages=ErrMessage.char(_("Retrieval Mode")))
+        ], label=_("Retrieval Mode"))
-        user_id = serializers.UUIDField(required=True, error_messages=ErrMessage.uuid(_("User ID")))
+        workspace_id = serializers.CharField(required=True, label=_("Workspace ID"))
 
     def get_step_serializer(self, manage: PipelineManage) -> Type[InstanceSerializer]:
         return self.InstanceSerializer
 
     def _run(self, manage: PipelineManage):
-        paragraph_list = self.execute(**self.context['step_args'])
+        paragraph_list = self.execute(**self.context['step_args'], manage=manage)
         manage.context['paragraph_list'] = paragraph_list
         self.context['paragraph_list'] = paragraph_list
 
     @abstractmethod
-    def execute(self, problem_text: str, dataset_id_list: list[str], exclude_document_id_list: list[str],
+    def execute(self, problem_text: str, knowledge_id_list: list[str], exclude_document_id_list: list[str],
                 exclude_paragraph_id_list: list[str], top_n: int, similarity: float, padding_problem_text: str = None,
                 search_mode: str = None,
-                user_id=None,
+                workspace_id=None,
+                manage: PipelineManage = None,
                 **kwargs) -> List[ParagraphPipelineModel]:
         """
         关于 用户和补全问题 说明: 补全问题如果有就使用补全问题去查询 反之就用用户原始问题查询
         :param similarity:                         相关性
         :param top_n:                              查询多少条
         :param problem_text:                       用户问题
-        :param dataset_id_list:                    需要查询的数据集id列表
+        :param knowledge_id_list:                  需要查询的数据集id列表
         :param exclude_document_id_list:           需要排除的文档id
         :param exclude_paragraph_id_list:          需要排除段落id
         :param padding_problem_text                补全问题
         :param search_mode                         检索模式
-        :param user_id                             用户id
+        :param workspace_id                        工作空间id
         :return: 段落列表
         """
         pass

apps/application/chat_pipeline/step/search_dataset_step/impl/base_search_dataset_step.py

@@ -16,51 +16,59 @@ from rest_framework.utils.formatting import lazy_format
 from application.chat_pipeline.I_base_chat_pipeline import ParagraphPipelineModel
 from application.chat_pipeline.step.search_dataset_step.i_search_dataset_step import ISearchDatasetStep
 from common.config.embedding_config import VectorStore, ModelManage
+from common.constants.permission_constants import RoleConstants
+from common.database_model_manage.database_model_manage import DatabaseModelManage
 from common.db.search import native_search
-from common.util.file_util import get_file_content
+from common.utils.common import get_file_content
-from dataset.models import Paragraph, DataSet
+from knowledge.models import Paragraph, Knowledge
-from embedding.models import SearchMode
+from knowledge.models import SearchMode
-from setting.models import Model
+from maxkb.conf import PROJECT_DIR
-from setting.models_provider import get_model
+from models_provider.models import Model
-from smartdoc.conf import PROJECT_DIR
+from models_provider.tools import get_model, get_model_by_id, get_model_default_params
 
 
-def get_model_by_id(_id, user_id):
+def reset_meta(meta):
-    model = QuerySet(Model).filter(id=_id).first()
+    if not meta.get('allow_download', False):
-    if model is None:
+        return {'allow_download': False}
-        raise Exception(_("Model does not exist"))
+    return meta
-    if model.permission_type == 'PRIVATE' and str(model.user_id) != str(user_id):
-        message = lazy_format(_('No permission to use this model {model_name}'), model_name=model.name)
-        raise Exception(message)
-    return model
 
 
-def get_embedding_id(dataset_id_list):
+def get_embedding_id(knowledge_id_list):
-    dataset_list = QuerySet(DataSet).filter(id__in=dataset_id_list)
+    knowledge_list = QuerySet(Knowledge).filter(id__in=knowledge_id_list)
-    if len(set([dataset.embedding_mode_id for dataset in dataset_list])) > 1:
+    if len(set([knowledge.embedding_model_id for knowledge in knowledge_list])) > 1:
-        raise Exception(_("The vector model of the associated knowledge base is inconsistent and the segmentation cannot be recalled."))
+        raise Exception(
-    if len(dataset_list) == 0:
+            _("The vector model of the associated knowledge base is inconsistent and the segmentation cannot be recalled."))
+    if len(knowledge_list) == 0:
         raise Exception(_("The knowledge base setting is wrong, please reset the knowledge base"))
-    return dataset_list[0].embedding_mode_id
+    return knowledge_list[0].embedding_model_id
 
 
 class BaseSearchDatasetStep(ISearchDatasetStep):
 
-    def execute(self, problem_text: str, dataset_id_list: list[str], exclude_document_id_list: list[str],
+    def execute(self, problem_text: str, knowledge_id_list: list[str], exclude_document_id_list: list[str],
                 exclude_paragraph_id_list: list[str], top_n: int, similarity: float, padding_problem_text: str = None,
                 search_mode: str = None,
-                user_id=None,
+                workspace_id=None,
+                manage=None,
                 **kwargs) -> List[ParagraphPipelineModel]:
-        if len(dataset_id_list) == 0:
+        get_knowledge_list_of_authorized = DatabaseModelManage.get_model('get_knowledge_list_of_authorized')
+        chat_user_type = manage.context.get('chat_user_type')
+        if get_knowledge_list_of_authorized is not None and RoleConstants.CHAT_USER.value.name == chat_user_type:
+            knowledge_id_list = get_knowledge_list_of_authorized(manage.context.get('chat_user_id'),
+                                                                 knowledge_id_list)
+        if len(knowledge_id_list) == 0:
             return []
         exec_problem_text = padding_problem_text if padding_problem_text is not None else problem_text
-        model_id = get_embedding_id(dataset_id_list)
+        model_id = get_embedding_id(knowledge_id_list)
-        model = get_model_by_id(model_id, user_id)
+        model = get_model_by_id(model_id, workspace_id)
+        if model.model_type != "EMBEDDING":
+            raise Exception(_("Model does not exist"))
         self.context['model_name'] = model.name
-        embedding_model = ModelManage.get_model(model_id, lambda _id: get_model(model))
+        default_params = get_model_default_params(model)
+        embedding_model = ModelManage.get_model(model_id, lambda _id: get_model(model, **{**default_params}))
         embedding_value = embedding_model.embed_query(exec_problem_text)
         vector = VectorStore.get_embedding_vector()
-        embedding_list = vector.query(exec_problem_text, embedding_value, dataset_id_list, exclude_document_id_list,
+        embedding_list = vector.query(exec_problem_text, embedding_value, knowledge_id_list, None, exclude_document_id_list,
                                       exclude_paragraph_id_list, True, top_n, similarity, SearchMode(search_mode))
         if embedding_list is None:
             return []
@@ -78,11 +86,12 @@ class BaseSearchDatasetStep(ISearchDatasetStep):
                     .add_paragraph(paragraph)
                     .add_similarity(find_embedding.get('similarity'))
                     .add_comprehensive_score(find_embedding.get('comprehensive_score'))
-                    .add_dataset_name(paragraph.get('dataset_name'))
+                    .add_knowledge_name(paragraph.get('knowledge_name'))
+                    .add_knowledge_type(paragraph.get('knowledge_type'))
                     .add_document_name(paragraph.get('document_name'))
                     .add_hit_handling_method(paragraph.get('hit_handling_method'))
                     .add_directly_return_similarity(paragraph.get('directly_return_similarity'))
-                    .add_meta(paragraph.get('meta'))
+                    .add_meta(reset_meta(paragraph.get('meta')))
                     .build())
 
     @staticmethod
@@ -102,7 +111,7 @@ class BaseSearchDatasetStep(ISearchDatasetStep):
         paragraph_list = native_search(QuerySet(Paragraph).filter(id__in=paragraph_id_list),
                                        get_file_content(
                                            os.path.join(PROJECT_DIR, "apps", "application", 'sql',
-                                                        'list_dataset_paragraph_by_paragraph_id.sql')),
+                                                        'list_knowledge_paragraph_by_paragraph_id.sql')),
                                        with_table_name=True)
         # 如果向量库中存在脏数据 直接删除
         if len(paragraph_list) != len(paragraph_id_list):

apps/application/flow/common.py

@@ -6,6 +6,22 @@
     @date：2024/12/11 17:57
     @desc:
 """
+from enum import Enum
+from typing import List, Dict
+
+from django.db.models import QuerySet
+from django.utils.translation import gettext as _
+from rest_framework.exceptions import ErrorDetail, ValidationError
+
+from common.exception.app_exception import AppApiException
+from common.utils.common import group_by
+from models_provider.models import Model
+from models_provider.tools import get_model_credential
+from tools.models.tool import Tool
+
+end_nodes = ['ai-chat-node', 'reply-node', 'function-node', 'function-lib-node', 'application-node',
+             'image-understand-node', 'speech-to-text-node', 'text-to-speech-node', 'image-generate-node',
+             'variable-assign-node']
 
 
 class Answer:
@@ -42,3 +58,220 @@ class NodeChunk:
 
     def is_end(self):
         return self.status == 200
+
+
+class Edge:
+    def __init__(self, _id: str, _type: str, sourceNodeId: str, targetNodeId: str, **keywords):
+        self.id = _id
+        self.type = _type
+        self.sourceNodeId = sourceNodeId
+        self.targetNodeId = targetNodeId
+        for keyword in keywords:
+            self.__setattr__(keyword, keywords.get(keyword))
+
+
+class Node:
+    def __init__(self, _id: str, _type: str, x: int, y: int, properties: dict, **kwargs):
+        self.id = _id
+        self.type = _type
+        self.x = x
+        self.y = y
+        self.properties = properties
+        for keyword in kwargs:
+            self.__setattr__(keyword, kwargs.get(keyword))
+
+
+class EdgeNode:
+    edge: Edge
+    node: Node
+
+    def __init__(self, edge, node):
+        self.edge = edge
+        self.node = node
+
+
+class WorkflowMode(Enum):
+    APPLICATION = "application"
+
+    APPLICATION_LOOP = "application-loop"
+
+    KNOWLEDGE = "knowledge"
+
+    KNOWLEDGE_LOOP = "knowledge-loop"
+
+
+class Workflow:
+    """
+    节点列表
+    """
+    nodes: List[Node]
+    """
+    线列表
+    """
+    edges: List[Edge]
+    """
+    节点id:node
+    """
+    node_map: Dict[str, Node]
+    """
+    节点id:当前节点id上面的所有节点
+    """
+    up_node_map: Dict[str, List[EdgeNode]]
+    """
+     节点id:当前节点id下面的所有节点
+    """
+    next_node_map: Dict[str, List[EdgeNode]]
+
+    workflow_mode: WorkflowMode
+
+    def __init__(self, nodes: List[Node], edges: List[Edge],
+                 workflow_mode: WorkflowMode = WorkflowMode.APPLICATION.value):
+        self.nodes = nodes
+        self.edges = edges
+        self.node_map = {node.id: node for node in nodes}
+
+        self.up_node_map = {key: [EdgeNode(edge, self.node_map.get(edge.sourceNodeId)) for
+                                  edge in edges] for
+                            key, edges in
+                            group_by(edges, key=lambda edge: edge.targetNodeId).items()}
+
+        self.next_node_map = {key: [EdgeNode(edge, self.node_map.get(edge.targetNodeId)) for edge in edges] for
+                              key, edges in
+                              group_by(edges, key=lambda edge: edge.sourceNodeId).items()}
+        self.workflow_mode = workflow_mode
+
+    def get_node(self, node_id):
+        """
+        根据node_id 获取节点信息
+        @param node_id: node_id
+        @return: 节点信息
+        """
+        return self.node_map.get(node_id)
+
+    def get_up_edge_nodes(self, node_id) -> List[EdgeNode]:
+        """
+        根据节点id 获取当前连接前置节点和连线
+        @param node_id: 节点id
+        @return: 节点连线列表
+        """
+        return self.up_node_map.get(node_id)
+
+    def get_next_edge_nodes(self, node_id) -> List[EdgeNode]:
+        """
+        根据节点id 获取当前连接目标节点和连线
+        @param node_id: 节点id
+        @return: 节点连线列表
+        """
+        return self.next_node_map.get(node_id)
+
+    def get_up_nodes(self, node_id) -> List[Node]:
+        """
+        根据节点id 获取当前连接前置节点
+        @param node_id: 节点id
+        @return: 节点列表
+        """
+        return [en.node for en in self.up_node_map.get(node_id)]
+
+    def get_next_nodes(self, node_id) -> List[Node]:
+        """
+        根据节点id 获取当前连接目标节点
+        @param node_id: 节点id
+        @return: 节点列表
+        """
+        return [en.node for en in self.next_node_map.get(node_id, [])]
+
+    @staticmethod
+    def new_instance(flow_obj: Dict, workflow_mode: WorkflowMode = WorkflowMode.APPLICATION):
+        nodes = flow_obj.get('nodes')
+        edges = flow_obj.get('edges')
+        nodes = [Node(node.get('id'), node.get('type'), **node)
+                 for node in nodes]
+        edges = [Edge(edge.get('id'), edge.get('type'), **edge) for edge in edges]
+        return Workflow(nodes, edges, workflow_mode)
+
+    def get_start_node(self):
+        return self.get_node('start-node')
+
+    def get_search_node(self):
+        return [node for node in self.nodes if node.type == 'search-dataset-node']
+
+    def is_valid(self):
+        """
+        校验工作流数据
+        """
+        self.is_valid_model_params()
+        self.is_valid_start_node()
+        self.is_valid_base_node()
+        self.is_valid_work_flow()
+
+    def is_valid_node_params(self, node: Node):
+        from application.flow.step_node import get_node
+        get_node(node.type, self.workflow_mode)(node, None, None)
+
+    def is_valid_node(self, node: Node):
+        self.is_valid_node_params(node)
+        if node.type == 'condition-node':
+            branch_list = node.properties.get('node_data').get('branch')
+            for branch in branch_list:
+                source_anchor_id = f"{node.id}_{branch.get('id')}_right"
+                edge_list = [edge for edge in self.edges if edge.sourceAnchorId == source_anchor_id]
+                if len(edge_list) == 0:
+                    raise AppApiException(500,
+                                          _('The branch {branch} of the {node} node needs to be connected').format(
+                                              node=node.properties.get("stepName"), branch=branch.get("type")))
+
+        else:
+            edge_list = [edge for edge in self.edges if edge.sourceNodeId == node.id]
+            if len(edge_list) == 0 and not end_nodes.__contains__(node.type):
+                raise AppApiException(500, _("{node} Nodes cannot be considered as end nodes").format(
+                    node=node.properties.get("stepName")))
+
+    def is_valid_work_flow(self, up_node=None):
+        if up_node is None:
+            up_node = self.get_start_node()
+        self.is_valid_node(up_node)
+        next_nodes = self.get_next_nodes(up_node)
+        for next_node in next_nodes:
+            self.is_valid_work_flow(next_node)
+
+    def is_valid_start_node(self):
+        start_node_list = [node for node in self.nodes if node.id == 'start-node']
+        if len(start_node_list) == 0:
+            raise AppApiException(500, _('The starting node is required'))
+        if len(start_node_list) > 1:
+            raise AppApiException(500, _('There can only be one starting node'))
+
+    def is_valid_model_params(self):
+        node_list = [node for node in self.nodes if (node.type == 'ai-chat-node' or node.type == 'question-node')]
+        for node in node_list:
+            model = QuerySet(Model).filter(id=node.properties.get('node_data', {}).get('model_id')).first()
+            if model is None:
+                raise ValidationError(ErrorDetail(
+                    _('The node {node} model does not exist').format(node=node.properties.get("stepName"))))
+            credential = get_model_credential(model.provider, model.model_type, model.model_name)
+            model_params_setting = node.properties.get('node_data', {}).get('model_params_setting')
+            model_params_setting_form = credential.get_model_params_setting_form(
+                model.model_name)
+            if model_params_setting is None:
+                model_params_setting = model_params_setting_form.get_default_form_data()
+                node.properties.get('node_data', {})['model_params_setting'] = model_params_setting
+            if node.properties.get('status', 200) != 200:
+                raise ValidationError(
+                    ErrorDetail(_("Node {node} is unavailable").format(node.properties.get("stepName"))))
+        node_list = [node for node in self.nodes if (node.type == 'function-lib-node')]
+        for node in node_list:
+            function_lib_id = node.properties.get('node_data', {}).get('function_lib_id')
+            if function_lib_id is None:
+                raise ValidationError(ErrorDetail(
+                    _('The library ID of node {node} cannot be empty').format(node=node.properties.get("stepName"))))
+            f_lib = QuerySet(Tool).filter(id=function_lib_id).first()
+            if f_lib is None:
+                raise ValidationError(ErrorDetail(_("The function library for node {node} is not available").format(
+                    node=node.properties.get("stepName"))))
+
+    def is_valid_base_node(self):
+        base_node_list = [node for node in self.nodes if node.id == 'base-node']
+        if len(base_node_list) == 0:
+            raise AppApiException(500, _('Basic information node is required'))
+        if len(base_node_list) > 1:
+            raise AppApiException(500, _('There can only be one basic information node'))

apps/application/flow/compare/__init__.py

@@ -8,6 +8,7 @@
 """
 
 from .contain_compare import *
+from .end_with import EndWithCompare
 from .equal_compare import *
 from .ge_compare import *
 from .gt_compare import *
@@ -23,8 +24,10 @@ from .len_le_compare import *
 from .len_lt_compare import *
 from .lt_compare import *
 from .not_contain_compare import *
+from .start_with import StartWithCompare
 
 compare_handle_list = [GECompare(), GTCompare(), ContainCompare(), EqualCompare(), LTCompare(), LECompare(),
                        LenLECompare(), LenGECompare(), LenEqualCompare(), LenGTCompare(), LenLTCompare(),
                        IsNullCompare(),
-                       IsNotNullCompare(), NotContainCompare(), IsTrueCompare(), IsNotTrueCompare()]
+                       IsNotNullCompare(), NotContainCompare(), IsTrueCompare(), IsNotTrueCompare(), StartWithCompare(),
+                       EndWithCompare()]

apps/application/flow/compare/contain_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare.compare import Compare
 
 
 class ContainCompare(Compare):
@@ -20,4 +20,7 @@ class ContainCompare(Compare):
     def compare(self, source_value, compare, target_value):
         if isinstance(source_value, str):
             return str(target_value) in source_value
-        return any([str(item) == str(target_value) for item in source_value])
+        elif isinstance(source_value, list):
+            return any([str(item) == str(target_value) for item in source_value])
+        else:
+            return str(target_value) in str(source_value)

apps/application/flow/compare/end_with.py

@@ -0,0 +1,22 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： start_with.py
+    @date：2025/10/20 10:37
+    @desc:
+"""
+from typing import List
+
+from application.flow.compare import Compare
+
+
+class EndWithCompare(Compare):
+
+    def support(self, node_id, fields: List[str], source_value, compare, target_value):
+        if compare == 'end_with':
+            return True
+
+    def compare(self, source_value, compare, target_value):
+        source_value = str(source_value)
+        return source_value.endswith(str(target_value))

apps/application/flow/compare/equal_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class EqualCompare(Compare):

apps/application/flow/compare/ge_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class GECompare(Compare):
@@ -21,4 +21,8 @@ class GECompare(Compare):
         try:
             return float(source_value) >= float(target_value)
         except Exception as e:
+            try:
+                return str(source_value) >= str(target_value)
+            except Exception as _:
+                pass
             return False

apps/application/flow/compare/gt_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class GTCompare(Compare):
@@ -21,4 +21,8 @@ class GTCompare(Compare):
         try:
             return float(source_value) > float(target_value)
         except Exception as e:
+            try:
+                return str(source_value) > str(target_value)
+            except Exception as _:
+                pass
             return False

apps/application/flow/compare/is_not_null_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare import Compare
+from application.flow.compare import Compare
 
 
 class IsNotNullCompare(Compare):

apps/application/flow/compare/is_not_true.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare import Compare
+from application.flow.compare import Compare
 
 
 class IsNotTrueCompare(Compare):

apps/application/flow/compare/is_null_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare import Compare
+from application.flow.compare import Compare
 
 
 class IsNullCompare(Compare):
@@ -18,4 +18,7 @@ class IsNullCompare(Compare):
             return True
 
     def compare(self, source_value, compare, target_value):
-        return source_value is None or len(source_value) == 0
+        try:
+            return source_value is None or len(source_value) == 0
+        except Exception as e:
+            return False

apps/application/flow/compare/is_true.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare import Compare
+from application.flow.compare import Compare
 
 
 class IsTrueCompare(Compare):

apps/application/flow/compare/le_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class LECompare(Compare):
@@ -21,4 +21,8 @@ class LECompare(Compare):
         try:
             return float(source_value) <= float(target_value)
         except Exception as e:
+            try:
+                return str(source_value) <= str(target_value)
+            except Exception as _:
+                pass
             return False

apps/application/flow/compare/len_equal_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class LenEqualCompare(Compare):

apps/application/flow/compare/len_ge_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class LenGECompare(Compare):

apps/application/flow/compare/len_gt_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class LenGTCompare(Compare):

apps/application/flow/compare/len_le_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class LenLECompare(Compare):

apps/application/flow/compare/len_lt_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class LenLTCompare(Compare):

apps/application/flow/compare/lt_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class LTCompare(Compare):
@@ -21,4 +21,8 @@ class LTCompare(Compare):
         try:
             return float(source_value) < float(target_value)
         except Exception as e:
+            try:
+                return str(source_value) < str(target_value)
+            except Exception as _:
+                pass
             return False

apps/application/flow/compare/not_contain_compare.py

@@ -8,7 +8,7 @@
 """
 from typing import List
 
-from application.flow.step_node.condition_node.compare.compare import Compare
+from application.flow.compare import Compare
 
 
 class NotContainCompare(Compare):
@@ -20,4 +20,7 @@ class NotContainCompare(Compare):
     def compare(self, source_value, compare, target_value):
         if isinstance(source_value, str):
             return str(target_value) not in source_value
-        return not any([str(item) == str(target_value) for item in source_value])
+        elif isinstance(self, list):
+            return not any([str(item) == str(target_value) for item in source_value])
+        else:
+            return str(target_value) not in str(source_value)

apps/application/flow/compare/start_with.py

@@ -0,0 +1,22 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： start_with.py
+    @date：2025/10/20 10:37
+    @desc:
+"""
+from typing import List
+
+from application.flow.compare import Compare
+
+
+class StartWithCompare(Compare):
+
+    def support(self, node_id, fields: List[str], source_value, compare, target_value):
+        if compare == 'start_with':
+            return True
+
+    def compare(self, source_value, compare, target_value):
+        source_value = str(source_value)
+        return source_value.startswith(str(target_value))

apps/application/flow/i_step_node.py

@@ -18,13 +18,12 @@ from rest_framework import serializers
 from rest_framework.exceptions import ValidationError, ErrorDetail
 
 from application.flow.common import Answer, NodeChunk
-from application.models import ChatRecord
+from application.models import ApplicationChatUserStats
-from application.models.api_key_model import ApplicationPublicAccessClient
+from application.models import ChatRecord, ChatUserType
-from common.constants.authentication_type import AuthenticationType
 from common.field.common import InstanceField
-from common.util.field_message import ErrMessage
+from knowledge.models.knowledge_action import KnowledgeAction, State
 
-chat_cache = cache.caches['chat_cache']
+chat_cache = cache
 
 
 def write_context(step_variable: Dict, global_variable: Dict, node, workflow):
@@ -46,16 +45,14 @@ def is_interrupt(node, step_variable: Dict, global_variable: Dict):
 
 
 class WorkFlowPostHandler:
-    def __init__(self, chat_info, client_id, client_type):
+    def __init__(self, chat_info):
         self.chat_info = chat_info
-        self.client_id = client_id
-        self.client_type = client_type
 
-    def handler(self, chat_id,
+    def handler(self, workflow):
-                chat_record_id,
+        workflow_body = workflow.get_body()
-                answer,
+        question = workflow_body.get('question')
-                workflow):
+        chat_record_id = workflow_body.get('chat_record_id')
-        question = workflow.params['question']
+        chat_id = workflow_body.get('chat_id')
         details = workflow.get_runtime_details()
         message_tokens = sum([row.get('message_tokens') for row in details.values() if
                               'message_tokens' in row and row.get('message_tokens') is not None])
@@ -82,21 +79,60 @@ class WorkFlowPostHandler:
                                      message_tokens=message_tokens,
                                      answer_tokens=answer_tokens,
                                      answer_text_list=answer_text_list,
-                                     run_time=time.time() - workflow.context['start_time'],
+                                     run_time=time.time() - workflow.context.get('start_time') if workflow.context.get(
+                                         'start_time') is not None else 0,
                                      index=0)
-        asker = workflow.context.get('asker', None)
+
-        self.chat_info.append_chat_record(chat_record, self.client_id, asker)
+        self.chat_info.append_chat_record(chat_record)
-        # 重新设置缓存
+        self.chat_info.set_cache()
-        chat_cache.set(chat_id,
+
-                       self.chat_info, timeout=60 * 30)
+        if not self.chat_info.debug and [ChatUserType.ANONYMOUS_USER.value, ChatUserType.CHAT_USER.value].__contains__(
-        if self.client_type == AuthenticationType.APPLICATION_ACCESS_TOKEN.value:
+                workflow_body.get('chat_user_type')):
-            application_public_access_client = (QuerySet(ApplicationPublicAccessClient)
+            application_public_access_client = (QuerySet(ApplicationChatUserStats)
-                                                .filter(client_id=self.client_id,
+                                                .filter(chat_user_id=workflow_body.get('chat_user_id'),
-                                                        application_id=self.chat_info.application.id).first())
+                                                        chat_user_type=workflow_body.get('chat_user_type'),
+                                                        application_id=self.chat_info.application_id).first())
             if application_public_access_client is not None:
                 application_public_access_client.access_num = application_public_access_client.access_num + 1
                 application_public_access_client.intraday_access_num = application_public_access_client.intraday_access_num + 1
                 application_public_access_client.save()
+        self.chat_info = None
+
+
+class KnowledgeWorkflowPostHandler(WorkFlowPostHandler):
+    def __init__(self, chat_info, knowledge_action_id):
+        super().__init__(chat_info)
+        self.knowledge_action_id = knowledge_action_id
+
+    def handler(self, workflow):
+        state = get_workflow_state(workflow)
+        QuerySet(KnowledgeAction).filter(id=self.knowledge_action_id).update(
+            state=state,
+            run_time=time.time() - workflow.context.get('start_time') if workflow.context.get(
+                'start_time') is not None else 0)
+
+
+def get_loop_workflow_node(node_list):
+    result = []
+    for item in node_list:
+        if item.get('type') == 'loop-node':
+            for loop_item in item.get('loop_node_data') or []:
+                for inner_item in loop_item.values():
+                    result.append(inner_item)
+    return result
+
+
+def get_workflow_state(workflow):
+    details = workflow.get_runtime_details()
+    node_list = details.values()
+    all_node = [*node_list, *get_loop_workflow_node(node_list)]
+    err = any([True for value in all_node if value.get('status') == 500])
+    if err:
+        return State.FAILURE
+    write_is_exist = any([True for value in all_node if value.get('type') == 'knowledge-write-node'])
+    if not write_is_exist:
+        return State.FAILURE
+    return State.SUCCESS
 
 
 class NodeResult:
@@ -123,31 +159,44 @@ class NodeResult:
 
 
 class ReferenceAddressSerializer(serializers.Serializer):
-    node_id = serializers.CharField(required=True, error_messages=ErrMessage.char("节点id"))
+    node_id = serializers.CharField(required=True, label="节点id")
     fields = serializers.ListField(
-        child=serializers.CharField(required=True, error_messages=ErrMessage.char("节点字段")), required=True,
+        child=serializers.CharField(required=True, label="节点字段"), required=True,
-        error_messages=ErrMessage.list("节点字段数组"))
+        label="节点字段数组")
 
 
 class FlowParamsSerializer(serializers.Serializer):
     # 历史对答
     history_chat_record = serializers.ListField(child=InstanceField(model_type=ChatRecord, required=True),
-                                                error_messages=ErrMessage.list("历史对答"))
+                                                label="历史对答")
 
-    question = serializers.CharField(required=True, error_messages=ErrMessage.list("用户问题"))
+    question = serializers.CharField(required=True, label="用户问题")
 
-    chat_id = serializers.CharField(required=True, error_messages=ErrMessage.list("对话id"))
+    chat_id = serializers.CharField(required=True, label="对话id")
 
-    chat_record_id = serializers.CharField(required=True, error_messages=ErrMessage.char("对话记录id"))
+    chat_record_id = serializers.CharField(required=True, label="对话记录id")
 
-    stream = serializers.BooleanField(required=True, error_messages=ErrMessage.boolean("流式输出"))
+    stream = serializers.BooleanField(required=True, label="流式输出")
 
-    client_id = serializers.CharField(required=False, error_messages=ErrMessage.char("客户端id"))
+    chat_user_id = serializers.CharField(required=False, label="对话用户id")
 
-    client_type = serializers.CharField(required=False, error_messages=ErrMessage.char("客户端类型"))
+    chat_user_type = serializers.CharField(required=False, label="对话用户类型")
 
-    user_id = serializers.UUIDField(required=True, error_messages=ErrMessage.uuid("用户id"))
+    workspace_id = serializers.CharField(required=True, label="工作空间id")
-    re_chat = serializers.BooleanField(required=True, error_messages=ErrMessage.boolean("换个答案"))
+
+    application_id = serializers.CharField(required=True, label="应用id")
+
+    re_chat = serializers.BooleanField(required=True, label="换个答案")
+
+    debug = serializers.BooleanField(required=True, label="是否debug")
+
+
+class KnowledgeFlowParamsSerializer(serializers.Serializer):
+    knowledge_id = serializers.UUIDField(required=True, label="知识库id")
+    workspace_id = serializers.CharField(required=True, label="工作空间id")
+    knowledge_action_id = serializers.UUIDField(required=True, label="知识库任务执行器id")
+    data_source = serializers.DictField(required=True, label="数据源")
+    knowledge_base = serializers.DictField(required=False, label="知识库设置")
 
 
 class INode:
@@ -162,11 +211,12 @@ class INode:
             return None
         reasoning_content_enable = self.context.get('model_setting', {}).get('reasoning_content_enable', False)
         return [
-            Answer(self.answer_text, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'], {},
+            Answer(self.answer_text, self.view_type, self.runtime_node_id, self.workflow_params.get('chat_record_id'),
+                   {},
                    self.runtime_node_id, self.context.get('reasoning_content', '') if reasoning_content_enable else '')]
 
     def __init__(self, node, workflow_params, workflow_manage, up_node_id_list=None,
-                 get_node_params=lambda node: node.properties.get('node_data')):
+                 get_node_params=lambda node: node.properties.get('node_data'), salt=None):
         # 当前步骤上下文,用于存储当前步骤信息
         self.status = 200
         self.err_message = ''
@@ -186,7 +236,8 @@ class INode:
         self.runtime_node_id = sha1(uuid.NAMESPACE_DNS.bytes + bytes(str(uuid.uuid5(uuid.NAMESPACE_DNS,
                                                                                     "".join([*sorted(up_node_id_list),
                                                                                              node.id]))),
-                                                                     "utf-8")).hexdigest()
+                                                                     "utf-8")).hexdigest() + (
+                                   "__" + str(salt) if salt is not None else '')
 
     def valid_args(self, node_params, flow_params):
         flow_params_serializer_class = self.get_flow_params_serializer_class()
@@ -218,13 +269,14 @@ class INode:
         pass
 
     def get_flow_params_serializer_class(self) -> Type[serializers.Serializer]:
-        return FlowParamsSerializer
+        return self.workflow_manage.get_params_serializer_class()
 
     def get_write_error_context(self, e):
         self.status = 500
         self.answer_text = str(e)
         self.err_message = str(e)
-        self.context['run_time'] = time.time() - self.context['start_time']
+        current_time = time.time()
+        self.context['run_time'] = current_time - (self.context.get('start_time') or current_time)
 
         def write_error_context(answer, status=200):
             pass

apps/application/flow/knowledge_loop_workflow_manage.py

@@ -0,0 +1,15 @@
+# coding=utf-8
+"""
+    @project: maxkb
+    @Author：虎
+    @file： workflow_manage.py
+    @date：2024/1/9 17:40
+    @desc:
+"""
+from application.flow.i_step_node import KnowledgeFlowParamsSerializer
+from application.flow.loop_workflow_manage import LoopWorkflowManage
+
+
+class KnowledgeLoopWorkflowManage(LoopWorkflowManage):
+    def get_params_serializer_class(self):
+        return KnowledgeFlowParamsSerializer

apps/application/flow/knowledge_workflow_manage.py

@@ -0,0 +1,102 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： Knowledge_workflow_manage.py
+    @date：2025/11/13 19:02
+    @desc:
+"""
+import time
+import traceback
+from concurrent.futures import ThreadPoolExecutor
+
+from django.db.models import QuerySet
+from django.utils.translation import get_language
+
+from application.flow.common import Workflow
+from application.flow.i_step_node import WorkFlowPostHandler, KnowledgeFlowParamsSerializer
+from application.flow.workflow_manage import WorkflowManage
+from common.handle.base_to_response import BaseToResponse
+from common.handle.impl.response.system_to_response import SystemToResponse
+from knowledge.models.knowledge_action import KnowledgeAction, State
+
+executor = ThreadPoolExecutor(max_workers=200)
+
+
+class KnowledgeWorkflowManage(WorkflowManage):
+
+    def __init__(self, flow: Workflow,
+                 params,
+                 work_flow_post_handler: WorkFlowPostHandler,
+                 base_to_response: BaseToResponse = SystemToResponse(),
+                 start_node_id=None,
+                 start_node_data=None, chat_record=None, child_node=None):
+        super().__init__(flow, params, work_flow_post_handler, base_to_response, None, None, None,
+                         None,
+                         None, None, start_node_id, start_node_data, chat_record, child_node)
+
+    def get_params_serializer_class(self):
+        return KnowledgeFlowParamsSerializer
+
+    def get_start_node(self):
+        start_node_list = [node for node in self.flow.nodes if
+                           self.params.get('data_source', {}).get('node_id') == node.id]
+        return start_node_list[0]
+
+    def run(self):
+        self.context['start_time'] = time.time()
+        executor.submit(self._run)
+
+    def _run(self):
+        QuerySet(KnowledgeAction).filter(id=self.params.get('knowledge_action_id')).update(
+            state=State.STARTED)
+        language = get_language()
+        self.run_chain_async(self.start_node, None, language)
+        while self.is_run():
+            pass
+        self.work_flow_post_handler.handler(self)
+
+    @staticmethod
+    def get_node_details(current_node, node, index):
+        if current_node == node:
+            return {
+                'name': node.node.properties.get('stepName'),
+                "index": index,
+                'run_time': 0,
+                'type': node.type,
+                'status': 202,
+                'err_message': ""
+            }
+
+        return node.get_details(index)
+
+    def run_chain(self, current_node, node_result_future=None):
+        QuerySet(KnowledgeAction).filter(id=self.params.get('knowledge_action_id')).update(
+            details=self.get_runtime_details(lambda node, index: self.get_node_details(current_node, node, index)))
+        if node_result_future is None:
+            node_result_future = self.run_node_future(current_node)
+        try:
+            result = self.hand_node_result(current_node, node_result_future)
+            return result
+        except Exception as e:
+            traceback.print_exc()
+        return None
+
+    def hand_node_result(self, current_node, node_result_future):
+        try:
+            current_result = node_result_future.result()
+            result = current_result.write_context(current_node, self)
+            if result is not None:
+                # 阻塞获取结果
+                list(result)
+            return current_result
+        except Exception as e:
+            traceback.print_exc()
+            self.status = 500
+            current_node.get_write_error_context(e)
+            self.answer += str(e)
+            QuerySet(KnowledgeAction).filter(id=self.params.get('knowledge_action_id')).update(state=State.FAILURE)
+        finally:
+            current_node.node_chunk.end()
+            QuerySet(KnowledgeAction).filter(id=self.params.get('knowledge_action_id')).update(
+                details=self.get_runtime_details())

apps/application/flow/loop_workflow_manage.py

@@ -0,0 +1,193 @@
+# coding=utf-8
+"""
+    @project: maxkb
+    @Author：虎
+    @file： workflow_manage.py
+    @date：2024/1/9 17:40
+    @desc:
+"""
+from concurrent.futures import ThreadPoolExecutor
+from typing import List
+
+from django.db import close_old_connections
+from django.utils.translation import get_language
+from langchain_core.prompts import PromptTemplate
+
+from application.flow.common import Workflow
+from application.flow.i_step_node import WorkFlowPostHandler, INode
+from application.flow.step_node import get_node
+from application.flow.workflow_manage import WorkflowManage
+from common.handle.base_to_response import BaseToResponse
+from common.handle.impl.response.system_to_response import SystemToResponse
+
+executor = ThreadPoolExecutor(max_workers=200)
+
+
+class NodeResultFuture:
+    def __init__(self, r, e, status=200):
+        self.r = r
+        self.e = e
+        self.status = status
+
+    def result(self):
+        if self.status == 200:
+            return self.r
+        else:
+            raise self.e
+
+
+def await_result(result, timeout=1):
+    try:
+        result.result(timeout)
+        return False
+    except Exception as e:
+        return True
+
+
+class NodeChunkManage:
+
+    def __init__(self, work_flow):
+        self.node_chunk_list = []
+        self.current_node_chunk = None
+        self.work_flow = work_flow
+
+    def add_node_chunk(self, node_chunk):
+        self.node_chunk_list.append(node_chunk)
+
+    def contains(self, node_chunk):
+        return self.node_chunk_list.__contains__(node_chunk)
+
+    def pop(self):
+        if self.current_node_chunk is None:
+            try:
+                current_node_chunk = self.node_chunk_list.pop(0)
+                self.current_node_chunk = current_node_chunk
+            except IndexError as e:
+                pass
+        if self.current_node_chunk is not None:
+            try:
+                chunk = self.current_node_chunk.chunk_list.pop(0)
+                return chunk
+            except IndexError as e:
+                if self.current_node_chunk.is_end():
+                    self.current_node_chunk = None
+                    if self.work_flow.answer_is_not_empty():
+                        chunk = self.work_flow.base_to_response.to_stream_chunk_response(
+                            self.work_flow.params['chat_id'],
+                            self.work_flow.params['chat_record_id'],
+                            '\n\n', False, 0, 0)
+                        self.work_flow.append_answer('\n\n')
+                        return chunk
+                    return self.pop()
+        return None
+
+
+class LoopWorkflowManage(WorkflowManage):
+
+    def __init__(self, flow: Workflow,
+                 params,
+                 work_flow_post_handler: WorkFlowPostHandler,
+                 parentWorkflowManage,
+                 loop_params,
+                 get_loop_context,
+                 base_to_response: BaseToResponse = SystemToResponse(),
+                 start_node_id=None,
+                 start_node_data=None, chat_record=None, child_node=None):
+        self.parentWorkflowManage = parentWorkflowManage
+        self.loop_params = loop_params
+        self.get_loop_context = get_loop_context
+        self.loop_field_list = []
+        super().__init__(flow, params, work_flow_post_handler, base_to_response, None, None, None,
+                         None,
+                         None, None, start_node_id, start_node_data, chat_record, child_node)
+
+    def get_node_cls_by_id(self, node_id, up_node_id_list=None,
+                           get_node_params=lambda node: node.properties.get('node_data')):
+        for node in self.flow.nodes:
+            if node.id == node_id:
+                node_instance = get_node(node.type, self.flow.workflow_mode)(node,
+                                                                             self.params, self, up_node_id_list,
+                                                                             get_node_params,
+                                                                             salt=self.get_index())
+                return node_instance
+        return None
+
+    def stream(self):
+        close_old_connections()
+        language = get_language()
+        self.run_chain_async(self.start_node, None, language)
+        return self.await_result(is_cleanup=False)
+
+    def get_index(self):
+        return self.loop_params.get('index')
+
+    def get_start_node(self):
+        start_node_list = [node for node in self.flow.nodes if
+                           ['loop-start-node'].__contains__(node.type)]
+        return start_node_list[0]
+
+    def get_reference_field(self, node_id: str, fields: List[str]):
+        """
+        @param node_id: 节点id
+        @param fields:  字段
+        @return:
+        """
+        if node_id == 'global':
+            return self.parentWorkflowManage.get_reference_field(node_id, fields)
+        elif node_id == 'chat':
+            return self.parentWorkflowManage.get_reference_field(node_id, fields)
+        elif node_id == 'loop':
+            loop_context = self.get_loop_context()
+            return INode.get_field(loop_context, fields)
+        else:
+            node = self.get_node_by_id(node_id)
+            if node:
+                return node.get_reference_field(fields)
+            return self.parentWorkflowManage.get_reference_field(node_id, fields)
+
+    def get_workflow_content(self):
+        context = {
+            'global': self.context,
+            'chat': self.chat_context,
+            'loop': self.get_loop_context(),
+        }
+
+        for node in self.node_context:
+            context[node.id] = node.context
+        return context
+
+    def init_fields(self):
+        super().init_fields()
+        loop_field_list = []
+        loop_start_node = self.flow.get_node('loop-start-node')
+        loop_input_field_list = loop_start_node.properties.get('loop_input_field_list')
+        node_name = loop_start_node.properties.get('stepName')
+        node_id = loop_start_node.id
+        if loop_input_field_list is not None:
+            for f in loop_input_field_list:
+                loop_field_list.append(
+                    {'label': f.get('label'), 'value': f.get('field'), 'node_id': node_id, 'node_name': node_name})
+        self.loop_field_list = loop_field_list
+
+    def reset_prompt(self, prompt: str):
+        prompt = super().reset_prompt(prompt)
+        for field in self.loop_field_list:
+            chatLabel = f"loop.{field.get('value')}"
+            chatValue = f"context.get('loop').get('{field.get('value', '')}','')"
+            prompt = prompt.replace(chatLabel, chatValue)
+
+        prompt = self.parentWorkflowManage.reset_prompt(prompt)
+        return prompt
+
+    def generate_prompt(self, prompt: str):
+        """
+        格式化生成提示词
+        @param prompt: 提示词信息
+        @return: 格式化后的提示词
+        """
+
+        context = {**self.get_workflow_content(), **self.parentWorkflowManage.get_workflow_content()}
+        prompt = self.reset_prompt(prompt)
+        prompt_template = PromptTemplate.from_template(prompt, template_format='jinja2')
+        value = prompt_template.format(context=context)
+        return value

apps/application/flow/step_node/__init__.py

@@ -9,34 +9,52 @@
 from .ai_chat_step_node import *
 from .application_node import BaseApplicationNode
 from .condition_node import *
+from .data_source_local_node.impl.base_data_source_local_node import BaseDataSourceLocalNode
+from .data_source_web_node.impl.base_data_source_web_node import BaseDataSourceWebNode
 from .direct_reply_node import *
+from .document_extract_node import *
 from .form_node import *
-from .function_lib_node import *
+from .image_generate_step_node import *
-from .function_node import *
+from .image_to_video_step_node import BaseImageToVideoNode
+from .image_understand_step_node import *
+from .intent_node import *
+from .knowledge_write_node.impl.base_knowledge_write_node import BaseKnowledgeWriteNode
+from .loop_break_node import BaseLoopBreakNode
+from .loop_continue_node import BaseLoopContinueNode
+from .loop_node import *
+from .loop_start_node import *
+from .mcp_node import BaseMcpNode
+from .parameter_extraction_node import BaseParameterExtractionNode
 from .question_node import *
 from .reranker_node import *
-
+from .search_document_node import BaseSearchDocumentNode
-from .document_extract_node import *
+from .search_knowledge_node import *
-from .image_understand_step_node import *
-from .image_generate_step_node import *
-
-from .search_dataset_node import *
 from .speech_to_text_step_node import BaseSpeechToTextNode
 from .start_node import *
 from .text_to_speech_step_node.impl.base_text_to_speech_node import BaseTextToSpeechNode
+from .text_to_video_step_node.impl.base_text_to_video_node import BaseTextToVideoNode
+from .tool_lib_node import *
+from .tool_node import *
+from .variable_aggregation_node.impl.base_variable_aggregation_node import BaseVariableAggregationNode
 from .variable_assign_node import BaseVariableAssignNode
-from .mcp_node import BaseMcpNode
+from .variable_splitting_node import BaseVariableSplittingNode
+from .video_understand_step_node import BaseVideoUnderstandNode
+from .document_split_node import BaseDocumentSplitNode
 
-node_list = [BaseStartStepNode, BaseChatNode, BaseSearchDatasetNode, BaseQuestionNode,
+node_list = [BaseStartStepNode, BaseChatNode, BaseSearchKnowledgeNode, BaseSearchDocumentNode, BaseQuestionNode,
              BaseConditionNode, BaseReplyNode,
-             BaseFunctionNodeNode, BaseFunctionLibNodeNode, BaseRerankerNode, BaseApplicationNode,
+             BaseToolNodeNode, BaseToolLibNodeNode, BaseRerankerNode, BaseApplicationNode,
              BaseDocumentExtractNode,
              BaseImageUnderstandNode, BaseFormNode, BaseSpeechToTextNode, BaseTextToSpeechNode,
-             BaseImageGenerateNode, BaseVariableAssignNode, BaseMcpNode]
+             BaseImageGenerateNode, BaseVariableAssignNode, BaseMcpNode, BaseTextToVideoNode, BaseImageToVideoNode,
+             BaseVideoUnderstandNode,
+             BaseIntentNode, BaseLoopNode, BaseLoopStartStepNode,
+             BaseLoopContinueNode,
+             BaseLoopBreakNode, BaseVariableSplittingNode, BaseParameterExtractionNode, BaseVariableAggregationNode,
+             BaseDataSourceLocalNode, BaseDataSourceWebNode, BaseKnowledgeWriteNode, BaseDocumentSplitNode]
+
+node_map = {n.type: {w: n for w in n.support} for n in node_list}
 
 
-def get_node(node_type):
+def get_node(node_type, workflow_model):
-    find_list = [node for node in node_list if node.type == node_type]
+    return node_map.get(node_type).get(workflow_model)
-    if len(find_list) > 0:
-        return find_list[0]
-    return None

apps/application/flow/step_node/ai_chat_step_node/i_chat_node.py

@@ -11,41 +11,55 @@ from typing import Type
 from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode, NodeResult
-from common.util.field_message import ErrMessage
 
 
 class ChatNodeSerializer(serializers.Serializer):
-    model_id = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Model id")))
+    model_id = serializers.CharField(required=True, label=_("Model id"))
     system = serializers.CharField(required=False, allow_blank=True, allow_null=True,
-                                   error_messages=ErrMessage.char(_("Role Setting")))
+                                   label=_("Role Setting"))
-    prompt = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Prompt word")))
+    prompt = serializers.CharField(required=True, label=_("Prompt word"))
     # 多轮对话数量
-    dialogue_number = serializers.IntegerField(required=True, error_messages=ErrMessage.integer(
+    dialogue_number = serializers.IntegerField(required=True, label=_("Number of multi-round conversations"))
-        _("Number of multi-round conversations")))
 
     is_result = serializers.BooleanField(required=False,
-                                         error_messages=ErrMessage.boolean(_('Whether to return content')))
+                                         label=_('Whether to return content'))
 
     model_params_setting = serializers.DictField(required=False,
-                                                 error_messages=ErrMessage.dict(_("Model parameter settings")))
+                                                 label=_("Model parameter settings"))
     model_setting = serializers.DictField(required=False,
-                                          error_messages=ErrMessage.dict('Model settings'))
+                                          label='Model settings')
     dialogue_type = serializers.CharField(required=False, allow_blank=True, allow_null=True,
-                                          error_messages=ErrMessage.char(_("Context Type")))
+                                          label=_("Context Type"))
-    mcp_enable = serializers.BooleanField(required=False,
+    mcp_enable = serializers.BooleanField(required=False, label=_("Whether to enable MCP"))
-                                         error_messages=ErrMessage.boolean(_("Whether to enable MCP")))
+    mcp_servers = serializers.JSONField(required=False, label=_("MCP Server"))
-    mcp_servers = serializers.JSONField(required=False, error_messages=ErrMessage.list(_("MCP Server")))
+    mcp_tool_id = serializers.CharField(required=False, allow_blank=True, allow_null=True, label=_("MCP Tool ID"))
+    mcp_tool_ids = serializers.ListField(child=serializers.UUIDField(), required=False, allow_empty=True,
+                                         label=_("MCP Tool IDs"), )
+    mcp_source = serializers.CharField(required=False, allow_blank=True, allow_null=True, label=_("MCP Source"))
+
+    tool_enable = serializers.BooleanField(required=False, default=False, label=_("Whether to enable tools"))
+    tool_ids = serializers.ListField(child=serializers.UUIDField(), required=False, allow_empty=True,
+                                     label=_("Tool IDs"), )
+    mcp_output_enable = serializers.BooleanField(required=False, default=True, label=_("Whether to enable MCP output"))
 
 
 class IChatNode(INode):
     type = 'ai-chat-node'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE_LOOP,
+               WorkflowMode.KNOWLEDGE]
 
     def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
         return ChatNodeSerializer
 
     def _run(self):
-        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data,
+                                **{'history_chat_record': [], 'stream': True, 'chat_id': None, 'chat_record_id': None})
+        else:
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
 
     def execute(self, model_id, system, prompt, dialogue_number, history_chat_record, stream, chat_id,
                 chat_record_id,
@@ -54,5 +68,11 @@ class IChatNode(INode):
                 model_setting=None,
                 mcp_enable=False,
                 mcp_servers=None,
+                mcp_tool_id=None,
+                mcp_tool_ids=None,
+                mcp_source=None,
+                tool_enable=False,
+                tool_ids=None,
+                mcp_output_enable=True,
                 **kwargs) -> NodeResult:
         pass

apps/application/flow/step_node/ai_chat_step_node/impl/base_chat_node.py

@@ -6,39 +6,27 @@
     @date：2024/6/4 14:30
     @desc:
 """
-import asyncio
 import json
+import os
 import re
 import time
 from functools import reduce
-from types import AsyncGeneratorType
 from typing import List, Dict
 
 from django.db.models import QuerySet
 from langchain.schema import HumanMessage, SystemMessage
-from langchain_core.messages import BaseMessage, AIMessage, AIMessageChunk, ToolMessage
+from langchain_core.messages import BaseMessage, AIMessage
-from langchain_mcp_adapters.client import MultiServerMCPClient
-from langgraph.prebuilt import create_react_agent
 
 from application.flow.i_step_node import NodeResult, INode
 from application.flow.step_node.ai_chat_step_node.i_chat_node import IChatNode
-from application.flow.tools import Reasoning
+from application.flow.tools import Reasoning, mcp_response_generator
-from setting.models import Model
+from common.utils.rsa_util import rsa_long_decrypt
-from setting.models_provider import get_model_credential
+from common.utils.tool_code import ToolExecutor
-from setting.models_provider.tools import get_model_instance_by_model_user_id
+from maxkb.const import CONFIG
+from models_provider.models import Model
+from models_provider.tools import get_model_credential, get_model_instance_by_model_workspace_id
+from tools.models import Tool
 
-tool_message_template = """
-<details>
-    <summary>
-        <strong>Called MCP Tool: <em>%s</em></strong>
-    </summary>
-
-```json
-%s
-```
-</details>
-
-"""
 
 def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow, answer: str,
                    reasoning_content: str):
@@ -102,38 +90,6 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
     _write_context(node_variable, workflow_variable, node, workflow, answer, reasoning_content)
 
 
-
-async def _yield_mcp_response(chat_model, message_list, mcp_servers):
-    async with MultiServerMCPClient(json.loads(mcp_servers)) as client:
-        agent = create_react_agent(chat_model, client.get_tools())
-        response = agent.astream({"messages": message_list}, stream_mode='messages')
-        async for chunk in response:
-            if isinstance(chunk[0], ToolMessage):
-                content = tool_message_template % (chunk[0].name, chunk[0].content)
-                chunk[0].content = content
-                yield chunk[0]
-            if isinstance(chunk[0], AIMessageChunk):
-                yield chunk[0]
-
-def mcp_response_generator(chat_model, message_list, mcp_servers):
-    loop = asyncio.new_event_loop()
-    try:
-        async_gen = _yield_mcp_response(chat_model, message_list, mcp_servers)
-        while True:
-            try:
-                chunk = loop.run_until_complete(anext_async(async_gen))
-                yield chunk
-            except StopAsyncIteration:
-                break
-    except Exception as e:
-        print(f'exception: {e}')
-    finally:
-        loop.close()
-
-async def anext_async(agen):
-    return await agen.__anext__()
-
-
 def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow):
     """
     写入上下文数据
@@ -150,10 +106,11 @@ def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, wor
     reasoning_result = reasoning.get_reasoning_content(response)
     reasoning_result_end = reasoning.get_end_reasoning_content()
     content = reasoning_result.get('content') + reasoning_result_end.get('content')
-    if 'reasoning_content' in response.response_metadata:
+    meta = {**response.response_metadata, **response.additional_kwargs}
-        reasoning_content = response.response_metadata.get('reasoning_content', '')
+    if 'reasoning_content' in meta:
+        reasoning_content = (meta.get('reasoning_content', '') or '')
     else:
-        reasoning_content = reasoning_result.get('reasoning_content') + reasoning_result_end.get('reasoning_content')
+        reasoning_content = (reasoning_result.get('reasoning_content') or '') + (reasoning_result_end.get('reasoning_content') or '')
     _write_context(node_variable, workflow_variable, node, workflow, content, reasoning_content)
 
 
@@ -186,7 +143,8 @@ class BaseChatNode(IChatNode):
         self.context['answer'] = details.get('answer')
         self.context['question'] = details.get('question')
         self.context['reasoning_content'] = details.get('reasoning_content')
-        self.answer_text = details.get('answer')
+        if self.node_params.get('is_result', False):
+            self.answer_text = details.get('answer')
 
     def execute(self, model_id, system, prompt, dialogue_number, history_chat_record, stream, chat_id, chat_record_id,
                 model_params_setting=None,
@@ -194,6 +152,12 @@ class BaseChatNode(IChatNode):
                 model_setting=None,
                 mcp_enable=False,
                 mcp_servers=None,
+                mcp_tool_id=None,
+                mcp_tool_ids=None,
+                mcp_source=None,
+                tool_enable=False,
+                tool_ids=None,
+                mcp_output_enable=True,
                 **kwargs) -> NodeResult:
         if dialogue_type is None:
             dialogue_type = 'WORKFLOW'
@@ -204,8 +168,9 @@ class BaseChatNode(IChatNode):
             model_setting = {'reasoning_content_enable': False, 'reasoning_content_end': '</think>',
                              'reasoning_content_start': '<think>'}
         self.context['model_setting'] = model_setting
-        chat_model = get_model_instance_by_model_user_id(model_id, self.flow_params_serializer.data.get('user_id'),
+        workspace_id = self.workflow_manage.get_body().get('workspace_id')
-                                                         **model_params_setting)
+        chat_model = get_model_instance_by_model_workspace_id(model_id, workspace_id,
+                                                              **model_params_setting)
         history_message = self.get_history_message(history_chat_record, dialogue_number, dialogue_type,
                                                    self.runtime_node_id)
         self.context['history_message'] = history_message
@@ -216,24 +181,98 @@ class BaseChatNode(IChatNode):
         message_list = self.generate_message_list(system, prompt, history_message)
         self.context['message_list'] = message_list
 
-        if mcp_enable and mcp_servers is not None:
+        # 处理 MCP 请求
-            r = mcp_response_generator(chat_model, message_list, mcp_servers)
+        mcp_result = self._handle_mcp_request(
-            return NodeResult(
+            mcp_enable, tool_enable, mcp_source, mcp_servers, mcp_tool_id, mcp_tool_ids, tool_ids, mcp_output_enable,
-                {'result': r, 'chat_model': chat_model, 'message_list': message_list,
+            chat_model, message_list, history_message, question
-                 'history_message': history_message, 'question': question.content}, {},
+        )
-                _write_context=write_context_stream)
+        if mcp_result:
+            return mcp_result
 
         if stream:
             r = chat_model.stream(message_list)
             return NodeResult({'result': r, 'chat_model': chat_model, 'message_list': message_list,
-                               'history_message': history_message, 'question': question.content}, {},
+                               'history_message': [{'content': message.content, 'role': message.type} for message in
+                                                   (history_message if history_message is not None else [])],
+                               'question': question.content}, {},
                               _write_context=write_context_stream)
         else:
             r = chat_model.invoke(message_list)
             return NodeResult({'result': r, 'chat_model': chat_model, 'message_list': message_list,
-                               'history_message': history_message, 'question': question.content}, {},
+                               'history_message': [{'content': message.content, 'role': message.type} for message in
+                                                   (history_message if history_message is not None else [])],
+                               'question': question.content}, {},
                               _write_context=write_context)
 
+    def _handle_mcp_request(self, mcp_enable, tool_enable, mcp_source, mcp_servers, mcp_tool_id, mcp_tool_ids, tool_ids,
+                            mcp_output_enable, chat_model, message_list, history_message, question):
+        if not mcp_enable and not tool_enable:
+            return None
+
+        mcp_servers_config = {}
+
+        # 迁移过来mcp_source是None
+        if mcp_source is None:
+            mcp_source = 'custom'
+        if mcp_enable:
+            # 兼容老数据
+            if not mcp_tool_ids:
+                mcp_tool_ids = []
+            if mcp_tool_id:
+                mcp_tool_ids = list(set(mcp_tool_ids + [mcp_tool_id]))
+            if mcp_source == 'custom' and mcp_servers is not None and '"stdio"' not in mcp_servers:
+                mcp_servers_config = json.loads(mcp_servers)
+                mcp_servers_config = self.handle_variables(mcp_servers_config)
+            elif mcp_tool_ids:
+                mcp_tools = QuerySet(Tool).filter(id__in=mcp_tool_ids).values()
+                for mcp_tool in mcp_tools:
+                    if mcp_tool and mcp_tool['is_active']:
+                        mcp_servers_config = {**mcp_servers_config, **json.loads(mcp_tool['code'])}
+                        mcp_servers_config = self.handle_variables(mcp_servers_config)
+
+        if tool_enable:
+            if tool_ids and len(tool_ids) > 0:  # 如果有工具ID，则将其转换为MCP
+                self.context['tool_ids'] = tool_ids
+                for tool_id in tool_ids:
+                    tool = QuerySet(Tool).filter(id=tool_id).first()
+                    if not tool.is_active:
+                        continue
+                    executor = ToolExecutor()
+                    if tool.init_params is not None:
+                        params = json.loads(rsa_long_decrypt(tool.init_params))
+                    else:
+                        params = {}
+                    tool_config = executor.get_tool_mcp_config(tool.code, params)
+
+                    mcp_servers_config[str(tool.id)] = tool_config
+
+        if len(mcp_servers_config) > 0:
+            r = mcp_response_generator(chat_model, message_list, json.dumps(mcp_servers_config), mcp_output_enable)
+            return NodeResult(
+                {'result': r, 'chat_model': chat_model, 'message_list': message_list,
+                 'history_message': [{'content': message.content, 'role': message.type} for message in
+                                     (history_message if history_message is not None else [])],
+                 'question': question.content}, {},
+                _write_context=write_context_stream)
+
+        return None
+
+    def handle_variables(self, tool_params):
+        # 处理参数中的变量
+        for k, v in tool_params.items():
+            if type(v) == str:
+                tool_params[k] = self.workflow_manage.generate_prompt(tool_params[k])
+            if type(v) == dict:
+                self.handle_variables(v)
+            if (type(v) == list) and (type(v[0]) == str):
+                tool_params[k] = self.get_reference_content(v)
+        return tool_params
+
+    def get_reference_content(self, fields: List[str]):
+        return str(self.workflow_manage.get_reference_field(
+            fields[0],
+            fields[1:]))
+
     @staticmethod
     def get_history_message(history_chat_record, dialogue_number, dialogue_type, runtime_node_id):
         start_index = len(history_chat_record) - dialogue_number
@@ -271,9 +310,7 @@ class BaseChatNode(IChatNode):
             "index": index,
             'run_time': self.context.get('run_time'),
             'system': self.context.get('system'),
-            'history_message': [{'content': message.content, 'role': message.type} for message in
+            'history_message': self.context.get('history_message'),
-                                (self.context.get('history_message') if self.context.get(
-                                    'history_message') is not None else [])],
             'question': self.context.get('question'),
             'answer': self.context.get('answer'),
             'reasoning_content': self.context.get('reasoning_content'),

apps/application/flow/step_node/application_node/i_application_node.py

@@ -3,29 +3,30 @@ from typing import Type
 
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode, NodeResult
-from common.util.field_message import ErrMessage
 
 from django.utils.translation import gettext_lazy as _
 
 
 class ApplicationNodeSerializer(serializers.Serializer):
-    application_id = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Application ID")))
+    application_id = serializers.CharField(required=True, label=_("Application ID"))
     question_reference_address = serializers.ListField(required=True,
-                                                       error_messages=ErrMessage.list(_("User Questions")))
+                                                       label=_("User Questions"))
-    api_input_field_list = serializers.ListField(required=False, error_messages=ErrMessage.list(_("API Input Fields")))
+    api_input_field_list = serializers.ListField(required=False, label=_("API Input Fields"))
     user_input_field_list = serializers.ListField(required=False,
-                                                  error_messages=ErrMessage.uuid(_("User Input Fields")))
+                                                  label=_("User Input Fields"))
-    image_list = serializers.ListField(required=False, error_messages=ErrMessage.list(_("picture")))
+    image_list = serializers.ListField(required=False, label=_("picture"))
-    document_list = serializers.ListField(required=False, error_messages=ErrMessage.list(_("document")))
+    document_list = serializers.ListField(required=False, label=_("document"))
-    audio_list = serializers.ListField(required=False, error_messages=ErrMessage.list(_("Audio")))
+    audio_list = serializers.ListField(required=False, label=_("Audio"))
     child_node = serializers.DictField(required=False, allow_null=True,
-                                       error_messages=ErrMessage.dict(_("Child Nodes")))
+                                       label=_("Child Nodes"))
-    node_data = serializers.DictField(required=False, allow_null=True, error_messages=ErrMessage.dict(_("Form Data")))
+    node_data = serializers.DictField(required=False, allow_null=True, label=_("Form Data"))
 
 
 class IApplicationNode(INode):
     type = 'application-node'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP]
 
     def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
         return ApplicationNodeSerializer
@@ -75,7 +76,7 @@ class IApplicationNode(INode):
                 if 'file_id' not in audio:
                     raise ValueError(
                         _("Parameter value error: The uploaded audio lacks file_id, and the audio upload fails."))
-        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data,
+        return self.execute(**{**self.flow_params_serializer.data, **self.node_params_serializer.data},
                             app_document_list=app_document_list, app_image_list=app_image_list,
                             app_audio_list=app_audio_list,
                             message=str(question), **kwargs)

apps/application/flow/step_node/application_node/impl/base_application_node.py

@@ -4,7 +4,7 @@ import re
 import time
 import uuid
 from typing import Dict, List
-
+from django.utils.translation import gettext as _
 from application.flow.common import Answer
 from application.flow.i_step_node import NodeResult, INode
 from application.flow.step_node.application_node.i_application_node import IApplicationNode
@@ -55,7 +55,7 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
         # 先把流转成字符串
         response_content = chunk.decode('utf-8')[6:]
         response_content = json.loads(response_content)
-        content = response_content.get('content', '')
+        content = (response_content.get('content', '') or '')
         runtime_node_id = response_content.get('runtime_node_id', '')
         chat_record_id = response_content.get('chat_record_id', '')
         child_node = response_content.get('child_node')
@@ -63,7 +63,7 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
         node_type = response_content.get('node_type')
         real_node_id = response_content.get('real_node_id')
         node_is_end = response_content.get('node_is_end', False)
-        _reasoning_content = response_content.get('reasoning_content', '')
+        _reasoning_content = (response_content.get('reasoning_content', '') or '')
         if node_type == 'form-node':
             is_interrupt_exec = True
         answer += content
@@ -168,17 +168,33 @@ class BaseApplicationNode(IApplicationNode):
         self.context['question'] = details.get('question')
         self.context['type'] = details.get('type')
         self.context['reasoning_content'] = details.get('reasoning_content')
-        self.answer_text = details.get('answer')
+        if self.node_params.get('is_result', False):
+            self.answer_text = details.get('answer')
 
-    def execute(self, application_id, message, chat_id, chat_record_id, stream, re_chat, client_id, client_type,
+    def get_chat_asker(self, kwargs):
+        asker = kwargs.get('asker')
+        if asker:
+            if isinstance(asker, dict):
+                return asker
+            return {'username': asker}
+        return self.workflow_manage.work_flow_post_handler.chat_info.get_chat_user()
+
+    def execute(self, application_id, message, chat_id, chat_record_id, stream, re_chat,
+                chat_user_id,
+                chat_user_type,
                 app_document_list=None, app_image_list=None, app_audio_list=None, child_node=None, node_data=None,
                 **kwargs) -> NodeResult:
-        from application.serializers.chat_message_serializers import ChatMessageSerializer
+        from chat.serializers.chat import ChatSerializers
+        if application_id == self.workflow_manage.get_body().get('application_id'):
+            raise Exception(_("The sub application cannot use the current node"))
         # 生成嵌入应用的chat_id
         current_chat_id = string_to_uuid(chat_id + application_id)
         Chat.objects.get_or_create(id=current_chat_id, defaults={
             'application_id': application_id,
-            'abstract': message[0:1024]
+            'abstract': message[0:1024],
+            'chat_user_id': chat_user_id,
+            'chat_user_type': chat_user_type,
+            'asker': self.get_chat_asker(kwargs)
         })
         if app_document_list is None:
             app_document_list = []
@@ -195,22 +211,26 @@ class BaseApplicationNode(IApplicationNode):
             child_node_value = child_node.get('child_node')
             application_node_dict = self.context.get('application_node_dict')
             reset_application_node_dict(application_node_dict, runtime_node_id, node_data)
+        response = ChatSerializers(data={
+            "chat_id": current_chat_id,
+            "chat_user_id": chat_user_id,
+            'chat_user_type': chat_user_type,
+            'application_id': application_id,
+            'debug': False
+        }).chat(instance=
+                {'message': message,
+                 're_chat': re_chat,
+                 'stream': stream,
+                 'document_list': app_document_list,
+                 'image_list': app_image_list,
+                 'audio_list': app_audio_list,
+                 'runtime_node_id': runtime_node_id,
+                 'chat_record_id': record_id,
+                 'child_node': child_node_value,
+                 'node_data': node_data,
+                 'form_data': kwargs}
+                )
 
-        response = ChatMessageSerializer(
-            data={'chat_id': current_chat_id, 'message': message,
-                  're_chat': re_chat,
-                  'stream': stream,
-                  'application_id': application_id,
-                  'client_id': client_id,
-                  'client_type': client_type,
-                  'document_list': app_document_list,
-                  'image_list': app_image_list,
-                  'audio_list': app_audio_list,
-                  'runtime_node_id': runtime_node_id,
-                  'chat_record_id': record_id,
-                  'child_node': child_node_value,
-                  'node_data': node_data,
-                  'form_data': kwargs}).chat()
         if response.status_code == 200:
             if stream:
                 content_generator = response.streaming_content

apps/application/flow/step_node/condition_node/i_condition_node.py

@@ -11,20 +11,20 @@ from typing import Type
 from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode
-from common.util.field_message import ErrMessage
 
 
 class ConditionSerializer(serializers.Serializer):
-    compare = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Comparator")))
+    compare = serializers.CharField(required=True, label=_("Comparator"))
-    value = serializers.CharField(required=True, error_messages=ErrMessage.char(_("value")))
+    value = serializers.CharField(required=True, label=_("value"))
-    field = serializers.ListField(required=True, error_messages=ErrMessage.char(_("Fields")))
+    field = serializers.ListField(required=True, label=_("Fields"))
 
 
 class ConditionBranchSerializer(serializers.Serializer):
-    id = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Branch id")))
+    id = serializers.CharField(required=True, label=_("Branch id"))
-    type = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Branch Type")))
+    type = serializers.CharField(required=True, label=_("Branch Type"))
-    condition = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Condition or|and")))
+    condition = serializers.CharField(required=True, label=_("Condition or|and"))
     conditions = ConditionSerializer(many=True)
 
 
@@ -37,3 +37,5 @@ class IConditionNode(INode):
         return ConditionNodeParamsSerializer
 
     type = 'condition-node'
+
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP]

apps/application/flow/step_node/condition_node/impl/base_condition_node.py

@@ -9,7 +9,7 @@
 from typing import List
 
 from application.flow.i_step_node import NodeResult
-from application.flow.step_node.condition_node.compare import compare_handle_list
+from application.flow.compare import compare_handle_list
 from application.flow.step_node.condition_node.i_condition_node import IConditionNode
 
 

apps/application/flow/step_node/data_source_local_node/__init__.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： __init__.py.py
+    @date：2025/11/11 10:06
+    @desc:
+"""

apps/application/flow/step_node/data_source_local_node/i_data_source_local_node.py

@@ -0,0 +1,42 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： i_data_source_local_node.py
+    @date：2025/11/11 10:06
+    @desc:
+"""
+from abc import abstractmethod
+from typing import Type
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import INode, NodeResult
+
+
+class DataSourceLocalNodeParamsSerializer(serializers.Serializer):
+    file_type_list = serializers.ListField(child=serializers.CharField(label=('')), label='')
+    file_size_limit = serializers.IntegerField(required=True, label=_("Number of uploaded files"))
+    file_count_limit = serializers.IntegerField(required=True, label=_("Upload file size"))
+
+
+class IDataSourceLocalNode(INode):
+    type = 'data-source-local-node'
+
+    @staticmethod
+    @abstractmethod
+    def get_form_list(node):
+        pass
+
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return DataSourceLocalNodeParamsSerializer
+
+    def _run(self):
+        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
+
+    def execute(self, file_type_list, file_size_limit, file_count_limit, **kwargs) -> NodeResult:
+        pass
+
+    support = [WorkflowMode.KNOWLEDGE]

apps/application/flow/step_node/data_source_local_node/impl/__init__.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： __init__.py.py
+    @date：2025/11/11 10:08
+    @desc:
+"""

apps/application/flow/step_node/data_source_local_node/impl/base_data_source_local_node.py

@@ -0,0 +1,51 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： base_data_source_local_node.py
+    @date：2025/11/11 10:30
+    @desc:
+"""
+from application.flow.i_step_node import NodeResult
+from application.flow.step_node.data_source_local_node.i_data_source_local_node import IDataSourceLocalNode
+from common import forms
+from common.forms import BaseForm
+
+
+class BaseDataSourceLocalNodeForm(BaseForm):
+    api_key = forms.PasswordInputField('API Key', required=True)
+
+
+class BaseDataSourceLocalNode(IDataSourceLocalNode):
+    def save_context(self, details, workflow_manage):
+        pass
+
+    @staticmethod
+    def get_form_list(node):
+        node_data = node.get('properties').get('node_data')
+        return [{
+            'field': 'file_list',
+            'input_type': 'LocalFileUpload',
+            'attrs': {
+                'file_count_limit': node_data.get('file_count_limit') or 10,
+                'file_size_limit': node_data.get('file_size_limit') or 100,
+                'file_type_list': node_data.get('file_type_list'),
+            },
+            'label': '',
+        }]
+
+    def execute(self, file_type_list, file_size_limit, file_count_limit, **kwargs) -> NodeResult:
+        return NodeResult({'file_list': self.workflow_manage.params.get('data_source', {}).get('file_list')},
+                          self.workflow_manage.params.get('knowledge_base') or {})
+
+    def get_details(self, index: int, **kwargs):
+        return {
+            'name': self.node.properties.get('stepName'),
+            "index": index,
+            'run_time': self.context.get('run_time'),
+            'type': self.node.type,
+            'file_list': self.context.get('file_list'),
+            'knowledge_base': self.workflow_params.get('knowledge_base'),
+            'status': self.status,
+            'err_message': self.err_message
+        }

apps/application/flow/step_node/data_source_web_node/__init__.py

@@ -1,8 +1,8 @@
 # coding=utf-8
 """
     @project: MaxKB
-    @Author：虎
+    @Author：niu
     @file： __init__.py.py
-    @date：2024/8/2 14:55
+    @date：2025/11/12 13:43
     @desc:
 """

apps/application/flow/step_node/data_source_web_node/i_data_source_web_node.py

@@ -0,0 +1,28 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：niu
+    @file： i_data_source_web_node.py
+    @date：2025/11/12 13:47
+    @desc:
+"""
+from abc import abstractmethod
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import INode, NodeResult
+
+
+class IDataSourceWebNode(INode):
+    type = 'data-source-web-node'
+    support = [WorkflowMode.KNOWLEDGE]
+
+    @staticmethod
+    @abstractmethod
+    def get_form_list(node):
+        pass
+
+    def _run(self):
+        return self.execute(**self.flow_params_serializer.data)
+
+    def execute(self, **kwargs) -> NodeResult:
+        pass

apps/application/flow/step_node/data_source_web_node/impl/__init__.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：niu
+    @file： __init__.py
+    @date：2025/11/12 13:44
+    @desc:
+"""

apps/application/flow/step_node/data_source_web_node/impl/base_data_source_web_node.py

@@ -0,0 +1,86 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：niu
+    @file： base_data_source_web_node.py
+    @date：2025/11/12 13:47
+    @desc:
+"""
+import traceback
+
+from django.utils.translation import gettext_lazy as _
+
+from application.flow.i_step_node import NodeResult
+from application.flow.step_node.data_source_web_node.i_data_source_web_node import IDataSourceWebNode
+from common import forms
+from common.forms import BaseForm
+from common.utils.fork import ForkManage, Fork, ChildLink
+from common.utils.logger import maxkb_logger
+
+
+class BaseDataSourceWebNodeForm(BaseForm):
+    source_url = forms.TextInputField(_('Web source url'), required=True, attrs={
+        'placeholder': _('Please enter the Web root address')})
+    selector = forms.TextInputField(_('Web knowledge selector'), required=False, attrs={
+        'placeholder': _('The default is body, you can enter .classname/#idname/tagname')})
+
+
+def get_collect_handler():
+    results = []
+
+    def handler(child_link: ChildLink, response: Fork.Response):
+        if response.status == 200:
+            try:
+                document_name = child_link.tag.text if child_link.tag is not None and len(
+                    child_link.tag.text.strip()) > 0 else child_link.url
+                results.append({
+                    "name": document_name.strip(),
+                    "content": response.content,
+                })
+            except Exception as e:
+                maxkb_logger.error(f'{str(e)}:{traceback.format_exc()}')
+
+    return handler, results
+
+
+class BaseDataSourceWebNode(IDataSourceWebNode):
+    def save_context(self, details, workflow_manage):
+        pass
+
+    @staticmethod
+    def get_form_list(node):
+        return BaseDataSourceWebNodeForm().to_form_list()
+
+    def execute(self, **kwargs) -> NodeResult:
+        BaseDataSourceWebNodeForm().valid_form(self.workflow_params.get("data_source"))
+
+        data_source = self.workflow_params.get("data_source")
+
+        node_id = data_source.get("node_id")
+        source_url = data_source.get("source_url")
+        selector = data_source.get("selector") or "body"
+
+        collect_handler, document_list = get_collect_handler()
+
+        try:
+            ForkManage(source_url, selector.split(" ") if selector is not None else []).fork(3, set(), collect_handler)
+
+            return NodeResult({'document_list': document_list,'source_url': source_url, 'selector': selector},
+                              self.workflow_manage.params.get('knowledge_base') or {})
+
+        except Exception as e:
+            maxkb_logger.error(_('data source web node:{node_id} error{error}{traceback}').format(
+                knowledge_id=node_id, error=str(e), traceback=traceback.format_exc()))
+
+    def get_details(self, index: int, **kwargs):
+        return {
+            'name': self.node.properties.get('stepName'),
+            "index": index,
+            'run_time': self.context.get('run_time'),
+            'type': self.node.type,
+            'input_params': {"source_url": self.context.get("source_url"), "selector": self.context.get('selector')},
+            'output_params': self.context.get('document_list'),
+            'knowledge_base': self.workflow_params.get('knowledge_base'),
+            'status': self.status,
+            'err_message': self.err_message
+        }

apps/application/flow/step_node/direct_reply_node/i_reply_node.py

@@ -10,18 +10,20 @@ from typing import Type
 
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode, NodeResult
 from common.exception.app_exception import AppApiException
-from common.util.field_message import ErrMessage
+
 from django.utils.translation import gettext_lazy as _
 
 
 class ReplyNodeParamsSerializer(serializers.Serializer):
-    reply_type = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Response Type")))
+    reply_type = serializers.CharField(required=True, label=_("Response Type"))
-    fields = serializers.ListField(required=False, error_messages=ErrMessage.list(_("Reference Field")))
+    fields = serializers.ListField(required=False, label=_("Reference Field"))
     content = serializers.CharField(required=False, allow_blank=True, allow_null=True,
-                                    error_messages=ErrMessage.char(_("Direct answer content")))
+                                    label=_("Direct answer content"))
-    is_result = serializers.BooleanField(required=False, error_messages=ErrMessage.boolean(_('Whether to return content')))
+    is_result = serializers.BooleanField(required=False,
+                                         label=_('Whether to return content'))
 
     def is_valid(self, *, raise_exception=False):
         super().is_valid(raise_exception=True)
@@ -37,12 +39,19 @@ class ReplyNodeParamsSerializer(serializers.Serializer):
 
 class IReplyNode(INode):
     type = 'reply-node'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE_LOOP,
+               WorkflowMode.KNOWLEDGE]
 
     def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
         return ReplyNodeParamsSerializer
 
     def _run(self):
-        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data,
+                                **{'stream': True})
+        else:
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
 
     def execute(self, reply_type, stream, fields=None, content=None, **kwargs) -> NodeResult:
         pass

apps/application/flow/step_node/direct_reply_node/impl/base_reply_node.py

@@ -15,7 +15,9 @@ from application.flow.step_node.direct_reply_node.i_reply_node import IReplyNode
 class BaseReplyNode(IReplyNode):
     def save_context(self, details, workflow_manage):
         self.context['answer'] = details.get('answer')
-        self.answer_text = details.get('answer')
+        if self.node_params.get('is_result', False):
+            self.answer_text = details.get('answer')
+
     def execute(self, reply_type, stream, fields=None, content=None, **kwargs) -> NodeResult:
         if reply_type == 'referencing':
             result = self.get_reference_content(fields)

apps/application/flow/step_node/document_extract_node/i_document_extract_node.py

@@ -5,17 +5,18 @@ from typing import Type
 from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode, NodeResult
-from common.util.field_message import ErrMessage
 
 
 class DocumentExtractNodeSerializer(serializers.Serializer):
-    document_list = serializers.ListField(required=False, error_messages=ErrMessage.list(_("document")))
+    document_list = serializers.ListField(required=False, label=_("document"))
 
 
 class IDocumentExtractNode(INode):
     type = 'document-extract-node'
-
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE_LOOP,
+               WorkflowMode.KNOWLEDGE]
     def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
         return DocumentExtractNodeSerializer
 
@@ -24,5 +25,5 @@ class IDocumentExtractNode(INode):
                                                        self.node_params_serializer.data.get('document_list')[1:])
         return self.execute(document=res, **self.flow_params_serializer.data)
 
-    def execute(self, document, chat_id, **kwargs) -> NodeResult:
+    def execute(self, document, chat_id=None, **kwargs) -> NodeResult:
         pass

apps/application/flow/step_node/document_extract_node/impl/base_document_extract_node.py

@@ -1,72 +1,65 @@
 # coding=utf-8
+import ast
 import io
-import mimetypes
 
-from django.core.files.uploadedfile import InMemoryUploadedFile
+import uuid_utils.compat as uuid
 from django.db.models import QuerySet
 
 from application.flow.i_step_node import NodeResult
 from application.flow.step_node.document_extract_node.i_document_extract_node import IDocumentExtractNode
-from dataset.models import File
+from knowledge.models import File, FileSourceType
-from dataset.serializers.document_serializers import split_handles, parse_table_handle_list, FileBufferHandle
+from knowledge.serializers.document import split_handles, parse_table_handle_list, FileBufferHandle
-from dataset.serializers.file_serializers import FileSerializer
-
-
-def bytes_to_uploaded_file(file_bytes, file_name="file.txt"):
-    content_type, _ = mimetypes.guess_type(file_name)
-    if content_type is None:
-        # 如果未能识别，设置为默认的二进制文件类型
-        content_type = "application/octet-stream"
-    # 创建一个内存中的字节流对象
-    file_stream = io.BytesIO(file_bytes)
-
-    # 获取文件大小
-    file_size = len(file_bytes)
-
-    # 创建 InMemoryUploadedFile 对象
-    uploaded_file = InMemoryUploadedFile(
-        file=file_stream,
-        field_name=None,
-        name=file_name,
-        content_type=content_type,
-        size=file_size,
-        charset=None,
-    )
-    return uploaded_file
-
 
 splitter = '\n`-----------------------------------`\n'
 
+
 class BaseDocumentExtractNode(IDocumentExtractNode):
     def save_context(self, details, workflow_manage):
         self.context['content'] = details.get('content')
 
-
+    def execute(self, document, chat_id=None, **kwargs):
-    def execute(self, document, chat_id, **kwargs):
         get_buffer = FileBufferHandle().get_buffer
 
         self.context['document_list'] = document
         content = []
         if document is None or not isinstance(document, list):
-            return NodeResult({'content': ''}, {})
+            return NodeResult({'content': '', 'document_list': []}, {})
 
-        application = self.workflow_manage.work_flow_post_handler.chat_info.application
+        # 安全获取 application
+        application_id = None
+        if (self.workflow_manage and
+                self.workflow_manage.work_flow_post_handler and
+                self.workflow_manage.work_flow_post_handler.chat_info):
+            application_id = self.workflow_manage.work_flow_post_handler.chat_info.application.id
+        knowledge_id = self.workflow_params.get('knowledge_id')
 
         # doc文件中的图片保存
         def save_image(image_list):
             for image in image_list:
                 meta = {
-                    'debug': False if application.id else True,
+                    'debug': False if (application_id or knowledge_id) else True,
                     'chat_id': chat_id,
-                    'application_id': str(application.id) if application.id else None,
+                    'application_id': str(application_id) if application_id else None,
+                    'knowledge_id': str(knowledge_id) if knowledge_id else None,
                     'file_id': str(image.id)
                 }
-                file = bytes_to_uploaded_file(image.image, image.image_name)
+                file_bytes = image.meta.pop('content')
-                FileSerializer(data={'file': file, 'meta': meta}).upload()
+                new_file = File(
+                    id=meta['file_id'],
+                    file_name=image.file_name,
+                    file_size=len(file_bytes),
+                    source_type=FileSourceType.APPLICATION.value if meta[
+                        'application_id'] else FileSourceType.KNOWLEDGE.value,
+                    source_id=meta['application_id'] if meta['application_id'] else meta['knowledge_id'],
+                    meta=meta
+                )
+                if not QuerySet(File).filter(id=new_file.id).exists():
+                    new_file.save(file_bytes)
 
+        document_list = []
         for doc in document:
             file = QuerySet(File).filter(id=doc['file_id']).first()
-            buffer = io.BytesIO(file.get_byte().tobytes())
+            buffer = io.BytesIO(file.get_bytes())
             buffer.name = doc['name']  # this is the important line
 
             for split_handle in (parse_table_handle_list + split_handles):
@@ -75,9 +68,10 @@ class BaseDocumentExtractNode(IDocumentExtractNode):
                     buffer.seek(0)
                     file_content = split_handle.get_content(buffer, save_image)
                     content.append('### ' + doc['name'] + '\n' + file_content)
+                    document_list.append({'id': str(file.id), 'name': doc['name'], 'content': file_content})
                     break
 
-        return NodeResult({'content': splitter.join(content)}, {})
+        return NodeResult({'content': splitter.join(content), 'document_list': document_list}, {})
 
     def get_details(self, index: int, **kwargs):
         content = self.context.get('content', '').split(splitter)

apps/application/flow/step_node/document_split_node/__init__.py

@@ -0,0 +1 @@
+from .impl import *

apps/application/flow/step_node/document_split_node/i_document_split_node.py

@@ -0,0 +1,90 @@
+# coding=utf-8
+
+from typing import Type
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import INode, NodeResult
+
+
+class DocumentSplitNodeSerializer(serializers.Serializer):
+    document_list = serializers.ListField(required=False, label=_("document list"))
+    split_strategy = serializers.ChoiceField(
+        choices=['auto', 'custom', 'qa'], required=False, label=_("split strategy"), default='auto'
+    )
+    paragraph_title_relate_problem_type = serializers.ChoiceField(
+        choices=['custom', 'referencing'], required=False, label=_("paragraph title relate problem type"),
+        default='custom'
+    )
+    paragraph_title_relate_problem = serializers.BooleanField(
+        required=False, label=_("paragraph title relate problem"), default=False
+    )
+    paragraph_title_relate_problem_reference = serializers.ListField(
+        required=False, label=_("paragraph title relate problem reference"), child=serializers.CharField(), default=[]
+    )
+    document_name_relate_problem_type = serializers.ChoiceField(
+        choices=['custom', 'referencing'], required=False, label=_("document name relate problem type"),
+        default='custom'
+    )
+    document_name_relate_problem = serializers.BooleanField(
+        required=False, label=_("document name relate problem"), default=False
+    )
+    document_name_relate_problem_reference = serializers.ListField(
+        required=False, label=_("document name relate problem reference"), child=serializers.CharField(), default=[]
+    )
+    limit = serializers.IntegerField(required=False, label=_("limit"), default=4096)
+    limit_type = serializers.ChoiceField(
+        choices=['custom', 'referencing'], required=False, label=_("document name relate problem type"),
+        default='custom'
+    )
+    limit_reference = serializers.ListField(
+        required=False, label=_("limit reference"), child=serializers.CharField(), default=[]
+    )
+    chunk_size = serializers.IntegerField(required=False, label=_("chunk size"), default=256)
+    chunk_size_type = serializers.ChoiceField(
+        choices=['custom', 'referencing'], required=False, label=_("chunk size type"), default='custom'
+    )
+    chunk_size_reference = serializers.ListField(
+        required=False, label=_("chunk size reference"), child=serializers.CharField(), default=[]
+    )
+    patterns = serializers.ListField(
+        required=False, label=_("patterns"), child=serializers.CharField(), default=[]
+    )
+    patterns_type = serializers.ChoiceField(
+        choices=['custom', 'referencing'], required=False, label=_("patterns type"), default='custom'
+    )
+    patterns_reference = serializers.ListField(
+        required=False, label=_("patterns reference"), child=serializers.CharField(), default=[]
+    )
+    with_filter = serializers.BooleanField(
+        required=False, label=_("with filter"), default=False
+    )
+    with_filter_type = serializers.ChoiceField(
+        choices=['custom', 'referencing'], required=False, label=_("with filter type"), default='custom'
+    )
+    with_filter_reference = serializers.ListField(
+        required=False, label=_("with filter reference"), child=serializers.CharField(), default=[]
+    )
+
+
+class IDocumentSplitNode(INode):
+    type = 'document-split-node'
+    support = [
+        WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE_LOOP, WorkflowMode.KNOWLEDGE
+    ]
+
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return DocumentSplitNodeSerializer
+
+    def _run(self):
+        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
+
+    def execute(self, document_list, knowledge_id, split_strategy, paragraph_title_relate_problem_type,
+                paragraph_title_relate_problem, paragraph_title_relate_problem_reference,
+                document_name_relate_problem_type, document_name_relate_problem,
+                document_name_relate_problem_reference, limit, limit_type, limit_reference, chunk_size, chunk_size_type,
+                chunk_size_reference, patterns, patterns_type, patterns_reference, with_filter, with_filter_type,
+                with_filter_reference, **kwargs) -> NodeResult:
+        pass

apps/application/flow/step_node/document_split_node/impl/__init__.py

@@ -0,0 +1 @@
+from .base_document_split_node import BaseDocumentSplitNode

apps/application/flow/step_node/document_split_node/impl/base_document_split_node.py

@@ -0,0 +1,190 @@
+# coding=utf-8
+import io
+import mimetypes
+from typing import List
+
+from django.core.files.uploadedfile import InMemoryUploadedFile
+
+from application.flow.i_step_node import NodeResult
+from application.flow.step_node.document_split_node.i_document_split_node import IDocumentSplitNode
+from common.chunk import text_to_chunk
+from knowledge.serializers.document import default_split_handle, FileBufferHandle, md_qa_split_handle
+
+
+def bytes_to_uploaded_file(file_bytes, file_name="file.txt"):
+    if file_name.startswith("http"):
+        file_name = "file.txt"
+    content_type, _ = mimetypes.guess_type(file_name)
+    if content_type is None:
+        # 如果未能识别，设置为默认的二进制文件类型
+        content_type = "application/octet-stream"
+    # 创建一个内存中的字节流对象
+    file_stream = io.BytesIO(file_bytes)
+
+    # 获取文件大小
+    file_size = len(file_bytes)
+
+    # 创建 InMemoryUploadedFile 对象
+    uploaded_file = InMemoryUploadedFile(
+        file=file_stream,
+        field_name=None,
+        name=file_name,
+        content_type=content_type,
+        size=file_size,
+        charset=None,
+    )
+    return uploaded_file
+
+
+class BaseDocumentSplitNode(IDocumentSplitNode):
+    def save_context(self, details, workflow_manage):
+        self.context['content'] = details.get('content')
+
+    def get_reference_content(self, fields: List[str]):
+        return self.workflow_manage.get_reference_field(fields[0], fields[1:])
+
+    def execute(self, document_list, knowledge_id, split_strategy, paragraph_title_relate_problem_type,
+                paragraph_title_relate_problem, paragraph_title_relate_problem_reference,
+                document_name_relate_problem_type, document_name_relate_problem,
+                document_name_relate_problem_reference, limit, limit_type, limit_reference, chunk_size, chunk_size_type,
+                chunk_size_reference, patterns, patterns_type, patterns_reference, with_filter, with_filter_type,
+                with_filter_reference, **kwargs) -> NodeResult:
+        self.context['knowledge_id'] = knowledge_id
+        file_list = self.get_reference_content(document_list)
+
+        # 处理引用类型的参数
+        if patterns_type == 'referencing':
+            patterns = self.get_reference_content(patterns_reference)
+        if limit_type == 'referencing':
+            limit = self.get_reference_content(limit_reference)
+        if chunk_size_type == 'referencing':
+            chunk_size = self.get_reference_content(chunk_size_reference)
+        if with_filter_type == 'referencing':
+            with_filter = self.get_reference_content(with_filter_reference)
+
+        paragraph_list = []
+        for doc in file_list:
+            get_buffer = FileBufferHandle().get_buffer
+
+            file_mem = bytes_to_uploaded_file(doc['content'].encode('utf-8'), doc['name'])
+            if split_strategy == 'qa':
+                result = md_qa_split_handle.handle(file_mem, get_buffer, self._save_image)
+            else:
+                result = default_split_handle.handle(file_mem, patterns, with_filter, limit, get_buffer,
+                                                     self._save_image)
+            # 统一处理结果为列表
+            results = result if isinstance(result, list) else [result]
+
+            for item in results:
+                self._process_split_result(
+                    item, knowledge_id, doc.get('id'), doc.get('name'),
+                    split_strategy, paragraph_title_relate_problem_type,
+                    paragraph_title_relate_problem, paragraph_title_relate_problem_reference,
+                    document_name_relate_problem_type, document_name_relate_problem,
+                    document_name_relate_problem_reference, chunk_size
+                )
+
+            paragraph_list += results
+
+        self.context['paragraph_list'] = paragraph_list
+        self.context['document_list'] = file_list
+        self.context['limit'] = limit
+        self.context['chunk_size'] = chunk_size
+        self.context['with_filter'] = with_filter
+        self.context['patterns'] = patterns
+        self.context['split_strategy'] = split_strategy
+
+        return NodeResult({'paragraph_list': paragraph_list}, {})
+
+    def _save_image(self, image_list):
+        pass
+
+    def _process_split_result(
+            self, item, knowledge_id, source_file_id, file_name,
+            split_strategy, paragraph_title_relate_problem_type,
+            paragraph_title_relate_problem, paragraph_title_relate_problem_reference,
+            document_name_relate_problem_type, document_name_relate_problem,
+            document_name_relate_problem_reference, chunk_size
+    ):
+        """处理文档分割结果"""
+        item['meta'] = {
+            'knowledge_id': knowledge_id,
+            'source_file_id': source_file_id,
+            'source_url': file_name,
+        }
+        if item.get('name', 'file.txt') == 'file.txt':
+            item['name'] = file_name
+        item['source_file_id'] = source_file_id
+        item['paragraphs'] = item.pop('content', item.get('paragraphs', []))
+
+        for paragraph in item['paragraphs']:
+            paragraph['problem_list'] = self._generate_problem_list(
+                paragraph, file_name,
+                split_strategy, paragraph_title_relate_problem_type,
+                paragraph_title_relate_problem, paragraph_title_relate_problem_reference,
+                document_name_relate_problem_type, document_name_relate_problem,
+                document_name_relate_problem_reference
+            )
+            paragraph['is_active'] = True
+            paragraph['chunks'] = text_to_chunk(paragraph['content'], chunk_size)
+
+    def _generate_problem_list(
+            self, paragraph, document_name, split_strategy, paragraph_title_relate_problem_type,
+            paragraph_title_relate_problem, paragraph_title_relate_problem_reference,
+            document_name_relate_problem_type, document_name_relate_problem,
+            document_name_relate_problem_reference
+    ):
+        if paragraph_title_relate_problem_type == 'referencing':
+            paragraph_title_relate_problem = self.get_reference_content(paragraph_title_relate_problem_reference)
+        if document_name_relate_problem_type == 'referencing':
+            document_name_relate_problem = self.get_reference_content(document_name_relate_problem_reference)
+
+        problem_list = [
+            item for p in paragraph.get('problem_list', []) for item in p.get('content', '').split('<br>')
+            if item.strip()
+        ]
+
+        if split_strategy == 'auto':
+            if paragraph_title_relate_problem and paragraph.get('title'):
+                problem_list.append(paragraph.get('title'))
+            if document_name_relate_problem and document_name:
+                problem_list.append(document_name)
+        elif split_strategy == 'custom':
+            if paragraph_title_relate_problem and paragraph.get('title'):
+                problem_list.append(paragraph.get('title'))
+            if document_name_relate_problem and document_name:
+                problem_list.append(document_name)
+        elif split_strategy == 'qa':
+            if document_name_relate_problem and document_name:
+                problem_list.append(document_name)
+
+        return list(set(problem_list))
+
+    def get_details(self, index: int, **kwargs):
+        paragraph_list = self.context.get('paragraph_list', [])
+        # 每个文档保留前5个分段
+        limited_paragraph_list = []
+        for doc in paragraph_list:
+            if doc.get('paragraphs'):
+                doc_copy = doc.copy()
+                doc_copy['paragraphs'] = doc['paragraphs'][:5]
+                limited_paragraph_list.append(doc_copy)
+            else:
+                limited_paragraph_list.append(doc)
+        paragraph_list = limited_paragraph_list
+
+        return {
+            'name': self.node.properties.get('stepName'),
+            "index": index,
+            'run_time': self.context.get('run_time'),
+            'type': self.node.type,
+            'status': self.status,
+            'err_message': self.err_message,
+            'paragraph_list': paragraph_list,
+            'limit': self.context.get('limit'),
+            'chunk_size': self.context.get('chunk_size'),
+            'with_filter': self.context.get('with_filter'),
+            'patterns': self.context.get('patterns'),
+            'split_strategy': self.context.get('split_strategy'),
+            # 'document_list': self.context.get('document_list', []),
+        }

apps/application/flow/step_node/form_node/i_form_node.py

@@ -10,20 +10,22 @@ from typing import Type
 
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode, NodeResult
-from common.util.field_message import ErrMessage
+
 from django.utils.translation import gettext_lazy as _
 
 
 class FormNodeParamsSerializer(serializers.Serializer):
-    form_field_list = serializers.ListField(required=True, error_messages=ErrMessage.list(_("Form Configuration")))
+    form_field_list = serializers.ListField(required=True, label=_("Form Configuration"))
-    form_content_format = serializers.CharField(required=True, error_messages=ErrMessage.char(_('Form output content')))
+    form_content_format = serializers.CharField(required=True, label=_('Form output content'))
-    form_data = serializers.DictField(required=False, allow_null=True, error_messages=ErrMessage.dict(_("Form Data")))
+    form_data = serializers.DictField(required=False, allow_null=True, label=_("Form Data"))
 
 
 class IFormNode(INode):
     type = 'form-node'
     view_type = 'single_view'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP]
 
     def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
         return FormNodeParamsSerializer

apps/application/flow/step_node/form_node/impl/base_form_node.py

@@ -16,6 +16,29 @@ from application.flow.common import Answer
 from application.flow.i_step_node import NodeResult
 from application.flow.step_node.form_node.i_form_node import IFormNode
 
+multi_select_list = [
+    'MultiSelect',
+    'MultiRow'
+]
+
+
+def get_default_option(option_list, _type, value_field):
+    try:
+        if option_list is not None and isinstance(option_list, list) and len(option_list) > 0:
+            default_value_list = [o.get(value_field) for o in option_list if o.get('default')]
+            if len(default_value_list) == 0:
+                return [option_list[0].get(
+                    value_field)] if multi_select_list.__contains__(_type) else option_list[0].get(
+                    value_field)
+            else:
+                if multi_select_list.__contains__(_type):
+                    return default_value_list
+                else:
+                    return default_value_list[0]
+    except Exception as _:
+        pass
+    return []
+
 
 def write_context(step_variable: Dict, global_variable: Dict, node, workflow):
     if step_variable is not None:
@@ -28,6 +51,13 @@ def write_context(step_variable: Dict, global_variable: Dict, node, workflow):
     node.context['run_time'] = time.time() - node.context['start_time']
 
 
+def generate_prompt(workflow_manage, _value):
+    try:
+        return workflow_manage.generate_prompt(_value)
+    except Exception as e:
+        return _value
+
+
 class BaseFormNode(IFormNode):
     def save_context(self, details, workflow_manage):
         form_data = details.get('form_data', None)
@@ -38,11 +68,43 @@ class BaseFormNode(IFormNode):
         self.context['start_time'] = details.get('start_time')
         self.context['form_data'] = form_data
         self.context['is_submit'] = details.get('is_submit')
-        self.answer_text = details.get('result')
+        if self.node_params.get('is_result', False):
+            self.answer_text = details.get('result')
         if form_data is not None:
             for key in form_data:
                 self.context[key] = form_data[key]
 
+    def reset_field(self, field):
+        reset_field = ['field', 'label', 'default_value']
+        for f in reset_field:
+            _value = field[f]
+            if _value is None:
+                continue
+            if isinstance(_value, str):
+                field[f] = generate_prompt(self.workflow_manage, _value)
+            elif f == 'label':
+                _label_value = _value.get('label')
+                _value['label'] = generate_prompt(self.workflow_manage, _label_value)
+                tooltip = _value.get('attrs').get('tooltip')
+                if tooltip is not None:
+                    _value.get('attrs')['tooltip'] = generate_prompt(self.workflow_manage, tooltip)
+
+        if ['SingleSelect', 'MultiSelect', 'RadioCard', 'RadioRow', 'MultiRow'].__contains__(field.get('input_type')):
+            if field.get('assignment_method') == 'ref_variables':
+                option_list = self.workflow_manage.get_reference_field(field.get('option_list')[0],
+                                                                       field.get('option_list')[1:])
+                option_list = option_list if isinstance(option_list, list) else []
+                field['option_list'] = option_list
+                field['default_value'] = get_default_option(option_list, field.get('input_type'),
+                                                            field.get('value_field'))
+
+        if ['JsonInput'].__contains__(field.get('input_type')):
+            if field.get('default_value_assignment_method') == 'ref_variables':
+                field['default_value'] = self.workflow_manage.get_reference_field(field.get('default_value')[0],
+                                                                                  field.get('default_value')[1:])
+
+        return field
+
     def execute(self, form_field_list, form_content_format, form_data, **kwargs) -> NodeResult:
         if form_data is not None:
             self.context['is_submit'] = True
@@ -51,6 +113,7 @@ class BaseFormNode(IFormNode):
                 self.context[key] = form_data.get(key)
         else:
             self.context['is_submit'] = False
+        form_field_list = [self.reset_field(field) for field in form_field_list]
         form_setting = {"form_field_list": form_field_list, "runtime_node_id": self.runtime_node_id,
                         "chat_record_id": self.flow_params_serializer.data.get("chat_record_id"),
                         "is_submit": self.context.get("is_submit", False)}
@@ -58,7 +121,10 @@ class BaseFormNode(IFormNode):
         context = self.workflow_manage.get_workflow_content()
         form_content_format = self.workflow_manage.reset_prompt(form_content_format)
         prompt_template = PromptTemplate.from_template(form_content_format, template_format='jinja2')
-        value = prompt_template.format(form=form, context=context)
+        value = prompt_template.format(form=form, context=context, runtime_node_id=self.runtime_node_id,
+                                       chat_record_id=self.flow_params_serializer.data.get("chat_record_id"),
+                                       form_field_list=form_field_list)
+
         return NodeResult(
             {'result': value, 'form_field_list': form_field_list, 'form_content_format': form_content_format}, {},
             _write_context=write_context)
@@ -70,11 +136,13 @@ class BaseFormNode(IFormNode):
                         "chat_record_id": self.flow_params_serializer.data.get("chat_record_id"),
                         'form_data': self.context.get('form_data', {}),
                         "is_submit": self.context.get("is_submit", False)}
-        form = f'<form_rander>{json.dumps(form_setting,ensure_ascii=False)}</form_rander>'
+        form = f'<form_rander>{json.dumps(form_setting, ensure_ascii=False)}</form_rander>'
         context = self.workflow_manage.get_workflow_content()
         form_content_format = self.workflow_manage.reset_prompt(form_content_format)
         prompt_template = PromptTemplate.from_template(form_content_format, template_format='jinja2')
-        value = prompt_template.format(form=form, context=context)
+        value = prompt_template.format(form=form, context=context, runtime_node_id=self.runtime_node_id,
+                                       chat_record_id=self.flow_params_serializer.data.get("chat_record_id"),
+                                       form_field_list=form_field_list)
         return [Answer(value, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'], None,
                        self.runtime_node_id, '')]
 
@@ -85,11 +153,13 @@ class BaseFormNode(IFormNode):
                         "chat_record_id": self.flow_params_serializer.data.get("chat_record_id"),
                         'form_data': self.context.get('form_data', {}),
                         "is_submit": self.context.get("is_submit", False)}
-        form = f'<form_rander>{json.dumps(form_setting,ensure_ascii=False)}</form_rander>'
+        form = f'<form_rander>{json.dumps(form_setting, ensure_ascii=False)}</form_rander>'
         context = self.workflow_manage.get_workflow_content()
         form_content_format = self.workflow_manage.reset_prompt(form_content_format)
         prompt_template = PromptTemplate.from_template(form_content_format, template_format='jinja2')
-        value = prompt_template.format(form=form, context=context)
+        value = prompt_template.format(form=form, context=context, runtime_node_id=self.runtime_node_id,
+                                       chat_record_id=self.flow_params_serializer.data.get("chat_record_id"),
+                                       form_field_list=form_field_list)
         return {
             'name': self.node.properties.get('stepName'),
             "index": index,

apps/application/flow/step_node/function_lib_node/impl/base_function_lib_node.py

@@ -1,149 +0,0 @@
-# coding=utf-8
-"""
-    @project: MaxKB
-    @Author：虎
-    @file： base_function_lib_node.py
-    @date：2024/8/8 17:49
-    @desc:
-"""
-import json
-import time
-from typing import Dict
-
-from django.db.models import QuerySet
-from django.utils.translation import gettext as _
-
-from application.flow.i_step_node import NodeResult
-from application.flow.step_node.function_lib_node.i_function_lib_node import IFunctionLibNode
-from common.exception.app_exception import AppApiException
-from common.util.function_code import FunctionExecutor
-from common.util.rsa_util import rsa_long_decrypt
-from function_lib.models.function import FunctionLib
-from smartdoc.const import CONFIG
-
-function_executor = FunctionExecutor(CONFIG.get('SANDBOX'))
-
-
-def write_context(step_variable: Dict, global_variable: Dict, node, workflow):
-    if step_variable is not None:
-        for key in step_variable:
-            node.context[key] = step_variable[key]
-        if workflow.is_result(node, NodeResult(step_variable, global_variable)) and 'result' in step_variable:
-            result = str(step_variable['result']) + '\n'
-            yield result
-            node.answer_text = result
-    node.context['run_time'] = time.time() - node.context['start_time']
-
-
-def get_field_value(debug_field_list, name, is_required):
-    result = [field for field in debug_field_list if field.get('name') == name]
-    if len(result) > 0:
-        return result[-1]['value']
-    if is_required:
-        raise AppApiException(500, _('Field: {name} No value set').format(name=name))
-    return None
-
-
-def valid_reference_value(_type, value, name):
-    if _type == 'int':
-        instance_type = int | float
-    elif _type == 'float':
-        instance_type = float | int
-    elif _type == 'dict':
-        instance_type = dict
-    elif _type == 'array':
-        instance_type = list
-    elif _type == 'string':
-        instance_type = str
-    else:
-        raise Exception(_('Field: {name} Type: {_type} Value: {value} Unsupported types').format(name=name,
-                                                                                                 _type=_type))
-    if not isinstance(value, instance_type):
-        raise Exception(
-            _('Field: {name} Type: {_type} Value: {value} Type error').format(name=name, _type=_type,
-                                                                              value=value))
-
-
-def convert_value(name: str, value, _type, is_required, source, node):
-    if not is_required and value is None:
-        return None
-    if not is_required and source == 'reference' and (value is None or len(value) == 0):
-        return None
-    if source == 'reference':
-        value = node.workflow_manage.get_reference_field(
-            value[0],
-            value[1:])
-        valid_reference_value(_type, value, name)
-        if _type == 'int':
-            return int(value)
-        if _type == 'float':
-            return float(value)
-        return value
-    try:
-        if _type == 'int':
-            return int(value)
-        if _type == 'float':
-            return float(value)
-        if _type == 'dict':
-            v = json.loads(value)
-            if isinstance(v, dict):
-                return v
-            raise Exception(_('type error'))
-        if _type == 'array':
-            v = json.loads(value)
-            if isinstance(v, list):
-                return v
-            raise Exception(_('type error'))
-        return value
-    except Exception as e:
-        raise Exception(
-            _('Field: {name} Type: {_type} Value: {value} Type error').format(name=name, _type=_type,
-                                                                              value=value))
-
-
-def valid_function(function_lib, user_id):
-    if function_lib is None:
-        raise Exception(_('Function does not exist'))
-    if function_lib.permission_type == 'PRIVATE' and str(function_lib.user_id) != str(user_id):
-        raise Exception(_('No permission to use this function {name}').format(name=function_lib.name))
-    if not function_lib.is_active:
-        raise Exception(_('Function {name} is unavailable').format(name=function_lib.name))
-
-
-class BaseFunctionLibNodeNode(IFunctionLibNode):
-    def save_context(self, details, workflow_manage):
-        self.context['result'] = details.get('result')
-        self.answer_text = str(details.get('result'))
-
-    def execute(self, function_lib_id, input_field_list, **kwargs) -> NodeResult:
-        function_lib = QuerySet(FunctionLib).filter(id=function_lib_id).first()
-        valid_function(function_lib, self.flow_params_serializer.data.get('user_id'))
-        params = {field.get('name'): convert_value(field.get('name'), field.get('value'), field.get('type'),
-                                                   field.get('is_required'),
-                                                   field.get('source'), self)
-                  for field in
-                  [{'value': get_field_value(input_field_list, field.get('name'), field.get('is_required'),
-                                             ), **field}
-                   for field in
-                   function_lib.input_field_list]}
-
-        self.context['params'] = params
-        # 合并初始化参数
-        if function_lib.init_params is not None:
-            all_params = json.loads(rsa_long_decrypt(function_lib.init_params)) | params
-        else:
-            all_params = params
-        result = function_executor.exec_code(function_lib.code, all_params)
-        return NodeResult({'result': result}, {}, _write_context=write_context)
-
-    def get_details(self, index: int, **kwargs):
-        return {
-            'name': self.node.properties.get('stepName'),
-            "index": index,
-            "result": self.context.get('result'),
-            "params": self.context.get('params'),
-            'run_time': self.context.get('run_time'),
-            'type': self.node.type,
-            'status': self.status,
-            'err_message': self.err_message
-        }

apps/application/flow/step_node/image_generate_step_node/i_image_generate_node.py

@@ -2,43 +2,51 @@
 
 from typing import Type
 
+from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode, NodeResult
-from common.util.field_message import ErrMessage
-from django.utils.translation import gettext_lazy as _
 
 
 class ImageGenerateNodeSerializer(serializers.Serializer):
-    model_id = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Model id")))
+    model_id = serializers.CharField(required=True, label=_("Model id"))
 
-    prompt = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Prompt word (positive)")))
+    prompt = serializers.CharField(required=True, label=_("Prompt word (positive)"))
 
-    negative_prompt = serializers.CharField(required=False, error_messages=ErrMessage.char(_("Prompt word (negative)")),
+    negative_prompt = serializers.CharField(required=False, label=_("Prompt word (negative)"),
                                             allow_null=True, allow_blank=True, )
     # 多轮对话数量
     dialogue_number = serializers.IntegerField(required=False, default=0,
-                                               error_messages=ErrMessage.integer(_("Number of multi-round conversations")))
+                                               label=_("Number of multi-round conversations"))
 
     dialogue_type = serializers.CharField(required=False, default='NODE',
-                                          error_messages=ErrMessage.char(_("Conversation storage type")))
+                                          label=_("Conversation storage type"))
 
-    is_result = serializers.BooleanField(required=False, error_messages=ErrMessage.boolean(_('Whether to return content')))
+    is_result = serializers.BooleanField(required=False,
+                                         label=_('Whether to return content'))
 
     model_params_setting = serializers.JSONField(required=False, default=dict,
-                                                 error_messages=ErrMessage.json(_("Model parameter settings")))
+                                                 label=_("Model parameter settings"))
 
 
 class IImageGenerateNode(INode):
     type = 'image-generate-node'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE,
+               WorkflowMode.KNOWLEDGE_LOOP]
 
     def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
         return ImageGenerateNodeSerializer
 
     def _run(self):
-        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data,
+                                **{'history_chat_record': [], 'stream': True, 'chat_id': None, 'chat_record_id': None})
+        else:
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data)
 
-    def execute(self, model_id, prompt, negative_prompt, dialogue_number, dialogue_type, history_chat_record, chat_id,
+    def execute(self, model_id, prompt, negative_prompt, dialogue_number, dialogue_type, history_chat_record,
                 model_params_setting,
                 chat_record_id,
                 **kwargs) -> NodeResult:

apps/application/flow/step_node/image_generate_step_node/impl/base_image_generate_node.py

@@ -5,26 +5,29 @@ from typing import List
 import requests
 from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import NodeResult
 from application.flow.step_node.image_generate_step_node.i_image_generate_node import IImageGenerateNode
-from common.util.common import bytes_to_uploaded_file
+from common.utils.common import bytes_to_uploaded_file
-from dataset.serializers.file_serializers import FileSerializer
+from knowledge.models import FileSourceType
-from setting.models_provider.tools import get_model_instance_by_model_user_id
+from oss.serializers.file import FileSerializer
+from models_provider.tools import get_model_instance_by_model_workspace_id
 
 
 class BaseImageGenerateNode(IImageGenerateNode):
     def save_context(self, details, workflow_manage):
         self.context['answer'] = details.get('answer')
         self.context['question'] = details.get('question')
-        self.answer_text = details.get('answer')
+        if self.node_params.get('is_result', False):
+            self.answer_text = details.get('answer')
 
-    def execute(self, model_id, prompt, negative_prompt, dialogue_number, dialogue_type, history_chat_record, chat_id,
+    def execute(self, model_id, prompt, negative_prompt, dialogue_number, dialogue_type, history_chat_record,
                 model_params_setting,
                 chat_record_id,
                 **kwargs) -> NodeResult:
-        print(model_params_setting)
+        workspace_id = self.workflow_manage.get_body().get('workspace_id')
-        application = self.workflow_manage.work_flow_post_handler.chat_info.application
+        tti_model = get_model_instance_by_model_workspace_id(model_id, workspace_id,
-        tti_model = get_model_instance_by_model_user_id(model_id, self.flow_params_serializer.data.get('user_id'), **model_params_setting)
+                                                             **model_params_setting)
         history_message = self.get_history_message(history_chat_record, dialogue_number)
         self.context['history_message'] = history_message
         question = self.generate_prompt_question(prompt)
@@ -32,19 +35,16 @@ class BaseImageGenerateNode(IImageGenerateNode):
         message_list = self.generate_message_list(question, history_message)
         self.context['message_list'] = message_list
         self.context['dialogue_type'] = dialogue_type
-        print(message_list)
+        self.context['negative_prompt'] = self.generate_prompt_question(negative_prompt)
         image_urls = tti_model.generate_image(question, negative_prompt)
         # 保存图片
         file_urls = []
         for image_url in image_urls:
             file_name = 'generated_image.png'
-            file = bytes_to_uploaded_file(requests.get(image_url).content, file_name)
+            if isinstance(image_url, str) and image_url.startswith('http'):
-            meta = {
+                image_url = requests.get(image_url).content
-                'debug': False if application.id else True,
+            file = bytes_to_uploaded_file(image_url, file_name)
-                'chat_id': chat_id,
+            file_url = self.upload_file(file)
-                'application_id': str(application.id) if application.id else None,
-            }
-            file_url = FileSerializer(data={'file': file, 'meta': meta}).upload()
             file_urls.append(file_url)
         self.context['image_list'] = [{'file_id': path.split('/')[-1], 'url': path} for path in file_urls]
         answer = ' '.join([f"![Image]({path})" for path in file_urls])
@@ -91,6 +91,42 @@ class BaseImageGenerateNode(IImageGenerateNode):
             question
         ]
 
+    def upload_file(self, file):
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.upload_knowledge_file(file)
+        return self.upload_application_file(file)
+
+    def upload_knowledge_file(self, file):
+        knowledge_id = self.workflow_params.get('knowledge_id')
+        meta = {
+            'debug': False,
+            'knowledge_id': knowledge_id,
+        }
+        file_url = FileSerializer(data={
+            'file': file,
+            'meta': meta,
+            'source_id': knowledge_id,
+            'source_type': FileSourceType.KNOWLEDGE.value
+        }).upload()
+        return file_url
+
+    def upload_application_file(self, file):
+        application = self.workflow_manage.work_flow_post_handler.chat_info.application
+        chat_id = self.workflow_params.get('chat_id')
+        meta = {
+            'debug': False if application.id else True,
+            'chat_id': chat_id,
+            'application_id': str(application.id) if application.id else None,
+        }
+        file_url = FileSerializer(data={
+            'file': file,
+            'meta': meta,
+            'source_id': meta['application_id'],
+            'source_type': FileSourceType.APPLICATION.value
+        }).upload()
+        return file_url
+
     @staticmethod
     def reset_message_list(message_list: List[BaseMessage], answer_text):
         result = [{'role': 'user' if isinstance(message, HumanMessage) else 'ai', 'content': message.content} for
@@ -116,5 +152,6 @@ class BaseImageGenerateNode(IImageGenerateNode):
             'status': self.status,
             'err_message': self.err_message,
             'image_list': self.context.get('image_list'),
-            'dialogue_type': self.context.get('dialogue_type')
+            'dialogue_type': self.context.get('dialogue_type'),
+            'negative_prompt': self.context.get('negative_prompt'),
         }

apps/application/flow/step_node/image_to_video_step_node/__init__.py

@@ -0,0 +1,3 @@
+# coding=utf-8
+
+from .impl import *

apps/application/flow/step_node/image_to_video_step_node/i_image_to_video_node.py

@@ -0,0 +1,71 @@
+# coding=utf-8
+
+from typing import Type
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import INode, NodeResult
+
+
+class ImageToVideoNodeSerializer(serializers.Serializer):
+    model_id = serializers.CharField(required=True, label=_("Model id"))
+
+    prompt = serializers.CharField(required=True, label=_("Prompt word (positive)"))
+
+    negative_prompt = serializers.CharField(required=False, label=_("Prompt word (negative)"),
+                                            allow_null=True, allow_blank=True, )
+    # 多轮对话数量
+    dialogue_number = serializers.IntegerField(required=False, default=0,
+                                               label=_("Number of multi-round conversations"))
+
+    dialogue_type = serializers.CharField(required=False, default='NODE',
+                                          label=_("Conversation storage type"))
+
+    is_result = serializers.BooleanField(required=False,
+                                         label=_('Whether to return content'))
+
+    model_params_setting = serializers.JSONField(required=False, default=dict,
+                                                 label=_("Model parameter settings"))
+
+    first_frame_url = serializers.ListField(required=True, label=_("First frame url"))
+    last_frame_url = serializers.ListField(required=False, label=_("Last frame url"))
+
+
+class IImageToVideoNode(INode):
+    type = 'image-to-video-node'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE,
+               WorkflowMode.KNOWLEDGE_LOOP]
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return ImageToVideoNodeSerializer
+
+    def _run(self):
+        first_frame_url = self.workflow_manage.get_reference_field(
+            self.node_params_serializer.data.get('first_frame_url')[0],
+            self.node_params_serializer.data.get('first_frame_url')[1:])
+        if first_frame_url is []:
+            raise ValueError(
+                _("First frame url cannot be empty"))
+        last_frame_url = None
+        if self.node_params_serializer.data.get('last_frame_url') is not None and self.node_params_serializer.data.get(
+                'last_frame_url') != []:
+            last_frame_url = self.workflow_manage.get_reference_field(
+                self.node_params_serializer.data.get('last_frame_url')[0],
+                self.node_params_serializer.data.get('last_frame_url')[1:])
+        node_params_data = {k: v for k, v in self.node_params_serializer.data.items()
+                            if k not in ['first_frame_url', 'last_frame_url']}
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.execute(first_frame_url=first_frame_url, last_frame_url=last_frame_url, **node_params_data, **self.flow_params_serializer.data,
+                                **{'history_chat_record': [], 'stream': True, 'chat_id': None, 'chat_record_id': None})
+        else:
+            return self.execute(first_frame_url=first_frame_url, last_frame_url=last_frame_url,
+                            **node_params_data, **self.flow_params_serializer.data)
+
+    def execute(self, model_id, prompt, negative_prompt, dialogue_number, dialogue_type, history_chat_record,
+                model_params_setting,
+                chat_record_id,
+                first_frame_url, last_frame_url,
+                **kwargs) -> NodeResult:
+        pass

apps/application/flow/step_node/image_to_video_step_node/impl/__init__.py

@@ -0,0 +1,3 @@
+# coding=utf-8
+
+from .base_image_to_video_node import BaseImageToVideoNode

apps/application/flow/step_node/image_to_video_step_node/impl/base_image_to_video_node.py

@@ -0,0 +1,184 @@
+# coding=utf-8
+import base64
+from functools import reduce
+from typing import List
+
+import requests
+from django.db.models import QuerySet
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import NodeResult
+from application.flow.step_node.image_to_video_step_node.i_image_to_video_node import IImageToVideoNode
+from common.utils.common import bytes_to_uploaded_file
+from knowledge.models import FileSourceType, File
+from oss.serializers.file import FileSerializer, mime_types
+from models_provider.tools import get_model_instance_by_model_workspace_id
+from django.utils.translation import gettext
+
+
+class BaseImageToVideoNode(IImageToVideoNode):
+    def save_context(self, details, workflow_manage):
+        self.context['answer'] = details.get('answer')
+        self.context['question'] = details.get('question')
+        if self.node_params.get('is_result', False):
+            self.answer_text = details.get('answer')
+
+    def execute(self, model_id, prompt, negative_prompt, dialogue_number, dialogue_type, history_chat_record,
+                model_params_setting,
+                chat_record_id,
+                first_frame_url, last_frame_url=None,
+                **kwargs) -> NodeResult:
+        workspace_id = self.workflow_manage.get_body().get('workspace_id')
+        ttv_model = get_model_instance_by_model_workspace_id(model_id, workspace_id,
+                                                             **model_params_setting)
+        history_message = self.get_history_message(history_chat_record, dialogue_number)
+        self.context['history_message'] = history_message
+        question = self.generate_prompt_question(prompt)
+        self.context['question'] = question
+        message_list = self.generate_message_list(question, history_message)
+        self.context['message_list'] = message_list
+        self.context['dialogue_type'] = dialogue_type
+        self.context['negative_prompt'] = self.generate_prompt_question(negative_prompt)
+        self.context['first_frame_url'] = first_frame_url
+        self.context['last_frame_url'] = last_frame_url
+        # 处理首尾帧图片 这块可以是url 也可以是file_id 如果是url 可以直接传递给模型  如果是file_id 需要传base64
+        # 判断是不是 url
+        first_frame_url = self.get_file_base64(first_frame_url)
+        last_frame_url = self.get_file_base64(last_frame_url)
+        video_urls = ttv_model.generate_video(question, negative_prompt, first_frame_url, last_frame_url)
+        # 保存图片
+        if video_urls is None or video_urls == '':
+            return NodeResult({'answer': gettext('Failed to generate video')}, {})
+        file_name = 'generated_video.mp4'
+        if isinstance(video_urls, str) and video_urls.startswith('http'):
+            video_urls = requests.get(video_urls).content
+        file = bytes_to_uploaded_file(video_urls, file_name)
+        file_url = self.upload_file(file)
+        video_label = f'<video src="{file_url}" controls style="max-width: 100%; width: 100%; height: auto; max-height: 60vh;"></video>'
+        video_list = [{'file_id': file_url.split('/')[-1], 'file_name': file_name, 'url': file_url}]
+        return NodeResult({'answer': video_label, 'chat_model': ttv_model, 'message_list': message_list,
+                           'video': video_list,
+                           'history_message': history_message, 'question': question}, {})
+
+    def get_file_base64(self, image_url):
+        try:
+            if isinstance(image_url, list):
+                image_url = image_url[0].get('file_id') if 'file_id' in image_url[0] else image_url[0].get('url')
+            if isinstance(image_url, str) and not image_url.startswith('http'):
+                file = QuerySet(File).filter(id=image_url).first()
+                file_bytes = file.get_bytes()
+                # 如果我不知道content_type 可以用 magic 库去检测
+                file_type = file.file_name.split(".")[-1].lower()
+                content_type = mime_types.get(file_type, 'application/octet-stream')
+                encoded_bytes = base64.b64encode(file_bytes)
+                return f'data:{content_type};base64,{encoded_bytes.decode()}'
+            return image_url
+        except Exception as e:
+            raise ValueError(
+                gettext("Failed to obtain the image"))
+
+    def upload_file(self, file):
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.upload_knowledge_file(file)
+        return self.upload_application_file(file)
+
+    def upload_knowledge_file(self, file):
+        knowledge_id = self.workflow_params.get('knowledge_id')
+        meta = {
+            'debug': False,
+            'knowledge_id': knowledge_id
+        }
+        file_url = FileSerializer(data={
+            'file': file,
+            'meta': meta,
+            'source_id': knowledge_id,
+            'source_type': FileSourceType.KNOWLEDGE.value
+        }).upload()
+        return file_url
+
+    def upload_application_file(self, file):
+        application = self.workflow_manage.work_flow_post_handler.chat_info.application
+        chat_id = self.workflow_params.get('chat_id')
+        meta = {
+            'debug': False if application.id else True,
+            'chat_id': chat_id,
+            'application_id': str(application.id) if application.id else None,
+        }
+        file_url = FileSerializer(data={
+            'file': file,
+            'meta': meta,
+            'source_id': meta['application_id'],
+            'source_type': FileSourceType.APPLICATION.value
+        }).upload()
+        return file_url
+
+    def generate_history_ai_message(self, chat_record):
+        for val in chat_record.details.values():
+            if self.node.id == val['node_id'] and 'image_list' in val:
+                if val['dialogue_type'] == 'WORKFLOW':
+                    return chat_record.get_ai_message()
+                image_list = val['image_list']
+                return AIMessage(content=[
+                    *[{'type': 'image_url', 'image_url': {'url': f'{file_url}'}} for file_url in image_list]
+                ])
+        return chat_record.get_ai_message()
+
+    def get_history_message(self, history_chat_record, dialogue_number):
+        start_index = len(history_chat_record) - dialogue_number
+        history_message = reduce(lambda x, y: [*x, *y], [
+            [self.generate_history_human_message(history_chat_record[index]),
+             self.generate_history_ai_message(history_chat_record[index])]
+            for index in
+            range(start_index if start_index > 0 else 0, len(history_chat_record))], [])
+        return history_message
+
+    def generate_history_human_message(self, chat_record):
+
+        for data in chat_record.details.values():
+            if self.node.id == data['node_id'] and 'image_list' in data:
+                image_list = data['image_list']
+                if len(image_list) == 0 or data['dialogue_type'] == 'WORKFLOW':
+                    return HumanMessage(content=chat_record.problem_text)
+                return HumanMessage(content=data['question'])
+        return HumanMessage(content=chat_record.problem_text)
+
+    def generate_prompt_question(self, prompt):
+        return self.workflow_manage.generate_prompt(prompt)
+
+    def generate_message_list(self, question: str, history_message):
+        return [
+            *history_message,
+            question
+        ]
+
+    @staticmethod
+    def reset_message_list(message_list: List[BaseMessage], answer_text):
+        result = [{'role': 'user' if isinstance(message, HumanMessage) else 'ai', 'content': message.content} for
+                  message
+                  in
+                  message_list]
+        result.append({'role': 'ai', 'content': answer_text})
+        return result
+
+    def get_details(self, index: int, **kwargs):
+        return {
+            'name': self.node.properties.get('stepName'),
+            "index": index,
+            'run_time': self.context.get('run_time'),
+            'history_message': [{'content': message.content, 'role': message.type} for message in
+                                (self.context.get('history_message') if self.context.get(
+                                    'history_message') is not None else [])],
+            'question': self.context.get('question'),
+            'answer': self.context.get('answer'),
+            'type': self.node.type,
+            'message_tokens': self.context.get('message_tokens'),
+            'answer_tokens': self.context.get('answer_tokens'),
+            'status': self.status,
+            'err_message': self.err_message,
+            'first_frame_url': self.context.get('first_frame_url'),
+            'last_frame_url': self.context.get('last_frame_url'),
+            'dialogue_type': self.context.get('dialogue_type'),
+            'negative_prompt': self.context.get('negative_prompt'),
+        }

apps/application/flow/step_node/image_understand_step_node/i_image_understand_node.py

@@ -4,31 +4,35 @@ from typing import Type
 
 from rest_framework import serializers
 
+from application.flow.common import WorkflowMode
 from application.flow.i_step_node import INode, NodeResult
-from common.util.field_message import ErrMessage
+
 from django.utils.translation import gettext_lazy as _
 
 
 class ImageUnderstandNodeSerializer(serializers.Serializer):
-    model_id = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Model id")))
+    model_id = serializers.CharField(required=True, label=_("Model id"))
     system = serializers.CharField(required=False, allow_blank=True, allow_null=True,
-                                   error_messages=ErrMessage.char(_("Role Setting")))
+                                   label=_("Role Setting"))
-    prompt = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Prompt word")))
+    prompt = serializers.CharField(required=True, label=_("Prompt word"))
     # 多轮对话数量
-    dialogue_number = serializers.IntegerField(required=True, error_messages=ErrMessage.integer(_("Number of multi-round conversations")))
+    dialogue_number = serializers.IntegerField(required=True, label=_("Number of multi-round conversations"))
 
-    dialogue_type = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Conversation storage type")))
+    dialogue_type = serializers.CharField(required=True, label=_("Conversation storage type"))
 
-    is_result = serializers.BooleanField(required=False, error_messages=ErrMessage.boolean(_('Whether to return content')))
+    is_result = serializers.BooleanField(required=False,
+                                         label=_('Whether to return content'))
 
-    image_list = serializers.ListField(required=False, error_messages=ErrMessage.list(_("picture")))
+    image_list = serializers.ListField(required=False, label=_("picture"))
 
     model_params_setting = serializers.JSONField(required=False, default=dict,
-                                                 error_messages=ErrMessage.json(_("Model parameter settings")))
+                                                 label=_("Model parameter settings"))
 
 
 class IImageUnderstandNode(INode):
     type = 'image-understand-node'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE,
+               WorkflowMode.KNOWLEDGE_LOOP]
 
     def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
         return ImageUnderstandNodeSerializer
@@ -36,9 +40,14 @@ class IImageUnderstandNode(INode):
     def _run(self):
         res = self.workflow_manage.get_reference_field(self.node_params_serializer.data.get('image_list')[0],
                                                        self.node_params_serializer.data.get('image_list')[1:])
-        return self.execute(image=res, **self.node_params_serializer.data, **self.flow_params_serializer.data)
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.execute(image=res, **self.node_params_serializer.data, **self.flow_params_serializer.data,
+                                **{'history_chat_record': [], 'stream': True,  'chat_record_id': None})
+        else:
+            return self.execute(image=res, **self.node_params_serializer.data, **self.flow_params_serializer.data)
 
-    def execute(self, model_id, system, prompt, dialogue_number, dialogue_type, history_chat_record, stream, chat_id,
+    def execute(self, model_id, system, prompt, dialogue_number, dialogue_type, history_chat_record, stream,
                 model_params_setting,
                 chat_record_id,
                 image,

apps/application/flow/step_node/image_understand_step_node/impl/base_image_understand_node.py

@@ -1,8 +1,8 @@
 # coding=utf-8
 import base64
-import os
 import time
 from functools import reduce
+from imghdr import what
 from typing import List, Dict
 
 from django.db.models import QuerySet
@@ -10,9 +10,8 @@ from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage, AI
 
 from application.flow.i_step_node import NodeResult, INode
 from application.flow.step_node.image_understand_step_node.i_image_understand_node import IImageUnderstandNode
-from dataset.models import File
+from knowledge.models import File
-from setting.models_provider.tools import get_model_instance_by_model_user_id
+from models_provider.tools import get_model_instance_by_model_workspace_id
-from imghdr import what
 
 
 def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow, answer: str):
@@ -60,27 +59,27 @@ def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, wor
 
 def file_id_to_base64(file_id: str):
     file = QuerySet(File).filter(id=file_id).first()
-    file_bytes = file.get_byte()
+    file_bytes = file.get_bytes()
     base64_image = base64.b64encode(file_bytes).decode("utf-8")
-    return [base64_image, what(None, file_bytes.tobytes())]
+    return [base64_image, what(None, file_bytes)]
 
 
 class BaseImageUnderstandNode(IImageUnderstandNode):
     def save_context(self, details, workflow_manage):
         self.context['answer'] = details.get('answer')
         self.context['question'] = details.get('question')
-        self.answer_text = details.get('answer')
+        if self.node_params.get('is_result', False):
+            self.answer_text = details.get('answer')
 
-    def execute(self, model_id, system, prompt, dialogue_number, dialogue_type, history_chat_record, stream, chat_id,
+    def execute(self, model_id, system, prompt, dialogue_number, dialogue_type, history_chat_record, stream,
                 model_params_setting,
                 chat_record_id,
                 image,
                 **kwargs) -> NodeResult:
         # 处理不正确的参数
-        if image is None or not isinstance(image, list):
+        workspace_id = self.workflow_manage.get_body().get('workspace_id')
-            image = []
+        image_model = get_model_instance_by_model_workspace_id(model_id, workspace_id,
-        print(model_params_setting)
+                                                               **model_params_setting)
-        image_model = get_model_instance_by_model_user_id(model_id, self.flow_params_serializer.data.get('user_id'), **model_params_setting)
         # 执行详情中的历史消息不需要图片内容
         history_message = self.get_history_message_for_details(history_chat_record, dialogue_number)
         self.context['history_message'] = history_message
@@ -90,7 +89,7 @@ class BaseImageUnderstandNode(IImageUnderstandNode):
         message_list = self.generate_message_list(image_model, system, prompt,
                                                   self.get_history_message(history_chat_record, dialogue_number), image)
         self.context['message_list'] = message_list
-        self.context['image_list'] = image
+        self.generate_context_image(image)
         self.context['dialogue_type'] = dialogue_type
         if stream:
             r = image_model.stream(message_list)
@@ -103,6 +102,12 @@ class BaseImageUnderstandNode(IImageUnderstandNode):
                                'history_message': history_message, 'question': question.content}, {},
                               _write_context=write_context)
 
+    def generate_context_image(self, image):
+        if isinstance(image, str) and image.startswith('http'):
+            self.context['image_list'] = [{'url': image}]
+        elif image is not None and len(image) > 0:
+            self.context['image_list'] = image
+
     def get_history_message_for_details(self, history_chat_record, dialogue_number):
         start_index = len(history_chat_record) - dialogue_number
         history_message = reduce(lambda x, y: [*x, *y], [
@@ -126,11 +131,18 @@ class BaseImageUnderstandNode(IImageUnderstandNode):
                 image_list = data['image_list']
                 if len(image_list) == 0 or data['dialogue_type'] == 'WORKFLOW':
                     return HumanMessage(content=chat_record.problem_text)
-                file_id_list = [image.get('file_id') for image in image_list]
+
+                file_id_list = []
+                url_list = []
+                for image in image_list:
+                    if 'file_id' in image:
+                        file_id_list.append(image.get('file_id'))
+                    elif 'url' in image:
+                        url_list.append(image.get('url'))
                 return HumanMessage(content=[
                     {'type': 'text', 'text': data['question']},
-                    *[{'type': 'image_url', 'image_url': {'url': f'/api/file/{file_id}'}} for file_id in file_id_list]
+                    *[{'type': 'image_url', 'image_url': {'url': f'./oss/file/{file_id}'}} for file_id in file_id_list],
-
+                    *[{'type': 'image_url', 'image_url': {'url': url}} for url in url_list]
                 ])
         return HumanMessage(content=chat_record.problem_text)
 
@@ -150,36 +162,58 @@ class BaseImageUnderstandNode(IImageUnderstandNode):
                 image_list = data['image_list']
                 if len(image_list) == 0 or data['dialogue_type'] == 'WORKFLOW':
                     return HumanMessage(content=chat_record.problem_text)
-                image_base64_list = [file_id_to_base64(image.get('file_id')) for image in image_list]
+                file_id_list = []
+                url_list = []
+                for image in image_list:
+                    if 'file_id' in image:
+                        file_id_list.append(image.get('file_id'))
+                    elif 'url' in image:
+                        url_list.append(image.get('url'))
+                image_base64_list = [file_id_to_base64(file_id) for file_id in file_id_list]
+
                 return HumanMessage(
                     content=[
                         {'type': 'text', 'text': data['question']},
-                        *[{'type': 'image_url', 'image_url': {'url': f'data:image/{base64_image[1]};base64,{base64_image[0]}'}} for
+                        *[{'type': 'image_url',
-                          base64_image in image_base64_list]
+                           'image_url': {'url': f'data:image/{base64_image[1]};base64,{base64_image[0]}'}} for
+                          base64_image in image_base64_list],
+                        *[{'type': 'image_url', 'image_url': url} for url in url_list]
                     ])
         return HumanMessage(content=chat_record.problem_text)
 
     def generate_prompt_question(self, prompt):
         return HumanMessage(self.workflow_manage.generate_prompt(prompt))
 
-    def generate_message_list(self, image_model, system: str, prompt: str, history_message, image):
+    def _process_images(self, image):
-        if image is not None and len(image) > 0:
+        """
-            # 处理多张图片
+        处理图像数据，转换为模型可识别的格式
-            images = []
+        """
+        images = []
+        if isinstance(image, str) and image.startswith('http'):
+            images.append({'type': 'image_url', 'image_url': {'url': image}})
+        elif image is not None and len(image) > 0:
             for img in image:
-                file_id = img['file_id']
+                if 'file_id' in img:
-                file = QuerySet(File).filter(id=file_id).first()
+                    file_id = img['file_id']
-                image_bytes = file.get_byte()
+                    file = QuerySet(File).filter(id=file_id).first()
-                base64_image = base64.b64encode(image_bytes).decode("utf-8")
+                    image_bytes = file.get_bytes()
-                image_format = what(None, image_bytes.tobytes())
+                    base64_image = base64.b64encode(image_bytes).decode("utf-8")
-                images.append({'type': 'image_url', 'image_url': {'url': f'data:image/{image_format};base64,{base64_image}'}})
+                    image_format = what(None, image_bytes)
-            messages = [HumanMessage(
+                    images.append(
-                content=[
+                        {'type': 'image_url', 'image_url': {'url': f'data:image/{image_format};base64,{base64_image}'}})
-                    {'type': 'text', 'text': self.workflow_manage.generate_prompt(prompt)},
+                elif 'url' in img and img['url'].startswith('http'):
-                    *images
+                    images.append(
-                ])]
+                        {'type': 'image_url', 'image_url': {'url': img["url"]}})
+        return images
+
+    def generate_message_list(self, image_model, system: str, prompt: str, history_message, image):
+        prompt_text = self.workflow_manage.generate_prompt(prompt)
+        images = self._process_images(image)
+
+        if images:
+            messages = [HumanMessage(content=[{'type': 'text', 'text': prompt_text}, *images])]
         else:
-            messages = [HumanMessage(self.workflow_manage.generate_prompt(prompt))]
+            messages = [HumanMessage(prompt_text)]
 
         if system is not None and len(system) > 0:
             return [

apps/application/flow/step_node/intent_node/__init__.py

@@ -0,0 +1,6 @@
+# coding=utf-8
+
+
+
+
+from .impl import *

apps/application/flow/step_node/intent_node/i_intent_node.py

@@ -0,0 +1,55 @@
+# coding=utf-8
+
+from typing import Type
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import INode, NodeResult
+
+
+class IntentBranchSerializer(serializers.Serializer):
+    id = serializers.CharField(required=True, label=_("Branch id"))
+    content = serializers.CharField(required=True, label=_("content"))
+    isOther = serializers.BooleanField(required=True, label=_("Branch Type"))
+
+
+class IntentNodeSerializer(serializers.Serializer):
+    model_id = serializers.CharField(required=True, label=_("Model id"))
+    content_list = serializers.ListField(required=True, label=_("Text content"))
+    dialogue_number = serializers.IntegerField(required=True, label=
+    _("Number of multi-round conversations"))
+    model_params_setting = serializers.DictField(required=False,
+                                                 label=_("Model parameter settings"))
+    branch = IntentBranchSerializer(many=True)
+
+
+class IIntentNode(INode):
+    type = 'intent-node'
+    support = [WorkflowMode.APPLICATION, WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE,
+               WorkflowMode.KNOWLEDGE_LOOP]
+
+    def save_context(self, details, workflow_manage):
+        pass
+
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return IntentNodeSerializer
+
+    def _run(self):
+        question = self.workflow_manage.get_reference_field(
+            self.node_params_serializer.data.get('content_list')[0],
+            self.node_params_serializer.data.get('content_list')[1:],
+        )
+        if [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP].__contains__(
+                self.workflow_manage.flow.workflow_mode):
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data,
+                                **{'history_chat_record': [], 'stream': True, 'chat_id': None, 'chat_record_id': None,
+                                   'user_input': str(question)})
+        else:
+            return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data,
+                                user_input=str(question))
+
+    def execute(self, model_id, dialogue_number, history_chat_record, user_input, branch,
+                model_params_setting=None, **kwargs) -> NodeResult:
+        pass

apps/application/flow/step_node/intent_node/impl/__init__.py

@@ -0,0 +1,3 @@
+
+
+from .base_intent_node import BaseIntentNode

apps/application/flow/step_node/intent_node/impl/base_intent_node.py

@@ -0,0 +1,261 @@
+# coding=utf-8
+import json
+import re
+import time
+from typing import List, Dict, Any
+from functools import reduce
+
+from django.db.models import QuerySet
+from langchain.schema import HumanMessage, SystemMessage
+
+from application.flow.i_step_node import INode, NodeResult
+from application.flow.step_node.intent_node.i_intent_node import IIntentNode
+from models_provider.models import Model
+from models_provider.tools import get_model_instance_by_model_workspace_id, get_model_credential
+from .prompt_template import PROMPT_TEMPLATE
+
+def get_default_model_params_setting(model_id):
+
+    model = QuerySet(Model).filter(id=model_id).first()
+    credential = get_model_credential(model.provider, model.model_type, model.model_name)
+    model_params_setting = credential.get_model_params_setting_form(
+        model.model_name).get_default_form_data()
+    return model_params_setting
+
+
+def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow, answer: str):
+
+    chat_model = node_variable.get('chat_model')
+    message_tokens = chat_model.get_num_tokens_from_messages(node_variable.get('message_list'))
+    answer_tokens = chat_model.get_num_tokens(answer)
+
+    node.context['message_tokens'] = message_tokens
+    node.context['answer_tokens'] = answer_tokens
+    node.context['answer'] = answer
+    node.context['history_message'] = node_variable['history_message']
+    node.context['user_input'] = node_variable['user_input']
+    node.context['branch_id'] = node_variable.get('branch_id')
+    node.context['reason'] = node_variable.get('reason')
+    node.context['category'] = node_variable.get('category')
+    node.context['run_time'] = time.time() - node.context['start_time']
+
+
+def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow):
+
+    response = node_variable.get('result')
+    answer = response.content
+    _write_context(node_variable, workflow_variable, node, workflow, answer)
+
+
+class BaseIntentNode(IIntentNode):
+
+
+    def save_context(self, details, workflow_manage):
+
+        self.context['branch_id'] = details.get('branch_id')
+        self.context['category'] = details.get('category')
+
+
+    def execute(self, model_id, dialogue_number, history_chat_record, user_input, branch,
+                model_params_setting=None, **kwargs) -> NodeResult:
+
+        # 设置默认模型参数
+        if model_params_setting is None:
+            model_params_setting = get_default_model_params_setting(model_id)
+
+        # 获取模型实例
+        workspace_id = self.workflow_manage.get_body().get('workspace_id')
+        chat_model = get_model_instance_by_model_workspace_id(
+            model_id, workspace_id, **model_params_setting
+        )
+
+        # 获取历史对话
+        history_message = self.get_history_message(history_chat_record, dialogue_number)
+        self.context['history_message'] = history_message
+
+        # 保存问题到上下文
+        self.context['user_input'] = user_input
+
+        # 构建分类提示词
+        prompt = self.build_classification_prompt(user_input, branch)
+
+
+        # 生成消息列表
+        system = self.build_system_prompt()
+        message_list = self.generate_message_list(system, prompt, history_message)
+        self.context['message_list'] = message_list
+
+        # 调用模型进行分类
+        try:
+            r = chat_model.invoke(message_list)
+            classification_result = r.content.strip()
+            # 解析分类结果获取分支信息
+            matched_branch = self.parse_classification_result(classification_result, branch)
+
+            #  返回结果
+            return NodeResult({
+                'result': r,
+                'chat_model': chat_model,
+                'message_list': message_list,
+                'history_message': history_message,
+                'user_input': user_input,
+                'branch_id': matched_branch['id'],
+                'reason': self.parse_result_reason(r.content),
+                'category': matched_branch.get('content', matched_branch['id'])
+            }, {}, _write_context=write_context)
+
+        except Exception as e:
+            # 错误处理：返回"其他"分支
+            other_branch = self.find_other_branch(branch)
+            if other_branch:
+                return NodeResult({
+                    'branch_id': other_branch['id'],
+                    'category': other_branch.get('content', other_branch['id']),
+                    'error': str(e)
+                }, {})
+            else:
+                raise Exception(f"error: {str(e)}")
+
+    @staticmethod
+    def get_history_message(history_chat_record, dialogue_number):
+        """获取历史消息"""
+        start_index = len(history_chat_record) - dialogue_number
+        history_message = reduce(lambda x, y: [*x, *y], [
+            [history_chat_record[index].get_human_message(), history_chat_record[index].get_ai_message()]
+            for index in
+            range(start_index if start_index > 0 else 0, len(history_chat_record))], [])
+
+        for message in history_message:
+            if isinstance(message.content, str):
+                message.content = re.sub('<form_rander>[\d\D]*?<\/form_rander>', '', message.content)
+        return history_message
+
+
+    def build_system_prompt(self) -> str:
+        """构建系统提示词"""
+        return "你是一个专业的意图识别助手，请根据用户输入和意图选项，准确识别用户的真实意图。"
+
+    def build_classification_prompt(self, user_input: str, branch: List[Dict]) -> str:
+        """构建分类提示词"""
+
+        classification_list = []
+
+        other_branch = self.find_other_branch(branch)
+        # 添加其他分支
+        if other_branch:
+            classification_list.append({
+                "classificationId": 0,
+                "content": other_branch.get('content')
+            })
+        # 添加正常分支
+        classification_id = 1
+        for b in branch:
+            if not b.get('isOther'):
+                classification_list.append({
+                    "classificationId": classification_id,
+                    "content": b['content']
+                })
+                classification_id += 1
+
+        return PROMPT_TEMPLATE.format(
+            classification_list=classification_list,
+            user_input=user_input
+        )
+
+
+    def generate_message_list(self, system: str, prompt: str, history_message):
+        """生成消息列表"""
+        if system is None or len(system) == 0:
+            return [*history_message, HumanMessage(self.workflow_manage.generate_prompt(prompt))]
+        else:
+            return [SystemMessage(self.workflow_manage.generate_prompt(system)), *history_message,
+                    HumanMessage(self.workflow_manage.generate_prompt(prompt))]
+
+    def parse_classification_result(self, result: str, branch: List[Dict]) -> Dict[str, Any]:
+        """解析分类结果"""
+
+        other_branch = self.find_other_branch(branch)
+        normal_intents = [
+            b
+            for b in branch
+            if not b.get('isOther')
+        ]
+
+        def get_branch_by_id(category_id: int):
+            if category_id == 0:
+                return other_branch
+            elif 1 <= category_id <= len(normal_intents):
+                return normal_intents[category_id - 1]
+            return None
+
+        try:
+            result_json = json.loads(result)
+            classification_id = result_json.get('classificationId')
+            # 如果是 0 ，返回其他分支
+            matched_branch = get_branch_by_id(classification_id)
+            if matched_branch:
+                return matched_branch
+
+        except Exception as e:
+            # json 解析失败，re 提取
+            numbers = re.findall(r'"classificationId":\s*(\d+)', result)
+            if numbers:
+                classification_id = int(numbers[0])
+
+                matched_branch = get_branch_by_id(classification_id)
+                if matched_branch:
+                    return matched_branch
+
+        # 如果都解析失败，返回“other”
+        return other_branch or (normal_intents[0] if normal_intents else {'id': 'unknown', 'content': 'unknown'})
+
+    def parse_result_reason(self, result: str):
+        """解析分类的原因"""
+        try:
+            result_json = json.loads(result)
+            return result_json.get('reason', '')
+        except Exception as e:
+            reason_patterns = [
+                r'"reason":\s*"([^"]*)"',  # 标准格式
+                r'"reason":\s*"([^"]*)',  # 缺少结束引号
+                r'"reason":\s*([^,}\n]*)',  # 没有引号包围的内容
+            ]
+            for pattern in reason_patterns:
+                match = re.search(pattern, result, re.DOTALL)
+                if match:
+                    reason = match.group(1).strip()
+                    # 清理可能的尾部字符
+                    reason = re.sub(r'["\s]*$', '', reason)
+                    return reason
+
+            return ''
+
+    def find_other_branch(self, branch: List[Dict]) -> Dict[str, Any] | None:
+        """查找其他分支"""
+        for b in branch:
+            if b.get('isOther'):
+                return b
+        return None
+
+
+    def get_details(self, index: int, **kwargs):
+        """获取节点执行详情"""
+        return {
+            'name': self.node.properties.get('stepName'),
+            'index': index,
+            'run_time': self.context.get('run_time'),
+            'system': self.context.get('system'),
+            'history_message': [
+                {'content': message.content, 'role': message.type}
+                for message in (self.context.get('history_message') or [])
+            ],
+            'user_input': self.context.get('user_input'),
+            'answer': self.context.get('answer'),
+            'branch_id': self.context.get('branch_id'),
+            'category': self.context.get('category'),
+            'type': self.node.type,
+            'message_tokens': self.context.get('message_tokens'),
+            'answer_tokens': self.context.get('answer_tokens'),
+            'status': self.status,
+            'err_message': self.err_message
+        }

apps/application/flow/step_node/intent_node/impl/prompt_template.py

@@ -0,0 +1,32 @@
+
+
+
+
+PROMPT_TEMPLATE = """
+    # Role
+    You are an intention classification expert, good at being able to judge which classification the user's input belongs to.
+
+    ## Skills
+    Skill 1: Clearly determine which of the following intention classifications the user's input belongs to.
+    Intention classification list:
+    {classification_list}
+
+    Note:
+    - Please determine the match only between the user's input content and the Intention classification list content, without judging or categorizing the match with the classification ID.
+    - **When classifying, you must give higher weight to the context and intent continuity shown in the historical conversation. Do not rely solely on the literal meaning of the current input; instead, prioritize the most consistent classification with the previous dialogue flow.**
+
+    ## User Input
+    {user_input}
+
+    ## Reply requirements
+    - The answer must be returned in JSON format.
+    - Strictly ensure that the output is in a valid JSON format.
+    - Do not add prefix ```json or suffix ```
+    - The answer needs to include the following fields such as:
+    {{
+    "classificationId": 0,
+    "reason": ""
+    }}
+
+    ## Limit
+    - Please do not reply in text."""

apps/application/flow/step_node/knowledge_write_node/__init__.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：niu
+    @file： __init__.py.py
+    @date：2025/11/13 11:17
+    @desc:
+"""

apps/application/flow/step_node/knowledge_write_node/i_knowledge_write_node.py

@@ -0,0 +1,43 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：niu
+    @file： i_knowledge_write_node.py
+    @date：2025/11/13 11:19
+    @desc:
+"""
+from typing import Type
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import INode, NodeResult
+
+
+class KnowledgeWriteNodeParamSerializer(serializers.Serializer):
+    document_list = serializers.ListField(required=True, child=serializers.CharField(required=True), allow_null=True,
+                                          label=_('document list'))
+
+
+class IKnowledgeWriteNode(INode):
+
+    def save_context(self, details, workflow_manage):
+        pass
+
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return KnowledgeWriteNodeParamSerializer
+
+    def _run(self):
+        documents = self.workflow_manage.get_reference_field(
+            self.node_params_serializer.data.get('document_list')[0],
+            self.node_params_serializer.data.get('document_list')[1:],
+        )
+
+        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data, documents=documents)
+
+    def execute(self, documents, **kwargs) -> NodeResult:
+        pass
+
+    type = 'knowledge-write-node'
+    support = [WorkflowMode.KNOWLEDGE, WorkflowMode.KNOWLEDGE_LOOP]

apps/application/flow/step_node/knowledge_write_node/impl/__init__.py

@@ -1,8 +1,8 @@
 # coding=utf-8
 """
     @project: MaxKB
-    @Author：虎
+    @Author：niu
     @file： __init__.py.py
-    @date：2024/8/2 14:55
+    @date：2025/11/13 11:18
     @desc:
 """

apps/application/flow/step_node/knowledge_write_node/impl/base_knowledge_write_node.py

@@ -0,0 +1,329 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：niu
+    @file： base_knowledge_write_node.py
+    @date：2025/11/13 11:19
+    @desc:
+"""
+from functools import reduce
+from typing import Dict, List, Any
+import uuid_utils.compat as uuid
+from django.db.models import QuerySet
+from django.db.models.aggregates import Max
+
+from rest_framework import serializers
+from django.utils.translation import gettext_lazy as _
+from application.flow.i_step_node import NodeResult
+from application.flow.step_node.knowledge_write_node.i_knowledge_write_node import IKnowledgeWriteNode
+from common.chunk import text_to_chunk
+from common.utils.common import bulk_create_in_batches, filter_special_character
+from knowledge.models import Document, KnowledgeType, Paragraph, File, FileSourceType, Problem, ProblemParagraphMapping, \
+    Tag, DocumentTag
+from knowledge.serializers.common import ProblemParagraphObject, ProblemParagraphManage
+from knowledge.serializers.document import DocumentSerializers
+
+
+class ParagraphInstanceSerializer(serializers.Serializer):
+    content = serializers.CharField(required=True, label=_('content'), max_length=102400, min_length=1, allow_null=True,
+                                    allow_blank=True)
+    title = serializers.CharField(required=False, max_length=256, label=_('section title'), allow_null=True,
+                                  allow_blank=True)
+    problem_list = serializers.ListField(required=False, child=serializers.CharField(required=False, allow_blank=True))
+    is_active = serializers.BooleanField(required=False, label=_('Is active'))
+    chunks = serializers.ListField(required=False, child=serializers.CharField(required=True))
+
+
+class TagInstanceSerializer(serializers.Serializer):
+    key = serializers.CharField(required=True, max_length=64, label=_('Tag Key'))
+    value = serializers.CharField(required=True, max_length=128, label=_('Tag Value'))
+
+
+class KnowledgeWriteParamSerializer(serializers.Serializer):
+    name = serializers.CharField(required=True, label=_('document name'), max_length=128, min_length=1,
+                                 source=_('document name'))
+    meta = serializers.DictField(required=False)
+    tags = serializers.ListField(required=False, label=_('Tags'), child=TagInstanceSerializer())
+    paragraphs = ParagraphInstanceSerializer(required=False, many=True, allow_null=True)
+    source_file_id = serializers.UUIDField(required=False, allow_null=True)
+
+
+def convert_uuid_to_str(obj):
+    if isinstance(obj, dict):
+        return {k: convert_uuid_to_str(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_uuid_to_str(i) for i in obj]
+    elif isinstance(obj, uuid.UUID):
+        return str(obj)
+    else:
+        return obj
+
+
+def link_file(source_file_id, document_id):
+    if source_file_id is None:
+        return
+    source_file = QuerySet(File).filter(id=source_file_id).first()
+    if source_file:
+        file_content = source_file.get_bytes()
+
+        new_file = File(
+            id=uuid.uuid7(),
+            file_name=source_file.file_name,
+            file_size=source_file.file_size,
+            source_type=FileSourceType.DOCUMENT,
+            source_id=document_id,  # 更新为当前知识库ID
+            meta=source_file.meta.copy() if source_file.meta else {}
+        )
+
+        # 保存文件内容和元数据
+        new_file.save(file_content)
+
+
+def get_paragraph_problem_model(knowledge_id: str, document_id: str, instance: Dict):
+    paragraph = Paragraph(
+        id=uuid.uuid7(),
+        document_id=document_id,
+        content=filter_special_character(instance.get("content")),
+        knowledge_id=knowledge_id,
+        title=instance.get("title") if 'title' in instance else '',
+        chunks=[filter_special_character(c) for c in (instance.get('chunks') if 'chunks' in instance else text_to_chunk(
+            instance.get("content")))],
+    )
+
+    problem_paragraph_object_list = [ProblemParagraphObject(
+        knowledge_id, document_id, str(paragraph.id), problem
+    ) for problem in (instance.get('problem_list') if 'problem_list' in instance else [])]
+
+    return {
+        'paragraph': paragraph,
+        'problem_paragraph_object_list': problem_paragraph_object_list,
+    }
+
+
+def get_paragraph_model(document_model, paragraph_list: List):
+    knowledge_id = document_model.knowledge_id
+    paragraph_model_dict_list = [
+        get_paragraph_problem_model(knowledge_id, document_model.id, paragraph)
+        for paragraph in paragraph_list
+    ]
+
+    paragraph_model_list = []
+    problem_paragraph_object_list = []
+    for paragraphs in paragraph_model_dict_list:
+        paragraph = paragraphs.get('paragraph')
+        for problem_model in paragraphs.get('problem_paragraph_object_list'):
+            problem_paragraph_object_list.append(problem_model)
+        paragraph_model_list.append(paragraph)
+
+    return {
+        'document': document_model,
+        'paragraph_model_list': paragraph_model_list,
+        'problem_paragraph_object_list': problem_paragraph_object_list,
+    }
+
+
+def get_document_paragraph_model(knowledge_id: str, instance: Dict):
+    source_meta = {'source_file_id': instance.get("source_file_id")} if instance.get("source_file_id") else {}
+    meta = {**instance.get('meta'), **source_meta} if instance.get('meta') is not None else source_meta
+    meta = {**convert_uuid_to_str(meta), 'allow_download': True}
+
+    document_model = Document(
+        **{
+            'knowledge_id': knowledge_id,
+            'id': uuid.uuid7(),
+            'name': instance.get('name'),
+            'char_length': reduce(
+                lambda x, y: x + y,
+                [len(p.get('content')) for p in instance.get('paragraphs', [])],
+                0),
+            'meta': meta,
+            'type': instance.get('type') if instance.get('type') is not None else KnowledgeType.WORKFLOW
+        }
+    )
+
+    return get_paragraph_model(
+        document_model,
+        instance.get('paragraphs') if 'paragraphs' in instance else []
+    )
+
+
+def save_knowledge_tags(knowledge_id: str, tags: List[Dict[str, Any]]):
+    existed_tags_dict = {
+        (key, value): str(tag_id)
+        for key, value, tag_id in QuerySet(Tag).filter(knowledge_id=knowledge_id).values_list("key", "value", "id")
+    }
+
+    tag_model_list = []
+    new_tag_dict = {}
+    for tag in tags:
+        key = tag.get("key")
+        value = tag.get("value")
+
+        if (key, value) not in existed_tags_dict:
+            tag_model = Tag(
+                id=uuid.uuid7(),
+                knowledge_id=knowledge_id,
+                key=key,
+                value=value
+            )
+            tag_model_list.append(tag_model)
+            new_tag_dict[(key, value)] = str(tag_model.id)
+
+    if tag_model_list:
+        Tag.objects.bulk_create(tag_model_list)
+
+    all_tag_dict = {**existed_tags_dict, **new_tag_dict}
+
+    return all_tag_dict, new_tag_dict
+
+
+def batch_add_document_tag(document_tag_map: Dict[str, List[str]]):
+    """
+    批量添加文档-标签关联
+    document_tag_map: {document_id: [tag_id1, tag_id2, ...]}
+    """
+    all_document_ids = list(document_tag_map.keys())
+    all_tag_ids = list(set(tag_id for tag_ids in document_tag_map.values() for tag_id in tag_ids))
+
+    # 查询已存在的文档-标签关联
+    existed_relations = set(
+        QuerySet(DocumentTag).filter(
+            document_id__in=all_document_ids,
+            tag_id__in=all_tag_ids
+        ).values_list('document_id', 'tag_id')
+    )
+
+    new_relations = [
+        DocumentTag(
+            id=uuid.uuid7(),
+            document_id=doc_id,
+            tag_id=tag_id,
+        )
+        for doc_id, tag_ids in document_tag_map.items()
+        for tag_id in tag_ids
+        if (doc_id, tag_id) not in existed_relations
+    ]
+
+    if new_relations:
+        QuerySet(DocumentTag).bulk_create(new_relations)
+
+
+class BaseKnowledgeWriteNode(IKnowledgeWriteNode):
+
+    def save_context(self, details, workflow_manage):
+        pass
+
+    def save(self, document_list):
+        serializer = KnowledgeWriteParamSerializer(data=document_list, many=True)
+        serializer.is_valid(raise_exception=True)
+        document_list = serializer.data
+
+        knowledge_id = self.workflow_params.get("knowledge_id")
+        workspace_id = self.workflow_params.get("workspace_id")
+
+        document_model_list = []
+        paragraph_model_list = []
+        problem_paragraph_object_list = []
+        # 所有标签
+        knowledge_tag_list = []
+        # 文档标签映射关系
+        document_tags_map = {}
+        knowledge_tag_dict = {}
+
+        for document in document_list:
+            document_paragraph_dict_model = get_document_paragraph_model(
+                knowledge_id,
+                document
+            )
+            document_instance = document_paragraph_dict_model.get('document')
+            link_file(document.get("source_file_id"), document_instance.id)
+            document_model_list.append(document_instance)
+            # 收集标签
+            single_document_tag_list = document.get("tags", [])
+            # 去重传入的标签
+            for tag in single_document_tag_list:
+                tag_key = (tag['key'], tag['value'])
+                if tag_key not in knowledge_tag_dict:
+                    knowledge_tag_dict[tag_key] = tag
+
+            if single_document_tag_list:
+                document_tags_map[str(document_instance.id)] = single_document_tag_list
+
+            for paragraph in document_paragraph_dict_model.get("paragraph_model_list"):
+                paragraph_model_list.append(paragraph)
+            for problem_paragraph_object in document_paragraph_dict_model.get("problem_paragraph_object_list"):
+                problem_paragraph_object_list.append(problem_paragraph_object)
+        knowledge_tag_list = list(knowledge_tag_dict.values())
+        # 保存所有文档中含有的标签到知识库
+        if knowledge_tag_list:
+            all_tag_dict, new_tag_dict = save_knowledge_tags(knowledge_id, knowledge_tag_list)
+            # 构建文档-标签ID映射
+            document_tag_id_map = {}
+            # 为每个文档添加其对应的标签
+            for doc_id, doc_tags in document_tags_map.items():
+                doc_tag_ids = [
+                    all_tag_dict[(tag.get("key"), tag.get("value"))]
+                    for tag in doc_tags
+                    if (tag.get("key"), tag.get("value")) in all_tag_dict
+                ]
+                if doc_tag_ids:
+                    document_tag_id_map[doc_id] = doc_tag_ids
+            if document_tag_id_map:
+                batch_add_document_tag(document_tag_id_map)
+
+        problem_model_list, problem_paragraph_mapping_list = (
+            ProblemParagraphManage(problem_paragraph_object_list, knowledge_id).to_problem_model_list()
+        )
+
+        QuerySet(Document).bulk_create(document_model_list) if len(document_model_list) > 0 else None
+
+        if len(paragraph_model_list) > 0:
+            for document in document_model_list:
+                max_position = Paragraph.objects.filter(document_id=document.id).aggregate(
+                    max_position=Max('position')
+                )['max_position'] or 0
+                sub_list = [p for p in paragraph_model_list if p.document_id == document.id]
+                for i, paragraph in enumerate(sub_list):
+                    paragraph.position = max_position + i + 1
+                QuerySet(Paragraph).bulk_create(sub_list if len(sub_list) > 0 else [])
+
+        bulk_create_in_batches(Problem, problem_model_list, batch_size=1000)
+
+        bulk_create_in_batches(ProblemParagraphMapping, problem_paragraph_mapping_list, batch_size=1000)
+
+        return document_model_list, knowledge_id, workspace_id
+
+    @staticmethod
+    def post_embedding(document_model_list, knowledge_id, workspace_id):
+        for document in document_model_list:
+            DocumentSerializers.Operate(data={
+                'knowledge_id': knowledge_id,
+                'document_id': document.id,
+                'workspace_id': workspace_id
+            }).refresh()
+
+    def execute(self, documents, **kwargs) -> NodeResult:
+
+        document_model_list, knowledge_id, workspace_id = self.save(documents)
+        self.post_embedding(document_model_list, knowledge_id, workspace_id)
+
+        write_content_list = [{
+            "name": document.get("name"),
+            "paragraphs": [{
+                "title": p.get("title"),
+                "content": p.get("content"),
+            } for p in document.get("paragraphs")[0:5]]
+        } for document in documents]
+
+        return NodeResult({'write_content': write_content_list}, {})
+
+    def get_details(self, index: int, **kwargs):
+        return {
+            'name': self.node.properties.get('stepName'),
+            "index": index,
+            'run_time': self.context.get('run_time'),
+            'type': self.node.type,
+            'write_content': self.context.get("write_content"),
+            'status': self.status,
+            'err_message': self.err_message
+        }

apps/application/flow/step_node/loop_break_node/__init__.py

@@ -0,0 +1,9 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： __init__.py.py
+    @date：2025/9/15 12:08
+    @desc:
+"""
+from .impl import *

apps/application/flow/step_node/loop_break_node/i_loop_break_node.py

@@ -0,0 +1,41 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： i_loop_break_node.py
+    @date：2025/9/15 12:14
+    @desc:
+"""
+from typing import Type
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from application.flow.common import WorkflowMode
+from application.flow.i_step_node import INode
+from application.flow.i_step_node import NodeResult
+
+
+class ConditionSerializer(serializers.Serializer):
+    compare = serializers.CharField(required=True, label=_("Comparator"))
+    value = serializers.CharField(required=True, label=_("value"))
+    field = serializers.ListField(required=True, label=_("Fields"))
+
+
+class LoopBreakNodeSerializer(serializers.Serializer):
+    condition = serializers.CharField(required=True, label=_("Condition or|and"))
+    condition_list = ConditionSerializer(many=True)
+
+
+class ILoopBreakNode(INode):
+    type = 'loop-break-node'
+    support = [WorkflowMode.APPLICATION_LOOP, WorkflowMode.KNOWLEDGE_LOOP]
+
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return LoopBreakNodeSerializer
+
+    def _run(self):
+        return self.execute(**self.node_params_serializer.data)
+
+    def execute(self, condition, condition_list, **kwargs) -> NodeResult:
+        pass

apps/application/flow/step_node/loop_break_node/impl/__init__.py

@@ -0,0 +1,9 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： __init__.py.py
+    @date：2025/9/15 12:16
+    @desc:
+"""
+from .base_loop_break_node import BaseLoopBreakNode

apps/application/flow/step_node/loop_break_node/impl/base_loop_break_node.py

@@ -0,0 +1,59 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： base_loop_break_node.py
+    @date：2025/9/15 12:17
+    @desc:
+"""
+import time
+from typing import List, Dict
+
+from application.flow.compare import compare_handle_list
+from application.flow.i_step_node import NodeResult
+from application.flow.step_node.loop_break_node.i_loop_break_node import ILoopBreakNode
+
+
+def _write_context(step_variable: Dict, global_variable: Dict, node, workflow):
+    if step_variable.get("is_break"):
+        yield "BREAK"
+
+    node.context['run_time'] = time.time() - node.context['start_time']
+
+
+class BaseLoopBreakNode(ILoopBreakNode):
+    def execute(self, condition, condition_list, **kwargs) -> NodeResult:
+        r = [self.assertion(row.get('field'), row.get('compare'), row.get('value')) for row in
+             condition_list]
+        is_break = all(r) if condition == 'and' else any(r)
+        if is_break:
+            self.node_params['is_result'] = True
+        self.context['is_break'] = is_break
+        return NodeResult({'is_break': is_break}, {},
+                          _write_context=_write_context,
+                          _is_interrupt=lambda n, v, w: is_break)
+
+    def assertion(self, field_list: List[str], compare: str, value):
+        try:
+            value = self.workflow_manage.generate_prompt(value)
+        except Exception as e:
+            pass
+        field_value = None
+        try:
+            field_value = self.workflow_manage.get_reference_field(field_list[0], field_list[1:])
+        except  Exception as e:
+            pass
+        for compare_handler in compare_handle_list:
+            if compare_handler.support(field_list[0], field_list[1:], field_value, compare, value):
+                return compare_handler.compare(field_value, compare, value)
+
+    def get_details(self, index: int, **kwargs):
+        return {
+            'name': self.node.properties.get('stepName'),
+            "index": index,
+            'is_break': self.context.get('is_break'),
+            'run_time': self.context.get('run_time'),
+            'type': self.node.type,
+            'status': self.status,
+            'err_message': self.err_message
+        }

apps/application/flow/step_node/loop_continue_node/__init__.py

@@ -0,0 +1,9 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎虎
+    @file： __init__.py.py
+    @date：2025/9/15 12:08
+    @desc:
+"""
+from .impl import *