How to Build a Local Offline AI Agent for ESP32 Using MQTT

1. The Fallacy of Cloud-Dependent IoT

For the better part of a decade, the standard operating procedure for connecting microcontrollers like the ESP32 to Artificial Intelligence engines has meant one thing: surrendering your data to the cloud. Whether utilizing AWS IoT Core, Google Cloud IoT, or Azure, the architecture invariably required your private, sensitive telemetry data to leave your local network, travel across the public internet, and be processed on servers you do not own.

While this architecture offers immense compute power, it introduces catastrophic vulnerabilities. Latency spikes can delay critical industrial commands by crucial milliseconds. Internet outages render multimillion-dollar smart infrastructures completely blind. Most importantly, transmitting unencrypted or poorly secured telemetry data exposes your facility, factory, or home to man-in-the-middle attacks and data breaches. The cloud is convenient, but for mission-critical automation, it is a liability.

2. Architecting the Local Edge Brain: Llama & Qwen32

The first phase in deploying an offline AI agent is establishing the "brain." We do not need to rely on the cloud, nor do we need to manually train massive logic matrices inside MqttDesk (which currently focuses entirely on cross-platform visualization and protocol aggregation across its 19 supported languages). Instead, we will deploy a localized LLM environment directly on your desktop or laptop.

Downloading and Exposing the Local AI

We highly recommend utilizing a tool like LM Studio or Ollama to host your model. For IoT logic generation, code parsing, and JSON payload manipulation, we have extensively tested the Qwen32 (32 Billion Parameter) model alongside the MQTTfy ecosystem. Its ability to adhere to rigid JSON structures and infer complex logic from raw sensor telemetry is phenomenal.

