Merge branch '1Panel-dev:main' into main

README.md

@@ -39,7 +39,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/pricing.html)；
+- 如果您需要向团队介绍 MaxKB，可以使用这个 [官方 PPT 材料](https://maxkb.cn/download/introduce-maxkb_202411.pdf)。
 
 如你有更多问题，可以查看使用手册，或者通过论坛与我们交流。
 

apps/application/flow/i_step_node.py

@@ -7,6 +7,7 @@
     @desc:
 """
 import time
+import uuid
 from abc import abstractmethod
 from typing import Type, Dict, List
 
@@ -31,7 +32,7 @@ def write_context(step_variable: Dict, global_variable: Dict, node, workflow):
         if workflow.is_result(node, NodeResult(step_variable, global_variable)) and 'answer' in step_variable:
             answer = step_variable['answer']
             yield answer
-            workflow.answer += answer
+            node.answer_text = answer
     if global_variable is not None:
         for key in global_variable:
             workflow.context[key] = global_variable[key]
@@ -54,15 +55,27 @@ def handler(self, chat_id,
                               'message_tokens' in row and row.get('message_tokens') is not None])
         answer_tokens = sum([row.get('answer_tokens') for row in details.values() if
                              'answer_tokens' in row and row.get('answer_tokens') is not None])
-        chat_record = ChatRecord(id=chat_record_id,
-                                 chat_id=chat_id,
-                                 problem_text=question,
-                                 answer_text=answer,
-                                 details=details,
-                                 message_tokens=message_tokens,
-                                 answer_tokens=answer_tokens,
-                                 run_time=time.time() - workflow.context['start_time'],
-                                 index=0)
+        answer_text_list = workflow.get_answer_text_list()
+        answer_text = '\n\n'.join(answer_text_list)
+        if workflow.chat_record is not None:
+            chat_record = workflow.chat_record
+            chat_record.answer_text = answer_text
+            chat_record.details = details
+            chat_record.message_tokens = message_tokens
+            chat_record.answer_tokens = answer_tokens
+            chat_record.answer_text_list = answer_text_list
+            chat_record.run_time = time.time() - workflow.context['start_time']
+        else:
+            chat_record = ChatRecord(id=chat_record_id,
+                                     chat_id=chat_id,
+                                     problem_text=question,
+                                     answer_text=answer_text,
+                                     details=details,
+                                     message_tokens=message_tokens,
+                                     answer_tokens=answer_tokens,
+                                     answer_text_list=answer_text_list,
+                                     run_time=time.time() - workflow.context['start_time'],
+                                     index=0)
         self.chat_info.append_chat_record(chat_record, self.client_id)
         # 重新设置缓存
         chat_cache.set(chat_id,
@@ -118,7 +131,15 @@ class FlowParamsSerializer(serializers.Serializer):
 
 
 class INode:
-    def __init__(self, node, workflow_params, workflow_manage):
+
+    @abstractmethod
+    def save_context(self, details, workflow_manage):
+        pass
+
+    def get_answer_text(self):
+        return self.answer_text
+
+    def __init__(self, node, workflow_params, workflow_manage, runtime_node_id=None):
         # 当前步骤上下文,用于存储当前步骤信息
         self.status = 200
         self.err_message = ''
@@ -129,7 +150,12 @@ def __init__(self, node, workflow_params, workflow_manage):
         self.node_params_serializer = None
         self.flow_params_serializer = None
         self.context = {}
+        self.answer_text = None
         self.id = node.id
+        if runtime_node_id is None:
+            self.runtime_node_id = str(uuid.uuid1())
+        else:
+            self.runtime_node_id = runtime_node_id
 
     def valid_args(self, node_params, flow_params):
         flow_params_serializer_class = self.get_flow_params_serializer_class()

apps/application/flow/step_node/__init__.py

@@ -7,17 +7,25 @@
     @desc:
 """
 from .ai_chat_step_node import *
+from .application_node import BaseApplicationNode
 from .condition_node import *
-from .question_node import *
-from .search_dataset_node import *
-from .start_node import *
 from .direct_reply_node import *
+from .form_node import *
 from .function_lib_node import *
 from .function_node import *
+from .question_node import *
 from .reranker_node import *
 
+from .document_extract_node import *
+from .image_understand_step_node import *
+
+from .search_dataset_node import *
+from .start_node import *
+
 node_list = [BaseStartStepNode, BaseChatNode, BaseSearchDatasetNode, BaseQuestionNode, BaseConditionNode, BaseReplyNode,
-             BaseFunctionNodeNode, BaseFunctionLibNodeNode, BaseRerankerNode]
+             BaseFunctionNodeNode, BaseFunctionLibNodeNode, BaseRerankerNode, BaseApplicationNode,
+             BaseDocumentExtractNode,
+             BaseImageUnderstandNode, BaseFormNode]
 
 
 def get_node(node_type):

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

