Exploring Natural Interaction IoT Applications with MQTT and ChatGPT

With the rapid development of IoT technology, interaction between people and devices, as well as between devices, has become easier. However, achieving more natural, efficient, and intelligent interactions has become a new challenge in the IoT field.

Recently, advanced large language models (LLMs) such as ChatGPT, GPT-3.5, and GPT-4 released by OpenAI have quickly gained popularity worldwide, bringing more possibilities for the integration of general artificial intelligence (AGI) and the IoT field.

As an advanced natural language processing application, ChatGPT can easily achieve natural dialogue between humans and machines due to its excellent natural language processing capabilities. Meanwhile, the mainstream protocol in the IoT field, MQTT (Message Queuing Telemetry Transport), ensures real-time data transmission and efficient processing through its lightweight communication method and publish/subscribe model.

Therefore, we can boldly imagine that combining the MQTT protocol with ChatGPT can facilitate intelligent human-machine interaction in the IoT field:

• In the smart home field, users can control smart devices at home through natural conversations with ChatGPT, improving their quality of life.

• In the industrial automation field, ChatGPT can help engineers analyze device data more quickly, increasing production efficiency.

• …

Based on this, this article will explore how to combine the MQTT protocol with natural language processing applications like ChatGPT, and will demonstrate an application scenario through a simple setup example, providing some ideas for readers to explore intelligent IoT applications.

MQTT Protocol

As mentioned above, the MQTT protocol is a lightweight messaging transport protocol based on a publish/subscribe model, which is now widely used in various fields, including IoT, mobile internet, smart hardware, vehicle networking, smart cities, remote medical care, power, oil, and energy.

Connecting massive IoT devices using the MQTT protocol requires a key component: the MQTT server. In the solution design below, we will use the large-scale distributed IoT MQTT message server EMQX to achieve efficient and reliable connections of massive IoT devices and real-time processing and distribution of message and event stream data.

After that, we can use an MQTT client to connect to the MQTT server to communicate with IoT devices. In this article, we will use the open-source cross-platform MQTT client MQTTX, which includes desktop, command-line, and web applications, allowing for easy connection testing with the MQTT server, helping developers quickly develop and debug MQTT services and applications.

ChatGPT

ChatGPT (https://openai.com/blog/chatgpt) is a natural language processing application built on advanced large language models such as OpenAI’s GPT-3.5 and GPT-4. GPT (Generative Pre-trained Transformer) is a deep learning model known for its powerful text generation and understanding capabilities. ChatGPT can understand and generate natural language, engaging in smooth and natural conversations with users. To achieve ChatGPT’s natural language processing capabilities, we need to use the API provided by OpenAI (https://platform.openai.com/docs/api-reference) to interact with the GPT model.

Based on the capabilities of the MQTT protocol and ChatGPT, we will design a solution to achieve the integration and interaction of the two.

To implement natural language processing functionality similar to ChatGPT, we will write a client script that uses the API provided by OpenAI to interact with the GPT model. When the MQTT client in this script receives a message and forwards it to the API, a corresponding natural language response will be generated. This response message will then be published to a specific MQTT topic to achieve an interaction loop between ChatGPT and the MQTT client.

Through this design, we will demonstrate the interoperability process of message reception, processing, and forwarding between ChatGPT and the MQTT protocol.

First, please prepare the necessary tools and resources according to the following steps.

• Install EMQX:

EMQX 5.0 can be quickly installed and started using Docker:

docker run -d --name emqx -p 1883:1883 -p 8083:8083 -p 8883:8883 -p 8084:8084 -p 18083:18083 emqx/emqx:latest

In addition to Docker installation, EMQX also supports installation using RPM or DEB packages. For specific installation methods, please refer to the EMQX 5.0 installation guide (https://www.emqx.io/docs/zh/v5.0/deploy/install.html).

• Install the MQTTX desktop application:

Go to the official MQTTX website (https://mqttx.app/zh), select the version corresponding to your operating system and CPU architecture, click download, and install.

• Register an OpenAI account and obtain an API key:

Visit OpenAI (https://platform.openai.com/overview), create or log into your account. Once done, click the top right corner, select <span>View</span><span> API Keys</span> , and under the API keys section, click <span>Create new secret key</span> to generate a new API key. Please keep this key safe, as it will be used for API authentication in subsequent programs.

After completing the above steps, we now have the tools and resources needed to combine the MQTT protocol with ChatGPT applications. For details on how to interact with the GPT language model using OpenAI’s API, you can refer to the OpenAI documentation (https://platform.openai.com/docs/introduction) for detailed guidance and learning materials.

const host = "127.0.0.1";
const port = "1883";
const clientId = `mqtt_${Math.random().toString(16).slice(3)}`;
const OPTIONS = {
  clientId,
  clean: true,
  connectTimeout: 4000,
  username: "emqx",
  password: "public",
  reconnectPeriod: 1000,
};
const connectUrl = `mqtt://${host}:${port}`;
const chatGPTReqTopic = "chatgpt/request/+";
const client = mqtt.connect(connectUrl, OPTIONS);

// Add your OpenAI API key to your environment variables in .env
const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
let messages = []; // Store conversation history
const maxMessageCount = 10;
const http = axios.create({
    baseURL: "https://api.openai.com/v1/chat",
    headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${OPENAI_API_KEY}`,
    },
});
const genText = async (userId) => {
    try {
        const { data } = await http.post("/completions", {
            model: "gpt-3.5-turbo",
            messages: messages[userId],
            temperature: 0.7,
        });
        if (data.choices && data.choices.length > 0) {
            const { content } = data.choices[0].message;
            messages[userId].push({ role: "assistant", content: content });
            if (messages[userId].length > maxMessageCount) {
               messages[userId].shift(); // Remove the oldest message
            }
            const replyTopic = `chatgpt/response/${userId}`;
            client.publish(replyTopic, content, { qos: 0, retain: false }, (error) => {
                if (error) {
                    console.error(error);
                }
            });
        }
    } catch (e) {
        console.log(e);
    }
};

client.on("message", (topic, payload) => {
    // Check if the topic is not the one you're publishing to
    if (topic.startsWith(chatGPTReqTopicPrefix)) {
        const userId = topic.replace(chatGPTReqTopicPrefix, "");
        messages[userId] = messages[userId] || [];
        messages[userId].push({ role: "user", content: payload.toString() });
        if (messages[userId].length > maxMessageCount) {
          messages[userId].shift(); // Remove the oldest message
        }
        genText(userId);
    }});

node index.js