1. Download the Runner: Install LM Studio on your Windows, Mac, or Linux machine.
2. Acquire Qwen32: Search for the `Qwen 2.5 32B Instruct` quantized GGUF file and download it.
3. Initialize the Local Server: Boot the model and activate the Local Inference Server. This will expose a REST API endpoint on your local network.
4. Verify the Endpoint: Your local AI will now be accessible via a local IP address (e.g., http://192.168.1.50:1234/v1/chat/completions). This is the exact endpoint we will feed into the MQTTfy Android Application.

3. Bridging Intelligence with the MQTTfy Android App

With the Qwen32 model running locally, the sheer compute power is isolated on your desktop. We need a bridge to connect this intelligence to the physical world (the ESP32). This is where the MQTTfy AI MQTT BLE Dashboard Automation Android Application comes in. This application is not merely a dashboard; it is a portable command center capable of unifying MQTT, Bluetooth (BLE), and REST APIs side-by-side. To understand its power, we must first understand its architecture.

The Connection Manager Registry

At the heart of the app is the Connection Manager. It is critical to note that the Connection Manager is strictly a registry for your physical data sources. This is where you add your server endpoints—such as an MQTT broker, a Bluetooth BLE scanner, or a REST server like a local Home Assistant instance.

You do not put your local AI (Llama/Qwen) address here. The Connection Manager exists purely so you can define your hardware or server connections once, assign them a name, and effortlessly call upon those names later in your widgets and automation logic without ever re-typing an IP address. It is the foundational data layer.

The Key Icon: Local AI Configuration

To link the massive intelligence of your desktop Qwen32 model to your phone, you must navigate to the dedicated AI Automation tab. Within this tab, you will find the Key Icon—this represents the Local AI Configuration settings.

• Click the Key Icon to open the configuration modal.
• Enter the local REST endpoint address of your LLM (e.g., http://192.168.1.50:1234/v1).
• Specify the exact model name running on your server (e.g., qwen2.5-32b).
• Save the configuration. The app is now successfully tethered to your offline AI brain.

4. Firmware Engineering: The ESP32 Implementation

We have a local AI, and we have the MQTTfy app bridging it. Now, we must configure the edge hardware. The ESP32 is a low-cost, low-power system on a chip with integrated Wi-Fi and dual-mode Bluetooth. It is the perfect candidate for local offline telemetry.

Below is the production-grade C++ firmware code required to establish a resilient MQTT connection from the ESP32 to a local MQTT broker. We will assume you are connecting to a local Mosquitto broker (or the upcoming Synapse Agentic MQTT Broker once it exits the current production-level spec development phase).

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

// --- Configuration ---
const char* ssid = "FACTORY_SECURE_NET";
const char* password = "AIR_GAPPED_PASSWORD";
const char* mqtt_server = "192.168.1.100"; // Local Broker IP
const int mqtt_port = 1883;

WiFiClient espClient;
PubSubClient client(espClient);

// Sensor simulation variables
float currentTemp = 25.0;
float vibrationFreq = 120.5;

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Connecting to offline network: ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected. IP address: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    String clientId = "ESP32Node-";
    clientId += String(random(0xffff), HEX);
    
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");
      client.subscribe("factory/zone1/control");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  // Simulate reading complex industrial sensors
  currentTemp = currentTemp + random(-10, 10) / 10.0;
  vibrationFreq = vibrationFreq + random(-5, 5) / 10.0;

  // Construct structured JSON payload for AI ingestion
  StaticJsonDocument<200> doc;
  doc["sensor_id"] = "ESP_ZONE_1";
  doc["telemetry"]["temperature_c"] = currentTemp;
  doc["telemetry"]["vibration_hz"] = vibrationFreq;
  doc["status"] = "ACTIVE";

  char jsonBuffer[512];
  serializeJson(doc, jsonBuffer);

  // Publish to the local broker
  client.publish("factory/zone1/telemetry", jsonBuffer);
  
  delay(2000); // Publish every 2 seconds
}

This firmware utilizes the ArduinoJson library to format the telemetry exactly how a Large Language Model expects it. By publishing raw, structured JSON to the factory/zone1/telemetry topic, the Qwen32 AI agent will have zero difficulty parsing the data keys (e.g., extracting temperature_c accurately).

5. Two Paths to Power: Visual No-Code vs. AI Automation

Now that the ESP32 is publishing data locally and the Connection Manager is populated, we must link it to actionable logic. The MQTTfy Android application provides two distinct, incredibly powerful paradigms for automation. It is crucial to understand that Visual No-Code Automation and AI Automation are completely separate features within the app.

Path A: Autonomous AI Automation

If you prefer a hands-off, intelligent approach, you utilize the AI Automation feature. Because you have already established the Local AI via the Key Icon, you can literally chat with your AI agent to construct the operational logic.

You simply instruct the agent: "Monitor the ESP32 connection on topic `factory/zone1/telemetry`. If the temperature exceeds 30C, generate a payload to turn on the cooling fan." The agent will autonomously create the automation script based on your parameters. But it doesn't stop there—it actually runs the automation continuously on your phone, querying the local desktop Qwen32 model in real-time and executing actions without human intervention, all while strictly adhering to the Local RAG guardrails.

Path B: The 8-Screen Visual No-Code Sequence

If you require explicit, rigid, deterministic logic outside of an AI's purview, the app offers a world-class Visual No-Code Automation engine. This is not a messy, tangled Node-RED canvas. It is a highly refined, linear sequence spanning 8 visual screens.

The workflow is elegantly simple: You start by selecting the data source (e.g., the REST server or MQTT broker you added earlier in the Connection Manager). Then, you swipe through the 8 screens, sequentially adding "Chips" (nodes) to build your logic stack.

• Thresholds & Conditions: Add chips to specify exact trigger points (e.g., temperature > 30).
• Transformations: Add chips to mutate or convert the raw JSON data before it is sent out.
• Action Nodes: Add final execution chips. Because the app supports cross-protocol routing natively, you can perform incredible feats instantly.

Using these action chips, you can route data seamlessly. Receive the ESP32 payload via MQTT, and automatically write a hexadecimal value to a Bluetooth (BLE) smart lock. Scan a BLE proximity badge, and trigger a REST webhook to your local attendance database. Or route processed edge data straight into Google PubSub, AWS IoT Core, Azure Event Hubs, Notion, Email, SMS, or private Database webhooks.

6. Monitoring the Ecosystem at Scale

Your local offline AI agent is now fully autonomous, bridging the Qwen32 LLM, your Android phone, and the physical ESP32. However, enterprise IoT requires overarching visibility.

To test your connections rapidly without installing any software, navigate to the Free MQTT Web Dashboard (mqtt-dashboard.mqttfy.com). It requires absolutely zero login, uses WebSockets to connect to brokers, and provides 20+ widgets across 19 languages. It is the perfect tool for quickly verifying that your ESP32 is publishing correctly.

For deep, persistent desktop monitoring, boot up MqttDesk. As our flagship cross-platform application (available on Windows, Linux, and macOS), MqttDesk allows engineers to monitor massive parallel data streams spanning MQTT, BLE, REST, Serial, WebSockets, and Sparkplug B. While MqttDesk does not contain native AI, it is the ultimate diagnostic tool to ensure your AI agents are behaving as expected.

Finally, as your deployment grows from a single ESP32 to thousands of industrial nodes, our upcoming AI Agent Platform for IoT & IIoT provides the efficient backend architecture necessary. Featuring BYOK (Bring Your Own Key) security and on-premise leader/team agent hierarchies, it scales the exact principles of this local AI tutorial to industrial manufacturing levels.