OPC-UA to AI: How to Connect Your SCADA to ASI Biont for Predictive Maintenance Without Writing Code

From SCADA Screens to Smart Alerts

If you work in industrial automation, you know the pain: your SCADA system logs thousands of tags every second—temperatures, pressures, flow rates, vibration levels—but turning that raw data into actionable insights usually requires a dedicated data science team. You set up thresholds, get false alarms, or miss early signs of failure until it's too late.

ASI Biont changes that. Instead of building a separate analytics pipeline, you connect your OPC-UA server directly to an AI agent that reads your tags, detects anomalies, predicts failures, and sends alerts to Telegram or Slack—all through a chat conversation. No dashboards, no YAML configs, no waiting for IT. You just describe what you need, and the AI writes the integration code on the fly.

Why OPC-UA?

OPC-UA (Unified Architecture) is the standard for industrial communication. It's platform-independent, secure, and used by every major SCADA, DCS, and PLC vendor—Siemens, Rockwell, Schneider, ABB, Honeywell. Unlike older protocols (Modbus, Profibus), OPC-UA supports data types, historical access, alarms, and complex structures. Your factory floor probably already exposes hundreds of tags via OPC-UA. The problem is that reading them programmatically usually requires C#, Java, or Python expertise, plus a deep understanding of the tag hierarchy.

ASI Biont bridges this gap. The AI agent uses the industrial_command tool with the opcua-asyncio library to connect to any OPC-UA server, browse the address space, read variable values, and even write setpoints—all from a chat message.

How the Integration Works

Connection Method: OPC-UA via industrial_command

ASI Biont connects to your OPC-UA server using the opcua-asyncio library (also known as asyncua). The AI agent uses the industrial_command tool with two primary commands:
- read_variable – reads the current value of a tag/node
- write_variable – writes a value to a tag/node

