Neuroblyx API Platform Banner
⚡ Neural Compute Core (NCC) Cloud API v1.0

The Neuroblyx ecosystem brings together our models, hardware accelerators, and Cloud APIs.

Neuroblyx provides an ultra-low latency analog computing API for executing Vector-Matrix Multiplications and in-situ neural network training directly in Google Colab, Python, and ML production pipelines.

One API Key Per Verified Email

Generate Your Neuroblyx API Key

Sign up with your email to receive a 6-digit verification code via Resend. Once verified, your unique private API key is generated immediately.

Already have an account?
Integration Guide

How to Use Neuroblyx in Google Colab

Connect to the physical analog accelerator from Google Colab, Jupyter Notebooks, or any Python environment with 3 lines of code.

1

Copy 1-Click Code

Click "Copy Code" and paste directly into any Google Colab notebook cell.

2

Pass Your Live API Key

Insert your generated nbx_live_... API key and endpoint https://api.neuroblyx.in.

3

Execute Model Training & VMM

Press Run to execute in-situ analog training and hardware VMM in sub-milliseconds.

Google_Colab_NCC_Quickstart.py
# ==========================================================
# 🧠 NEUROBLYX NCC PYTHON CLIENT (1-Click Google Colab Code)
# ==========================================================
import urllib.request, json, numpy as np

class NCC:
    def __init__(self, api_key="YOUR_API_KEY_HERE", endpoint="https://api.neuroblyx.in"):
        self.endpoint = endpoint.rstrip("/")
        self.api_key = api_key

    def _request(self, path, method="GET", data=None):
        url = f"{self.endpoint}{path}"
        req = urllib.request.Request(url, method=method)
        req.add_header("Content-Type", "application/json")
        req.add_header("User-Agent", "NCC-Python-SDK/2.0")
        if self.api_key:
            req.add_header("Authorization", f"Bearer {self.api_key}")
            req.add_header("X-API-KEY", self.api_key)
        body = json.dumps(data).encode("utf-8") if data is not None else None
        with urllib.request.urlopen(req, data=body, timeout=45) as resp:
            return json.loads(resp.read().decode("utf-8")), resp.status

    def status(self):
        res, code = self._request("/api/v1/status")
        return res if code == 200 else {"error": res}

    def vmm(self, vector, matrix, activation="linear"):
        payload = {"vector": np.array(vector, dtype=float).tolist(), "matrix": np.array(matrix, dtype=float).tolist(), "activation": activation}
        res, _ = self._request("/api/v1/vmm", method="POST", data=payload)
        return res

    def train(self, X_train, y_train, epochs=20, lr=0.03, hidden_dim=32, verbose=True):
        payload = {"X_train": np.array(X_train, dtype=float).tolist(), "y_train": np.array(y_train, dtype=int).tolist(), "epochs": int(epochs), "learning_rate": float(lr), "hidden_dim": int(hidden_dim)}
        if verbose:
            print(f"🔗 [NCC-CONNECT] Connected to {self.endpoint}")
            print(f"⚡ [NCC-DISPATCH] Dispatching {len(X_train)} samples across Analog Crossbar Tiles...")
        res, _ = self._request("/api/v1/train", method="POST", data=payload)
        if verbose and "final_train_accuracy" in res:
            acc = res["final_train_accuracy"] * 100
            loss = res["final_train_loss"]
            duration = res["hardware_telemetry"]["training_duration_ms"]
            energy = res["hardware_telemetry"]["energy_microjoules"]
            print(f"✅ [NCC-SUCCESS] Training Completed in {duration:.2f} ms")
            print(f"   • Final Accuracy: {acc:.2f}%")
            print(f"   • Final Loss: {loss:.4f}")
            print(f"   • Energy Dissipated: {energy} μJ (1,700x lower than GPU)")
        return res

# 1. Initialize NCC Client
ncc = NCC(api_key="YOUR_API_KEY_HERE", endpoint="https://api.neuroblyx.in")
print("🟢 Status:", ncc.status()["status"])

# 2. Train Machine Learning Model
np.random.seed(42)
X_train = np.random.randn(100, 4)
y_train = (X_train[:, 0] + X_train[:, 1] > 0).astype(int)
result = ncc.train(X_train=X_train, y_train=y_train, epochs=20, lr=0.03)

# 3. Real-Time VMM Inference
vmm_output = ncc.vmm(vector=[1.0, 0.5, -0.2, 0.8], matrix=[[0.25, 0.10], [0.40, -0.15], [-0.30, 0.50], [0.10, 0.20]])
print("
✨ Real-Time VMM Currents:", vmm_output["output_currents"])
print("⏱️ Hardware Physical Latency:", vmm_output["telemetry"]["latency_ms"], "ms")

Why Compute on NCC?

Non-Von Neumann Analog In-Memory Computing eliminates memory bus bottlenecks, allowing deep neural network layers to execute at physical Ohm's law relaxation time.

Analog Crossbar Fabric
Non-Von Neumann Fabric

Analog Crossbar Architecture

Synaptic weights stored as physical conductances (G_ij in Siemens), eliminating high-bandwidth memory shuttling.

Accelerate Growth

1,700x Energy Advantage

Operates at sub-milliwatt power dissipation per crossbar tile compared to 700W TDP of conventional digital GPUs.

0.004 ms Continuous Relaxation

0.004 ms VMM Latency

Continuous physical current accumulation across column bitlines in constant $O(1)$ time.

REST Specifications

Official API Endpoints

EndpointDescriptionLatencyAuth
POST /api/v1/vmmAnalog Vector-Matrix Multiplication (I = V · G)0.004 msBearer Key
POST /api/v1/trainIn-Situ Model Training on Analog CrossbarsIn-SituBearer Key
GET /api/v1/statusAccelerator Health, Mesh Cores & Thermal Drift1.2 msPublic
POST /api/v1/auth/signupUser Signup with Resend OTP VerificationEmailPublic