Zevionix Developers & API Reference

# 1. Add the official Zevionix Enterprise Helm repository
$ helm repo add zevionix https://charts.zevionix.ai
$ helm repo update

# 2. Deploy AURA Enterprise Core SDK with NVIDIA TensorRT & TLS
$ helm install aura-mesh zevionix/aura-enterprise \
  --namespace zevionix-system \
  --create-namespace \
  --set telemetry.tls=true \
  --set telemetry.protocol="quic-grpc" \
  --set vision.gpuAcceleration="nvidia-tensorrt-fp8" \
  --set agentMesh.workerReplicas=32 \
  --set finOps.autonomousHarvesting=true

# 3. Verify deployment cluster status
$ kubectl get pods -n zevionix-system -l app=aura-core

version: '3.8'
services:
  aura-core-engine:
    image: registry.zevionix.ai/aura-core:v3.4-cuda12.4
    restart: always
    ports:
      - "8080:8080"   # REST / Telemetry Ingest
      - "9090:9090"   # Sub-ms gRPC / QUIC Stream
    environment:
      - AURA_CLUSTER_ID=us-east-dgx-h100-node04
      - GPU_ACCEL_MODE=NVIDIA_TENSORRT_FP8
      - TLS_ENCLAVE_ENABLED=true
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

// Cargo.toml: zevionix-aura = { version = "3.4", features = ["tensorrt", "quic"] }
use zevionix_aura::{AuraMeshClient, IngestPayload, StreamConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = AuraMeshClient::connect("quic://api.zevionix.ai:9090")
        .with_hardware_enclave("/etc/aura/vault.key")
        .with_tensorrt_fp8()
        .await?;

    let payload = IngestPayload::new("camera-yolo-edge-01")
        .with_fps(120)
        .with_metric("p99_latency", 0.42);

    let response = client.ingest_telemetry(&payload).await?;
    println!("AURA Node Committed Hash: 0x{:x}", response.hash);
    Ok(())
}

# pip install zevionix-aura
import asyncio
from zevionix import AuraCoreMesh, TelemetryFrame

async def stream_edge_telemetry():
    client = AuraCoreMesh(
        endpoint="https://api.zevionix.ai",
        api_key="zvx_sec_enclave_9942a",
        gpu_accel=True
    )
    
    # Transmit 120 FPS YOLO spatial frames with sub-millisecond SLA
    frame = TelemetryFrame(
        edge_id="camera-yolo-edge-99",
        detected_objects=["person", "defect_gear"],
        confidence=0.9942
    )
    receipt = await client.telemetry.ingest(frame)
    print(f"Payload Hash: {receipt.tx_hash} | Latency: {receipt.latency_ms}ms")

asyncio.run(stream_edge_telemetry())

# 1. Install AURA Edge Agent on Ubuntu 22.04 / JetPack 6.0
$ curl -sSL https://get.zevionix.ai/edge-agent.sh | bash

# 2. Authenticate edge gateway with Zero-Trust Enclave
$ aura-edge provision \
  --token "zvx_edge_token_9942" \
  --cluster "us-east-dgx-h100-node04" \
  --accel "tensorrt-fp8"

# 3. Stream RTSP Camera Video (120 FPS / YOLOv10 spatial parsing)
$ aura-edge ingest rtsp://192.168.1.100:554/live --fps 120 --yolo-stream

# 4. K3s Lightweight Cluster Edge Node Join
$ k3s agent --server https://cluster.zevionix.ai:6443 --token zvx_edge_k3s_token