@aws/ml-container-creator 0.2.4 → 0.2.6

package/servers/instance-recommender/index.js

@@ -1,284 +0,0 @@
-#!/usr/bin/env node
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * Instance Recommender MCP Server
- *
- * A bundled MCP server that recommends SageMaker instance types and
- * IAM role ARNs based on the current ML framework and model configuration.
- *
- * Supports two modes:
- *   - Static (default): Returns hardcoded instance lists by framework category
- *   - Smart (--smart flag or BEDROCK_SMART=true): Queries Amazon Bedrock for
- *     context-aware recommendations, falling back to static on failure
- *
- * Tool: get_instance_types
- *   Accepts: { parameters: string[], limit: number, context: object }
- *   Returns: { values: Record<string, string>, choices: Record<string, string[]> }
- */
-
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { z } from 'zod'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { resolve, dirname } from 'node:path'
-import { queryBedrock } from '../lib/bedrock-client.js'
-
-// ── Catalog loader ───────────────────────────────────────────────────────────
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-
-/**
- * Load and parse a JSON catalog file relative to the server directory.
- * Throws on missing file or invalid JSON with the file path in the message.
- *
- * @param {string} relativePath - Path relative to server dir (e.g. './catalogs/instances.json')
- * @returns {any} Parsed JSON content
- */
-function loadCatalog(relativePath) {
-    const fullPath = resolve(__dirname, relativePath)
-    let raw
-    try {
-        raw = readFileSync(fullPath, 'utf8')
-    } catch (err) {
-        throw new Error(`Catalog file not found: ${fullPath}`)
-    }
-    try {
-        return JSON.parse(raw)
-    } catch (err) {
-        throw new Error(`Failed to parse catalog ${fullPath}: ${err.message}`)
-    }
-}
-
-// ── Load catalogs from JSON files ─────────────────────────────────────────────
-
-let INSTANCE_CATALOG
-let INSTANCE_RECOMMENDATIONS
-
-try {
-    const data = loadCatalog('./catalogs/instances.json')
-    INSTANCE_CATALOG = data.catalog
-    INSTANCE_RECOMMENDATIONS = data.recommendations
-} catch (err) {
-    process.stderr.write(`[instance-recommender] Fatal: ${err.message}\n`)
-    process.exit(1)
-}
-
-const GPU_FRAMEWORKS = new Set(['transformers'])
-
-// Bedrock configuration
-const SMART_MODE = process.env.BEDROCK_SMART === 'true'
-const BEDROCK_MODEL = process.env.BEDROCK_MODEL || 'global.anthropic.claude-sonnet-4-20250514-v1:0'
-const BEDROCK_REGION = process.env.BEDROCK_REGION || process.env.AWS_REGION || 'us-east-1'
-
-/**
- * Per-server configuration passed to the shared Bedrock client.
- */
-const SERVER_CONFIG = {
-    serverName: 'instance-recommender',
-    systemPromptTemplate: `You are an AWS SageMaker instance type advisor. Given the following ML deployment context, recommend the best SageMaker instance types.
-
-Current configuration: {context}
-Requested parameters: {parameters}
-Maximum recommendations per parameter: {limit}
-
-Respond with ONLY a JSON object in this exact format, no other text:
-{
-  "values": {
-    "instanceType": "the single best instance type as a string",
-    "awsRoleArn": "a recommended role ARN pattern if applicable"
-  }
-}
-
-Rules:
-- Only include parameters that were requested
-- For instanceType: recommend real SageMaker instance types (ml.* prefix) appropriate for the framework and model
-- For awsRoleArn: skip this field, do not recommend ARNs
-- The first value in any list should be your top recommendation
-- Consider GPU vs CPU needs based on the framework
-- Consider model size and memory requirements if model info is available
-- Return valid JSON only`,
-    temperature: 0.3,
-    maxTokens: 1024,
-    modelId: BEDROCK_MODEL,
-    region: BEDROCK_REGION
-}
-
-/**
- * Determine which instance list to use based on framework context and optional search term.
- * When instanceSearch is provided, filters the catalog by keyword matching.
- */
-function getStaticInstances(context) {
-    const framework = context?.framework
-    const search = context?.instanceSearch
-
-    // Start with framework-based category filter
-    const isGpu = framework && GPU_FRAMEWORKS.has(framework)
-    if (!search) {
-        // No search term — return the legacy category-based list
-        return isGpu ? INSTANCE_RECOMMENDATIONS.gpu : INSTANCE_RECOMMENDATIONS.cpu
-    }
-
-    // Search mode: use the full catalog
-    let candidates = Object.entries(INSTANCE_CATALOG)
-
-    // Tokenize search into lowercase keywords
-    const tokens = search.toLowerCase().split(/[\s,\-_]+/).filter(Boolean)
-
-    // Detect compound terms before tokenization
-    const rawLower = search.toLowerCase()
-    const wantsMultiGpu = rawLower.includes('multi gpu') || rawLower.includes('multi-gpu') || rawLower.includes('multigpu')
-
-    // Detect CUDA version requests: "cuda 12", "cuda 11.8", "cuda-12.1"
-    const cudaMatch = rawLower.match(/cuda[\s\-_]*(\d+(?:\.\d+)?)/)
-    const wantsCudaVersion = cudaMatch ? cudaMatch[1] : null
-
-    // Score each instance by how many tokens match its tags, accelerator, or instance name
-    const scored = candidates.map(([name, meta]) => {
-        let score = 0
-        const cudaStr = meta.cudaVersions ? meta.cudaVersions.join(' ') : ''
-        const haystack = [...meta.tags, meta.accelerator.toLowerCase(), name, meta.category, cudaStr].join(' ')
-
-        // Compound term: multi-gpu — only match instances with >1 GPU
-        if (wantsMultiGpu) {
-            if (meta.gpus > 1) {
-                score += 5
-            } else {
-                return { name, meta, score: 0 }
-            }
-        }
-
-        // Compound term: cuda version — only match instances supporting that version
-        if (wantsCudaVersion) {
-            if (!meta.cudaVersions) return { name, meta, score: 0 }
-            const hasExact = meta.cudaVersions.includes(wantsCudaVersion)
-            const hasMajor = meta.cudaVersions.some(v => v.startsWith(wantsCudaVersion))
-            if (hasExact) {
-                score += 4
-            } else if (hasMajor) {
-                score += 3
-            } else {
-                return { name, meta, score: 0 }
-            }
-        }
-
-        for (const token of tokens) {
-            // Skip tokens already handled by compound term detection
-            if (wantsMultiGpu && (token === 'multi' || token === 'gpu')) continue
-            if (wantsCudaVersion && (token === 'cuda' || token === wantsCudaVersion)) continue
-
-            if (haystack.includes(token)) score += 1
-            if (meta.gpus > 1 && (token === 'parallel')) score += 2
-            if (token === 'gpu' && meta.gpus > 0) score += 1
-            if (token === 'cpu' && meta.gpus === 0) score += 1
-            if (token === 'cheap' || token === 'budget' || token === 'cost') {
-                if (meta.tags.includes('budget') || meta.tags.includes('cost-effective')) score += 1
-            }
-            if (token === 'memory' || token === 'high-memory') {
-                if (meta.memGb >= 32) score += 1
-            }
-            if (token === 'large' && meta.vcpus >= 16) score += 1
-            // Match specific CUDA versions (e.g. "11.8", "12.1")
-            if (meta.cudaVersions && meta.cudaVersions.includes(token)) score += 2
-        }
-        return { name, meta, score }
-    })
-
-    // Keep only instances with a positive score, sorted descending
-    const matched = scored.filter(s => s.score > 0).sort((a, b) => b.score - a.score)
-
-    if (matched.length === 0) {
-        // No matches — fall back to legacy category-based list
-        return isGpu ? INSTANCE_RECOMMENDATIONS.gpu : INSTANCE_RECOMMENDATIONS.cpu
-    }
-
-    return matched.map(s => s.name)
-}
-
-/**
- * Log to stderr so it doesn't interfere with MCP stdio protocol on stdout.
- */
-function log(message) {
-    process.stderr.write(`[instance-recommender] ${message}\n`)
-}
-
-// Create MCP server
-const server = new McpServer({
-    name: 'instance-recommender',
-    version: '1.0.0'
-})
-
-// Register the get_instance_types tool
-server.tool(
-    'get_instance_types',
-    'Returns recommended SageMaker instance types and configuration values for ML Container Creator',
-    {
-        parameters: z.array(z.string()).describe('List of parameter names to provide values for'),
-        limit: z.number().int().positive().default(10).describe('Maximum number of choices per parameter'),
-        context: z.record(z.string(), z.any()).optional().describe('Current configuration context (framework, modelServer, etc.)')
-    },
-    async ({ parameters, limit, context }) => {
-        const values = {}
-        const choices = {}
-        let usedSmart = false
-
-        // Smart mode: try Bedrock first
-        if (SMART_MODE && parameters.includes('instanceType')) {
-            log('[smart] Smart mode enabled, querying Amazon Bedrock...')
-            const bedrockResult = await queryBedrock(SERVER_CONFIG, parameters, limit, context || {})
-
-            if (bedrockResult?.values?.instanceType) {
-                values.instanceType = bedrockResult.values.instanceType
-                // Use the Bedrock recommendation as the top choice, pad with static list
-                const staticInstances = getStaticInstances(context || {})
-                const bedrockValue = bedrockResult.values.instanceType
-                const combined = [bedrockValue, ...staticInstances.filter(i => i !== bedrockValue)]
-                choices.instanceType = combined.slice(0, limit)
-                usedSmart = true
-                log(`[smart] Using Bedrock recommendation: ${bedrockValue}`)
-            } else {
-                log('[smart] Bedrock did not return usable results, falling back to static recommendations')
-            }
-        }
-
-        // Static fallback (or non-smart mode)
-        if (!usedSmart) {
-            for (const param of parameters) {
-                if (param === 'instanceType') {
-                    const instances = getStaticInstances(context || {})
-                    const limited = instances.slice(0, limit)
-                    values.instanceType = limited[0]
-                    choices.instanceType = limited
-                }
-                // awsRoleArn is left to the user — no default recommendations
-            }
-        }
-
-        return {
-            content: [{
-                type: 'text',
-                text: JSON.stringify({ values, choices })
-            }]
-        }
-    }
-)
-
-// Export for standalone testing
-export { loadCatalog, getStaticInstances, INSTANCE_CATALOG, INSTANCE_RECOMMENDATIONS, GPU_FRAMEWORKS }
-
-// Guard MCP transport — only connect when run as main module
-const isMain = process.argv[1] && resolve(process.argv[1]) === __filename
-
-if (isMain) {
-    if (SMART_MODE) {
-        log(`Smart mode enabled (model: ${BEDROCK_MODEL}, region: ${BEDROCK_REGION})`)
-    } else {
-        log('Static mode (set BEDROCK_SMART=true to enable Bedrock-powered recommendations)')
-    }
-
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-}

package/servers/instance-recommender/manifest.json

@@ -1,16 +0,0 @@
-{
-    "name": "@amzn/ml-container-creator-instance-recommender",
-    "version": "1.0.0",
-    "description": "MCP server that recommends SageMaker instance types for ML Container Creator.",
-    "modes": {
-        "static": true,
-        "smart": true,
-        "discover": false
-    },
-    "catalogs": {
-        "instances": "./catalogs/instances.json"
-    },
-    "tool": {
-        "name": "get_instance_types"
-    }
-}

package/servers/instance-recommender/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "@amzn/ml-container-creator-instance-recommender",
-  "private": true,
-  "version": "1.0.0",
-  "description": "MCP server that recommends SageMaker instance types and IAM role ARNs based on ML framework and model configuration. Supports Bedrock-powered smart recommendations.",
-  "type": "module",
-  "main": "index.js",
-  "license": "Apache-2.0",
-  "scripts": {
-    "test": "node test.js"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
-  }
-}