pricing.md 1.0.0

package/data/tools/weaviate.json

@@ -0,0 +1,93 @@
+{
+  "id": "weaviate",
+  "name": "Weaviate",
+  "description": "Open-source vector database for hybrid search, RAG, and AI-native applications with managed cloud deployment",
+  "url": "https://weaviate.io",
+  "pricingUrl": "https://weaviate.io/pricing.md",
+  "category": "search",
+  "tags": [
+    "vector-database",
+    "semantic-search",
+    "hybrid-search",
+    "rag",
+    "embeddings"
+  ],
+  "lastVerified": "2026-04-02",
+  "freshnessCategory": "volatile",
+  "currency": "USD",
+  "portability": {
+    "switchingCost": "significant",
+    "openStandard": null,
+    "whatYouLose": "Weaviate-specific schema and module configuration, Query Agent integration, vector compression settings, multi-tenancy setup, hybrid search tuning"
+  },
+  "tiers": [
+    {
+      "name": "Free Trial",
+      "slug": "free-trial",
+      "pricingModel": "free",
+      "basePrice": 0,
+      "billingPeriod": "monthly",
+      "annualDiscount": null,
+      "seatPrice": null,
+      "usageMetrics": [
+        {
+          "name": "query-agent-requests",
+          "pricePerUnit": 0,
+          "unitQuantity": 1,
+          "includedQuantity": 250,
+          "unit": "requests"
+        }
+      ],
+      "features": [],
+      "limits": {
+        "trialDays": 14,
+        "queryAgentRequests": 250
+      }
+    },
+    {
+      "name": "Flex",
+      "slug": "flex",
+      "pricingModel": "usage_based",
+      "basePrice": 45,
+      "billingPeriod": "monthly",
+      "annualDiscount": null,
+      "seatPrice": null,
+      "usageMetrics": [
+        {
+          "name": "query-agent-requests",
+          "pricePerUnit": 0,
+          "unitQuantity": 1,
+          "includedQuantity": 30000,
+          "unit": "requests"
+        }
+      ],
+      "features": [],
+      "limits": {
+        "queryAgentRequests": 30000,
+        "uptimeSLA": 995
+      }
+    },
+    {
+      "name": "Premium",
+      "slug": "premium",
+      "pricingModel": "custom",
+      "basePrice": 400,
+      "billingPeriod": "monthly",
+      "annualDiscount": null,
+      "seatPrice": null,
+      "usageMetrics": [
+        {
+          "name": "query-agent-requests",
+          "pricePerUnit": 0,
+          "unitQuantity": 1,
+          "includedQuantity": 0,
+          "unit": "requests"
+        }
+      ],
+      "features": [],
+      "limits": {
+        "uptimeSLA": 9995
+      }
+    }
+  ]
+}

package/data/tools/workos.json

