feat: implement Docker AI model provider with various model credentials and parameters

Author: wxg0103

apps/locales/en_US/LC_MESSAGES/django.po

@@ -8772,4 +8772,13 @@ msgid "Application token usage statistics"
 msgstr ""
 
 msgid "Application top question statistics"
+msgstr ""
+
+msgid "SAML2 Metadata"
+msgstr ""
+
+msgid "SAML2 Log in"
+msgstr ""
+
+msgid "SAML2 SSO"
 msgstr ""

apps/locales/zh_CN/LC_MESSAGES/django.po

@@ -8899,3 +8899,12 @@ msgstr "应用令牌使用统计"
 
 msgid "Application top question statistics"
 msgstr "应用提问次数统计"
+
+msgid "SAML2 Metadata"
+msgstr "SAML2 元数据"
+
+msgid "SAML2 Log in"
+msgstr "SAML2 登录"
+
+msgid "SAML2 SSO"
+msgstr "SAML2 单点登录"

apps/locales/zh_Hant/LC_MESSAGES/django.po

@@ -8898,4 +8898,13 @@ msgid "Application token usage statistics"
 msgstr "應用令牌使用統計"
 
 msgid "Application top question statistics"
-msgstr "應用提問次數統計"
+msgstr "應用提問次數統計"
+
+msgid "SAML2 Metadata"
+msgstr "SAML2 元數據"
+
+msgid "SAML2 Log in"
+msgstr "SAML2 登入"
+
+msgid "SAML2 SSO"
+msgstr "SAML2 單點登入"

apps/models_provider/constants/model_provider_constants.py

@@ -7,6 +7,7 @@
 from models_provider.impl.aws_bedrock_model_provider.aws_bedrock_model_provider import BedrockModelProvider
 from models_provider.impl.azure_model_provider.azure_model_provider import AzureModelProvider
 from models_provider.impl.deepseek_model_provider.deepseek_model_provider import DeepSeekModelProvider
+from models_provider.impl.docker_ai_model_provider.docker_ai_model_provider import DockerModelProvider
 from models_provider.impl.gemini_model_provider.gemini_model_provider import GeminiModelProvider
 from models_provider.impl.kimi_model_provider.kimi_model_provider import KimiModelProvider
 from models_provider.impl.local_model_provider.local_model_provider import LocalModelProvider
@@ -30,6 +31,7 @@ class ModelProvideConstants(Enum):
     model_wenxin_provider = WenxinModelProvider()
     model_ollama_provider = OllamaModelProvider()
     model_openai_provider = OpenAIModelProvider()
+    model_docker_ai_provider = DockerModelProvider()
     model_kimi_provider = KimiModelProvider()
     model_zhipu_provider = ZhiPuModelProvider()
     model_xf_provider = XunFeiModelProvider()

apps/models_provider/impl/docker_ai_model_provider/__init__.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+"""
+    @project: maxkb
+    @Author：虎
+    @file： __init__.py.py
+    @date：2024/3/28 16:25
+    @desc:
+"""

apps/models_provider/impl/docker_ai_model_provider/credential/__init__.py