You provide the server endpoint (e.g., opc.tcp://192.168.1.100:4840), and optionally a username/password or certificate if your server uses authentication. The AI handles the rest.

Step-by-Step: Connecting a Temperature Sensor from a SCADA

Imagine you have an OPC-UA server running on a Siemens WinCC system at opc.tcp://192.168.1.100:4840. It contains a tag Line1.Oven.Temperature that updates every second. You want the AI to monitor this tag, detect when the temperature exceeds 250°C, and send a Telegram alert.

Here's what you type in the chat:

"Connect to OPC-UA server at opc.tcp://192.168.1.100:4840. Read tag Line1.Oven.Temperature every 30 seconds. If it goes above 250°C, send me a Telegram message with the timestamp and value. Also log the value to a CSV file every hour."

The AI agent responds by generating and executing a Python script in the execute_python sandbox. Here's a simplified version of the code it would write:

import asyncio
from asyncua import Client
import csv
from datetime import datetime

SERVER_URL = "opc.tcp://192.168.1.100:4840"
TAG = "Line1.Oven.Temperature"
THRESHOLD = 250.0

async def monitor_temperature():
    async with Client(url=SERVER_URL) as client:
        # Connect to server
        await client.connect()
        print(f"Connected to {SERVER_URL}")

        # Get the node for the tag
        node = client.get_node(TAG)

        # Open CSV for logging
        with open('temperature_log.csv', 'a', newline='') as csvfile:
            writer = csv.writer(csvfile)

            while True:
                # Read the value
                value = await node.read_value()
                timestamp = datetime.now().isoformat()
                print(f"{timestamp} - Temperature: {value}°C")

                # Check threshold
                if value > THRESHOLD:
                    # Send Telegram alert (using aiohttp)
                    # ... (AI would include actual Telegram send code)
                    print(f"ALERT: Temperature {value}°C exceeded {THRESHOLD}°C at {timestamp}")

                # Log every hour (simplified: log every read for demo)
                writer.writerow([timestamp, value])

                await asyncio.sleep(30)

asyncio.run(monitor_temperature())

Important: The script runs in the ASI Biont sandbox with a 30-second timeout. For continuous monitoring, the AI would use a different approach—like a scheduled task or a persistent agent—but the principle is the same: you describe the logic, AI writes the code.

Real-World Use Case: Predictive Maintenance for a Compressor

Let's say you have a compressor with three critical tags exposed via OPC-UA:
- Compressor.Motor.Temperature
- Compressor.Vibration.Level
- Compressor.Pressure.Output

You want the AI to:
1. Read all three tags every 60 seconds
2. If motor temperature > 90°C, send a Slack warning
3. If vibration > 5.0 mm/s, log the incident and send an email to maintenance
4. If pressure drops below 6 bar, automatically write a setpoint to increase the relief valve opening

Here's how you'd describe it in the chat:

"Monitor Compressor.Motor.Temperature, Compressor.Vibration.Level, and Compressor.Pressure.Output from the OPC-UA server at opc.tcp://192.168.1.50:4840. Alert on Slack if temperature > 90°C. If vibration > 5.0, log to a file and email maintenance@factory.com. If pressure < 6 bar, write 75 to tag Compressor.ReliefValve.Setpoint."

The AI would generate a script using asyncua, slack_sdk, and smtplib (or sendgrid). It would handle the OPC-UA write with:

relief_node = client.get_node("Compressor.ReliefValve.Setpoint")
await relief_node.write_value(75.0)

No need to learn the OPC-UA specification—the AI knows how to browse the address space, handle data types, and manage connections.

Why This Beats Traditional Approaches

Connecting Any Device Without Waiting

ASI Biont doesn't just support OPC-UA. The AI can connect to any device that speaks a protocol from the list: Modbus/TCP, Siemens S7, BACnet, EtherNet/IP, CAN bus, MQTT, SSH, serial (via Hardware Bridge), HTTP API, gRPC, CoAP, and more. If your device isn't in the list, the AI can still connect via execute_python—it writes a custom Python script using any of the 80+ pre-installed libraries (pyserial, paramiko, paho-mqtt, aiohttp, etc.).

You just describe the device and its parameters:

"Connect to my Siemens S7-1200 at 192.168.1.200 via snap7, read DB1.DBW0 and DB1.DBW2 every 10 seconds, and log to PostgreSQL."

The AI generates the code, runs it, and starts collecting data. No plugin installation, no SDK downloads.

Practical Tips for OPC-UA Integration

1. Server Discovery

Before connecting, you need the server endpoint. In most SCADA systems, it's listed in the OPC-UA configuration (e.g., Siemens WinCC: opc.tcp://<IP>:4840). If you're not sure, use an OPC-UA client like UaExpert to browse the server—it shows the exact endpoint and available tags.

2. Authentication

If your server uses username/password, include it in your description:

"Connect to opc.tcp://192.168.1.100:4840 with username 'admin' and password 'pass123'"

The AI will pass these to the Client constructor.

3. Tag Paths

OPC-UA tags are identified by node IDs (e.g., ns=2;i=1234) or browse paths (e.g., Objects/Line1/Temperature). The AI can browse the address space automatically if you're unsure—just ask:

"Browse the OPC-UA server at opc.tcp://192.168.1.100:4840 and list all tags under Line1"

The AI will call client.browse() and return the structure.

4. Data Types

OPC-UA supports integers, floats, strings, arrays, and custom structures. The AI handles type conversion automatically. If you need a specific format (e.g., round to 2 decimal places), just mention it.

From Chat to Production

The beauty of this approach is that you can start with a simple monitoring script and evolve it into a full predictive maintenance system without ever leaving the chat. Want to add a dashboard? Ask the AI to generate a CSV upload to Google Sheets. Need a daily report? Ask for an email summary every morning. The AI remembers the context and builds on previous conversations.

For example, after the initial temperature monitoring, you could say:

"Now also calculate the rate of temperature change. If it rises more than 5°C per minute, send an urgent SMS."

The AI would modify the script, adding a moving window calculation and integrating Twilio for SMS.

Conclusion

Connecting your OPC-UA SCADA to an AI agent isn't science fiction—it's a chat message away. ASI Biont lets you tap into your industrial data without writing a single line of Python yourself. The AI does the heavy lifting: it browses tags, reads values, detects anomalies, sends alerts, and even writes back to the controller. Whether you're monitoring a single oven or an entire factory floor, the process is the same: describe what you need, and the AI delivers.

Stop waiting for IT to build your predictive maintenance pipeline. Try it today at asibiont.com and connect your first OPC-UA server in minutes.