@tokcalc/mcp-server 0.1.3 → 0.1.4

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

@@ -1,230 +0,0 @@
-/**
- * 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

@@ -1,164 +0,0 @@
-/**
- * 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

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

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

@@ -1,30 +0,0 @@
-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;
-}