@@ -32,7 +32,7 @@ def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, wo
     node.context['question'] = node_variable['question']
     node.context['run_time'] = time.time() - node.context['start_time']
     if workflow.is_result(node, NodeResult(node_variable, workflow_variable)):
-        workflow.answer += answer
+        node.answer_text = answer
 
 
 def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INode, workflow):
@@ -73,6 +73,11 @@ def get_default_model_params_setting(model_id):
 
 
 class BaseChatNode(IChatNode):
+    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')
+
     def execute(self, model_id, system, prompt, dialogue_number, history_chat_record, stream, chat_id, chat_record_id,
                 model_params_setting=None,
                 **kwargs) -> NodeResult:

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

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

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

@@ -0,0 +1,40 @@
+# coding=utf-8
+from typing import Type
+
+from rest_framework import serializers
+
+from application.flow.i_step_node import INode, NodeResult
+from common.util.field_message import ErrMessage
+
+
+class ApplicationNodeSerializer(serializers.Serializer):
+    application_id = serializers.CharField(required=True, error_messages=ErrMessage.char("应用id"))
+    question_reference_address = serializers.ListField(required=True, error_messages=ErrMessage.list("用户问题"))
+    api_input_field_list = serializers.ListField(required=False, error_messages=ErrMessage.list("api输入字段"))
+    user_input_field_list = serializers.ListField(required=False, error_messages=ErrMessage.uuid("用户输入字段"))
+
+
+class IApplicationNode(INode):
+    type = 'application-node'
+
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return ApplicationNodeSerializer
+
+    def _run(self):
+        question = self.workflow_manage.get_reference_field(
+            self.node_params_serializer.data.get('question_reference_address')[0],
+            self.node_params_serializer.data.get('question_reference_address')[1:])
+        kwargs = {}
+        for api_input_field in self.node_params_serializer.data.get('api_input_field_list', []):
+            kwargs[api_input_field['variable']] = self.workflow_manage.get_reference_field(api_input_field['value'][0],
+                                                                                           api_input_field['value'][1:])
+        for user_input_field in self.node_params_serializer.data.get('user_input_field_list', []):
+            kwargs[user_input_field['field']] = self.workflow_manage.get_reference_field(user_input_field['value'][0],
+                                                                                         user_input_field['value'][1:])
+
+        return self.execute(**self.node_params_serializer.data, **self.flow_params_serializer.data,
+                            message=str(question), **kwargs)
+
+    def execute(self, application_id, message, chat_id, chat_record_id, stream, re_chat, client_id, client_type,
+                **kwargs) -> NodeResult:
+        pass

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

@@ -0,0 +1,2 @@
+# coding=utf-8
+from .base_application_node import BaseApplicationNode

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

