Todos os produtos
Search
Central de documentação

Container Service for Kubernetes:Build an AI Q&A assistant with Dify

Última atualização: Jun 27, 2026

Implante o Dify no ACK para criar um assistente de perguntas e respostas com IA escalável, apoiado pela base de conhecimento da sua empresa.

Visão geral da solução

Exemplo de aplicação de IA personalizada do Dify

2024-08-21_16-01-26 (1)

Exemplo de aplicação de IA integrada à web

2024-08-23_14-14-02 (1)

Configure um assistente dedicado de perguntas e respostas com IA em três etapas:

  1. Instale o componente ack-dify: Crie um cluster ACK e instale o componente ack-dify.

  2. Adicione um assistente de perguntas e respostas com IA: Acesse o serviço Dify para adicionar um assistente de perguntas e respostas com IA ao seu site.

  3. Personalize o assistente de perguntas e respostas com IA: Adicione uma base de conhecimento dedicada para melhorar a precisão nas respostas a perguntas específicas do domínio.

yuque_diagram12

Interação entre o serviço Dify e o cluster ACK:

image

Introdução ao Dify

O Dify é uma plataforma de desenvolvimento de aplicações de modelos de linguagem grandes (LLM) de código aberto que combina Backend-as-a-Service (BaaS) e LLMOps. Ele permite que desenvolvedores e usuários não técnicos criem aplicações de IA generativa prontas para produção sem precisar reinventar componentes essenciais.

Principais componentes da arquitetura do Dify:

  1. Componentes tecnológicos principais: O Dify integra elementos essenciais para a criação de aplicações LLM, incluindo compatibilidade com diversos modelos, uma interface intuitiva para design de prompts, um sistema de Geração Aumentada por Recuperação (RAG) de alto desempenho e uma arquitetura de Agent personalizável.

  2. Orquestração visual e operações: A interface intuitiva do Dify possibilita a orquestração visual de prompts, fluxos de trabalho operacionais simplificados e gestão eficiente de conjuntos de dados. Isso acelera significativamente o desenvolvimento de aplicações de IA, permitindo que os desenvolvedores façam implantações rápidas ou integrem LLMs a sistemas existentes, além de apoiar a otimização contínua das operações.

  3. Modelos de aplicação e framework de orquestração: O Dify oferece aos desenvolvedores modelos de aplicação prontos para uso e um framework de orquestração, permitindo o desenvolvimento rápido de aplicações de IA generativa baseadas em modelos de linguagem grandes. A plataforma também suporta dimensionamento instantâneo e fluido para atender às mudanças nas necessidades do negócio, impulsionando o crescimento empresarial.

Em conjunto, esses componentes formam uma plataforma completa para desenvolver e implantar rapidamente aplicações de IA generativa.

1. Instale o componente ack-dify

Implantação com um clique

Se você está começando agora com clusters ACK e não conhece o processo de criação, clique em implantação com um clique para criar o ambiente de execução do Dify. Essa opção implanta uma aplicação Dify de instância única por meio do modelo Helm ack-dify no ACK App Marketplace, ideal para desenvolvimento e testes.

Importante

Antes de usar a implantação com um clique, certifique-se de que o ACK esteja ativado e autorizado. Para mais informações, consulte Criar um cluster gerenciado pelo ACK.

Esta solução utiliza os seguintes recursos de nuvem. Para informações sobre faturamento, consulte Faturamento.

Recursos de nuvem

Descrição

1 Virtual Private Cloud (VPC)

Fornece uma rede privada para recursos de nuvem, como instâncias do Elastic Compute Service (ecs) e clusters ACK.

2 vSwitches

Conecta recursos como instâncias ecs e clusters ACK para comunicação e isolamento de rede.

1 grupo de segurança

Define regras de rede de entrada e saída para instâncias ecs na VPC.

1 instância de Classic Load Balancer (CLB)

Fornece acesso à internet para a plataforma Dify.

1 sistema de arquivos NAS

Armazena dados para serviços internos do Dify (API e worker).

1 cluster gerenciado pelo ACK

Implanta o Dify. Selecione pelo menos um nó com 8 vCPUs e 16 GiB de memória (como ecs.u1-c1m2.2xlarge) para evitar falta de recursos.

