Build focused intelligence into your website.

01 / Intermediate language

IR is the boundary, not the interface.

Training frameworks are good at creating models. Target runtimes are good at executing them. Robotron IR keeps those two concerns separate by describing the model graph, tensors, tokenizer, task metadata, labels, limits, and integrity records in a versioned artifact.

02 / Node.js backend

Load the engine when the service starts.

Import the server-facing wrapper, load the IR artifact from a private local path, and reuse the same engine for every request. The JavaScript backend is the portable default for Node.js; select another target runtime when deploying to ARM, CUDA, or custom silicon.

// src/inference.js
  import { RobotronInferenceEngine } from "../cmir-web/backend.js";
  
  export const inference = await RobotronInferenceEngine.load({
    modelPath: new URL("../models/content-model.ir", import.meta.url),
    task: "generation",
    backend: "js",
    activationQuantization: "int8",
  });
  
  console.log("Robotron inference ready", inference.health());

03 / HTTP integration

Expose a narrow backend endpoint.

The endpoint owns validation and generation policy. The caller sends business input—not engine configuration—and receives only the fields the application contract allows.

// src/server.js
  import http from "node:http";
  import { inference } from "./inference.js";
  
  const server = http.createServer(async (request, response) => {
    if (request.method !== "POST" || request.url !== "/api/content/analyze") {
      response.writeHead(404).end();
      return;
    }
  
    try {
      const chunks = [];
      for await (const chunk of request) chunks.push(chunk);
      const { title, body } = JSON.parse(Buffer.concat(chunks));
  
      if (typeof title !== "string" || typeof body !== "string") {
        throw new TypeError("title and body must be strings");
      }
      if (!body.trim() || body.length > 20_000) {
        throw new RangeError("body must contain 1 to 20,000 characters");
      }
  
      const prompt = `title: ${title}\nbody: ${body}\nlabels:`;
      const result = inference.generate(prompt, {
        maxNewTokens: 64,
        temperature: 0,
        topK: 1,
      });
  
      response.writeHead(200, { "Content-Type": "application/json" });
      response.end(JSON.stringify({ output: result.continuation }));
    } catch (error) {
      const status = error instanceof TypeError || error instanceof RangeError ? 400 : 500;
      response.writeHead(status, { "Content-Type": "application/json" });
      response.end(JSON.stringify({ error: status === 400 ? error.message : "Inference failed" }));
    }
  });
  
  server.listen(3000);

04 / Service lifecycle

One engine, many requests.

1. 1
   Start

   Resolve the model version, load the IR artifact, verify integrity, and initialize the selected execution backend.

2. 2
   Warm

   Run a representative request before the instance enters the load balancer so initialization cost never reaches a user.

3. 3
   Serve

   Validate inputs, bound work, execute inference, and publish latency plus task metrics without logging sensitive content.

4. 4
   Drain

   Stop accepting new work, finish in-flight requests, call inference.close(), and then terminate the process.

async function shutdown(signal) {
    console.info(`${signal}: draining inference service`);
    server.close(() => {
      inference.close();
      process.exit(0);
    });
  }
  
  process.on("SIGTERM", () => shutdown("SIGTERM"));
  process.on("SIGINT", () => shutdown("SIGINT"));

05 / Content model

Use classification for structured decisions.

For classification models, load the taxonomy beside the IR artifact. The backend returns a task result and runtime metrics; your API should map that internal result into the smaller public schema used by the content-management system.

const contentClassifier = await RobotronInferenceEngine.load({
    modelPath: new URL("../models/content-classifier.ir", import.meta.url),
    taxonomyPath: new URL("../models/content-taxonomy.json", import.meta.url),
    task: "classification",
    backend: "js",
  });
  
  const { result, metrics } = contentClassifier.classify(articleText);
  
  // Keep metrics internal; return only the application contract.
  const response = {
    category: result.primary_label,
    confidence: result.confidence,
    action: result.action,
  };

06 / Target runtime

Keep the API stable while the engine changes.

The backend contract remains the same when the execution target changes. Package the IR artifact with the engine built for the destination hardware, run target-specific parity tests, and switch traffic only after the new service passes its health gate.

07 / IR contract

What the intermediate language carries.

Runtime compatibility

EmbeddingRMSNormLayerNormLinearSplitReshape TransposeRoPEScaledDotProductAttentionAddMulGELU PositionIdsSequencePool

An exporter must target the operation subset, tokenizer implementation, data types, and quantization schemes supported by the deployed engine. Unsupported operations fail during loading or execution; they are never silently approximated.

08 / Production gate

Ship the model and service as one release.

• Pin the artifact. Deploy an immutable model version and record its digest in the service release.
• Keep it private. Store IR files outside public static roots and grant read access only to the inference process.
• Validate parity. Compare the exported model with its PyTorch checkpoint on a held-out fixture set.
• Bound requests. Enforce body size, sequence length, generation length, timeouts, concurrency, and rate limits.
• Separate readiness from liveness. Readiness requires a loaded model; liveness only proves the process can respond.
• Protect data. Avoid logging prompts and documents by default; record identifiers, timings, model version, and error class.
• Roll back atomically. Keep the prior engine and artifact pair available until the new release passes live checks.

GET /health/live
  200 { "status": "alive" }
  
  GET /health/ready
  200 {
    "status": "ready",
    "model": "content-model@2026-08-30",
    "task": "classification",
    "backend": "js"
  }

09 / Diagnostics

Troubleshooting