@aws/ml-container-creator 0.2.4 → 0.2.6

package/servers/instance-sizer/lib/instance-ranker.js

@@ -0,0 +1,245 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Instance Filter & Ranker
+ *
+ * Filters and ranks SageMaker instances by compatibility with a model's
+ * VRAM requirement. Considers tensor parallelism for multi-GPU instances
+ * and applies cost-efficiency ranking within each TP tier.
+ */
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+/**
+ * GPU memory per chip (in GB) by hardware type.
+ * Used when the catalog doesn't have a direct gpuMemoryGb field.
+ */
+const GPU_MEMORY_MAP = {
+    'NVIDIA T4': 16,
+    'NVIDIA A10G': 24,
+    'NVIDIA V100': 16,
+    'NVIDIA L4': 24,
+    'NVIDIA A100': 40,
+    'NVIDIA H100': 80,
+    'AWS Inferentia2': 32,
+    'AWS Trainium': 32
+}
+
+/**
+ * Cost tier classification by instance family.
+ */
+const COST_TIER_MAP = {
+    'g4dn': 'low',
+    'inf2': 'low',
+    'g5': 'medium',
+    'g6': 'medium',
+    'trn1': 'medium',
+    'p3': 'high',
+    'p4d': 'high',
+    'p4de': 'high',
+    'p5': 'high'
+}
+
+/**
+ * Relative cost weight by tier for sorting within TP groups.
+ * Lower is better (more cost-efficient).
+ */
+const COST_TIER_WEIGHT = {
+    'low': 1,
+    'medium': 2,
+    'high': 3
+}
+
+/**
+ * TP overhead penalty: 10% per additional GPU beyond the first.
+ * Effective VRAM = totalVram × (1 - 0.10 × (gpuCount - 1))
+ */
+const TP_OVERHEAD_PER_GPU = 0.10
+
+// ── Helper Functions ─────────────────────────────────────────────────────────
+
+/**
+ * Extract per-GPU memory in GB from an instance catalog entry.
+ *
+ * Tries these approaches in order:
+ * 1. Direct gpuMemoryGb field (if catalog has been extended)
+ * 2. Parse from accelerator string (e.g., "4x A10G 96GB" → 24 per GPU)
+ * 3. Lookup by hardware type from GPU_MEMORY_MAP
+ *
+ * @param {object} instance - Instance catalog entry
+ * @returns {number|null} Per-GPU memory in GB, or null if not determinable
+ */
+const getPerGpuMemoryGb = (instance) => {
+    // 1. Direct field
+    if (instance.gpuMemoryGb) {
+        return instance.gpuMemoryGb
+    }
+
+    // 2. Parse from accelerator string
+    if (instance.accelerator) {
+        // Match patterns like "A10G 24GB", "4x A10G 96GB", "T4 16GB"
+        const totalMatch = instance.accelerator.match(/(\d+)GB/)
+        if (totalMatch) {
+            const totalGb = parseInt(totalMatch[1], 10)
+            const gpuCount = instance.gpus || 1
+            // If the string has a multiplier prefix like "4x", the GB is total
+            const hasMultiplier = instance.accelerator.match(/^(\d+)x\s/)
+            if (hasMultiplier) {
+                return totalGb / gpuCount
+            }
+            // Single GPU entry — the GB value is per-GPU
+            return totalGb
+        }
+    }
+
+    // 3. Lookup by hardware type
+    if (instance.hardware && GPU_MEMORY_MAP[instance.hardware]) {
+        return GPU_MEMORY_MAP[instance.hardware]
+    }
+
+    return null
+}
+
+/**
+ * Determine cost tier for an instance based on its family.
+ *
+ * @param {object} instance - Instance catalog entry
+ * @returns {string} 'low', 'medium', or 'high'
+ */
+const getCostTier = (instance) => {
+    if (instance.costTier) {
+        return instance.costTier
+    }
+    const family = instance.family || ''
+    return COST_TIER_MAP[family] || 'medium'
+}
+
+/**
+ * Calculate effective VRAM available after TP overhead penalty.
+ *
+ * Each additional GPU beyond the first loses 10% of its per-GPU capacity
+ * to communication overhead. The first GPU contributes its full capacity.
+ *
+ * Formula: perGpuMemory + (gpuCount - 1) × perGpuMemory × (1 - TP_OVERHEAD_PER_GPU)
+ * Simplified: perGpuMemory × (1 + (gpuCount - 1) × 0.9)
+ * Or equivalently: totalVram - perGpuMemory × 0.10 × (gpuCount - 1)
+ *
+ * @param {number} totalVramGb - Total GPU VRAM in GB
+ * @param {number} gpuCount - Number of GPUs (TP degree)
+ * @returns {number} Effective usable VRAM in GB
+ */
+const effectiveVram = (totalVramGb, gpuCount) => {
+    if (gpuCount <= 1) return totalVramGb
+    const perGpuMemory = totalVramGb / gpuCount
+    const overhead = perGpuMemory * TP_OVERHEAD_PER_GPU * (gpuCount - 1)
+    return totalVramGb - overhead
+}
+
+// ── Main Function ────────────────────────────────────────────────────────────
+
+/**
+ * Filter and rank instances by compatibility with VRAM requirement.
+ *
+ * @param {number} vramRequired - Required VRAM in GB
+ * @param {object} instanceCatalog - Object keyed by instance type, values are metadata
+ * @param {object} [options={}]
+ * @param {number} [options.limit=8] - Max results to return
+ * @param {boolean} [options.allowTensorParallelism=true] - Consider multi-GPU splits
+ * @returns {object[]} Ranked list of compatible instances
+ */
+const filterAndRankInstances = (vramRequired, instanceCatalog, options = {}) => {
+    const { limit = 8, allowTensorParallelism = true } = options
+
+    if (!vramRequired || vramRequired <= 0) {
+        return []
+    }
+
+    if (!instanceCatalog || typeof instanceCatalog !== 'object') {
+        return []
+    }
+
+    const candidates = []
+
+    for (const [instanceType, meta] of Object.entries(instanceCatalog)) {
+        // Skip non-GPU instances
+        if (!meta.gpus || meta.gpus <= 0) continue
+        if (meta.category !== 'gpu') continue
+
+        const perGpuMemory = getPerGpuMemoryGb(meta)
+        if (!perGpuMemory) continue
+
+        const gpuCount = meta.gpus
+        const totalVramGb = perGpuMemory * gpuCount
+
+        // Determine if model fits on a single GPU
+        if (gpuCount === 1) {
+            if (perGpuMemory >= vramRequired) {
+                const utilizationPercent = Math.round((vramRequired / perGpuMemory) * 100)
+                candidates.push({
+                    instanceType,
+                    gpuCount,
+                    totalVramGb,
+                    utilizationPercent,
+                    tensorParallelism: 1,
+                    costTier: getCostTier(meta)
+                })
+            }
+        } else if (allowTensorParallelism) {
+            // Multi-GPU: check if model fits with TP across all GPUs
+            const effectiveTotal = effectiveVram(totalVramGb, gpuCount)
+            if (effectiveTotal >= vramRequired) {
+                const utilizationPercent = Math.round((vramRequired / effectiveTotal) * 100)
+                candidates.push({
+                    instanceType,
+                    gpuCount,
+                    totalVramGb,
+                    utilizationPercent,
+                    tensorParallelism: gpuCount,
+                    costTier: getCostTier(meta)
+                })
+            }
+        }
+    }
+
+    // Sort candidates by ranking criteria:
+    // 1. Single-GPU first (TP=1), then multi-GPU by lowest TP degree
+    // 2. Within each TP tier, sort by cost-efficiency (lowest cost tier first,
+    //    then by lowest utilization — more headroom is better for the same cost)
+    candidates.sort((a, b) => {
+        // Primary: TP degree (lower is better)
+        if (a.tensorParallelism !== b.tensorParallelism) {
+            return a.tensorParallelism - b.tensorParallelism
+        }
+
+        // Secondary: cost tier (lower is better)
+        const costA = COST_TIER_WEIGHT[a.costTier] || 2
+        const costB = COST_TIER_WEIGHT[b.costTier] || 2
+        if (costA !== costB) {
+            return costA - costB
+        }
+
+        // Tertiary: cost-efficiency — lower $/GB approximated by
+        // lower cost tier with higher total VRAM (more GB per dollar)
+        // Since cost tier is equal here, prefer higher total VRAM (better value)
+        if (a.totalVramGb !== b.totalVramGb) {
+            return a.totalVramGb - b.totalVramGb
+        }
+
+        // Final tiebreaker: instance type name for deterministic ordering
+        return a.instanceType.localeCompare(b.instanceType)
+    })
+
+    return candidates.slice(0, limit)
+}
+
+export {
+    filterAndRankInstances,
+    getPerGpuMemoryGb,
+    getCostTier,
+    effectiveVram,
+    GPU_MEMORY_MAP,
+    COST_TIER_MAP,
+    COST_TIER_WEIGHT,
+    TP_OVERHEAD_PER_GPU
+}

