10 free hours of engineering. · 1-hour scoping call up front — we'll start this week.Claim hours →
Remote monitoring

Watch the floor from anywhere.

The Bridge turns equipment you could only see on-site into a live feed you can watch from a browser. Field devices in, one encrypted WebSocket out, real-time dashboards on the other side.

On-site · the plant network
DataVisions Bridge
A signed Rust client on your Windows server. Reads equipment over the protocols you already run — and streams it out over one outbound, encrypted WebSocket. No inbound ports.
OPC-UAModbusMQTTSensors
Real-time telemetry
Sensor readings
Equipment status
Energy production
Environmental data
Secure
WebSocket
TLS · tenant-scoped
tenant.app.datavisions.ai · Remote Monitoring
Throughput
1,284▲ 4%
Uptime
all sites online
Live status · 4 sites · 38 devices
Why a native client

Outbound-only. Signed. Auditable.

The Bridge runs on the customer's Windows server inside their plant network. It opens one outbound WebSocket to the platform. No inbound ports, no VPN tunnels, no jump boxes.

MSIX-installed

Signed by us, deployable through your existing Windows distribution. Updates are atomic.

Embedded Python

Bridge tool authors get Python's ecosystem for OPC-UA, Modbus, and SCADA libraries — packaged in.

Tool sync over WS

When the platform deploys a new tool, the bridge fetches and warms it within seconds.

Tenant-scoped

Each bridge is bound to a single tenant. It cannot service another.

Data Visions Client Bridge · v2.1.0 · Windows
The DataVisions Bridge client installed on a Windows server — connection status, managed folders, tool executions
How a bridge tool runs

Dispatch flow.

01 · cloud
Agent / API call
@platform_tool(target='bridge')
RBACaudit
02 · ws
WebSocket dispatch
Tenant-scoped channel
JSON envelopetls
03 · bridge
Bridge runtime
Python tool function
opc-uamodbusscada
04 · floor
PLC / SCADA / sensor
The thing on the floor
readwritesubscribe
# modules/scada_ops/bridge_tools.py — runs on the bridge, not the cloud

from platform.sdk import platform_tool, BridgeContext
from asyncua import Client

@platform_tool(
    name="scada.read_throughput",
    description="Read live throughput from the OPC-UA server.",
    target="bridge",
    roles=["operator", "supervisor"],
)
async def read_throughput(
    ctx: BridgeContext,
    line_id: str,
) -> dict:
    async with Client(url=ctx.secret("opcua_url")) as c:
        node = c.get_node(f"ns=2;s=Line.{line_id}.Throughput")
        value = await node.read_value()
        return {"line": line_id, "throughput": value}
Reach

Speaks the protocols you'd expect.

OPC-UA
Read, write, subscribe. Tested against KEPServerEX and standard PLC OPC servers.
Modbus
TCP/RTU. Polling cadence configurable per tool.
MQTT
Subscribe to topic patterns. Bridge into the agent's event stream.
ODBC / OLE-DB
Legacy historians and PI System adapters.
REST / SOAP
Internal-network APIs the cloud can't reach.
Files / SMB
Drop folders, shift reports, batch outputs.
Sensors
USB-attached test equipment via the embedded Python.
Custom
Anything Python can talk to. The bridge is a sandbox, not a wall.