Procedimento

  1. Clique em implantação com um clique. No ROS, selecione sua região, como China (Hangzhou). Siga o modelo ROS para configurar IDs de zona do vSwitch, tipo de instância do pool de nós, senha, confirmação de segurança e outras definições. Mantenha os padrões para o restante e clique em Next: Check and Confirm.

  2. A criação do cluster leva cerca de 10 minutos. Após a criação, faça login no console do Container Service for Kubernetes. No painel de navegação à esquerda, escolha Clusters. Clique no cluster desejado. Escolha Workloads > Pods, defina o namespace como dify-system e verifique se o componente ack-dify está instalado no cluster.

  3. (Opcional) Se algum pod estiver com status Pending, o cluster pode estar sem a dependência PVC necessária para o ack-dify. Crie um sistema de arquivos CNFS e uma StorageClass NAS para o cluster. Para mais informações, consulte Gerenciar sistemas de arquivos NAS usando CNFS. Para mais detalhes sobre solução de problemas de exceções em pods, consulte Solucionar exceções de pods.

Após a instalação do componente ack-dify, prossiga para a próxima etapa.

Nota

Se você já utilizou a implantação com um clique do ROS para instalar o componente ack-dify, o acesso público já está habilitado para o serviço ack-dify. Pule as etapas em Acessar o serviço Dify.

Implantação manual

Se você já conhece o processo de criação de clusters ACK, siga estas etapas para criar um cluster adaptado às suas necessidades.

1.1 Pré-requisitos

  1. Crie um cluster ACK Pro, versão 1,22 ou superior. Para mais informações, consulte Criar um cluster gerenciado pelo ACK e Atualizar um cluster.

    Reserve pelo menos 2 vCPUs e 4 GB de memória. Certifique-se de que o plugin de armazenamento CSI e o sistema de arquivos CNFS estejam configurados.

    Configurar o plugin de armazenamento CSI (para novos clusters)

    Ao criar um cluster, selecione Dynamically Provision Volumes by Using Default NAS File Systems and CNFS, Enable NAS Recycle Bin, and Support Fast Data Restore

    image

    Configurar sistema de arquivos CNFS e StorageClass NAS (para clusters existentes)

    Se o seu cluster existente foi criado sem um sistema de arquivos NAS padrão e CNFS, verifique se existe uma StorageClass chamada alibabacloud-cnfs-nas no cluster.

    kubectl get sc alibabacloud-cnfs-nas

    Se o comando retornar um erro NotFound, o cluster está sem a dependência PVC necessária para o ack-dify. Salve o conteúdo YAML abaixo em um arquivo chamado cnfs-nas-filesystem.yaml e execute o comando kubectl apply -f cnfs-nas-filesystem.yaml para criar o sistema de arquivos CNFS e a StorageClass NAS.

    apiVersion: storage.alibabacloud.com/v1beta1
    kind: ContainerNetworkFileSystem
    metadata:
      name: cnfs-nas-filesystem
    spec:
      description: "cnfs"
      type: nas
      reclaimPolicy: Retain  # Only Retain is supported. The backend NAS instance is not deleted when the CNFS is deleted.
    ---
    apiVersion: storage.k8s.io/v1
    kind: StorageClass
    metadata:
      name: alibabacloud-cnfs-nas
    mountOptions:
      - nolock,tcp,noresvport
      - vers=3
    parameters:
      volumeAs: subpath # A separate subdirectory is created under NAS for each PVC.
      containerNetworkFileSystem: cnfs-nas-filesystem # Associates with the CNFS instance defined above.
      path: "/"
    provisioner: nasplugin.csi.alibabacloud.com
    reclaimPolicy: Retain
    allowVolumeExpansion: true # Optional: Set to true to allow expansion of the volume's directory quota.
  2. Conecte o kubectl ao cluster. Consulte Conectar-se a um cluster ACK usando kubectl.

1.2 Implantar o componente