@@ -0,0 +1,74 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎
+    @file： embedding.py
+    @date：2024/7/12 16:45
+    @desc:
+"""
+from typing import Dict
+
+from django.utils.translation import gettext as _
+
+from common import forms
+from common.exception.app_exception import AppApiException
+from common.forms import BaseForm, TooltipLabel
+from models_provider.base_model_provider import BaseModelCredential, ValidCode
+from common.utils.logger import maxkb_logger
+
+class DockerAIEmbeddingModelParams(BaseForm):
+    dimensions = forms.SingleSelect(
+        TooltipLabel(
+            _('Dimensions'),
+            _('')
+        ),
+        required=True,
+        default_value=1024,
+        value_field='value',
+        text_field='label',
+        option_list=[
+            {'label': '1536', 'value': '1536'},
+            {'label': '1024', 'value': '1024'},
+            {'label': '768', 'value': '768'},
+            {'label': '512', 'value': '512'},
+        ]
+    )
+
+
+class DockerAIEmbeddingCredential(BaseForm, BaseModelCredential):
+    def is_valid(self, model_type: str, model_name, model_credential: Dict[str, object], model_params, provider,
+                 raise_exception=True):
+        model_type_list = provider.get_model_type_list()
+        if not any(list(filter(lambda mt: mt.get('value') == model_type, model_type_list))):
+            raise AppApiException(ValidCode.valid_error.value,
+                                  _('{model_type} Model type is not supported').format(model_type=model_type))
+
+        for key in ['api_base', 'api_key']:
+            if key not in model_credential:
+                if raise_exception:
+                    raise AppApiException(ValidCode.valid_error.value, _('{key}  is required').format(key=key))
+                else:
+                    return False
+        try:
+            model = provider.get_model(model_type, model_name, model_credential)
+            model.embed_query(_('Hello'))
+        except Exception as e:
+            maxkb_logger.error(f'Exception: {e}', exc_info=True)
+            if isinstance(e, AppApiException):
+                raise e
+            if raise_exception:
+                raise AppApiException(ValidCode.valid_error.value,
+                                      _('Verification failed, please check whether the parameters are correct: {error}').format(
+                                          error=str(e)))
+            else:
+                return False
+        return True
+
+    def encryption_dict(self, model: Dict[str, object]):
+        return {**model, 'api_key': super().encryption(model.get('api_key', ''))}
+
+    def get_model_params_setting_form(self, model_name):
+        return DockerAIEmbeddingModelParams()
+
+    api_base = forms.TextInputField('API URL', required=True)
+    api_key = forms.PasswordInputField('API Key', required=True)

apps/models_provider/impl/docker_ai_model_provider/credential/embedding.py

@@ -0,0 +1,74 @@
+# coding=utf-8
+import base64
+import os
+from typing import Dict
+
+from langchain_core.messages import HumanMessage
+
+from common import forms
+from common.exception.app_exception import AppApiException
+from common.forms import BaseForm, TooltipLabel
+from common.utils.logger import maxkb_logger
+from models_provider.base_model_provider import BaseModelCredential, ValidCode
+from django.utils.translation import gettext_lazy as _, gettext
+
+
+class DockerAIImageModelParams(BaseForm):
+    temperature = forms.SliderField(TooltipLabel(_('Temperature'),
+                                                 _('Higher values make the output more random, while lower values make it more focused and deterministic')),
+                                    required=True, default_value=0.7,
+                                    _min=0.1,
+                                    _max=1.0,
+                                    _step=0.01,
+                                    precision=2)
+
+    max_tokens = forms.SliderField(
+        TooltipLabel(_('Output the maximum Tokens'),
+                     _('Specify the maximum number of tokens that the model can generate')),
+        required=True, default_value=800,
+        _min=1,
+        _max=100000,
+        _step=1,
+        precision=0)
+
+
+class DockerAIImageModelCredential(BaseForm, BaseModelCredential):
+    api_base = forms.TextInputField('API URL', required=True)
+    api_key = forms.PasswordInputField('API Key', required=True)
+
+    def is_valid(self, model_type: str, model_name, model_credential: Dict[str, object], model_params, provider,
+                 raise_exception=False):
+        model_type_list = provider.get_model_type_list()
+        if not any(list(filter(lambda mt: mt.get('value') == model_type, model_type_list))):
+            raise AppApiException(ValidCode.valid_error.value,
+                                  gettext('{model_type} Model type is not supported').format(model_type=model_type))
+
+        for key in ['api_base', 'api_key']:
+            if key not in model_credential:
+                if raise_exception:
+                    raise AppApiException(ValidCode.valid_error.value, gettext('{key}  is required').format(key=key))
+                else:
+                    return False
+        try:
+            model = provider.get_model(model_type, model_name, model_credential, **model_params)
+            res = model.stream([HumanMessage(content=[{"type": "text", "text": gettext('Hello')}])])
+            for chunk in res:
+                maxkb_logger.info(chunk)
+        except Exception as e:
+            maxkb_logger.error(f'Exception: {e}', exc_info=True)
+            if isinstance(e, AppApiException):
+                raise e
+            if raise_exception:
+                raise AppApiException(ValidCode.valid_error.value,
+                                      gettext(
+                                          'Verification failed, please check whether the parameters are correct: {error}').format(
+                                          error=str(e)))
+            else:
+                return False
+        return True
+
+    def encryption_dict(self, model: Dict[str, object]):
+        return {**model, 'api_key': super().encryption(model.get('api_key', ''))}
+
+    def get_model_params_setting_form(self, model_name):
+        return DockerAIImageModelParams()

apps/models_provider/impl/docker_ai_model_provider/credential/image.py

@@ -0,0 +1,79 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎
+    @file： llm.py
+    @date：2024/7/11 18:32
+    @desc:
+"""
+from typing import Dict
+
+from django.utils.translation import gettext_lazy as _, gettext
+from langchain_core.messages import HumanMessage
+from openai import BadRequestError
+
+from common import forms
+from common.exception.app_exception import AppApiException
+from common.forms import BaseForm, TooltipLabel
+from models_provider.base_model_provider import BaseModelCredential, ValidCode
+from common.utils.logger import maxkb_logger
+
+class DockerAILLMModelParams(BaseForm):
+    temperature = forms.SliderField(TooltipLabel(_('Temperature'),
+                                                 _('Higher values make the output more random, while lower values make it more focused and deterministic')),
+                                    required=True, default_value=0.7,
+                                    _min=0.1,
+                                    _max=1.0,
+                                    _step=0.01,
+                                    precision=2)
+
+    max_tokens = forms.SliderField(
+        TooltipLabel(_('Output the maximum Tokens'),
+                     _('Specify the maximum number of tokens that the model can generate')),
+        required=True, default_value=800,
+        _min=1,
+        _max=100000,
+        _step=1,
+        precision=0)
+
+
+class DockerAILLMModelCredential(BaseForm, BaseModelCredential):
+
+    def is_valid(self, model_type: str, model_name, model_credential: Dict[str, object], model_params, provider,
+                 raise_exception=False):
+        model_type_list = provider.get_model_type_list()
+        if not any(list(filter(lambda mt: mt.get('value') == model_type, model_type_list))):
+            raise AppApiException(ValidCode.valid_error.value,
+                                  gettext('{model_type} Model type is not supported').format(model_type=model_type))
+
+        for key in ['api_base', 'api_key']:
+            if key not in model_credential:
+                if raise_exception:
+                    raise AppApiException(ValidCode.valid_error.value, gettext('{key}  is required').format(key=key))
+                else:
+                    return False
+        try:
+
+            model = provider.get_model(model_type, model_name, model_credential, **model_params)
+            model.invoke([HumanMessage(content=gettext('Hello'))])
+        except Exception as e:
+            maxkb_logger.error(f'Exception: {e}', exc_info=True)
+            if isinstance(e, AppApiException) or isinstance(e, BadRequestError):
+                raise e
+            if raise_exception:
+                raise AppApiException(ValidCode.valid_error.value,
+                                      gettext(
+                                          'Verification failed, please check whether the parameters are correct: {error}').format(
+                                          error=str(e)))
+            else:
+                return False
+        return True
+
+    def encryption_dict(self, model: Dict[str, object]):
+        return {**model, 'api_key': super().encryption(model.get('api_key', ''))}
+
+    api_base = forms.TextInputField('API URL', required=True)
+    api_key = forms.PasswordInputField('API Key', required=True)
+
+    def get_model_params_setting_form(self, model_name):
+        return DockerAILLMModelParams()

