ai-compute-radar 0.0.0-stage → 1.2.1

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 AI Compute Radar (https://aicomputeradar.dev)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The data the bridged server returns is licensed separately: CC BY 4.0,
+attribution "AI Compute Radar (https://aicomputeradar.dev)".

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# ai-compute-radar
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+MCP server for questions that usually end in a guess: will this open model run on my GPU or Mac, what does a GPU-hour cost right now, which open models are gaining attention this week.
+
+This package is a stdio bridge to the hosted server at `https://aicomputeradar.dev/api/mcp`. It holds no data, keeps no cache, sends no telemetry and needs no key; it forwards each JSON-RPC message and writes the answer back. Clients that speak Streamable HTTP can use the URL directly and do not need it.
+
+## Install
+
+Claude Desktop, Claude Code, Cursor and other stdio clients:
+
+```json
+{
+  "mcpServers": {
+    "ai-compute-radar": {
+      "command": "npx",
+      "args": ["-y", "ai-compute-radar"]
+    }
+  }
+}
+```
+
+Claude Code, one line:
+
+```bash
+claude mcp add ai-compute-radar -- npx -y ai-compute-radar
+```
+
+Clients that speak Streamable HTTP (no package needed):
+
+```json
+{
+  "mcpServers": {
+    "ai-compute-radar": { "url": "https://aicomputeradar.dev/api/mcp" }
+  }
+}
+```
+
+## Tools
+
+- **find_fit** — which tracked models run on a given GPU or Mac at a chosen context length. Weights are measured from the GGUF file listing, the context cache is computed from the model's config, the runtime allowance is a declared assumption; every fit says which part is which (`basis`). Verdicts EXCELLENT / GOOD / TIGHT / OFFLOAD_REQUIRED / UNKNOWN with the arithmetic behind each.
+- **gpu_prices** — the price board: eight GPU classes (RTX 3090 to B200) against eight sources (Vast.ai and Clore.ai marketplace medians, RunPod's posted price, AWS, Azure, Oracle Cloud, Lambda and Nebius list prices), per GPU-hour, with offer counts and the Rent Index.
+- **trending_models** — tracked open models ranked by Heat Score, a published composite of Hugging Face downloads, trending rank and likes, with the raw signals.
+- **list_hardware** — the hardware profiles the fit engine knows, with usable memory after margins.
+- **weekly_pick** — one model a week chosen by a fixed rule, with its readings frozen at selection time.
+
+Every response carries `meta.source` (live or fallback) and `meta.collectedAt`. There are no benchmarks, no speed figures and no forecasts; the server says what was measured and nothing else.
+
+## Try it
+
+"Which open models run comfortably on an RTX 4090 at 16K context, and what is the largest one?"
+"What does an H100 hour cost right now across marketplaces and clouds, and which source is cheapest?"
+"Show me this week's pick and whether it fits a 12 GB card at 32K context."
+
+## Options
+
+- `--url <endpoint>` or `AI_COMPUTE_RADAR_URL` — another endpoint (a local build, for example).
+- `--version`, `--help`.
+
+## Licence
+
+Code MIT. Data CC BY 4.0, attribution "AI Compute Radar (https://aicomputeradar.dev)". Method: https://aicomputeradar.dev/methodology · Docs and REST API: https://aicomputeradar.dev/developers

package/bin.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { DEFAULT_URL, VERSION, run } from "./bridge.mjs";
+
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  process.stderr.write(
+    `ai-compute-radar ${VERSION} — stdio bridge to the AI Compute Radar MCP server\n` +
+      `Usage: ai-compute-radar [--url <endpoint>]\n` +
+      `Default endpoint: ${DEFAULT_URL} (or AI_COMPUTE_RADAR_URL)\n` +
+      `Tools: trending_models, find_fit, gpu_prices, list_hardware, weekly_pick\n` +
+      `Docs: https://aicomputeradar.dev/developers\n`,
+  );
+  process.exit(0);
+}
+if (args.includes("--version") || args.includes("-v")) {
+  process.stdout.write(`${VERSION}\n`);
+  process.exit(0);
+}
+const flag = args.indexOf("--url");
+const url = flag >= 0 && args[flag + 1] ? args[flag + 1] : process.env.AI_COMPUTE_RADAR_URL || DEFAULT_URL;
+
+// stdin closing means the client is gone; leave with it instead of idling on an open handle.
+run({ url }).then(
+  () => process.exit(0),
+  (error) => {
+    process.stderr.write(`ai-compute-radar: ${error?.message ?? error}\n`);
+    process.exit(1);
+  },
+);

package/bridge.mjs

@@ -0,0 +1,106 @@
+/*
+ * ai-compute-radar — stdio bridge to the hosted MCP server.
+ *
+ * Clients that only speak stdio start this file; every JSON-RPC message
+ * they write is POSTed unchanged to https://aicomputeradar.dev/api/mcp
+ * (Streamable HTTP, stateless, no auth) and every message the server
+ * answers is written back, one JSON object per line. No data lives here:
+ * no cache, no telemetry, no keys. Node 18 or newer, no dependencies.
+ */
+
+export const DEFAULT_URL = "https://aicomputeradar.dev/api/mcp";
+export const VERSION = "1.2.1";
+
+/** Messages in a text/event-stream body, in order; non-JSON data lines are skipped. */
+export function parseSseMessages(text) {
+  const messages = [];
+  for (const event of text.split(/\r?\n\r?\n/)) {
+    const data = event
+      .split(/\r?\n/)
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trimStart())
+      .join("\n");
+    if (!data) continue;
+    try {
+      messages.push(JSON.parse(data));
+    } catch {
+      // A keep-alive or a partial line is not a message.
+    }
+  }
+  return messages;
+}
+
+/** Messages in a response body of either kind the server sends. */
+export function parseBody(contentType, text) {
+  if (!text.trim()) return [];
+  if (/text\/event-stream/i.test(contentType ?? "")) return parseSseMessages(text);
+  const parsed = JSON.parse(text);
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+
+function errorFor(message, text) {
+  const id = message && typeof message === "object" && "id" in message ? message.id : null;
+  return { jsonrpc: "2.0", id, error: { code: -32000, message: text } };
+}
+
+/**
+ * Forward one client message; resolves to the messages to write back.
+ * A notification (no id) expects nothing and gets nothing.
+ * @param {Record<string, unknown>} message one JSON-RPC message from the client
+ * @param {{ url?: string; fetchImpl?: typeof fetch; protocolVersion?: string }} [options]
+ * @returns {Promise<Array<Record<string, any>>>}
+ */
+export async function forward(message, { url = DEFAULT_URL, fetchImpl = fetch, protocolVersion } = {}) {
+  const headers = {
+    "content-type": "application/json",
+    accept: "application/json, text/event-stream",
+    "user-agent": `ai-compute-radar-bridge/${VERSION}`,
+  };
+  if (protocolVersion) headers["mcp-protocol-version"] = protocolVersion;
+  let response;
+  try {
+    response = await fetchImpl(url, { method: "POST", headers, body: JSON.stringify(message) });
+  } catch (cause) {
+    return "id" in message ? [errorFor(message, `Could not reach ${url}: ${cause?.message ?? cause}`)] : [];
+  }
+  const text = await response.text();
+  if (!response.ok) {
+    return "id" in message ? [errorFor(message, `${url} answered HTTP ${response.status}${text ? `: ${text.slice(0, 200)}` : ""}`)] : [];
+  }
+  try {
+    return parseBody(response.headers.get("content-type"), text);
+  } catch {
+    return "id" in message ? [errorFor(message, `${url} answered something that is not JSON-RPC`)] : [];
+  }
+}
+
+/**
+ * Reads stdin line by line, writes server messages to stdout.
+ * @param {{ url?: string; input?: NodeJS.ReadableStream; output?: NodeJS.WritableStream; fetchImpl?: typeof fetch }} [options]
+ */
+export async function run({ url = DEFAULT_URL, input = process.stdin, output = process.stdout, fetchImpl = fetch } = {}) {
+  const { createInterface } = await import("node:readline");
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  let protocolVersion;
+  const pending = new Set();
+  const write = (msg) => output.write(`${JSON.stringify(msg)}\n`);
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      continue;
+    }
+    if (message?.method === "initialize" && typeof message?.params?.protocolVersion === "string") {
+      protocolVersion = message.params.protocolVersion;
+    }
+    const job = forward(message, { url, fetchImpl, protocolVersion }).then((replies) => {
+      for (const reply of replies) write(reply);
+    });
+    pending.add(job);
+    job.finally(() => pending.delete(job));
+  }
+  await Promise.all(pending);
+}

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "ai-compute-radar",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.1",
+  "description": "MCP server bridge for AI Compute Radar: which open models fit your GPU or Mac (measured GGUF sizes + computed context cache), GPU rental prices from eight sources, model momentum, weekly pick. Read-only, no auth, no telemetry.",
+  "keywords": ["mcp", "model-context-protocol", "gpu", "vram", "llm", "local-ai", "gpu-rental", "cloud-pricing", "hugging-face", "open-models"],
+  "homepage": "https://aicomputeradar.dev/developers",
+  "bugs": { "email": "aicomputeradar@gmail.com" },
+  "license": "MIT",
+  "author": "AI Compute Radar (https://aicomputeradar.dev)",
+  "type": "module",
+  "bin": { "ai-compute-radar": "bin.mjs" },
+  "exports": "./bridge.mjs",
+  "files": ["bin.mjs", "bridge.mjs", "README.md", "LICENSE"],
+  "engines": { "node": ">=18" },
+  "mcpName": "dev.aicomputeradar/ai-compute-radar"
+}