Implante o componente ack-dify no seu cluster para o serviço Dify.

  1. Faça login no console do Container Service for Kubernetes. No painel de navegação à esquerda, escolha Clusters. Clique no cluster desejado. Siga as etapas numeradas na figura para instalar o componente ack-dify.

    Não é necessário configurar o Application Name ou o Namespace do componente. Clique em Next. Na caixa de diálogo Confirm, clique em Yes para aceitar os padrões (ack-dify / dify-system). Em seguida, selecione a Chart Version mais recente e clique em OK para instalar o componente ack-dify.

    image

  2. Aguarde cerca de um minuto e verifique se todos os pods no namespace dify-system estão no estado Running.

    kubectl get pod -n dify-system

    Se algum pod estiver com status Pending, o cluster pode estar sem a dependência PVC necessária para o ack-dify. Crie um sistema de arquivos CNFS e uma StorageClass NAS. Para mais informações, consulte Gerenciar sistemas de arquivos NAS usando CNFS. Para mais detalhes sobre solução de problemas de exceções em pods, consulte Solucionar exceções de pods.

2. Adicionar um assistente de perguntas e respostas com IA

2.1 Acessar o serviço Dify

  1. Habilite o acesso público para o serviço ack-dify.

    Nota

    O acesso público serve apenas para fins de demonstração. Para garantir a segurança dos dados em ambiente de produção, ative o recurso Access Control.

    image

  2. Após a configuração, escolha Network > Services > ack-dify e defina o namespace como dify-system. O External ip do serviço ack-dify será exibido. Abra esse ip no navegador para acessar o Dify.

    image

  3. Registre uma conta.

    Acesse o External ip e siga as instruções para criar uma conta de administrador (e-mail, nome de usuário, senha).

    image

2.2 Criar um assistente de perguntas e respostas com IA

  1. Insira o External ip no navegador e faça login na plataforma Dify.

  2. Adicione um modelo de IA (Qwen neste exemplo) e configure a chave de API obtida na Alibaba Cloud. Veja a figura abaixo:

    Quando a cota gratuita do Qwen se esgotar, a cobrança será baseada no uso de tokens. Isso reduz os custos iniciais em comparação com a hospedagem própria de um modelo.

    1. Obter chave de API: Escolha Username > Settings > Model Provider > Instale e configure o plugin Qwen > Get API Key From Alibaba Cloud.

    2. Insira a chave de API e clique em Save.

    image

  3. Crie um assistente de perguntas e respostas com IA de uso geral.

    Escolha Studio > Create from Blank e insira um Name e uma Description para o assistente. Mantenha os demais parâmetros com os valores padrão.

    image

2.3 Verificar o assistente de perguntas e respostas com IA

Teste o assistente fazendo perguntas. O chatbot de uso geral lida com conversas simples, mas ainda não consegue responder a perguntas específicas sobre o Dify.

image

3. Personalizar o assistente de IA

3.1 Criar uma base de conhecimento

Para responder com precisão a perguntas técnicas relacionadas ao Dify, configure uma base de conhecimento dedicada para o assistente.

Este exemplo fornece um arquivo de corpus dify_doc.md. Crie e carregue a base de conhecimento conforme descrito a seguir.

  1. Carregue o arquivo de corpus preparado dify_doc.md na base de conhecimento.

    Escolha Knowledge > Create Knowledge > Import from file > Select File > Next.

    image

  2. Clique em Next. Execute a segmentação e limpeza de texto e salve.

    Mantenha os padrões. A base de conhecimento limpa, segmenta e indexa automaticamente o documento para recuperação.

Para entender como os arquivos de corpus acima são organizados em um único arquivo .md, expanda a seção recolhível abaixo para mais detalhes.

Preparar uma base de conhecimento personalizada

Prepare uma base de conhecimento dedicada ao Dify. Atualmente, o Dify suporta o upload de um único arquivo nos formatos TXT, HTML, Markdown ou PDF.

