Raspberry Pi HDMI Displays Meet AI: How ASI Biont Turns Chat into Digital Signage

Picture this: you walk into a busy café and the digital menu board instantly updates to show today's specials, pulled from a database. No one touched an SD card. No one opened a terminal. The display is a Raspberry Pi connected to an HDMI monitor, and the command came from a chat message to an AI agent. This is not a futuristic fantasy — it's what happens when you connect a Raspberry Pi to ASI Biont, an AI agent that integrates with hardware through natural language.

ASI Biont isn't a device-specific platform. It doesn't have a 'Raspberry Pi' plugin. Instead, it uses a universal mechanism called execute_python: the agent writes a Python script for your exact device and runs it in a sandbox. Whether it's an industrial controller over Modbus, a sensor over a COM port, or this Pi over SSH, you just describe the task in chat, and the AI handles the integration.

The Problem with Traditional Digital Signage

Raspberry Pi has become the de facto standard for DIY digital signage. It's affordable (the Pi 5 with 8GB costs around $80, while older models are even cheaper), runs a full Linux distribution, and outputs 4K HDMI. According to the official Raspberry Pi documentation, it supports both HDMI and DSI displays, making it ideal for menu boards, info kiosks, and office dashboards.

However, the typical workflow for updating content is far from pleasant. You either SSH into the box, edit HTML or image files, or build a custom web application. If you have multiple displays, you need multiple configuration files and a maintenance headache. Non-technical staff can't make changes without calling IT. This is where an AI agent changes everything.

Why ASI Biont?

ASI Biont is an AI agent that connects to hardware devices through a chat interface. It supports a wide range of industrial and consumer protocols: COM ports (RS-232/RS-485) via a Hardware Bridge, MQTT via paho-mqtt, Modbus/TCP via pymodbus, SSH via paramiko, HTTP APIs/WebSockets via aiohttp, OPC-UA via opcua-asyncio, Siemens S7 via snap7, BACnet via bac0, EtherNet/IP via pycomm3, CAN bus via python-can, gRPC, CoAP, and more. For a device like the Raspberry Pi, the two most practical methods are SSH and MQTT. Both are implemented through execute_python, meaning the AI writes the code on the fly.

Connection Methods at a Glance

The table below shows the two main approaches for HDMI displays, plus a third you might consider for web-based dashboards:

In this article, we focus on SSH and MQTT.

Hardware Setup: What You Need

The hardware part is trivial. Connect the HDMI output of the Raspberry Pi to any monitor or TV with an HDMI input. The Pi should be powered, running Raspberry Pi OS (Bullseye or later), and have network access (Ethernet or Wi-Fi). Here's the topology:

+------------------+     HDMI      +------------------+       Network       +------------------+

|  HDMI Monitor    | <-----------> |  Raspberry Pi    | <-----------------> |   ASI Biont      |
|  (any TV/screen) |               |  192.168.1.100   |                     |  (AI chat agent) |
+------------------+               +------------------+                     +------------------+

For SSH, you need to know the Pi's IP address or use its hostname (e.g., raspberrypi.local). For MQTT, you'll need a broker. You can run Mosquitto on a separate server or even on the Pi itself.

Example 1: SSH Integration — Display Text from a Chat Command

Let's walk through a real scenario. Suppose you want a lobby display to greet visitors. You send the following message to ASI Biont:

"Connect to my Raspberry Pi at 192.168.1.100 via SSH. User is pi, password is raspberry. Display the text 'Welcome to Acme Corp' on the HDMI screen using pygame. Make it look nice."

ASI Biont's AI agent decomposes this task and writes a Python script using paramiko. Here's the generated code (with comments):

import paramiko

# Connect to the Raspberry Pi
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.100', username='pi', password='raspberry')

# Upload a reusable renderer script
sftp = ssh.open_sftp()
renderer = '''
import pygame, sys
pygame.init()
screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
font = pygame.font.Font(None, 72)
text = font.render(sys.argv[1], True, (255, 255, 255))
screen.fill((0, 0, 0))
screen.blit(text, (100, 100))
pygame.display.flip()
'''
with sftp.open('/home/pi/render_text.py', 'w') as f:
    f.write(renderer)
sftp.close()

# Execute the renderer with the message
stdin, stdout, stderr = ssh.exec_command(
    "python3 /home/pi/render_text.py 'Welcome to Acme Corp'"
)
print(stdout.read().decode())

ssh.close()

After executing this, the HDMI monitor shows "Welcome to Acme Corp" in large white text on a black background. The Pi doesn't need an X server; pygame runs in fullscreen mode directly on the framebuffer. (If you run into permission issues, make sure the script is executed with sudo or the pi user has access to the framebuffer.)

The beauty is that the AI wrote this code in seconds. It knows the paramiko API, the pygame API, and how to handle the Pi's user environment. You didn't have to look up any documentation.

Example 2: MQTT Integration — Multi-Display Content Updates

Now imagine a retail chain with three Raspberry Pi displays showing promotions. You want to change the content on all of them simultaneously from a central dashboard or directly from a chat command. MQTT is perfect here.

First, each Pi runs a listener script that subscribes to a topic, for example display/command. The listener receives JSON payloads and renders them. You can install this script on the Pi using SSH (as shown above) or it can be pre-installed. Here's the listener code that runs on the Pi:

import paho.mqtt.client as mqtt
import subprocess

def on_message(client, userdata, msg):
    # msg.payload is a JSON string
    payload = msg.payload.decode('utf-8')
    subprocess.run(['python3', '/home/pi/render_payload.py', payload])

client = mqtt.Client()
client.connect('192.168.1.50', 1883, 60)  # broker address
client.subscribe('display/command')
client.on_message = on_message

# This loop runs forever on the Pi
client.loop_forever()

On the ASI Biont side, the user simply has to tell the AI:

"Publish a message to all displays: 'Summer Sale — 20% off all drinks'."

The AI generates a short publisher script:

import paho.mqtt.client as mqtt

client = mqtt.Client()
client.connect('192.168.1.50', 1883, 60)
client.publish('display/command', '{"text": "Summer Sale — 20% off all drinks", "duration": 30}')
client.disconnect()

All three displays update within milliseconds. The listener on each Pi decodes the JSON and renders it. This is de-coupled architecture at its best: the AI agent doesn't need to know each Pi's IP address; it only needs the broker's address.

Advanced Scenario: Dynamic Content with a Weather API

Let's step up the complexity. Suppose you want the lobby display to show the current weather and today's schedule. You can describe the task in natural language:

"Every morning at 9 AM, fetch the weather from an API and display
it on the lobby screen at reception. The ASI Biont can generate a complete Python script that fetches the data, parses it, and publishes it to the broker — no manual wiring needed:

```python
import requests
import json
import paho.mqtt.client as mqtt

Fetch weather data

api_key = 'YOUR_API_KEY'
city = 'Berlin'
url = f'https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric'
response = requests.get(url)
data = response.json()

Build the display payload

payload = {