Universal Data Middleware

Any data. Any domain.

Intelligent middleware for structured data pipelines — IoT, AI/ML, DeFi, legal, geospatial, supply chain, and beyond. Edge to cloud, any protocol, any scale.

py pip install wire-band-edge
rs cargo add wireband-edge
0+ Domain families
6+ Edge protocols
0 Tests passing
wire.band — live stream
Domain coverage

Every domain.
One pipeline.

IOT
Internet of Things
Sensors, actuators, gateways, GPIO events, device lifecycle, industrial control — any edge device, any topology.
MQTT · BLE · CoAP · Modbus
AI
AI & ML
Model inference events, embedding pipelines, agent telemetry, LLM token streams, ONNX and TFLite edge inference.
Inference · Embeddings · Agents
DEFI
DeFi & Finance
Swap events, liquidity pool changes, token transfers, price feeds, on-chain state transitions, market data streams.
Events · Feeds · Settlements
LEX
Legal & Compliance
Document lifecycle, audit trails, e-signature events, regulatory reporting, contract state machines, compliance signals.
Audit · Signatures · Reporting
GEO
Geospatial
Location events, boundary transitions, coordinate streams, fleet tracking, spatial analytics, map tile pipelines.
Coordinates · Boundaries · Tracks
SCM
Supply Chain
Shipment tracking, inventory deltas, provenance chains, warehouse events, customs milestones, cold-chain telemetry.
Tracking · Provenance · Inventory
MED
Healthcare
Patient vitals, lab results, medical device telemetry, HL7/FHIR event streams, clinical decision signals, wearable data.
Vitals · Devices · FHIR events
SYS
Protocols & Systems
Network telemetry, observability pipelines, infrastructure events, custom protocols — the Theta vocabulary is extensible by design.
Telemetry · Observability · Custom
0+
Domain families
6+
Edge protocols
0
Unit tests
3
Crypto layers
How it works

Source to server,
intelligently routed.

01
📡
Connect at the edge
Connect to MQTT brokers, serial/UART, BLE GATT, CoAP, or Modbus/RTU. The classifier maps incoming events to their domain family in microseconds — no schema configuration required.
Python · Rust
→
02
🔩
Classify & buffer
Each event is classified by domain, encoded via the Theta Protocol, and queued in a 50k-event ring buffer. Batches of up to 200 frames are flushed on interval — delta filtering drops unchanged readings.
Theta Protocol · Ring buffer
→
03
⚡
Server-side processing
On the server, the Rust-accelerated batch processor handles ingest with graceful Python fallback. The intelligent cache deduplicates identical payloads across tenants using content fingerprinting.
Rust · Python fallback
→
04
🔐
Encrypt & stream
Optional AEAD encryption (AES-256-GCM or ChaCha20-Poly1305) with HKDF per-frame key derivation and symbol-space permutation. SSE stream delivers decoded events to consumers in real time.
Forward secrecy · SSE
Features

Built for
any pipeline.

θ
Theta Protocol
A proprietary symbolic vocabulary spanning 16 primary domain families and 14 extended families — IoT, AI, DeFi, legal, geospatial, supply chain, healthcare, and more. Zero imports on constrained devices. Domain coverage is frozen at v1.2.0 and extensible via namespaces.
16 primary families · 14 extended families · v1.2.0
🔐
Layered crypto stack
Three independent, stackable layers: AEAD frame encryption, a Fisher-Yates symbol remapper (65,536-value bijection keyed by 32-byte secret), and HKDF-SHA256 per-frame key derivation for time-windowed forward secrecy. All optional, all zero-config default.
AES-256-GCM · ChaCha20-Poly1305 · HKDF-SHA256
⚡
Intelligent cache
Content fingerprinting strips volatile fields (timestamps, sequence numbers) before caching identical payloads. In-memory LRU or Redis-backed, with per-domain TTL policies and namespace isolation per tenant — dramatically reducing redundant processing.
In-memory LRU · Redis · Per-tenant namespaces
📨
MQTT bridge
Server-side MQTT bridge connects directly to brokers — no edge code required. Longest-match topic routing, TLS, username/password auth, and graceful degradation when the optional MQTT dependency is absent.
mqtts:// · TLS · aiomqtt
🏢
Multi-tenant API
SHA-256 hashed API keys map to isolated cache namespaces and crypto contexts per tenant. Single-tenant mode requires zero config. Bearer auth, constant-time lookup, per-tenant key rotation.
Per-tenant cache · Per-tenant crypto · Bearer auth
🦀
Rust edge client
Full-featured Rust implementation with PyO3 Python bindings on crates.io. Connectors for serial/UART, BLE GATT, CoAP, Modbus/RTU, ONNX and TFLite inference, device twin sync, OTA updates, and watchdog.
wireband-edge v0.2.0 · crates.io · PyO3
Quick start

Streaming in
under a minute.

gateway.py 
import asyncio
from wire_band_edge import WireBandEdgeClient, MQTTConnector

async def main():
    # 50k ring buffer · 200 events/batch · 1s flush
    client = WireBandEdgeClient(
        backend_url="https://wire.band",
        device_id="gateway-01",
    )

    # Topics auto-classified by domain family
    connector = MQTTConnector("mqtt://broker.local:1883")
    await client.run_mqtt(connector, topics=["data/#"])

asyncio.run(main())
main.rs 
use wireband_edge::{WireBandClient, MqttConnector};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let client = WireBandClient::builder()
        .backend_url("https://wire.band")
        .device_id("edge-node-01")
        .build()?;

    let connector = MqttConnector::new(
        "mqtt://broker.local:1883",
        &["data/#"],
    )?;

    client.run_mqtt(connector).await?;
    Ok(())
}
deploy 
# Docker — Redis + Caddy + Wire.Band
docker compose -f docker-compose.prod.yml up -d

# Enable full crypto stack
THETA_ENVELOPE_KEY=$(openssl rand -hex 32)
THETA_SYMBOL_REMAP_KEY=$(openssl rand -hex 32)
THETA_CONTEXTUAL_SALT=1  # HKDF forward secrecy

# Subscribe to live event stream
curl -N https://wire.band/iot/v1/stream

# Pipeline health check
curl https://wire.band/stats
1

Install the edge client

Python: pip install "wire-band-edge[mqtt]" for MQTT support. Rust: cargo add wireband-edge. Zero private dependencies — installs on any constrained device.

2

Point at a server

Deploy the Wire.Band server with docker compose up or run bare with uvicorn. Set backend_url in your edge client — that's it.

3

Connect your data source

MQTTConnector classifies events automatically via longest-match routing. IoT sensors, AI inference results, DeFi events — all classified, encoded, and batched transparently.

4

Stream to your consumers

Subscribe to GET /iot/v1/stream (SSE) for real-time decoded events across all domains. Enable end-to-end encryption with two environment variables.