Antes de iniciar o treinamento, prepare a base de conhecimento. Como todos os documentos anteriores de CODING eram gerenciados em um repositório git com Markdown, basta baixar os documentos localmente e mesclar a série de arquivos .md em um único arquivo. Abaixo está um exemplo geral para referência:

  1. Clone o repositório de código. Use o comando git para clonar o repositório de código do Dify correspondente.

    git clone https://github.com/langgenius/dify-docs.git
  2. Organização do corpus. Para facilitar a vetorização subsequente do corpus, use o código Python a seguir para mesclar e organizar os arquivos .md no repositório de código do Dify.

    from langchain_text_splitters import MarkdownHeaderTextSplitter, RecursiveCharacterTextSplitter
    import os
    
    def merge_markdown_files_from_directory(root_dir, output_file):
        """
        merge_markdown_files_from_directory function
          1. Function: Merges the content of all .md files in a specified directory into an output file.
          2. Parameters:
            root_dir: The path of the specified root directory.
            output_file: The path of the output file.
          3. Implementation:
            Uses os.walk to traverse the root_dir directory and its subdirectories.
            Checks if each file ends with .md. If so, adds its path to the markdown_files list.
            Opens output_file and writes the content of each file from markdown_files into it.
        """
        markdown_files = []
        for root, dirs, files in os.walk(root_dir):
            for file in files:
                if file.endswith('.md'):
                    markdown_files.append(os.path.join(root, file))
    
        with open(output_file, 'w', encoding='utf-8') as outfile:
            for file_path in markdown_files:
                with open(file_path, 'r', encoding='utf-8') as infile:
                    outfile.write(infile.read())
                    # outfile.write('\n\n')
    
                   
    def process_and_write_markdown(file_path: str, headers_to_split_on: list, chunk_size: int, chunk_overlap: int, output_file: str):
        """
        process_and_write_markdown function
          1. Function:
            Processes the content of a single Markdown file, splits the text based on specified headers and chunking rules, and writes the result to a new file.
          2. Parameters:
            file_path: The path of the input Markdown file.
            headers_to_split_on: A list of tuples defining header levels, e.g., [("#", "Header 1"), ("##", "Header 2")].
            chunk_size: The maximum length of each text chunk.
            chunk_overlap: The overlap length between text chunks.
            output_file: The path of the output file.
          3. Implementation:
            Reads the content of the Markdown file from file_path.
            Creates a MarkdownHeaderTextSplitter object to split the content based on headers_to_split_on.
            Creates a RecursiveCharacterTextSplitter object to further split the text based on chunk_size and chunk_overlap.
            Opens output_file and writes the metadata and content of each split chunk to the file.
        """
        try:
            # Read the content of the Markdown file from file_path.
            with open(file_path, "r", encoding="utf-8") as doc:
                markdown_content = doc.read()
    
            # Create a MarkdownHeaderTextSplitter object to split the content based on headers_to_split_on.
            splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on, strip_headers=True)
            md_splits = splitter.split_text(markdown_content)
    
            # Create a RecursiveCharacterTextSplitter object to further split the text based on chunk_size and chunk_overlap.
            text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
            splits = text_splitter.split_documents(md_splits)
    
            # Open output_file and write the metadata and content of each split text chunk to the file.
            with open(output_file, "w") as f:
                for line in splits:
                    f.write(str(line.metadata))
                    f.write("\n")
                    f.write(line.page_content)
                    f.write("\n\n\n\n")
    
        except FileNotFoundError:
            raise FileNotFoundError(f"The file {file_path} does not exist.")
    
    # Example usage
    if __name__ == "__main__":
        """
         1. Set parameters:
          root_directory: The path of the specified root directory.
          merged_file_path: The path of the merged Markdown file.
          output_file: The path of the final processed output file.
          headers_to_split_on: The list of header levels.
          chunk_size and chunk_overlap: The size and overlap length for text chunks.
        2. Execution steps:
          Call merge_markdown_files_from_directory to merge all .md files into merged_file_path.
          Call process_and_write_markdown to process the merged file and write the result to output_file.
          These steps complete the script's process from merging multiple Markdown files to final processing and output.
        """
        
        # Path of the folder to be processed
        root_directory = 'path/to/dify-docs/en'
        # Path of the merged file
        merged_file_path = './merged_markdown.md'
        # Path of the cleaned file
        output_file = './dify_doc.md'
        
        merge_markdown_files_from_directory(root_directory, merged_file_path)
        headers_to_split_on = [
            ("#", "Header 1"),
            ("##", "Header 2"),
            ("###", "Header 3"),
        ]
        chunk_size = 500
        chunk_overlap = 50
        process_and_write_markdown(merged_file_path, headers_to_split_on, chunk_size, chunk_overlap, output_file)
    
  3. Carregue o documento preparado dify_doc.md na base de conhecimento.

3.2 Orquestrar e publicar o assistente