apps/models_provider/impl/docker_ai_model_provider/credential/llm.py

@@ -0,0 +1,51 @@
+# coding=utf-8
+"""
+    @project: MaxKB
+    @Author：虎
+    @file： reranker.py
+    @date：2024/9/9 17:51
+    @desc:
+"""
+from typing import Dict
+
+from django.utils.translation import gettext as _
+from langchain_core.documents import Document
+
+from common import forms
+from common.exception.app_exception import AppApiException
+from common.forms import BaseForm
+from models_provider.base_model_provider import BaseModelCredential, ValidCode
+from models_provider.impl.docker_ai_model_provider.model.reranker import DockerAIReranker
+from common.utils.logger import maxkb_logger
+
+class DockerAIRerankerCredential(BaseForm, BaseModelCredential):
+
+    def is_valid(self, model_type: str, model_name, model_credential: Dict[str, object], model_params, provider,
+                 raise_exception=False):
+        if not model_type == 'RERANKER':
+            raise AppApiException(ValidCode.valid_error.value,
+                                  _('{model_type} Model type is not supported').format(model_type=model_type))
+        for key in ['api_base']:
+            if key not in model_credential:
+                if raise_exception:
+                    raise AppApiException(ValidCode.valid_error.value, _('{key}  is required').format(key=key))
+                else:
+                    return False
+        try:
+            model: DockerAIReranker = provider.get_model(model_type, model_name, model_credential)
+            model.compress_documents([Document(page_content=_('Hello'))], _('Hello'))
+        except Exception as e:
+            maxkb_logger.error(f'Exception: {e}', exc_info=True)
+            if isinstance(e, AppApiException):
+                raise e
+            if raise_exception:
+                raise AppApiException(ValidCode.valid_error.value,
+                                      _('Verification failed, please check whether the parameters are correct: {error}').format(
+                                          error=str(e)))
+            else:
+                return False
+        return True
+
+    def encryption_dict(self, model: Dict[str, object]):
+        return {**model}
+    api_base = forms.TextInputField('API URL', required=True)