@@ -0,0 +1,127 @@
+{
+  "id": "workos",
+  "name": "WorkOS",
+  "description": "Enterprise-ready authentication and identity platform with SSO, directory sync, and user management",
+  "url": "https://workos.com",
+  "pricingUrl": "https://workos.com/pricing.md",
+  "category": "auth",
+  "tags": [
+    "authentication",
+    "sso",
+    "directory-sync",
+    "enterprise",
+    "oauth",
+    "oidc",
+    "scim"
+  ],
+  "lastVerified": "2026-04-02",
+  "freshnessCategory": "volatile",
+  "currency": "USD",
+  "portability": {
+    "switchingCost": "significant",
+    "openStandard": "OAuth 2.0 / OIDC",
+    "whatYouLose": "AuthKit UI components, WorkOS SDKs, SSO connection configurations, directory sync integrations, audit log pipeline"
+  },
+  "tiers": [
+    {
+      "name": "Pay as You Go",
+      "slug": "pay-as-you-go",
+      "pricingModel": "usage_based",
+      "basePrice": 0,
+      "billingPeriod": "monthly",
+      "annualDiscount": null,
+      "seatPrice": null,
+      "usageMetrics": [
+        {
+          "name": "MAUs",
+          "pricePerUnit": 2500,
+          "unitQuantity": 1000000,
+          "includedQuantity": 1000000,
+          "tieredPricing": [
+            {
+              "upTo": 1000000,
+              "pricePerUnit": 0
+            },
+            {
+              "upTo": null,
+              "pricePerUnit": 2500
+            }
+          ],
+          "unit": "MAUs"
+        },
+        {
+          "name": "SSO connections",
+          "pricePerUnit": 125,
+          "unitQuantity": 1,
+          "includedQuantity": 0,
+          "tieredPricing": [
+            {
+              "upTo": 15,
+              "pricePerUnit": 125
+            },
+            {
+              "upTo": 30,
+              "pricePerUnit": 100
+            },
+            {
+              "upTo": 50,
+              "pricePerUnit": 80
+            },
+            {
+              "upTo": 100,
+              "pricePerUnit": 65
+            },
+            {
+              "upTo": 200,
+              "pricePerUnit": 50
+            }
+          ],
+          "unit": "connections"
+        },
+        {
+          "name": "Directory Sync connections",
+          "pricePerUnit": 125,
+          "unitQuantity": 1,
+          "includedQuantity": 0,
+          "tieredPricing": [
+            {
+              "upTo": 15,
+              "pricePerUnit": 125
+            },
+            {
+              "upTo": 30,
+              "pricePerUnit": 100
+            },
+            {
+              "upTo": 50,
+              "pricePerUnit": 80
+            },
+            {
+              "upTo": 100,
+              "pricePerUnit": 65
+            },
+            {
+              "upTo": 200,
+              "pricePerUnit": 50
+            }
+          ],
+          "unit": "connections"
+        }
+      ],
+      "features": [],
+      "limits": {}
+    },
+    {
+      "name": "Annual Credits",
+      "slug": "annual-credits",
+      "pricingModel": "custom",
+      "basePrice": null,
+      "billingPeriod": "annual",
+      "annualDiscount": null,
+      "seatPrice": null,
+      "usageMetrics": [],
+      "features": [],
+      "limits": {}
+    }
+  ]
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const registry_js_1 = require("./registry/registry.js");
+const server_js_1 = require("./server.js");
+// __dirname is dist/src/ when compiled, so go up two levels to project root
+const DATA_DIR = path_1.default.join(__dirname, "..", "..", "data", "tools");
+async function main() {
+    const registry = new registry_js_1.Registry(DATA_DIR);
+    console.error(`Pricing.md: loaded ${registry.size} tools across ${registry.categories().length} categories`);
+    const server = (0, server_js_1.createServer)(registry);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/src/registry/registry.d.ts

@@ -0,0 +1,52 @@
+import { type ToolEntry, type Category } from "../schema/pricing.js";
+export interface SearchParams {
+    query?: string;
+    category?: Category;
+    hasFreeOption?: boolean;
+    maxBasePrice?: number;
+    tags?: string[];
+}
+export interface EstimateCostParams {
+    toolId: string;
+    usage: Record<string, number>;
+    seats?: number;
+    tierSlug?: string;
+}
+export interface CostEstimate {
+    toolId: string;
+    toolName: string;
+    tierName: string;
+    tierSlug: string;
+    currency: string;
+    basePrice: number;
+    seatCost: number;
+    usageCosts: {
+        metric: string;
+        quantity: number;
+        cost: number;
+        unit: string;
+    }[];
+    totalMonthly: number;
+    exceedsLimits: boolean;
+    limitWarnings: string[];
+}
+export declare class Registry {
+    private tools;
+    private byCategory;
+    constructor(dataDir: string);
+    private loadTools;
+    get size(): number;
+    get(id: string): ToolEntry | undefined;
+    search(params: SearchParams): ToolEntry[];
+    compare(toolIds: string[]): (ToolEntry | null)[];
+    estimateCost(params: EstimateCostParams): CostEstimate[];
+    private checkSeatLimits;
+    private checkUsageLimits;
+    private isSeatLimitKey;
+    private normalizeLimitKey;
+    private normalizeMetricAlias;
+    private calculateMetricCost;
+    private calculateTieredCost;
+    categories(): string[];
+    allTools(): ToolEntry[];
+}

package/dist/src/registry/registry.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registry = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pricing_js_1 = require("../schema/pricing.js");
+class Registry {
+    tools = new Map();
+    byCategory = new Map();
+    constructor(dataDir) {
+        this.loadTools(dataDir);
+    }
+    loadTools(dataDir) {
+        const files = fs_1.default.readdirSync(dataDir).filter((f) => f.endsWith(".json"));
+        for (const file of files) {
+            const raw = fs_1.default.readFileSync(path_1.default.join(dataDir, file), "utf-8");
+            const data = JSON.parse(raw);
+            const result = pricing_js_1.ToolEntrySchema.safeParse(data);
+            if (!result.success) {
+                console.warn(`Skipping ${file}: invalid schema (${result.error.issues.length} issues)`);
+                continue;
+            }
+            const tool = result.data;
+            this.tools.set(tool.id, tool);
+            const catList = this.byCategory.get(tool.category) || [];
+            catList.push(tool);
+            this.byCategory.set(tool.category, catList);
+        }
+    }
+    get size() {
+        return this.tools.size;
+    }
+    get(id) {
+        return this.tools.get(id);
+    }
+    search(params) {
+        let results = Array.from(this.tools.values());
+        if (params.category) {
+            results = results.filter((t) => t.category === params.category);
+        }
+        if (params.hasFreeOption) {
+            results = results.filter((t) => t.tiers.some((tier) => tier.pricingModel === "free" || tier.basePrice === 0));
+        }
+        if (params.maxBasePrice !== undefined) {
+            results = results.filter((t) => t.tiers.some((tier) => tier.basePrice !== null && tier.basePrice <= params.maxBasePrice));
+        }
+        if (params.tags && params.tags.length > 0) {
+            const searchTags = params.tags.map((t) => t.toLowerCase());
+            results = results.filter((t) => searchTags.some((st) => t.tags.map((tag) => tag.toLowerCase()).includes(st)));
+        }
+        if (params.query) {
+            const q = params.query.toLowerCase();
+            results = results.filter((t) => t.name.toLowerCase().includes(q) ||
+                t.description.toLowerCase().includes(q) ||
+                t.tags.some((tag) => tag.toLowerCase().includes(q)) ||
+                t.category.toLowerCase().includes(q));
+        }
+        return results;
+    }
+    compare(toolIds) {
+        return toolIds.map((id) => this.tools.get(id) || null);
+    }
+    estimateCost(params) {
+        const tool = this.tools.get(params.toolId);
+        if (!tool)
+            return [];
+        const tiersToEstimate = params.tierSlug
+            ? tool.tiers.filter((t) => t.slug === params.tierSlug)
+            : tool.tiers.filter((t) => t.pricingModel !== "custom");
+        return tiersToEstimate.map((tier) => {
+            const basePrice = tier.basePrice ?? 0;
+            const seats = params.seats ?? 1;
+            const seatCost = tier.seatPrice !== null ? tier.seatPrice * seats : 0;
+            const usageCosts = [];
+            const limitWarnings = [];
+            this.checkSeatLimits(tier.limits, params.seats, limitWarnings);
+            for (const metric of tier.usageMetrics) {
+                const quantity = params.usage[metric.name];
+                if (quantity === undefined)
+                    continue;
+                // Check if usage exceeds included quantity on a free/capped tier
+                if (quantity > metric.includedQuantity && metric.pricePerUnit === 0 && !metric.tieredPricing) {
+                    limitWarnings.push(`${metric.name}: usage (${quantity.toLocaleString()}) exceeds included ${metric.includedQuantity.toLocaleString()} ${metric.unit} with no overage pricing — this tier won't work`);
+                }
+                const cost = this.calculateMetricCost(metric, quantity);
+                usageCosts.push({
+                    metric: metric.name,
+                    quantity,
+                    cost,
+                    unit: metric.unit,
+                });
+            }
+            this.checkUsageLimits(tier.limits, params.usage, limitWarnings);
+            const totalMonthly = basePrice + seatCost + usageCosts.reduce((sum, uc) => sum + uc.cost, 0);
+            return {
+                toolId: tool.id,
+                toolName: tool.name,
+                tierName: tier.name,
+                tierSlug: tier.slug,
+                currency: tool.currency,
+                basePrice,
+                seatCost,
+                usageCosts,
+                totalMonthly,
+                exceedsLimits: limitWarnings.length > 0,
+                limitWarnings,
+            };
+        });
+    }
+    checkSeatLimits(limits, requestedSeats, limitWarnings) {
+        if (requestedSeats === undefined)
+            return;
+        const seatLimitEntries = Object.entries(limits).filter(([key]) => this.isSeatLimitKey(key));
+        for (const [key, limit] of seatLimitEntries) {
+            if (requestedSeats > limit) {
+                limitWarnings.push(`seats: requested ${requestedSeats} exceeds ${key} limit of ${limit} on this tier`);
+            }
+        }
+    }
+    checkUsageLimits(limits, usage, limitWarnings) {
+        for (const [limitKey, limitValue] of Object.entries(limits)) {
+            const normalized = this.normalizeLimitKey(limitKey);
+            if (!normalized)
+                continue;
+            const requestedQuantity = usage[normalized.metric];
+            if (requestedQuantity === undefined)
+                continue;
+            if (normalized.period === "monthly" && requestedQuantity > limitValue) {
+                limitWarnings.push(`${normalized.metric}: requested ${requestedQuantity.toLocaleString()} exceeds ${limitKey} limit of ${limitValue.toLocaleString()} on this tier`);
+            }
+            if (normalized.period === "daily") {
+                const maxMonthlyQuantity = limitValue * 31;
+                if (requestedQuantity > maxMonthlyQuantity) {
+                    limitWarnings.push(`${normalized.metric}: requested ${requestedQuantity.toLocaleString()} exceeds ${limitKey} limit of ${limitValue.toLocaleString()} per day on this tier`);
+                }
+            }
+        }
+    }
+    isSeatLimitKey(key) {
+        return ["seats", "seat", "teammates", "teammate", "members", "users"].some((token) => key.toLowerCase().includes(token));
+    }
+    normalizeLimitKey(key) {
+        const lowerKey = key.toLowerCase();
+        if (this.isSeatLimitKey(lowerKey))
+            return null;
+        const period = lowerKey.includes("permonth") || lowerKey.includes("monthly")
+            ? "monthly"
+            : lowerKey.includes("perday") || lowerKey.includes("daily")
+                ? "daily"
+                : "unknown";
+        const metric = lowerKey
+            .replace(/permonth|perday|monthly|daily/g, "")
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-+|-+$/g, "");
+        if (!metric)
+            return null;
+        return {
+            metric: this.normalizeMetricAlias(metric),
+            period,
+        };
+    }
+    normalizeMetricAlias(metric) {
+        const aliases = {
+            email: "emails",
+            emails: "emails",
+            request: "requests",
+            requests: "requests",
+            seat: "seats",
+            seats: "seats",
+            teammate: "seats",
+            teammates: "seats",
+            member: "seats",
+            members: "seats",
+            user: "seats",
+            users: "seats",
+        };
+        return aliases[metric] ?? metric;
+    }
+    calculateMetricCost(metric, quantity) {
+        const billableQuantity = Math.max(0, quantity - metric.includedQuantity);
+        if (billableQuantity === 0)
+            return 0;
+        if (metric.tieredPricing && metric.tieredPricing.length > 0) {
+            return this.calculateTieredCost(metric.tieredPricing, quantity, metric.includedQuantity, metric.unitQuantity);
+        }
+        return (billableQuantity / metric.unitQuantity) * metric.pricePerUnit;
+    }
+    calculateTieredCost(tiers, quantity, includedQuantity, unitQuantity) {
+        let cost = 0;
+        let remaining = Math.max(0, quantity - includedQuantity);
+        let prevUpTo = includedQuantity;
+        for (const tier of tiers) {
+            if (remaining <= 0)
+                break;
+            if (tier.upTo !== null && tier.upTo <= includedQuantity)
+                continue;
+            const tierCeiling = tier.upTo !== null ? Math.max(0, tier.upTo - prevUpTo) : remaining;
+            const quantityInTier = Math.min(remaining, tierCeiling);
+            cost += (quantityInTier / unitQuantity) * tier.pricePerUnit;
+            remaining -= quantityInTier;
+            if (tier.upTo !== null)
+                prevUpTo = tier.upTo;
+        }
+        return cost;
+    }
+    categories() {
+        return Array.from(this.byCategory.keys()).sort();
+    }
+    allTools() {
+        return Array.from(this.tools.values());
+    }
+}
+exports.Registry = Registry;