Configure um prompt e adicione a base de conhecimento ao contexto do assistente.

  1. Configure o prompt: Copie o conteúdo abaixo para o campo Instructions. Os prompts melhoram a precisão das respostas por meio de instruções e restrições.

    You will act as Dify's AI assistant, dedicated to answering customers' questions about Dify products and their features. Your responses should be based on the existing knowledge base to ensure accuracy. If a question is beyond your knowledge, please honestly inform them that you do not know the answer, in order to maintain the integrity of the information. Please communicate in a friendly and warm tone, and feel free to use emoticons appropriately to enhance the interactive experience.
  2. Adicione a base de conhecimento ao contexto: Clique em Add na área Context para incluir a base de conhecimento, permitindo respostas precisas e profissionais.

  3. Clique em Releases > Update para salvar e aplicar a configuração.

A configuração é mostrada na figura a seguir:

image

3.3 Verificar os resultados

Com uma base de conhecimento dedicada, o assistente de IA fornece respostas mais precisas e específicas do domínio do que o chatbot de uso geral.image

Resumo

Principais recursos do Dify:

Recurso

Descrição

LLMOps abrangente

Monitoramento em tempo real de logs e métricas da aplicação, com otimização contínua de prompts, conjuntos de dados e modelos com base em dados de produção.

Mecanismo RAG

Pipeline RAG de ponta a ponta, desde a ingestão de documentos até a recuperação. Processa diretamente formatos comuns como PDF e PPT.

Agent

Defina agentes usando chamadas de função LLM ou o paradigma ReAct, com mais de 50 ferramentas integradas e suporte para ferramentas personalizadas.

Orquestração de fluxo de trabalho

Canvas visual para construir fluxos de trabalho de IA arrastando e conectando componentes, com codificação mínima.

Observabilidade

Acompanhe e avalie a qualidade e o custo das aplicações LLM por meio de um painel de monitoramento.

Recursos empresariais (SSO/controle de acesso)

As organizações podem reduzir o risco de vazamento de informações e danos aos dados, garantindo a segurança da informação e a continuidade dos negócios.

Entrando em produção

Quatro opções para implantar o assistente de perguntas e respostas com IA em produção:

  1. Site compartilhado publicamente.

    Publique a aplicação de IA criada com o Dify como uma aplicação web acessível na internet, operando com base nas suas configurações de prompt e orquestração. Para mais informações, consulte Publicar como aplicação web pública.

  2. Chamadas baseadas em API.

    O Dify fornece APIs para todas as aplicações baseadas no conceito de "Backend-as-a-Service", permitindo que os desenvolvedores aproveitem o poder dos modelos de linguagem grandes em suas aplicações front-end sem se preocupar com arquiteturas e implantações complexas de back-end. Para mais informações, consulte Desenvolver com APIs.

  3. Redesenvolvimento baseado em componentes front-end.

    Se você estiver desenvolvendo um novo produto do zero ou estiver na fase de design de protótipo, use o Dify para publicar rapidamente um site de IA. Para mais informações, consulte Redesenvolver com base em componentes front-end.

  4. Incorporação no site da sua empresa ou pessoal.

    O Dify suporta a incorporação da sua aplicação de IA no site da sua empresa. Use essa capacidade para criar um serviço oficial de atendimento ao cliente com IA, perguntas e respostas comerciais e outras aplicações com seus dados comerciais em minutos. Para mais informações, consulte Incorporar em um site.

Exemplo: Incorporar em um site

Incorpore sua aplicação LLM em um site empresarial ou pessoal.

