@tokcalc/mcp-server 0.1.1 → 0.1.3

package/src/app/api/pricing/azure/route.ts

@@ -0,0 +1,168 @@
+/**
+ * Azure Retail Prices API proxy.
+ *
+ * Fetches live GPU pricing from Azure's public, unauthenticated API:
+ *   GET https://prices.azure.com/api/retail/prices
+ *
+ * This serverless function:
+ *   1. Fetches server-side (avoids CORS issues)
+ *   2. Caches in memory for 24 hours (reduces API load)
+ *   3. Returns a clean JSON response with per-GPU pricing
+ *
+ * Usage from client:
+ *   fetch('/api/pricing/azure?XTransformPort=3000')
+ *   or (since this is the same app):
+ *   fetch('/api/pricing/azure')
+ *
+ * Per the fullstack skill rules, if requesting to a different port,
+ * use XTransformPort query param. But this API is on the same port
+ * so no special handling needed.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+
+interface AzurePriceItem {
+  currencyCode: string;
+  tierMinimumUnits: number;
+  reservationPrice?: number;
+  retailPrice: number;
+  unitPrice: number;
+  armRegionName: string;
+  location: string;
+  armSkuName: string;
+  productName: string;
+  skuName: string;
+  serviceName: string;
+  serviceFamily: string;
+  unit: string;
+  meters: Array<{
+    meterId: string;
+    meterName: string;
+    unit: string;
+    unitPrice: number;
+  }>;
+}
+
+// In-memory cache (lives for the lifetime of the serverless function instance)
+let cache: {
+  data: Array<{ gpu: string; sku: string; price: number; region: string; retrievedAt: string }>;
+  timestamp: number;
+} | null = null;
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+// GPU instance types to query (H100, H200, A100, L40S, T4, L4, V100)
+const AZURE_GPU_SKUS = [
+  "Standard_ND96isr_H100_v5",    // 8× H100 80GB
+  "Standard_NDm_A100_v4",       // 8× A100 80GB (NDm)
+  "Standard_ND96asr_v4",        // 8× A100 80GB (NDasr)
+  "Standard_NC24ads_A100_v4",   // 1× A100 80GB
+  "Standard_NC4as_T4_v3",       // 1× T4
+  "Standard_ND96amsr_A100_v4",   // 4× A100 80GB
+];
+
+export async function GET(_request: NextRequest) {
+  // Return cached data if fresh
+  if (cache && Date.now() - cache.timestamp < CACHE_TTL_MS) {
+    return NextResponse.json({
+      source: "azure",
+      cached: true,
+      retrievedAt: new Date(cache.timestamp).toISOString(),
+      prices: cache.data,
+    });
+  }
+
+  try {
+    // Fetch from Azure's public, unauthenticated API
+    const prices: Array<{ gpu: string; sku: string; price: number; region: string; retrievedAt: string }> = [];
+
+    for (const sku of AZURE_GPU_SKUS) {
+      const url = `https://prices.azure.com/api/retail/prices?$filter=armSkuName eq '${sku}' and priceType eq 'Consumption'`;
+      const response = await fetch(url, {
+        headers: { "Accept": "application/json" },
+      });
+
+      if (!response.ok) continue;
+
+      const data = await response.json() as { Items: AzurePriceItem[]; NextPageLink?: string };
+      const items = data.Items || [];
+
+      for (const item of items) {
+        // Extract GPU name from product name
+        const productName = item.productName || "";
+        let gpuName = "unknown";
+        let gpuCount = 1;
+
+        if (productName.includes("H100")) { gpuName = "H100"; gpuCount = 8; }
+        else if (productName.includes("H200")) { gpuName = "H200"; gpuCount = 8; }
+        else if (productName.includes("A100") && productName.includes("80")) { gpuName = "A100 80GB"; gpuCount = sku.includes("96") ? 8 : (sku.includes("24") ? 1 : 4); }
+        else if (productName.includes("A100")) { gpuName = "A100 40GB"; gpuCount = sku.includes("96") ? 8 : 1; }
+        else if (productName.includes("T4")) { gpuName = "T4"; gpuCount = 1; }
+        else if (productName.includes("L40")) { gpuName = "L40S"; gpuCount = 8; }
+
+        if (gpuName === "unknown") continue;
+
+        // Skip spot/reserved — only on-demand for now
+        if (item.skuName?.toLowerCase().includes("spot")) continue;
+        if (item.skuName?.toLowerCase().includes("low priority")) continue;
+
+        const instancePricePerHour = item.retailPrice;
+        const derivedGpuPrice = instancePricePerHour / gpuCount;
+
+        prices.push({
+          gpu: gpuName,
+          sku: item.armSkuName,
+          price: Math.round(derivedGpuPrice * 100) / 100, // per-GPU $/hr, 2 decimals
+          region: item.armRegionName,
+          retrievedAt: new Date().toISOString(),
+        });
+      }
+
+      // Follow pagination if needed (Azure API returns max 100 items per page)
+      let nextLink = data.NextPageLink;
+      while (nextLink) {
+        const nextResponse = await fetch(nextLink);
+        if (!nextResponse.ok) break;
+        const nextData = await nextResponse.json() as { Items: AzurePriceItem[]; NextPageLink?: string };
+        // Process same as above (simplified — just get first page for now)
+        nextLink = nextData.NextPageLink;
+        break; // Limit to 2 pages to avoid timeout
+      }
+    }
+
+    // Deduplicate: keep cheapest per GPU per region
+    const seen = new Map<string, { gpu: string; sku: string; price: number; region: string; retrievedAt: string }>();
+    for (const p of prices) {
+      const key = `${p.gpu}-${p.region}`;
+      if (!seen.has(key) || seen.get(key)!.price > p.price) {
+        seen.set(key, p);
+      }
+    }
+
+    const deduped = Array.from(seen.values());
+
+    // Update cache
+    cache = {
+      data: deduped,
+      timestamp: Date.now(),
+    };
+
+    return NextResponse.json({
+      source: "azure",
+      cached: false,
+      retrievedAt: new Date().toISOString(),
+      count: deduped.length,
+      prices: deduped,
+    });
+  } catch (error) {
+    console.error("Azure pricing fetch error:", error);
+    return NextResponse.json(
+      {
+        source: "azure",
+        error: "Failed to fetch Azure pricing. The Azure Retail Prices API may be temporarily unavailable.",
+        fallback: "Use static pricing from tokcalc's GPU catalog.",
+      },
+      { status: 502 },
+    );
+  }
+}

package/src/app/api/pricing/gcp/route.ts

@@ -0,0 +1,230 @@
+/**
+ * Google Cloud GPU pricing proxy.
+ *
+ * Uses the Google Cloud Billing Catalog API:
+ *   GET https://cloudbilling.googleapis.com/v1/services/{SERVICE_ID}/skus?key=API_KEY
+ *
+ * Requires GCP_API_KEY environment variable.
+ * Set on Vercel: Settings → Environment Variables → GCP_API_KEY
+ *
+ * This serverless function:
+ *   1. Fetches Compute Engine SKUs from the Cloud Billing Catalog API
+ *   2. Filters for GPU instance types (a3, a4 — H100, H200, B200)
+ *   3. Extracts on-demand pricing
+ *   4. Caches in memory for 24 hours
+ *
+ * The API key is stored as an env var — NOT hardcoded in source code.
+ * This is important because tokcalc is open source on GitHub.
+ */
+
+import { NextResponse } from "next/server";
+
+// GCP GPU instance types to look for in SKU descriptions
+const GPU_PATTERNS = [
+  { pattern: "H100", gpu: "H100" },
+  { pattern: "H200", gpu: "H200" },
+  { pattern: "B200", gpu: "B200" },
+  { pattern: "A100", gpu: "A100" },
+  { pattern: "L4", gpu: "L4" },
+  { pattern: "T4", gpu: "T4" },
+  { pattern: "L40", gpu: "L40S" },
+  { pattern: "V100", gpu: "V100" },
+];
+
+// GCP instance type → GPU count mapping
+const GCP_GPU_COUNTS: Record<string, number> = {
+  "a3-highgpu-8g": 8, "a3-highgpu-2g": 2,
+  "a3-edgegpu-8g": 8, "a3-edgegpu-2g": 2,
+  "a4-highgpu-8g": 8,
+  "a2-highgpu-1g": 1, "a2-highgpu-2g": 2, "a2-highgpu-4g": 4, "a2-highgpu-8g": 8,
+  "n1-standard-4": 1, // T4 usually 1 per instance
+  "g2-standard-4": 1, "g2-standard-8": 1, "g2-standard-12": 1, "g2-standard-16": 1, "g2-standard-24": 4, "g2-standard-32": 1, "g2-standard-48": 8,
+};
+
+let cache: { data: CleanGcpPrice[]; timestamp: number } | null = null;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+interface CleanGcpPrice {
+  gpu: string;
+  instanceType: string;
+  pricePerGpuHour: number;
+  instancePriceHour: number;
+  gpuCount: number;
+  region: string;
+  retrievedAt: string;
+}
+
+export async function GET() {
+  const apiKey = process.env.GCP_API_KEY;
+
+  if (!apiKey) {
+    return NextResponse.json(
+      {
+        source: "gcp",
+        error: "GCP_API_KEY environment variable is not set. Add it on Vercel: Settings → Environment Variables → GCP_API_KEY",
+        fallback: "Use Azure or Vast.ai live pricing instead.",
+      },
+      { status: 503 },
+    );
+  }
+
+  if (cache && Date.now() - cache.timestamp < CACHE_TTL_MS) {
+    return NextResponse.json({
+      source: "gcp",
+      cached: true,
+      retrievedAt: new Date(cache.timestamp).toISOString(),
+      count: cache.data.length,
+      prices: cache.data,
+    });
+  }
+
+  try {
+    // Step 1: Get the list of services to find Compute Engine's service ID
+    const servicesUrl = `https://cloudbilling.googleapis.com/v1/services?key=${apiKey}&pageSize=100`;
+    const servicesResponse = await fetch(servicesUrl, {
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!servicesResponse.ok) {
+      throw new Error(`GCP Services API returned ${servicesResponse.status}`);
+    }
+
+    const servicesData = await servicesResponse.json() as {
+      services?: Array<{ serviceId: string; displayName: string }>;
+    };
+
+    // Find Compute Engine service
+    const computeService = servicesData.services?.find(
+      (s) => s.displayName?.toLowerCase().includes("compute engine"),
+    );
+
+    if (!computeService) {
+      throw new Error("Compute Engine service not found in GCP billing catalog");
+    }
+
+    // Step 2: Fetch SKUs for Compute Engine
+    const skusUrl = `https://cloudbilling.googleapis.com/v1/services/${computeService.serviceId}/skus?key=${apiKey}&pageSize=5000`;
+    const skusResponse = await fetch(skusUrl, {
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!skusResponse.ok) {
+      throw new Error(`GCP SKUs API returned ${skusResponse.status}`);
+    }
+
+    const skusData = await skusResponse.json() as {
+      skus?: Array<{
+        skuId: string;
+        description: string;
+        pricingInfo?: Array<{
+          pricingExpression?: {
+            tieredRates?: Array<{
+              unitPrice?: { units?: string; nanos?: number };
+            }>;
+          };
+        }>;
+        serviceRegions?: string[];
+        geoTaxonomy?: { regions?: string[] };
+      }>;
+      nextPagePageToken?: string;
+    };
+
+    const skus = skusData.skus || [];
+
+    const prices: CleanGcpPrice[] = [];
+
+    for (const sku of skus) {
+      const description = sku.description || "";
+
+      // Check if this SKU matches any GPU pattern
+      const gpuMatch = GPU_PATTERNS.find((p) => description.includes(p.pattern));
+      if (!gpuMatch) continue;
+
+      // Skip preemptible/spot/reserved
+      if (description.toLowerCase().includes("preemptible")) continue;
+      if (description.toLowerCase().includes("spot")) continue;
+      if (description.toLowerCase().includes("reserved")) continue;
+      if (description.toLowerCase().includes("commitment")) continue;
+
+      // Skip non-GPU SKUs that happen to mention GPU in text
+      if (!description.toLowerCase().includes("gpu") && !description.toLowerCase().includes("premium")) {
+        // Only include if the instance type is in our known GPU instances
+        const instanceMatch = Object.keys(GCP_GPU_COUNTS).find(
+          (it) => description.toLowerCase().includes(it.toLowerCase()),
+        );
+        if (!instanceMatch) continue;
+      }
+
+      // Extract price
+      const pricingInfo = sku.pricingInfo?.[0];
+      const tieredRates = pricingInfo?.pricingExpression?.tieredRates;
+      const firstRate = tieredRates?.[0];
+      const unitPrice = firstRate?.unitPrice;
+
+      if (!unitPrice) continue;
+
+      // GCP prices are in USD with nanos precision
+      const dollars = parseFloat(unitPrice.units || "0");
+      const nanos = (unitPrice.nanos || 0) / 1e9;
+      const pricePerHour = dollars + nanos;
+
+      if (isNaN(pricePerHour) || pricePerHour <= 0) continue;
+
+      // Try to determine instance type and GPU count
+      let instanceType = "unknown";
+      let gpuCount = 1;
+
+      for (const [it, count] of Object.entries(GCP_GPU_COUNTS)) {
+        if (description.toLowerCase().includes(it.toLowerCase())) {
+          instanceType = it;
+          gpuCount = count;
+          break;
+        }
+      }
+
+      const pricePerGpuHour = Math.round((pricePerHour / gpuCount) * 100) / 100;
+
+      prices.push({
+        gpu: gpuMatch.gpu,
+        instanceType,
+        pricePerGpuHour,
+        instancePriceHour: Math.round(pricePerHour * 100) / 100,
+        gpuCount,
+        region: sku.serviceRegions?.[0] || sku.geoTaxonomy?.regions?.[0] || "global",
+        retrievedAt: new Date().toISOString(),
+      });
+    }
+
+    // Deduplicate: keep cheapest per-GPU price per GPU model
+    const seen = new Map<string, CleanGcpPrice>();
+    for (const p of prices) {
+      const key = p.gpu;
+      if (!seen.has(key) || seen.get(key)!.pricePerGpuHour > p.pricePerGpuHour) {
+        seen.set(key, p);
+      }
+    }
+
+    const deduped = Array.from(seen.values()).sort((a, b) => a.pricePerGpuHour - b.pricePerGpuHour);
+
+    cache = { data: deduped, timestamp: Date.now() };
+
+    return NextResponse.json({
+      source: "gcp",
+      cached: false,
+      retrievedAt: new Date().toISOString(),
+      count: deduped.length,
+      prices: deduped,
+      note: "On-demand pricing from Google Cloud Billing Catalog API. Region varies by SKU. Requires GCP_API_KEY env var.",
+    });
+  } catch (error) {
+    console.error("GCP pricing fetch error:", error);
+    return NextResponse.json(
+      {
+        source: "gcp",
+        error: "Failed to fetch GCP pricing. Check that GCP_API_KEY is set and valid.",
+        fallback: "Use Azure or Vast.ai live pricing instead.",
+      },
+      { status: 502 },
+    );
+  }
+}

package/src/app/api/pricing/vast-ai/route.ts

@@ -0,0 +1,164 @@
+/**
+ * Vast.ai marketplace pricing proxy.
+ *
+ * Fetches live spot-market GPU offers from Vast.ai's public API:
+ *   GET https://cloud.vast.ai/api/v0/bundles/
+ *
+ * This serverless function:
+ *   1. Fetches server-side (avoids CORS issues)
+ *   2. Filters for GPU-only offers
+ *   3. Deduplicates by GPU model (keeps cheapest available)
+ *   4. Caches in memory for 5 minutes (spot prices change rapidly)
+ *
+ * Per Perplexity research (Prompt #3):
+ *   "Vast.ai is the best fit for dynamic spot/marketplace pricing"
+ *   "Official offer-search REST API / OpenAPI"
+ *   "Treat every returned offer as temporary market data"
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+
+interface VastAiBundle {
+  id: number;
+  gpu_name?: string;
+  num_gpus?: number;
+  gpu_ram?: number;
+  dph_total?: number;     // total $/hour
+  reliability?: number;
+  geolocation?: string;
+  inetname?: string;
+  dlperf?: number;       // download performance
+  cuda_max_good?: number; // CUDA version
+  total_flops?: number;
+  cpu_ram?: number;
+  cpu_cores?: number;
+}
+
+interface CleanOffer {
+  gpu: string;
+  gpuCount: number;
+  vramGb: number;
+  pricePerGpuHour: number;
+  totalPriceHour: number;
+  reliability: number;
+  region: string;
+  bundleId: number;
+}
+
+// In-memory cache (5 minute TTL — spot prices change rapidly)
+let cache: { data: CleanOffer[]; timestamp: number } | null = null;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+// GPUs we care about — use short names for flexible matching
+// (e.g., "H100" matches both "H100 SXM" and "H100 NVL")
+const TARGET_GPUS = [
+  "H100", "H200", "B200",
+  "A100", "A6000",
+  "RTX 4090", "RTX 3090", "RTX 4080", "RTX 3080",
+  "RTX 5090", "RTX 5080", "RTX 5070",
+  "L40", "L4",
+  "V100",
+  "T4",
+];
+
+export async function GET(_request: NextRequest) {
+  // Return cached data if fresh
+  if (cache && Date.now() - cache.timestamp < CACHE_TTL_MS) {
+    return NextResponse.json({
+      source: "vast_ai",
+      cached: true,
+      retrievedAt: new Date(cache.timestamp).toISOString(),
+      count: cache.data.length,
+      offers: cache.data,
+      note: "Spot-market prices. Updated every 5 minutes. Individual offers may be gone by the time you try to rent.",
+    });
+  }
+
+  try {
+    // Vast.ai API: search for GPU offers, sorted by cheapest first
+    // The q parameter filters by GPU name, order sorts by price ascending
+    const url = "https://cloud.vast.ai/api/v0/bundles/";
+    const response = await fetch(url, {
+      headers: { "Accept": "application/json" },
+      // Timeout after 10 seconds
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Vast.ai API returned ${response.status}`);
+    }
+
+    const data = await response.json() as { offers?: VastAiBundle[] };
+    const bundles = data.offers || [];
+
+    // Filter and clean offers
+    const offers: CleanOffer[] = [];
+
+    for (const bundle of bundles) {
+      if (!bundle.gpu_name || !bundle.dph_total || bundle.dph_total <= 0) continue;
+      if (!bundle.num_gpus || bundle.num_gpus <= 0) continue;
+
+      const gpuName = bundle.gpu_name.trim();
+      const gpuCount = bundle.num_gpus;
+      const totalPriceHour = bundle.dph_total;
+      const pricePerGpuHour = Math.round((totalPriceHour / gpuCount) * 100) / 100;
+
+      // Check if this GPU is in our target list (bidirectional matching)
+      const isTarget = TARGET_GPUS.some(
+        (target) =>
+          gpuName.toLowerCase().includes(target.toLowerCase()) ||
+          target.toLowerCase().includes(gpuName.toLowerCase()),
+      );
+      if (!isTarget) continue;
+
+      offers.push({
+        gpu: gpuName,
+        gpuCount,
+        vramGb: bundle.gpu_ram || 0,
+        pricePerGpuHour,
+        totalPriceHour: Math.round(totalPriceHour * 100) / 100,
+        reliability: bundle.reliability || 0,
+        region: bundle.geolocation || "unknown",
+        bundleId: bundle.id,
+      });
+    }
+
+    // Deduplicate: keep cheapest per-GPU price for each GPU model
+    const cheapestPerGpu = new Map<string, CleanOffer>();
+    for (const offer of offers) {
+      const key = offer.gpu;
+      if (!cheapestPerGpu.has(key) || cheapestPerGpu.get(key)!.pricePerGpuHour > offer.pricePerGpuHour) {
+        cheapestPerGpu.set(key, offer);
+      }
+    }
+
+    const deduped = Array.from(cheapestPerGpu.values()).sort(
+      (a, b) => a.pricePerGpuHour - b.pricePerGpuHour,
+    );
+
+    // Update cache
+    cache = {
+      data: deduped,
+      timestamp: Date.now(),
+    };
+
+    return NextResponse.json({
+      source: "vast_ai",
+      cached: false,
+      retrievedAt: new Date().toISOString(),
+      count: deduped.length,
+      offers: deduped,
+      note: "Spot-market prices from Vast.ai marketplace. Individual offers may be gone by the time you try to rent. Reliability score indicates host trustworthiness (0-1).",
+    });
+  } catch (error) {
+    console.error("Vast.ai pricing fetch error:", error);
+    return NextResponse.json(
+      {
+        source: "vast_ai",
+        error: "Failed to fetch Vast.ai marketplace pricing. The API may be temporarily unavailable or rate-limited.",
+        fallback: "Use static pricing from tokcalc's GPU catalog.",
+      },
+      { status: 502 },
+    );
+  }
+}

package/src/app/api/route.ts

@@ -0,0 +1,5 @@
+import { NextResponse } from "next/server";
+
+export async function GET() {
+  return NextResponse.json({ message: "Hello, world!" });
+}

package/src/app/compare/h100-vs-h200/layout.tsx

@@ -0,0 +1,30 @@
+import type { Metadata } from "next";
+
+export const metadata: Metadata = {
+  title: "H100 vs H200 for LLM Inference: Throughput, Latency, VRAM & Cost",
+  description:
+    "Side-by-side comparison of NVIDIA H100 SXM5 80GB vs H200 SXM5 141GB for Llama 3.3 70B FP8 serving. Interactive throughput, latency, VRAM, and cost calculator with transparent formulas.",
+  keywords: [
+    "H100 vs H200",
+    "H100 H200 comparison",
+    "LLM inference GPU comparison",
+    "H100 LLM throughput",
+    "H200 LLM throughput",
+    "H100 vs H200 VRAM",
+    "Llama 70B GPU comparison",
+    "NVIDIA H100 H200",
+  ],
+  openGraph: {
+    title: "H100 vs H200 for LLM Inference — Throughput, VRAM & Cost",
+    description:
+      "Interactive comparison of H100 80GB vs H200 141GB for Llama 3.3 70B serving. See how context length affects capacity.",
+    type: "article",
+  },
+  alternates: {
+    canonical: "https://tokcalc.vercel.app/compare/h100-vs-h200",
+  },
+};
+
+export default function Page({ children }: { children: React.ReactNode }) {
+  return children;
+}