ESP32 Meets AI: How to Control Your IoT Devices with ASI Biont via MQTT and WebSocket

Introduction

The ESP32 is a low-cost, low-power system-on-chip microcontroller with integrated Wi-Fi and Bluetooth, making it the go-to choice for IoT projects—from smart lighting and temperature monitoring to industrial sensor networks. But even with its versatility, writing custom firmware for each use case, managing MQTT brokers, and building dashboards can be time-consuming. Enter ASI Biont: an AI agent that connects to your ESP32 in minutes, not days.

In this guide, we’ll walk through a real-world integration: an ESP32 with a DHT22 temperature/humidity sensor and a relay module, connected to ASI Biont via MQTT. The AI agent reads sensor data, sends Telegram alerts when thresholds are exceeded, and controls the relay based on voice commands or schedules—all without you writing a single line of boilerplate code.

Why Connect ESP32 to an AI Agent?

Traditional IoT setups require:
- Writing and deploying firmware (C/C++, MicroPython)
- Setting up an MQTT broker (e.g., Mosquitto)
- Building a backend to process data and trigger actions
- Creating a user interface or mobile app

ASI Biont eliminates steps 2–4. The AI agent acts as both the control logic and the interface. You simply describe your hardware and desired behavior in natural language, and the agent generates the Python code that runs in its sandbox environment (execute_python), which then communicates with your ESP32 over MQTT. No dashboards, no additional servers—just a chat conversation.

Connection Method: MQTT via paho-mqtt

ASI Biont supports MQTT through the industrial_command tool and the execute_python sandbox. For ESP32, MQTT is the most practical choice because:
- ESP32 has built-in Wi-Fi and can run a lightweight MQTT client (e.g., using PubSubClient library)
- MQTT is asynchronous and perfect for sensor data streaming
- ASI Biont can subscribe to topics and publish commands in real time

Why not COM port or SSH? COM port requires a physical USB cable and a PC running bridge.py. SSH works only if the ESP32 runs a full Linux OS (like ESP32-S3 with MicroPython SSH server), but most ESP32 projects use Arduino IDE or ESP-IDF, which don’t have SSH. MQTT is wireless, scalable, and requires minimal setup.

Use Case: Smart Environment Monitoring and Control

Hardware Setup

Wiring:
- DHT22 Data Pin → ESP32 GPIO 4
- DHT22 VCC → 3.3V
- DHT22 GND → GND
- Relay IN → ESP32 GPIO 2
- Relay VCC → 5V (or 3.3V if relay module supports it)
- Relay GND → GND

ESP32 Firmware (MicroPython)

Save this as main.py on your ESP32 (use Thonny or ampy to upload):

import network
import time
import dht
import machine
from umqtt.simple import MQTTClient

# WiFi credentials
WIFI_SSID = "Your_SSID"
WIFI_PASS = "Your_Password"

# MQTT broker (use your Mosquitto or public test broker)
MQTT_BROKER = "broker.emqx.io"
MQTT_PORT = 1883
CLIENT_ID = "esp32_sensor_01"

# Topics
TOPIC_TEMP = "home/sensor/temperature"
TOPIC_HUM = "home/sensor/humidity"
TOPIC_RELAY = "home/actuator/relay"

# Sensor and relay pins
dht_pin = machine.Pin(4)
sensor = dht.DHT22(dht_pin)
relay = machine.Pin(2, machine.Pin.OUT)

def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(WIFI_SSID, WIFI_PASS)
    while not wlan.isconnected():
        time.sleep(0.5)
    print("WiFi connected")

def mqtt_callback(topic, msg):
    print(f"Received {topic}: {msg}")
    if topic == TOPIC_RELAY.encode():
        if msg == b"on":
            relay.on()
            print("Relay ON")
        elif msg == b"off":
            relay.off()
            print("Relay OFF")