Este exemplo serve apenas para fins de demonstração. Para garantir a segurança dos dados em ambiente de produção, ative também o recurso Access Control.

  1. Habilite o acesso público para o serviço ack-dify e abra o ip externo no navegador. Para mais informações, consulte Acessar o serviço Dify.

    image

  2. Crie rapidamente uma aplicação web simples no seu cluster ACK para depurar seu assistente de perguntas e respostas com IA.

    Isso implanta uma aplicação web no seu cluster ACK para hospedar a aplicação LLM do Dify incorporada.

    1. Obtenha o código do serviço Dify.

      Conforme mostrado na figura, escolha um método para incorporar o código da aplicação de chat ao seu site.image

    2. No cluster, crie um Deployment para executar sua aplicação web e crie um Service para expô-la.

      Abaixo está um exemplo simples de YAML que mostra como implantar um servidor Nginx com HTML estático.

      1. Faça login no console do Container Service for Kubernetes (ACK). Na página ConfigMaps, defina o namespace como default e clique em Create from YAML. Copie o conteúdo YAML abaixo para o modelo e modifique os parâmetros window.difyChatbotConfig, src e id com base no código do serviço Dify obtido.

        Veja o exemplo abaixo.

        Conteúdo YAML

        apiVersion: apps/v1
        kind: Deployment
        metadata:
          name: web-deployment
        spec:
          replicas: 2
          selector:
            matchLabels:
              app: web
          template:
            metadata:
              labels:
                app: web
            spec:
              containers:
              - name: web
                image: registry.openanolis.cn/openanolis/nginx:1.14.1-8.6
                ports:
                - containerPort: 80
                volumeMounts:
                - name: web-content
                  mountPath: /usr/share/nginx/html
              volumes:
              - name: web-content
                configMap:
                  name: web-config
          
        
        ---
        apiVersion: v1
        kind: Service
        metadata:
          name: web-service
        spec:
          selector:
            app: web
          ports:
            - protocol: TCP
              port: 80
              targetPort: 80
          type: LoadBalancer
        
        ---
        apiVersion: v1
        kind: ConfigMap
        metadata:
          name: web-config
        data:
          index.html: |
            <!DOCTYPE html>
            <html lang="en">
            <head>
                <meta charset="UTF-8">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
                <title>The simplest website service</title>
                <style>
                    #dify-chatbot-bubble-button {
                        background-color: #1C64F2 !important;
                    }
                </style>
            </head>
            <body>
                <h1>Welcome to my website!</h1>
            
            
                <script>
                 window.difyChatbotConfig = {
                  token: 'W1b8mRL******yiD6',
                  baseUrl: 'http://8.154.XX.XX'
                 }
                </script>
                <script
                 src="http://8.154.XX.XX/embed.min.js"
                 id="W1b8mRL******yiD6"
                 defer>
                </script>
                <style>
                  #dify-chatbot-bubble-button {
                    background-color: #1C64F2 !important;
                  }
                </style>
        
            </body>
            </html>
      2. Verifique o status da implantação. A implantação é bem-sucedida quando ambos os pods estão no estado Running.

      3. Habilite o acesso público para o serviço implantado.

        Para garantir a segurança dos dados em ambiente de produção, recomendamos que você também ative o recurso Access Control.

        image

        Após a configuração, o External ip do serviço web-service será exibido. Abra esse ip no navegador.

        image

        Importante
        • Se quiser que outros dispositivos acessem o serviço, certifique-se de que o firewall ou grupo de segurança do seu cluster permita tráfego na porta 80. Para mais informações, consulte Adicionar uma regra de grupo de segurança.

        • Garanta que seu código e códigos de terceiros sejam seguros para evitar possíveis XSS ou incorporação de código malicioso. Este é um exemplo básico apenas para fins de demonstração; você pode expandi-lo e modificá-lo conforme suas necessidades.

      4. Resultado do exemplo.

        2024-08-23_14-14-02 (1)

Faturamento

O uso deste recurso gera cobranças pelo gerenciamento de clusters ACK Pro e pelo uso de recursos da Alibaba Cloud. Os produtos da Alibaba Cloud envolvidos incluem Elastic Compute Service (ecs), Classic Load Balancer (CLB), elastic ip address (EIP) e Apsara File Storage NAS. Você será cobrado pelos recursos utilizados de acordo com as regras de preços de cada produto. Para mais informações sobre taxas de gerenciamento de cluster e custos de recursos de produtos de nuvem, consulte Visão geral do faturamento.

Aviso legal

O Dify no ACK é uma solução de implantação Helm que adapta o projeto open-source Dify para o ambiente ACK da Alibaba Cloud, permitindo uma implantação rápida. O ACK não garante o desempenho da aplicação Dify nem sua compatibilidade com outros componentes do ecossistema, como plugins e bancos de dados. O ACK não fornece serviços comerciais, como compensação ou indenização, por quaisquer perdas comerciais causadas por defeitos no Dify ou em seus componentes de ecossistema. Para garantir a estabilidade e a segurança do Dify, acompanhe as atualizações da comunidade open-source e corrija proativamente problemas no software open-source.