Container Service for Kubernetes:Build a general-purpose web chatbot using Flowise

1.1 Prerequisites

1. An ACK Pro cluster of version 1.22 or later is created. For more information, see Create an ACK managed cluster and Upgrade a cluster.

2. You have connected to the Kubernetes cluster using the kubectl tool. For more information, see Obtain the kubeconfig file of a cluster and use kubectl to connect to the cluster.

1.2 Deploy the component

2.1 Access the Flowise service

1. Enable Internet access for the Flowise component.

   If you are using a production environment, enable the Access Control feature to ensure that your application data is secure.

2. After the configuration is complete, you can view the External IP of the Flowise component. Enter this external IP address in your browser's address bar to access the Flowise service.

   

3. Access the Flowise service.

   Go to the External IP address and enter the custom Username and Password as prompted to use the service.

   

   If you did not specify a custom username and password when you installed the Flowise component, use the default values to access the service: Username=flowiseuser and Password=flowisepassword.

2.2 Create Chatflows

One of the powerful features of Flowise is that you can turn flows into tools. For example, you can have a main flow that coordinates when to use the necessary tools, and each tool is designed to perform a specific task.

Each child flow tool executes independently and has a separate memory to provide clearer output. The detailed output from each child flow is summarized into a final agent, which usually produces higher-quality output.

To create a Chatflow, perform the following steps.

1. Enter your username and password to log on to the Flowise service platform.

2. On the Flowise service platform page, click ChatFlows > Add Newto create a new Chatflow.

   

3.1 Configure Chat Models

In the Flowise service, you can orchestrate LLM applications by creating nodes and building connections between them. Similar to building blocks, you can use all available nodes in the Flowise service to build a custom LLM application, such as an LLM orchestration flow, a chatbot, or an intelligent agent. The Flowise service currently supports concepts from frameworks such as LangChain and LlamaIndex, from which you can abstract various types of nodes, such as Agents, Chains, and Chat Models.

1. Click to enter the Chat Models Panel and drag to create a ChatOpenAI Custom Node. Then, click the Connect Credential drop-down list > Create New and enter the API key for Tongyi Qianwen to create a new Connect Credential.

   

2. Set Model Name to qwen-turbo. Then, on the Additional Parameters page, set BasePath to https://dashscope.aliyuncs.com/compatible-mode/v1.

   

3.2 Set up a prompt template

Go to the Prompts panel, drag to create a Prompt Template node, and configure the Template information as follows.

Question: {question}
Answer: Let's think step by step.

3.3 Set up an LLM Chain

1. Go to the Chains panel and drag to create an LLM Chain node.

   

2. Connect the nodes of the created template to complete the orchestration of the general-purpose chatbot.

   

3.3 Verify the result

After you orchestrate the Chatflow, click the Save button in the upper-right corner of the page. Then, you can use the Message button in the upper-right corner to debug the chatbot. The result is shown in the following figure.

Apply to a production environment

There are two methods to introduce the developed AI Q&A assistant into your enterprise or personal production environment:

Example: Embed an AI application into a website

This section describes how to embed a developed LLM application into your enterprise or personal website. Follow the steps in the example.

This example is for demonstration purposes. To ensure that your application data is secure, enable the Access Control feature in your production environment.

1. Enable Internet access for the Flowise component. Enter the external IP address in your browser's address bar to access the Flowise service. For more information, see Access the Flowise service.

   

2. Build a simple web application in an ACK cluster to debug your general-purpose chatbot.

   The following example shows how to deploy a web application in an ACK cluster. It runs on your ACK cluster, and you can embed the LLM application developed in the Flowise service.

   1. Obtain the Flowise service code.

      As shown in the following figure, select a method to embed the corresponding code of the chat application into your website.

      

   2. In the ACK cluster, create a deployment to run your web application and create a service to expose the application.

      The following is a simple YAML example that shows how to deploy an Nginx server that contains static HTML.

      1. Log on to the ACK console. On the Configurations > ConfigMaps page, select the default namespace and click Create From YAML. Copy the following YAML content to the template and replace window.difyChatbotConfig, scr, and id with the Flowise service code that you obtained.

         For more information about the code, see the following example.

         View YAML content

         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>
               
             </head>
             <body>
                 <h1>Welcome to my website!</h1>
             
             
                 <script type="module">
             import Chatbot from "https://cdn.jsdelivr.net/npm/flowise-embed/dist/web.js"
             Chatbot.init({
                 chatflowid: "86c03xxx-de3a-4xx3-9xx2-f5d56xxxx0a4",
                 apiHost: "http://127.xx.xx.1:8080",
             })
                 </script>
         
         
         
             </body>
             </html>

      2. A successful deployment is shown in the following figure:

         

      3. Enable Internet access for the deployed service.

         To ensure that your application data is secure, enable the Access Control feature in your production environment.

         

         After the configuration is complete, you can view the External IP of the web-service. Enter this external IP address in your browser's address bar to access the web service.

         

         Important

         • If you want other devices to access the service, make sure that your cluster's firewall or security group allows traffic on port 80. For more information, see Add a security group rule.

         • Ensure that your code and any third-party code are secure to prevent potential cross-site scripting (XSS) or malicious code injection. This document provides a basic example for demonstration. You can extend and modify it as needed.

      4. View the result.

         

Continuous improvement

To learn more about how to integrate customized LLM applications, see Build a customized AI Q&A assistant for a website using Dify.

Using Dify, you can integrate enterprise or personal knowledge bases into large model applications. This lets you create highly customized AI Q&A solutions and integrate them into your business scenarios, which helps you improve daily development and management efficiency.