MQTT kann mehr: So baust du deinen eigenen Chat mit Node-RED
Meist wird MQTT verwendet, um Sensordaten oder SchaltzustĂ€nde zu ĂŒbertragen: Temperaturwerte, Luftfeuchtigkeit oder das Ein- und Ausschalten eines Relais. Klassisches IoT eben.
Doch was viele dabei ĂŒbersehen:
MQTT ist völlig unabhĂ€ngig davon, was du ĂŒbertrĂ€gst.
Ob Zahlen, Texte oder sogar strukturierte Daten â fĂŒr MQTT ist alles einfach nur eine Nachricht.
Und genau hier wird es spannend.
Denn im Grunde passiert beim Chatten nichts anderes:
Eine Nachricht wird gesendet, verteilt und von anderen empfangen.
đ Genau das macht MQTT bereits â nur normalerweise ohne Menschen.
https://youtu.be/zNiSUmRnl9c
đ GerĂ€te âchattenâ lĂ€ngst miteinander â wir mĂŒssen nur den Menschen mit ins Spiel bringen.
In diesem Beitrag zeige ich dir, wie du mit MQTT, Node-RED und einer kleinen SQLite-Datenbank einen eigenen Chat baust.
Kein riesiges Framework, keine komplizierte Architektur â sondern ein leicht verstĂ€ndliches Praxisprojekt, das dir gleichzeitig zeigt, wie flexibel MQTT wirklich ist.
Und das Beste daran:
Der Chat funktioniert nicht nur im Browser, sondern lÀsst sich spÀter problemlos auf ESP32, andere Clients oder sogar dein eigenes Smart Home erweitern.
In diesem Beitrag bauen wir gemeinsam einen einfachen Chat auf Basis von MQTT und Node-RED.
Der Fokus liegt dabei nicht auf einer vollwertigen Chat-Anwendung, sondern auf dem VerstÀndnis der zugrunde liegenden Kommunikation.
einfacher Chat umgesetzt mit MQTT und Node-RED
Das Ziel ist es, aufzuzeigen, wie Nachrichten ĂŒber MQTT gesendet, verteilt und von mehreren Teilnehmern empfangen werden können â genau so, wie es auch in klassischen IoT-Szenarien passiert.
Dabei setzen wir auf folgende Komponenten:
- MQTT als Transportprotokoll fĂŒr die Nachrichten
- Node-RED zur Verarbeitung und Visualisierung
- SQLite zur Speicherung der Chat-Historie
Die Datenbank dient dabei ausschlieĂlich dazu, bereits gesendete Nachrichten persistent zu speichern und beim Beitritt zum Chat erneut anzeigen zu können.
Bewusst verzichten wir in diesem Projekt auf zusÀtzliche Funktionen wie:
- Upload von Bildern oder Dateien
- Versand von Videos
- komplexe Benutzerverwaltung
Stattdessen konzentrieren wir uns auf das Wesentliche:
đ Das Senden und Empfangen von Textnachrichten ĂŒber MQTT
Genau dieser reduzierte Ansatz macht das Projekt so interessant, denn er zeigt sehr deutlich, wie einfach sich mit MQTT ein verteiltes Kommunikationssystem umsetzen lÀsst.
Architektur & Funktionsweise des Chats
Bevor wir mit der eigentlichen Umsetzung starten, werfen wir einen Blick auf die Architektur unseres Chats und das Zusammenspiel der einzelnen Komponenten.
In diesem Projekt ĂŒbernimmt Node-RED eine zentrale Rolle:
- Es stellt das Dashboard fĂŒr die BenutzeroberflĂ€che bereit
- Es fungiert als Publisher und Subscriber im MQTT-System
- Es dient als Schnittstelle zur SQLite-Datenbank, in der die Nachrichten gespeichert werden
Dadurch entsteht eine flexible Architektur, bei der Node-RED zwar das Frontend liefert, aber nicht zwingend der einzige Teilnehmer im System ist.
Ablauf der Kommunikation im Chat Client mit MQTT und Node-RED
Offenes System durch MQTT
Ein groĂer Vorteil von MQTT ist die Offenheit des Systems.
đ Das bedeutet konkret:
Dein Chat ist nicht auf das Dashboard beschrĂ€nkt â er ist ein offenes System.
Neben dem Node-RED Dashboard können also auch andere Clients Nachrichten senden und empfangen, zum Beispiel:
- der MQTT Explorer zur direkten Analyse und zum Testen
- ein Mikrocontroller wie ESP8266 oder ESP32
- eigene Anwendungen oder Skripte
Chatnachrichten vom MQTT Explorer als JSON
Diese Clients können problemlos Nachrichten in den Chat senden oder empfangen.
Einziger Unterschied:
đ Der Zugriff auf die Chat-Historie erfolgt in unserem Projekt ausschlieĂlich ĂŒber Node-RED und die angebundene SQLite-Datenbank.
Ablauf einer Chatnachricht
Der Ablauf einer Nachricht ist bewusst einfach gehalten und orientiert sich vollstÀndig am MQTT-Prinzip:
- Der Benutzer meldet sich im Dashboard mit einem Benutzernamen an
- AnschlieĂend kann er â wie in jedem klassischen Chat â eine Nachricht eingeben und absenden
- Node-RED veröffentlicht diese Nachricht auf einem MQTT-Topic
- Der MQTT-Broker verteilt die Nachricht an alle verbundenen Clients
- Node-RED empfÀngt die Nachricht erneut als Subscriber
- Die Nachricht wird in der SQLite-Datenbank gespeichert
- Der Chatverlauf wird aktualisiert und im Dashboard angezeigt
đ Wichtig:
Jede Nachricht durchlĂ€uft immer denselben Weg â unabhĂ€ngig davon, ob sie vom Browser, einem Mikrocontroller oder einem anderen MQTT-Client stammt.
FĂŒr die Kommunikation verwenden wir ein zentrales Topic:
Alle Teilnehmer abonnieren dieses Topic und erhalten dadurch jede neue Nachricht in Echtzeit.
Speicherung der Nachrichten
Da MQTT selbst keine dauerhafte Speicherung vorsieht, wird jede Nachricht zusÀtzlich in einer SQLite-Datenbank abgelegt.
SQLite Datenbank mit Chat Historie
- das Nachladen der Chat-Historie beim Einstieg
- die Anzeige vergangener Nachrichten
- einen konsistenten Zustand im Dashboard
Simple MQTT Chat mit Node-REDHerunterladen
FĂŒr dieses Projekt benötigst du eine laufende Umgebung mit Node-RED, einem MQTT-Broker sowie einer SQLite-Datenbank.
Die gute Nachricht:
Alle notwendigen Grundlagen habe ich bereits in separaten BeitrĂ€gen ausfĂŒhrlich erklĂ€rt.
đ Wenn du diese Komponenten noch nicht eingerichtet hast, findest du hier die passenden Anleitungen:
- Node-RED mit Docker installieren â Schritt fĂŒr Schritt
- Node-RED unter Windows 11 mit WSL installieren â Schritt fĂŒr Schritt
- Node-RED mit Docker â SQLite Datenbank anbinden und erste Abfragen
Benötigte Komponenten im Ăberblick
FĂŒr den Chat selbst setzen wir auf folgende Bausteine:
- Node-RED
zur Verarbeitung der Daten und Bereitstellung des Dashboards
- MQTT-Broker (z. B. Mosquitto)
fĂŒr die Verteilung der Nachrichten zwischen den Teilnehmern
- SQLite-Datenbank
zur Speicherung der Chat-Historie
Hinweis
In diesem Beitrag konzentrieren wir uns vollstÀndig auf die Umsetzung des Chats.
Die Installation und Grundkonfiguration der einzelnen Komponenten wird daher nicht erneut behandelt.
đ So kannst du dich direkt auf das Wesentliche konzentrieren:
Das Senden und Empfangen von Nachrichten ĂŒber MQTT.
Einrichten der SQLite-Datenbank fĂŒr die Chat-Historie
Die Historie des Chats wird in einer SQLite-Datenbank gespeichert.
Diese liegt als einfache Datei im Dateisystem vor â genau das ist einer der groĂen Vorteile von SQLite:
Es wird kein separater Datenbankserver benötigt.
SQLite Datenbank im Docker Container von Node-RED
FĂŒr unser Projekt reicht eine einzige Tabelle aus, da wir zunĂ€chst nur einen Chatraum verwenden.
Die Tabelle chat_messages enthÀlt folgende Spalten:
- id â fortlaufende, eindeutige Nummer (PrimĂ€rschlĂŒssel)
- name â Name des Benutzers, der die Nachricht gesendet hat
- message â eigentlicher Text der Nachricht
- zeit â UNIX-Timestamp der Nachricht
SQL zum Anlegen der Tabelle
CREATE TABLE chat_messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
message TEXT NOT NULL,
zeit INTEGER NOT NULL
);
Nachdem die Datenbank vorbereitet ist, kĂŒmmern wir uns im nĂ€chsten Schritt um den eigentlichen Node-RED Flow.
Dieser verbindet das Dashboard, den MQTT-Broker und die SQLite-Datenbank zu einem einfachen, aber erstaunlich flexiblen Chat-System.
đ Ziel ist es, drei zentrale Komponenten miteinander zu verbinden:
- BenutzeroberflÀche (Dashboard)
- NachrichtenĂŒbertragung (MQTT)
- Speicherung der Historie (SQLite)
Aufbau des Flows im Ăberblick
Der Flow besteht im Kern aus drei Bereichen:
1. Dashboard (ui-template)
Hier wird die Chat-OberflÀche dargestellt und Benutzereingaben werden erfasst.
Code
Chat beitreten
Absenden
Angemeldet als {{ username }}
{{ entry.name }}
{{ entry.message }}
{{ entry.zeit_format }}
Senden
Anmeldung an einen einfachen Chat
aktiver Chat mit drei Teilnehmern
2. MQTT-Kommunikation
Nachrichten werden ĂŒber das Topic chat/message versendet und empfangen.
3. Datenbank-Anbindung (SQLite)
Alle Nachrichten werden gespeichert und bei Bedarf wieder geladen.
kompletter Node-RED Flow fĂŒr ein einfaches Chat System
đ Importiere den folgenden Flow in Node-RED:
Simple MQTT Chat mit Node-REDHerunterladen
Verarbeitung eingehender Nachrichten
Sobald eine Nachricht im Dashboard abgesendet wird, passiert Folgendes:
- Das Dashboard sendet eine Nachricht mit:
- name (Benutzername)
- message (Text)
- In der Function-Node âbaue Nachrichtâ wird die Nachricht erweitert:
let name = msg.payload.name;
let message = msg.payload.message;
let time = Date.now();
msg.payload = {
name: name,
message: message,
timestamp: time
};
return msg;
đ Hier wird der UNIX-Zeitstempel ergĂ€nzt, damit die Nachricht spĂ€ter korrekt sortiert und angezeigt werden kann.
Nachricht via MQTT versenden
Die aufbereitete Nachricht wird anschlieĂend ĂŒber eine mqtt out-Node veröffentlicht:
đ Wichtig: Alle Teilnehmer im System abonnieren genau dieses Topic.
Nachricht empfangen (Subscriber)
Node-RED ist gleichzeitig auch Subscriber und empfĂ€ngt jede gesendete Nachricht erneut ĂŒber die mqtt in-Node.
đ Egal ob die Nachricht vom Browser, einem ESP32 oder dem MQTT Explorer kommt â sie wird immer gleich verarbeitet.
Speicherung in der SQLite-Datenbank
Die empfangene Nachricht wird anschlieĂend in der Datenbank gespeichert.
Dazu wird in einer Function-Node ein SQL-Statement erzeugt:
function esc(str) {
return String(str).replace(/'/g, "''");
}
const name = esc(msg.payload.name);
const message = esc(msg.payload.message);
const zeit = esc(msg.payload.timestamp);
msg.topic = `INSERT INTO chat_messages (name, message, zeit) VALUES ('${name}', '${message}', ${zeit});`;
return msg;
đ Die SQLite-Node fĂŒhrt dieses Statement aus und speichert die Nachricht persistent.
Damit der Benutzer alle bisherigen Nachrichten sieht, wird nach jedem Event die Historie neu geladen.
Das erfolgt ĂŒber folgende SQL-Abfrage:
SELECT
id,
name,
message,
strftime('%d.%m.%Y %H:%M:%S', zeit / 1000, 'unixepoch', 'localtime') AS zeit_format
FROM chat_messages ORDER BY zeit ASC;
đ Hier passiert etwas Wichtiges:
- Der gespeicherte UNIX-Timestamp wird direkt in ein lesbares Datum umgewandelt
- Format: Tag.Monat.Jahr Stunde:Minute:Sekunde
Steuerung ĂŒber Topics
Im Flow wird zwischen zwei Aktionen unterschieden:
- load_chat â lĂ€dt die Historie
- send_message â sendet eine neue Nachricht
Das erfolgt ĂŒber eine switch-Node:
đ Dadurch bleibt der Flow ĂŒbersichtlich und klar strukturiert.
Warum funktioniert das Ganze so gut mit MQTT?
Ganz einfach:
MQTT ist von Grund auf fĂŒr verteilte Systeme gebaut.
- Nachrichten senden (Publisher)
- Nachrichten empfangen (Subscriber)
đ Und genau das macht einen Chat aus.
Der groĂe Vorteil:
Neue Teilnehmer können jederzeit hinzugefĂŒgt werden, ohne dass die bestehende Architektur angepasst werden muss.
Ob Browser, ESP32 oder ein eigenes Script:
Solange das richtige Topic verwendet wird, ist jeder sofort Teil des Systems.
Nachrichten mit anderen MQTT-Clients senden
Ein groĂer Vorteil dieses Aufbaus ist, dass der Chat nicht fest an das Node-RED Dashboard gebunden ist.
Da alle Nachrichten ĂŒber das MQTT-Topic chat/message laufen, kann grundsĂ€tzlich jeder MQTT-fĂ€hige Client an der Kommunikation teilnehmen. Das kann ein weiteres Node-RED Dashboard sein, ein ESP32, ein ESP8266 oder auch ein externes MQTT-Tool wie CorreoMQTT.
Wichtig ist nur, dass die Nachricht im erwarteten JSON-Format gesendet wird:
{
"name": "CorreoMQTT",
"message": "Hallo aus einem externen MQTT-Client!",
"timestamp": 1715779200000
}
Die Nachricht wird anschlieĂend vom Node-RED Subscriber empfangen, in der SQLite-Datenbank gespeichert und beim erneuten Laden der Historie im Dashboard angezeigt.
Damit wird sehr schön sichtbar, worum es bei MQTT eigentlich geht:
đ Der Absender muss das Dashboard nicht kennen.
đ Der EmpfĂ€nger muss den Absender nicht kennen.
đ Beide mĂŒssen nur dasselbe MQTT-Topic verwenden.
FĂŒr unser Beispiel lautet dieses Topic:
Dadurch lÀsst sich der Chat sehr einfach erweitern. So könnte spÀter zum Beispiel ein ESP32 automatisch Statusmeldungen senden oder ein anderes System Benachrichtigungen in den Chat schreiben.
Mit diesem Projekt hast du gesehen, dass MQTT deutlich mehr kann als nur Sensordaten oder Schaltbefehle zwischen GerÀten auszutauschen.
Mit ĂŒberraschend wenig Aufwand haben wir einen einfachen Chat aufgebaut, der Nachrichten in Echtzeit verteilt, dauerhaft speichert und unabhĂ€ngig vom eigentlichen Client funktioniert.
Dabei ĂŒbernehmen die einzelnen Komponenten klar getrennte Aufgaben:
- MQTT verteilt die Nachrichten
- Node-RED ĂŒbernimmt OberflĂ€che und Logik
- SQLite speichert die Historie dauerhaft
Genau diese Trennung macht den Aufbau so flexibel.
Das Spannende daran:
Der Chat selbst ist am Ende nur ein Beispiel.
Denn technisch betrachtet unterscheiden sich Chatnachrichten kaum von Sensordaten, Statusmeldungen oder Befehlen aus einem Smart-Home-System.
Heute schreibt ein Benutzer eine Nachricht.
Morgen sendet ein ESP32 eine Warnung.
Ăbermorgen meldet ein Shelly automatisch einen Zustand.
Und genau hier zeigt sich die eigentliche StÀrke von MQTT:
Nicht die Nachricht ist entscheidend â sondern dass jeder Teilnehmer dieselbe Sprache spricht.
Ich hoffe, ich konnte dir mit diesem Projekt zeigen, dass MQTT weit mehr ist als nur ein Protokoll fĂŒr Temperaturwerte.
Vielleicht ist dieser kleine Chat ja der Einstieg in dein nĂ€chstes gröĂeres IoT-Projekt.