package/servers/instance-sizer/lib/model-resolver.js

@@ -0,0 +1,265 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Model Metadata Resolver
+ *
+ * Three-tier resolution strategy for model metadata:
+ * 1. Check model-sizes catalog (exact match or glob pattern match)
+ * 2. If discover mode enabled, fetch HuggingFace config.json
+ * 3. If neither available, return null (caller handles fallback)
+ */
+
+import { readFile } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const DEFAULT_CATALOG_PATH = join(__dirname, '..', '..', 'lib', 'catalogs', 'models.json')
+const HUGGINGFACE_BASE_URL = 'https://huggingface.co'
+const HUGGINGFACE_TIMEOUT_MS = 5000
+
+// ── Glob Pattern Matching ────────────────────────────────────────────────────
+
+/**
+ * Simple glob pattern matcher supporting * wildcards.
+ * Case-insensitive matching.
+ *
+ * @param {string} pattern - Glob pattern (e.g., 'meta-llama/Llama-2-7b*')
+ * @param {string} text - Text to match against
+ * @returns {boolean} Whether the text matches the pattern
+ */
+const globMatch = (pattern, text) => {
+    const regexStr = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+    const regex = new RegExp(`^${regexStr}$`, 'i')
+    return regex.test(text)
+}
+
+// ── Catalog Lookup ───────────────────────────────────────────────────────────
+
+/**
+ * Load the model-sizes catalog from disk.
+ *
+ * @param {string} [catalogPath] - Path to catalog JSON file
+ * @returns {Promise<object|null>} Parsed catalog or null on failure
+ */
+const loadCatalog = async (catalogPath) => {
+    try {
+        const raw = await readFile(catalogPath || DEFAULT_CATALOG_PATH, 'utf-8')
+        return JSON.parse(raw)
+    } catch {
+        return null
+    }
+}
+
+/**
+ * Look up a model in the catalog by exact match or glob pattern.
+ *
+ * @param {string} modelName - HuggingFace model ID or catalog key
+ * @param {object} catalog - Parsed catalog object (flat or with .models wrapper)
+ * @returns {object|null} Catalog entry or null if not found
+ */
+const catalogLookup = (modelName, catalog) => {
+    if (!catalog) {
+        return null
+    }
+
+    // Support both flat catalog (models.json) and wrapped format ({ models: {...} })
+    const models = catalog.models || catalog
+
+    // Try exact match first
+    if (models[modelName]) {
+        return models[modelName]
+    }
+
+    // Try glob pattern matching
+    for (const pattern of Object.keys(models)) {
+        if (globMatch(pattern, modelName)) {
+            return models[pattern]
+        }
+    }
+
+    return null
+}
+
+// ── HuggingFace API ──────────────────────────────────────────────────────────
+
+/**
+ * Fetch model config.json from HuggingFace Hub.
+ *
+ * @param {string} modelName - HuggingFace model ID (e.g., 'meta-llama/Llama-2-7b-chat-hf')
+ * @returns {Promise<object|null>} Parsed config or null on failure
+ */
+const fetchHuggingFaceConfig = async (modelName) => {
+    const url = `${HUGGINGFACE_BASE_URL}/${modelName}/resolve/main/config.json`
+
+    try {
+        const controller = new AbortController()
+        const timeout = setTimeout(() => controller.abort(), HUGGINGFACE_TIMEOUT_MS)
+
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: { 'Accept': 'application/json' }
+        })
+
+        clearTimeout(timeout)
+
+        if (!response.ok) {
+            return null
+        }
+
+        return await response.json()
+    } catch {
+        return null
+    }
+}
+
+/**
+ * Estimate parameter count from architecture dimensions.
+ * Uses the approximation: hidden_size × num_hidden_layers × 12
+ *
+ * This accounts for:
+ * - Attention weights (Q, K, V, O projections = 4 × hidden_size²)
+ * - FFN weights (typically 8 × hidden_size²)
+ * - Embeddings and other components
+ *
+ * @param {object} config - HuggingFace config.json contents
+ * @returns {number|null} Estimated parameter count or null if dimensions unavailable
+ */
+const estimateParamsFromConfig = (config) => {
+    const hiddenSize = config.hidden_size
+    const numLayers = config.num_hidden_layers
+
+    if (!hiddenSize || !numLayers) {
+        return null
+    }
+
+    return hiddenSize * numLayers * 12
+}
+
+/**
+ * Extract model metadata from a HuggingFace config.json.
+ *
+ * @param {object} config - Parsed HuggingFace config.json
+ * @returns {object} Extracted metadata
+ */
+const extractFromHuggingFaceConfig = (config) => {
+    const parameterCount = config.num_parameters
+        ?? estimateParamsFromConfig(config)
+
+    const dtype = config.torch_dtype || 'float16'
+    const architecture = config.architectures?.[0] || 'unknown'
+    const maxPositionEmbeddings = config.max_position_embeddings || 4096
+
+    return {
+        parameterCount,
+        dtype,
+        architecture,
+        maxPositionEmbeddings,
+        source: 'huggingface_api'
+    }
+}
+
+// ── In-memory cache for discover mode ────────────────────────────────────────
+
+const discoverCache = new Map()
+
+// ── Protocol prefix detection ────────────────────────────────────────────────
+
+const PROTOCOL_PREFIXES = ['jumpstart://', 'jumpstart-hub://', 's3://', 'registry://']
+
+/**
+ * Check if a model name matches the HuggingFace org/model-name pattern.
+ * Must contain exactly one `/` and no protocol prefix.
+ *
+ * @param {string} modelName - Model identifier to check
+ * @returns {boolean} True if it matches the HuggingFace pattern
+ */
+const isHuggingFacePattern = (modelName) => {
+    if (!modelName || typeof modelName !== 'string') return false
+    // Must not have a protocol prefix
+    if (PROTOCOL_PREFIXES.some(prefix => modelName.startsWith(prefix))) return false
+    // Must contain exactly one `/` (org/model-name)
+    const slashCount = (modelName.match(/\//g) || []).length
+    return slashCount === 1
+}
+
+// ── Main Resolver ────────────────────────────────────────────────────────────
+
+/**
+ * Resolve model metadata from available sources.
+ *
+ * Three-tier resolution:
+ * 1. Check model-sizes catalog (exact match or pattern match)
+ * 2. If discover mode enabled AND model matches HuggingFace pattern, fetch config.json
+ * 3. If neither available, return null
+ *
+ * @param {string} modelName - HuggingFace model ID or catalog key
+ * @param {object} [options={}]
+ * @param {boolean} [options.discover=false] - Enable HuggingFace API lookups
+ * @param {string} [options.catalogPath] - Path to model-sizes catalog (for testing)
+ * @returns {Promise<{ parameterCount: number, dtype: string, architecture: string, maxPositionEmbeddings: number, source: string } | null>}
+ */
+const resolveModelMetadata = async (modelName, options = {}) => {
+    const { discover = false, catalogPath } = options
+
+    // Tier 1: Catalog lookup
+    const catalog = await loadCatalog(catalogPath)
+    const catalogEntry = catalogLookup(modelName, catalog)
+
+    if (catalogEntry) {
+        return {
+            parameterCount: catalogEntry.parameterCount,
+            dtype: catalogEntry.defaultDtype,
+            architecture: catalogEntry.architecture,
+            maxPositionEmbeddings: catalogEntry.maxPositionEmbeddings,
+            source: 'catalog'
+        }
+    }
+
+    // Tier 2: HuggingFace API (only in discover mode, only for org/model-name pattern)
+    if (discover && isHuggingFacePattern(modelName)) {
+        // Check in-memory cache first
+        if (discoverCache.has(modelName)) {
+            return discoverCache.get(modelName)
+        }
+
+        const config = await fetchHuggingFaceConfig(modelName)
+
+        if (config) {
+            const metadata = extractFromHuggingFaceConfig(config)
+
+            // Only return if we got a usable parameter count
+            if (metadata.parameterCount) {
+                // Cache for session duration
+                discoverCache.set(modelName, metadata)
+                return metadata
+            }
+        }
+    }
+
+    // Tier 3: No metadata available
+    return null
+}
+
+export {
+    resolveModelMetadata,
+    globMatch,
+    loadCatalog,
+    catalogLookup,
+    fetchHuggingFaceConfig,
+    estimateParamsFromConfig,
+    extractFromHuggingFaceConfig,
+    isHuggingFacePattern,
+    discoverCache,
+    PROTOCOL_PREFIXES,
+    DEFAULT_CATALOG_PATH,
+    HUGGINGFACE_BASE_URL,
+    HUGGINGFACE_TIMEOUT_MS
+}

package/servers/instance-sizer/lib/vram-estimator.js

@@ -0,0 +1,177 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * VRAM Estimation Engine
+ *
+ * Converts model metadata (parameter count, dtype, quantization) into a
+ * memory requirement estimate. Used by the instance-sizer MCP server to
+ * filter and rank compatible SageMaker instances.
+ */
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const BYTES_PER_PARAM = {
+    float32: 4.0,
+    float16: 2.0,
+    bfloat16: 2.0,
+    int8: 1.0,
+    int4: 0.5
+}
+
+const QUANTIZATION_BYTES = {
+    'awq': 0.5,
+    'gptq': 0.5,
+    'bnb-4bit': 0.5,
+    'bnb-8bit': 1.0
+}
+
+const BYTES_IN_GB = 1024 ** 3
+
+const DEFAULT_MAX_SEQUENCE_LENGTH = 4096
+const DEFAULT_BATCH_SIZE = 1
+const OVERHEAD_FACTOR = 0.1
+
+// ── Helper Functions ─────────────────────────────────────────────────────────
+
+/**
+ * Look up bytes per parameter based on dtype and optional quantization.
+ * Quantization takes precedence over dtype when provided.
+ *
+ * @param {string} dtype - Data type: 'float32', 'float16', 'bfloat16', 'int8', 'int4'
+ * @param {string} [quantization] - Quantization method: 'awq', 'gptq', 'bnb-4bit', 'bnb-8bit'
+ * @returns {number} Bytes per parameter
+ */
+const bytesPerParam = (dtype, quantization) => {
+    if (quantization && QUANTIZATION_BYTES[quantization] !== undefined) {
+        return QUANTIZATION_BYTES[quantization]
+    }
+    return BYTES_PER_PARAM[dtype] ?? BYTES_PER_PARAM.float16
+}
+
+/**
+ * Estimate KV cache memory usage.
+ *
+ * The KV cache scales with sequence length and batch size. This uses a
+ * simplified heuristic based on the observation that KV cache for a typical
+ * transformer is roughly proportional to (numLayers × hiddenSize × seqLen × batch × 2 keys+values × 2 bytes).
+ * We approximate numLayers × hiddenSize as sqrt(parameterCount) × scaling factor.
+ *
+ * For a 7B model at seq=4096, batch=1, this yields ~0.5GB which matches
+ * real-world observations for Llama-2-7B.
+ *
+ * @param {number} parameterCount - Total model parameters
+ * @param {number} maxSequenceLength - Maximum context/sequence length
+ * @param {number} batchSize - Expected concurrent batch size
+ * @returns {number} Estimated KV cache size in bytes
+ */
+const estimateKvCache = (parameterCount, maxSequenceLength, batchSize) => {
+    const seqLength = maxSequenceLength ?? DEFAULT_MAX_SEQUENCE_LENGTH
+    const batch = batchSize ?? DEFAULT_BATCH_SIZE
+
+    // Heuristic: KV cache ≈ parameterCount × (seqLength / 4096) × batch × 0.05 bytes
+    // This gives ~5% of raw param count in bytes at default seq length and batch=1
+    // For 7B params: 7e9 × 0.05 = 350MB at seq=4096, batch=1
+    // Scales linearly with sequence length and batch size
+    const kvBytes = parameterCount * (seqLength / DEFAULT_MAX_SEQUENCE_LENGTH) * batch * 0.05
+    return kvBytes
+}
+
+// ── Main Estimation Function ─────────────────────────────────────────────────
+
+/**
+ * Estimate VRAM required to serve a model.
+ *
+ * @param {object} modelInfo
+ * @param {number} modelInfo.parameterCount - Total parameters (e.g., 7_000_000_000)
+ * @param {string} modelInfo.dtype - Data type: 'float32', 'float16', 'bfloat16', 'int8', 'int4'
+ * @param {string} [modelInfo.quantization] - Quantization method: 'awq', 'gptq', 'bnb-4bit', 'bnb-8bit'
+ * @param {number} [modelInfo.maxSequenceLength] - Max context length (affects KV cache)
+ * @param {number} [modelInfo.batchSize] - Expected concurrent batch size
+ * @returns {{ vramGb: number, breakdown: { weightsGb: number, kvCacheGb: number, overheadGb: number }, confidence: string, source: string }}
+ */
+const estimateVram = (modelInfo) => {
+    const {
+        parameterCount,
+        dtype,
+        quantization,
+        maxSequenceLength,
+        batchSize
+    } = modelInfo
+
+    // Determine confidence based on what was explicitly provided
+    const confidence = determineConfidence(modelInfo)
+
+    // Calculate base weight bytes
+    const bpp = bytesPerParam(dtype, quantization)
+    const baseWeightBytes = parameterCount * bpp
+
+    // Calculate KV cache
+    const kvCacheBytes = estimateKvCache(
+        parameterCount,
+        maxSequenceLength ?? DEFAULT_MAX_SEQUENCE_LENGTH,
+        batchSize ?? DEFAULT_BATCH_SIZE
+    )
+
+    // Calculate overhead (framework/CUDA)
+    const overheadBytes = baseWeightBytes * OVERHEAD_FACTOR
+
+    // Total VRAM
+    const totalVramBytes = baseWeightBytes + kvCacheBytes + overheadBytes
+    const vramGb = totalVramBytes / BYTES_IN_GB
+
+    return {
+        vramGb,
+        breakdown: {
+            weightsGb: baseWeightBytes / BYTES_IN_GB,
+            kvCacheGb: kvCacheBytes / BYTES_IN_GB,
+            overheadGb: overheadBytes / BYTES_IN_GB
+        },
+        confidence,
+        source: 'estimate'
+    }
+}
+
+/**
+ * Determine confidence level based on which parameters were explicitly provided.
+ *
+ * - 'high': All key parameters (parameterCount, dtype) are explicitly provided
+ * - 'medium': Some parameters are provided but others use defaults
+ * - 'low': Using fallback values for critical parameters
+ *
+ * @param {object} modelInfo
+ * @returns {'high' | 'medium' | 'low'}
+ */
+const determineConfidence = (modelInfo) => {
+    const { parameterCount, dtype, maxSequenceLength, batchSize } = modelInfo
+
+    if (!parameterCount || !dtype) {
+        return 'low'
+    }
+
+    // If dtype is not in our known list, confidence drops
+    if (!BYTES_PER_PARAM[dtype]) {
+        return 'low'
+    }
+
+    // All key params explicitly provided
+    if (maxSequenceLength !== undefined && batchSize !== undefined) {
+        return 'high'
+    }
+
+    // Core params present but some optional ones use defaults
+    return 'medium'
+}
+
+export {
+    estimateVram,
+    bytesPerParam,
+    estimateKvCache,
+    determineConfidence,
+    BYTES_PER_PARAM,
+    QUANTIZATION_BYTES,
+    DEFAULT_MAX_SEQUENCE_LENGTH,
+    DEFAULT_BATCH_SIZE,
+    OVERHEAD_FACTOR,
+    BYTES_IN_GB
+}

package/servers/instance-sizer/manifest.json

@@ -0,0 +1,17 @@
+{
+    "name": "@amzn/ml-container-creator-instance-sizer",
+    "version": "1.0.0",
+    "description": "MCP server that estimates VRAM requirements and recommends compatible SageMaker instances.",
+    "modes": {
+        "static": true,
+        "smart": true,
+        "discover": true
+    },
+    "catalogs": {
+        "models": "../lib/catalogs/models.json",
+        "instances": "../lib/catalogs/instances.json"
+    },
+    "tool": {
+        "name": "get_instance_recommendation"
+    }
+}