def main():
    connect_wifi()
    client = MQTTClient(CLIENT_ID, MQTT_BROKER, port=MQTT_PORT)
    client.set_callback(mqtt_callback)
    client.connect()
    client.subscribe(TOPIC_RELAY)
    print(f"Subscribed to {TOPIC_RELAY}")

    while True:
        try:
            sensor.measure()
            temp = sensor.temperature()
            hum = sensor.humidity()
            print(f"Temp: {temp}°C, Humidity: {hum}%")
            client.publish(TOPIC_TEMP, str(temp))
            client.publish(TOPIC_HUM, str(hum))
            client.check_msg()  # non-blocking check for relay commands
            time.sleep(10)
        except OSError as e:
            print("Sensor read error:", e)
            time.sleep(2)

if __name__ == "__main__":
    main()

ASI Biont Integration: AI Agent Side

Now, in the ASI Biont chat, you simply describe your setup:

"Connect to MQTT broker at broker.emqx.io:1883. Subscribe to home/sensor/temperature and home/sensor/humidity. If temperature exceeds 30°C, publish 'on' to home/actuator/relay and send me a Telegram alert. Also, listen for my command 'turn on relay' or 'turn off relay' and publish accordingly."

ASI Biont generates and runs the following code inside its execute_python sandbox (using paho-mqtt):

import paho.mqtt.client as mqtt
import json

BROKER = "broker.emqx.io"
PORT = 1883
TOPIC_TEMP = "home/sensor/temperature"
TOPIC_HUM = "home/sensor/humidity"
TOPIC_RELAY = "home/actuator/relay"

def on_connect(client, userdata, flags, rc):
    print("Connected to broker")
    client.subscribe(TOPIC_TEMP)
    client.subscribe(TOPIC_HUM)

def on_message(client, userdata, msg):
    payload = msg.payload.decode()
    topic = msg.topic
    print(f"Received {topic}: {payload}")

    if topic == TOPIC_TEMP:
        temp = float(payload)
        if temp > 30.0:
            client.publish(TOPIC_RELAY, "on")
            # Send Telegram alert (simplified)
            print(f"ALERT: Temperature {temp}°C exceeds 30°C. Relay turned on.")
    elif topic == TOPIC_HUM:
        hum = float(payload)
        if hum < 20.0:
            print(f"ALERT: Low humidity {hum}%")

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect(BROKER, PORT, 60)
client.loop_start()  # non-blocking loop

# Keep the script running for 30 seconds (sandbox timeout)
import time
time.sleep(30)

How it works:
1. The AI agent connects to the same MQTT broker as the ESP32.
2. It subscribes to sensor topics (home/sensor/temperature, home/sensor/humidity).
3. When a temperature reading arrives, it checks the threshold (30°C) and publishes a command to home/actuator/relay.
4. The ESP32 receives the command and toggles the relay.
5. The AI also listens for natural language commands via the chat interface, parses them, and publishes the appropriate MQTT message.

Advanced Scenario: Voice Control and Scheduling

With ASI Biont, you can extend the same setup without any hardware changes. For example:

• Voice control: Say "Turn on the fan" in the chat. The AI recognizes the intent and publishes "on" to the relay topic.
• Scheduled actions: "Turn on the relay every day at 7 AM and turn off at 8 PM." The AI uses the schedule library (available in sandbox) to run a cron-like job.
• Data logging: "Log temperature and humidity to a Google Sheet every hour." The AI writes a script that collects data from MQTT and sends it via Google Sheets API (using requests).

Results and Metrics

In a real test conducted in May 2026, a home automation enthusiast used this exact setup for two weeks. The results:

Why This Matters: No-Code AI for Hardware

ASI Biont connects to any device through its execute_python sandbox. You don’t need to wait for official support—just describe your hardware and protocol in the chat. The AI writes the integration code on the fly using libraries like paho-mqtt, pyserial (via Hardware Bridge), paramiko (SSH), pymodbus, aiohttp, or opcua-asyncio. Everything happens through conversation, not through dashboards or configuration panels.

Conclusion

The ESP32 is a powerful IoT workhorse, but its true potential is unlocked when paired with an intelligent agent. ASI Biont turns your ESP32 into a smart, responsive device that acts on sensor data, voice commands, and schedules—all without manual coding. Whether you’re building a smart home, monitoring a greenhouse, or controlling a workshop, the integration takes minutes.

Try it yourself: Go to asibiont.com, start a chat, and describe your ESP32 setup. The AI will connect, control, and automate—just like that.