@tokcalc/mcp-server 0.1.1 → 0.1.3

package/postcss.config.mjs

@@ -0,0 +1,5 @@
+const config = {
+  plugins: ["@tailwindcss/postcss"],
+};
+
+export default config;

package/prisma/schema.prisma

@@ -0,0 +1,32 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model Post {
+  id        String   @id @default(cuid())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+  authorId  String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}

package/public/google6f58ca6be85fa903.html

@@ -0,0 +1 @@
+google-site-verification: google6f58ca6be85fa903.html

package/public/logo.svg

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 30 30" style="enable-background:new 0 0 30 30;" xml:space="preserve">
+<defs>
+  <style type="text/css">
+    .st194{fill:#2D2D2D;stroke:#FFFFFF;stroke-width:0.6317;stroke-miterlimit:10;}
+    .st23{fill:#FFFFFF;}
+
+    .z-breathe {
+      animation: breathe 2.5s ease-in-out infinite;
+    }
+
+    @keyframes breathe {
+      0%, 100% { opacity: 0.7; }
+      50% { opacity: 1; }
+    }
+  </style>
+</defs>
+
+<g>
+  <path class="st194" d="M24.51,28.51H5.49c-2.21,0-4-1.79-4-4V5.49c0-2.21,1.79-4,4-4h19.03c2.21,0,4,1.79,4,4v19.03
+    C28.51,26.72,26.72,28.51,24.51,28.51z"/>
+  <g class="z-breathe">
+    <path class="st23" d="M15.47,7.1l-1.3,1.85c-0.2,0.29-0.54,0.47-0.9,0.47h-7.1V7.09C6.16,7.1,15.47,7.1,15.47,7.1z"/>
+    <polygon class="st23" points="24.3,7.1 13.14,22.91 5.7,22.91 16.86,7.1"/>
+    <path class="st23" d="M14.53,22.91l1.31-1.86c0.2-0.29,0.54-0.47,0.9-0.47h7.09v2.33H14.53z"/>
+  </g>
+</g>
+</svg>

package/public/manifest.json

@@ -0,0 +1,51 @@
+{
+  "name": "tokcalc — LLM serving capacity planner",
+  "short_name": "tokcalc",
+  "description": "Plan your LLM deployment before you rent the GPUs. Open-source capacity planner: model fit, KV-cache, throughput, latency, multi-GPU scaling, cost — with transparent formulas.",
+  "start_url": "/",
+  "display": "standalone",
+  "background_color": "#0a0e0a",
+  "theme_color": "#0a0e0a",
+  "orientation": "any",
+  "categories": ["developer", "productivity", "utilities"],
+  "icons": [
+    {
+      "src": "/og-icon-256.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/og-icon-256.png",
+      "sizes": "256x256",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/og-icon-256.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ],
+  "shortcuts": [
+    {
+      "name": "Calculator",
+      "short_name": "Calc",
+      "description": "Open the LLM capacity calculator",
+      "url": "/#t=calculator"
+    },
+    {
+      "name": "Build vs Buy",
+      "short_name": "BvB",
+      "description": "Compare self-hosting to API pricing",
+      "url": "/#t=build-vs-buy"
+    },
+    {
+      "name": "Reference catalog",
+      "short_name": "Ref",
+      "description": "Browse all models, GPUs, and quantization formats",
+      "url": "/#t=reference"
+    }
+  ]
+}

package/public/robots.txt

@@ -0,0 +1,25 @@
+# Crawl everything
+User-agent: *
+Allow: /
+
+# Block the dev API route from indexing
+Disallow: /api/
+
+# Explicitly allow social preview crawlers (redundant, but explicit)
+User-agent: Twitterbot
+Allow: /
+
+User-agent: facebookexternalhit
+Allow: /
+
+User-agent: LinkedInBot
+Allow: /
+
+User-agent: Discordbot
+Allow: /
+
+User-agent: Slackbot
+Allow: /
+
+# Sitemap
+Sitemap: https://tokcalc.vercel.app/sitemap.xml

package/public/sitemap.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://tokcalc.vercel.app/</loc>
+    <changefreq>weekly</changefreq>
+    <priority>1.0</priority>
+  </url>
+  <url>
+    <loc>https://tokcalc.vercel.app/compare/h100-vs-h200</loc>
+    <changefreq>monthly</changefreq>
+    <priority>0.9</priority>
+  </url>
+  <url>
+    <loc>https://tokcalc.vercel.app/compare/gguf-q4-k-m-vs-q5-k-m</loc>
+    <changefreq>monthly</changefreq>
+    <priority>0.8</priority>
+  </url>
+  <url>
+    <loc>https://tokcalc.vercel.app/self-host-vs-openai-api</loc>
+    <changefreq>monthly</changefreq>
+    <priority>0.8</priority>
+  </url>
+</urlset>

package/scripts/og-template.html

@@ -0,0 +1,120 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+  @import url('https://fonts.googleapis.com/css2?family=Inter:wght@600;700;800;900&family=JetBrains+Mono:wght@500;700&display=swap');
+
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body { width: 1200px; height: 630px; overflow: hidden; }
+  body {
+    font-family: 'Inter', -apple-system, sans-serif;
+    /* Solid dark background — no gradients (LinkedIn compression destroys subtle gradients).
+       Slight green tint stays on-brand without losing contrast. */
+    background: #0a0e0a;
+    color: #ffffff;
+    display: flex;
+    flex-direction: column;
+    padding: 80px 88px;
+  }
+
+  /* Top row: BIG logo + brand name. Logo is 96px (was 56px) — visible at 520px card */
+  .header { display: flex; align-items: center; gap: 24px; }
+  .logo-mark {
+    width: 96px; height: 96px; border-radius: 22px;
+    background: linear-gradient(135deg, #34d399 0%, #059669 100%);
+    display: flex; align-items: center; justify-content: center;
+    /* Subtle shadow only — no glow effect (gets destroyed by compression) */
+    box-shadow: 0 12px 40px rgba(16, 185, 129, 0.5);
+  }
+  .logo-mark svg { width: 52px; height: 52px; }
+  .brand {
+    font-size: 64px; font-weight: 900; letter-spacing: -0.05em;
+    color: #ffffff; line-height: 1;
+  }
+  .brand-sub {
+    font-size: 22px; color: #34d399; font-weight: 600;
+    margin-left: 20px; padding-left: 20px;
+    border-left: 2px solid rgba(52, 211, 153, 0.4);
+    line-height: 1.2;
+  }
+
+  /* Hero headline — MASSIVE. 88px so even at 520px card width it's ~38px = readable.
+     Pure white on near-black = max contrast, survives LinkedIn compression. */
+  .hero {
+    margin-top: 40px;
+    font-size: 88px;
+    font-weight: 900;
+    line-height: 1.05;
+    letter-spacing: -0.045em;
+    color: #ffffff;
+  }
+  .hero .accent {
+    color: #34d399; /* Saturated emerald, not subtle — survives compression */
+  }
+
+  /* Tagline — 28px (was 18px). Single line, no metric clutter. */
+  .tagline {
+    margin-top: 24px;
+    font-size: 28px;
+    color: #d4d4d8; /* Light gray, not dark gray — stays readable */
+    font-weight: 500;
+    line-height: 1.35;
+    max-width: 1000px;
+  }
+
+  /* Footer: bold URL. No chips, no metric pills — those get destroyed by compression.
+     Just one big readable brand line. */
+  .footer {
+    margin-top: auto;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding-top: 32px;
+    border-top: 2px solid rgba(52, 211, 153, 0.25);
+  }
+  .url {
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 32px;
+    color: #34d399;
+    font-weight: 700;
+    letter-spacing: -0.02em;
+  }
+  .tagline-pill {
+    font-size: 24px;
+    color: #ffffff;
+    font-weight: 700;
+    background: rgba(52, 211, 153, 0.15);
+    border: 2px solid rgba(52, 211, 153, 0.4);
+    padding: 10px 20px;
+    border-radius: 8px;
+  }
+</style>
+</head>
+<body>
+  <div class="header">
+    <div class="logo-mark">
+      <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+        <path d="M12 2L12 6M12 18L12 22M4.93 4.93L7.76 7.76M16.24 16.24L19.07 19.07M2 12L6 12M18 12L22 12M4.93 19.07L7.76 16.24M16.24 7.76L19.07 4.93"
+              stroke="#042f1c" stroke-width="3" stroke-linecap="round"/>
+        <circle cx="12" cy="12" r="3" fill="#042f1c"/>
+      </svg>
+    </div>
+    <div class="brand">tokcalc</div>
+    <div class="brand-sub">LLM serving<br>capacity planner</div>
+  </div>
+
+  <div class="hero">
+    Plan your LLM deployment<br>
+    <span class="accent">before you rent the GPUs.</span>
+  </div>
+  <div class="tagline">
+    Open-source capacity planner: model fit, KV-cache, throughput, latency, multi-GPU scaling, and cost.
+  </div>
+
+  <div class="footer">
+    <div class="url">tokcalc.dev</div>
+    <div class="tagline-pill">Open source · 35 models · 30 GPUs</div>
+  </div>
+</body>
+</html>

package/scripts/render-og.mjs

@@ -0,0 +1,43 @@
+/**
+ * Render tokcalc OG image via Playwright snapshot of an HTML template.
+ * Outputs:
+ *   - /home/z/my-project/public/og.png (2400x1260 @ 2x scale, for all social platforms)
+ *
+ * The og-icon-256.png is generated separately if needed (see git history for the
+ * original render script with the icon step).
+ *
+ * Usage: node scripts/render-og.mjs
+ */
+import { chromium } from 'playwright';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE = path.join(__dirname, 'og-template.html');
+const OUT_OG = path.join(__dirname, '..', 'public', 'og.png');
+
+async function main() {
+  const browser = await chromium.launch();
+  const context = await browser.newContext({
+    viewport: { width: 1200, height: 630 },
+    deviceScaleFactor: 2, // 2x for crisp retina display
+  });
+
+  const page = await context.newPage();
+  await page.goto('file://' + TEMPLATE, { waitUntil: 'networkidle' });
+  // Give web fonts a moment to settle (Inter / JetBrains Mono from Google Fonts CDN)
+  await page.waitForTimeout(1000);
+  await page.screenshot({
+    path: OUT_OG,
+    type: 'png',
+    clip: { x: 0, y: 0, width: 1200, height: 630 },
+  });
+  console.log('✓ OG image:', OUT_OG);
+
+  await browser.close();
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/server.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.stevecrates489-commits/tokcalc",
+  "title": "TokCalc MCP Server",
+  "description": "LLM capacity planning tools to estimate VRAM, compute, latency, and GPU topology for agents.",
+  "version": "0.1.3",
+  "repository": {
+    "url": "https://github.com/stevecrates489-commits/tokcalc.git",
+    "source": "github"
+  },
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@tokcalc/mcp-server",
+      "version": "0.1.3",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}   

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

@@ -0,0 +1,186 @@
+/**
+ * AWS EC2 pricing proxy — uses public bulk pricing files (NO IAM credentials required).
+ *
+ * Per the user's research: AWS publishes public pricing JSON files at:
+ *   https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonEC2/current/us-east-1/index.json
+ *
+ * This file is large (~50-100MB) but contains all EC2 pricing for us-east-1.
+ * This serverless function:
+ *   1. Fetches the bulk file (with 8s timeout — might fail on slow connections)
+ *   2. Streams-parses to extract only GPU instance types (p5, p4d, g5, g6, etc.)
+ *   3. Caches in memory for 24 hours
+ *   4. Returns clean JSON with per-GPU pricing
+ *
+ * No IAM credentials, no API key, no payment setup — just public data.
+ */
+
+import { NextResponse } from "next/server";
+
+// GPU instance type prefixes — filter the massive EC2 catalog
+const GPU_INSTANCE_PREFIXES = ["p5", "p5e", "p6", "p4d", "p4de", "p3", "g5", "g6", "g4dn"];
+
+// Known GPU counts per instance type
+const GPU_COUNTS: Record<string, number> = {
+  "p5.48xlarge": 8, "p5e.48xlarge": 8, "p6.48xlarge": 8,
+  "p4d.24xlarge": 8, "p4de.24xlarge": 8,
+  "p3.2xlarge": 1, "p3.8xlarge": 4, "p3.16xlarge": 8,
+  "g5.xlarge": 1, "g5.2xlarge": 1, "g5.4xlarge": 1, "g5.8xlarge": 1, "g5.12xlarge": 4, "g5.16xlarge": 1, "g5.48xlarge": 8,
+  "g6.xlarge": 1, "g6.2xlarge": 1, "g6.4xlarge": 1, "g6.8xlarge": 1, "g6.12xlarge": 4, "g6.16xlarge": 1, "g6.48xlarge": 8,
+  "g4dn.xlarge": 1, "g4dn.2xlarge": 1, "g4dn.4xlarge": 1, "g4dn.8xlarge": 1, "g4dn.12xlarge": 4, "g4dn.16xlarge": 1,
+};
+
+// Known GPU model per instance type
+const GPU_MODEL: Record<string, string> = {
+  p5: "H100", p5e: "H200", p6: "B200",
+  p4d: "A100 40GB", p4de: "A100 80GB",
+  p3: "V100",
+  g5: "A10G", g6: "L4", g4dn: "T4",
+};
+
+let cache: { data: CleanGpuPrice[]; timestamp: number } | null = null;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+interface CleanGpuPrice {
+  gpu: string;
+  instanceType: string;
+  pricePerGpuHour: number;
+  instancePriceHour: number;
+  gpuCount: number;
+  region: string;
+  retrievedAt: string;
+}
+
+function getGpuModel(instanceType: string): string | null {
+  const prefix = Object.keys(GPU_MODEL).find((p) => instanceType.startsWith(p));
+  return prefix ? GPU_MODEL[prefix] : null;
+}
+
+function getGpuCount(instanceType: string): number {
+  return GPU_COUNTS[instanceType] || 1;
+}
+
+export async function GET() {
+  if (cache && Date.now() - cache.timestamp < CACHE_TTL_MS) {
+    return NextResponse.json({
+      source: "aws",
+      cached: true,
+      retrievedAt: new Date(cache.timestamp).toISOString(),
+      count: cache.data.length,
+      prices: cache.data,
+    });
+  }
+
+  try {
+    // Fetch the AWS EC2 bulk pricing file for us-east-1
+    // This is a large file (~50-100MB) but we only need GPU instances
+    const url = "https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonEC2/current/us-east-1/index.json";
+
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(8000), // 8 second timeout
+      headers: { "Accept": "application/json" },
+    });
+
+    if (!response.ok) {
+      throw new Error(`AWS pricing API returned ${response.status}`);
+    }
+
+    // Parse the large JSON — this is memory-intensive but works on Vercel's 1GB limit
+    const data = await response.json() as {
+      products?: Record<string, {
+        productFamily?: string;
+        attributes?: {
+          instanceType?: string;
+          location?: string;
+          operatingSystem?: string;
+          tenancy?: string;
+          capacitystatus?: string;
+        };
+      }>;
+      terms?: {
+        OnDemand?: Record<string, {
+          priceDimensions?: Record<string, {
+            pricePerUnit?: { USD?: string };
+          }>;
+        }>;
+      };
+    };
+
+    const products = data.products || {};
+    const onDemandTerms = data.terms?.OnDemand || {};
+
+    const prices: CleanGpuPrice[] = [];
+
+    // Iterate products and find GPU instance types
+    for (const [sku, product] of Object.entries(products)) {
+      const attrs = product.attributes || {};
+      const instanceType = attrs.instanceType || "";
+
+      // Skip non-GPU instances
+      if (!GPU_INSTANCE_PREFIXES.some((p) => instanceType.startsWith(p))) continue;
+
+      // Filter: Linux, Shared tenancy, Used capacity (on-demand)
+      if (attrs.operatingSystem !== "Linux") continue;
+      if (attrs.tenancy !== "Shared") continue;
+      if (attrs.capacitystatus !== "Used") continue;
+
+      // Find the OnDemand price for this SKU
+      const term = onDemandTerms[sku];
+      if (!term?.priceDimensions) continue;
+
+      const priceDims = Object.values(term.priceDimensions);
+      const usdPrice = priceDims[0]?.pricePerUnit?.USD;
+      if (!usdPrice) continue;
+
+      const instancePriceHour = parseFloat(usdPrice);
+      if (isNaN(instancePriceHour) || instancePriceHour <= 0) continue;
+
+      const gpuModel = getGpuModel(instanceType);
+      const gpuCount = getGpuCount(instanceType);
+      if (!gpuModel) continue;
+
+      const pricePerGpuHour = Math.round((instancePriceHour / gpuCount) * 100) / 100;
+
+      prices.push({
+        gpu: gpuModel,
+        instanceType,
+        pricePerGpuHour,
+        instancePriceHour: Math.round(instancePriceHour * 100) / 100,
+        gpuCount,
+        region: "us-east-1",
+        retrievedAt: new Date().toISOString(),
+      });
+    }
+
+    // Deduplicate: keep cheapest per-GPU price
+    const seen = new Map<string, CleanGpuPrice>();
+    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: "aws",
+      cached: false,
+      retrievedAt: new Date().toISOString(),
+      count: deduped.length,
+      prices: deduped,
+      note: "On-demand Linux pricing from AWS public bulk files. No IAM credentials required. Region: us-east-1.",
+    });
+  } catch (error) {
+    console.error("AWS pricing fetch error:", error);
+    return NextResponse.json(
+      {
+        source: "aws",
+        error: "Failed to fetch AWS bulk pricing. The file is large (~50MB) and may have timed out. Cached results from a previous fetch may still be available.",
+        fallback: "Use static pricing from tokcalc's GPU catalog or Azure/Vast.ai live pricing.",
+      },
+      { status: 502 },
+    );
+  }
+}