@@ -0,0 +1,130 @@
+# coding=utf-8
+import json
+import time
+import uuid
+from typing import List, Dict
+from application.flow.i_step_node import NodeResult, INode
+from application.flow.step_node.application_node.i_application_node import IApplicationNode
+from application.models import Chat
+from common.handle.impl.response.openai_to_response import OpenaiToResponse
+
+
+def string_to_uuid(input_str):
+    return str(uuid.uuid5(uuid.NAMESPACE_DNS, input_str))
+
+
+def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow, answer: str):
+    result = node_variable.get('result')
+    node.context['message_tokens'] = result.get('usage', {}).get('prompt_tokens', 0)
+    node.context['answer_tokens'] = result.get('usage', {}).get('completion_tokens', 0)
+    node.context['answer'] = answer
+    node.context['question'] = node_variable['question']
+    node.context['run_time'] = time.time() - node.context['start_time']
+    if workflow.is_result(node, NodeResult(node_variable, workflow_variable)):
+        node.answer_text = answer
+
+
+def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INode, workflow):
+    """
+    写入上下文数据 (流式)
+    @param node_variable:      节点数据
+    @param workflow_variable:  全局数据
+    @param node:               节点
+    @param workflow:           工作流管理器
+    """
+    response = node_variable.get('result')
+    answer = ''
+    usage = {}
+    for chunk in response:
+        # 先把流转成字符串
+        response_content = chunk.decode('utf-8')[6:]
+        response_content = json.loads(response_content)
+        choices = response_content.get('choices')
+        if choices and isinstance(choices, list) and len(choices) > 0:
+            content = choices[0].get('delta', {}).get('content', '')
+            answer += content
+            yield content
+        usage = response_content.get('usage', {})
+    node_variable['result'] = {'usage': usage}
+    _write_context(node_variable, workflow_variable, node, workflow, answer)
+
+
+def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow):
+    """
+    写入上下文数据
+    @param node_variable:      节点数据
+    @param workflow_variable:  全局数据
+    @param node:               节点实例对象
+    @param workflow:           工作流管理器
+    """
+    response = node_variable.get('result')['choices'][0]['message']
+    answer = response.get('content', '') or "抱歉，没有查找到相关内容，请重新描述您的问题或提供更多信息。"
+    _write_context(node_variable, workflow_variable, node, workflow, answer)
+
+
+class BaseApplicationNode(IApplicationNode):
+
+    def save_context(self, details, workflow_manage):
+        self.context['answer'] = details.get('answer')
+        self.context['question'] = details.get('question')
+        self.context['type'] = details.get('type')
+        self.answer_text = details.get('answer')
+
+    def execute(self, application_id, message, chat_id, chat_record_id, stream, re_chat, client_id, client_type,
+                **kwargs) -> NodeResult:
+        from application.serializers.chat_message_serializers import ChatMessageSerializer
+        # 生成嵌入应用的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
+        })
+        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, 'form_data': kwargs}).chat(base_to_response=OpenaiToResponse())
+        if response.status_code == 200:
+            if stream:
+                content_generator = response.streaming_content
+                return NodeResult({'result': content_generator, 'question': message}, {},
+                                  _write_context=write_context_stream)
+            else:
+                data = json.loads(response.content)
+                return NodeResult({'result': data, 'question': message}, {},
+                                  _write_context=write_context)
+
+    def get_details(self, index: int, **kwargs):
+        global_fields = []
+        for api_input_field in self.node_params_serializer.data.get('api_input_field_list', []):
+            global_fields.append({
+                'label': api_input_field['variable'],
+                'key': api_input_field['variable'],
+                'value': self.workflow_manage.get_reference_field(
+                    api_input_field['value'][0],
+                    api_input_field['value'][1:])
+            })
+        for user_input_field in self.node_params_serializer.data.get('user_input_field_list', []):
+            global_fields.append({
+                'label': user_input_field['label'],
+                'key': user_input_field['field'],
+                'value': self.workflow_manage.get_reference_field(
+                    user_input_field['value'][0],
+                    user_input_field['value'][1:])
+            })
+        return {
+            'name': self.node.properties.get('stepName'),
+            "index": index,
+            "info": self.node.properties.get('node_data'),
+            'run_time': self.context.get('run_time'),
+            '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,
+            'global_fields': global_fields
+        }

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

@@ -14,6 +14,10 @@
 
 
 class BaseConditionNode(IConditionNode):
+    def save_context(self, details, workflow_manage):
+        self.context['branch_id'] = details.get('branch_id')
+        self.context['branch_name'] = details.get('branch_name')
+
     def execute(self, **kwargs) -> NodeResult:
         branch_list = self.node_params_serializer.data['branch']
         branch = self._execute(branch_list)

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

@@ -13,6 +13,9 @@
 
 
 class BaseReplyNode(IReplyNode):
+    def save_context(self, details, workflow_manage):
+        self.context['answer'] = details.get('answer')
+        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/__init__.py

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

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

@@ -0,0 +1,27 @@
+# coding=utf-8
+
+from typing import Type
+
+from rest_framework import serializers
+
+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("文档"))
+
+
+class IDocumentExtractNode(INode):
+    type = 'document-extract-node'
+
+    def get_node_params_serializer_class(self) -> Type[serializers.Serializer]:
+        return DocumentExtractNodeSerializer
+
+    def _run(self):
+        res = 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(document=res, **self.flow_params_serializer.data)
+
+    def execute(self, document, **kwargs) -> NodeResult:
+        pass

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

@@ -0,0 +1 @@
+from .base_document_extract_node import BaseDocumentExtractNode