vme-mcp-server 0.1.2

package/README.md

@@ -0,0 +1,154 @@
+# VME MCP Server
+
+An intelligent Model Context Protocol (MCP) server that transforms HPE VM Essentials (VME) infrastructure management into natural language conversations. Provision VMs, manage resources, and control your infrastructure through simple English commands with Claude Code.
+
+## Quick Start
+
+### Prerequisites
+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed
+- Node.js 18+ and npm
+- Access to an HPE VM Essentials (VME) instance
+
+### 1. Clone and Setup
+
+```bash
+git clone https://github.com/frippe75/vme-mcp-server.git
+cd vme-mcp-server
+npm install
+```
+
+### 2. Configure VME API Access
+
+Create a `.env` file with your VME credentials:
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env`:
+```env
+VME_API_BASE_URL=https://your-vme-instance.com/api
+VME_API_TOKEN=your-bearer-token-here
+```
+
+### 3. Add to Claude Code
+
+**Option A: Using Claude Code CLI (Recommended)**
+
+```bash
+claude mcp add vme-server \
+  -e VME_API_BASE_URL=https://your-vme-instance.com/api \
+  -e VME_API_TOKEN=your-bearer-token \
+  -- npx tsx src/server.ts
+```
+
+**Option B: Manual Configuration**
+
+Add to your Claude Code configuration file:
+
+```json
+{
+  "mcpServers": {
+    "vme-server": {
+      "command": "npx",
+      "args": ["tsx", "src/server.ts"],
+      "cwd": "/path/to/vme-mcp-server",
+      "env": {
+        "VME_API_BASE_URL": "https://your-vme-instance.com/api",
+        "VME_API_TOKEN": "your-bearer-token"
+      }
+    }
+  }
+}
+```
+
+### 4. Restart Claude Code
+
+```bash
+claude --restart
+```
+
+### 5. Verify Installation
+
+```bash
+claude mcp list
+```
+
+You should see `vme-server` in the list of active servers.
+
+## Usage Examples
+
+### Basic VM Creation
+```
+Create a VM named "web-server-01" in the production group using Ubuntu 22.04 with 4GB memory
+```
+
+### Multi-VM Creation
+```
+Create VMs web01->web03 running on each node of the cluster. OS is not important. Small VMs
+Provision web01 through web05 spread across all cluster nodes with Ubuntu and 4GB memory
+```
+
+### Advanced VM Provisioning
+```
+Provision 3 small Ubuntu VMs for testing in the dev environment on tc-lab cloud
+Create VMs db01->db03 on specific nodes 1,2,3 respectively with Rocky Linux
+```
+
+## Key Features
+
+### Natural Language Processing
+- **Flexible terminology**: Use "zone" or "cloud", "small" or "4GB" interchangeably
+- **Smart template matching**: "Ubuntu", "ubuntu", "Ubuntu 22.04" all work
+- **Multi-VM patterns**: "web01->web03" creates web01, web02, web03
+
+### Intelligent Distribution
+- **Auto-placement**: VME cluster load balancing (default)
+- **Spread strategy**: Distribute VMs across all cluster nodes
+- **Specific targeting**: Assign VMs to particular nodes
+
+### Resource Resolution
+- Automatically finds the latest OS versions (Ubuntu 24.04, Rocky 9, etc.)
+- Intelligent size matching (small → 4GB, medium → 8GB)
+- Fallback handling for unknown resources
+
+## Testing
+
+```bash
+# Verify API connectivity (optional)
+npm run test:api
+
+# Run comprehensive test suite
+npm test
+```
+
+## Troubleshooting
+
+### Server Not Loading
+```bash
+claude mcp get vme-server
+claude --debug
+```
+
+### Authentication Issues
+```bash
+npm run test:api
+```
+
+### VM Creation Problems
+Check your VME permissions and resource availability.
+
+## Documentation
+
+- **[CONTRIBUTING.md](./CONTRIBUTING.md)** - Development setup, testing, and contribution guidelines
+- **[TESTING.md](./TESTING.md)** - Comprehensive test documentation and coverage
+- **[CLAUDE.md](./CLAUDE.md)** - Architecture vision and AI-driven development roadmap
+
+## License
+
+ISC License - see LICENSE file for details.
+
+---
+
+**Need help?** Check the [troubleshooting guide](./CONTRIBUTING.md#troubleshooting) or open an issue.

package/dist/server.js

@@ -0,0 +1,933 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const axios_1 = __importDefault(require("axios"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+dotenv_1.default.config();
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+// AI Training Data Collection Configuration
+const AI_TRAINING_ENABLED = process.env.ENABLE_AI_TRAINING_DATA === 'true';
+const AI_TRAINING_FIELDS = (process.env.AI_TRAINING_DATA_FIELDS || 'user_input,parsed_output,success_metrics').split(',');
+const AI_TRAINING_RETENTION_DAYS = parseInt(process.env.AI_TRAINING_DATA_RETENTION_DAYS || '30');
+// Privacy-aware interaction logging
+function logInteraction(interaction) {
+    if (!AI_TRAINING_ENABLED) {
+        return; // Respect user privacy choice
+    }
+    try {
+        // Ensure logs directory exists
+        const logsDir = (0, path_1.join)(process.cwd(), 'ai-training-logs');
+        if (!(0, fs_1.existsSync)(logsDir)) {
+            (0, fs_1.mkdirSync)(logsDir, { recursive: true });
+        }
+        // Filter fields based on user preferences
+        const filteredInteraction = {
+            id: interaction.id || `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: new Date().toISOString(),
+            session_id: interaction.session_id || 'unknown',
+            tool_name: interaction.tool_name || 'unknown'
+        };
+        // Only include fields user has opted into
+        if (AI_TRAINING_FIELDS.includes('user_input') && interaction.user_input) {
+            filteredInteraction.user_input = interaction.user_input;
+        }
+        if (AI_TRAINING_FIELDS.includes('parsed_output') && interaction.parsed_output) {
+            filteredInteraction.parsed_output = interaction.parsed_output;
+        }
+        if (AI_TRAINING_FIELDS.includes('api_calls') && interaction.api_calls) {
+            filteredInteraction.api_calls = interaction.api_calls;
+        }
+        if (AI_TRAINING_FIELDS.includes('success_metrics') && interaction.success_metrics) {
+            filteredInteraction.success_metrics = interaction.success_metrics;
+        }
+        if (AI_TRAINING_FIELDS.includes('timing') && interaction.timing) {
+            filteredInteraction.timing = interaction.timing;
+        }
+        // Append to daily log file (JSONL format)
+        const logFile = (0, path_1.join)(logsDir, `interactions-${new Date().toISOString().split('T')[0]}.jsonl`);
+        const logEntry = JSON.stringify(filteredInteraction) + '\n';
+        (0, fs_1.writeFileSync)(logFile, logEntry, { flag: 'a' });
+    }
+    catch (error) {
+        // Fail silently to not disrupt user experience
+        console.warn('AI training data logging failed:', error);
+    }
+}
+// Generate session ID for interaction tracking
+function generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+const api = axios_1.default.create({
+    baseURL: process.env.VME_API_BASE_URL,
+    headers: {
+        Authorization: `Bearer ${process.env.VME_API_TOKEN}`,
+        "Content-Type": "application/json"
+    }
+});
+// Helper function to parse VM name patterns
+function parseVMNames(nameInput, count) {
+    // Handle range patterns like "web01->web03" or "web01 -> web03"
+    const rangeMatch = nameInput.match(/^(.+?)(\d+)\s*->\s*(.+?)(\d+)$/);
+    if (rangeMatch) {
+        const [, prefix1, start, prefix2, end] = rangeMatch;
+        if (prefix1.trim() === prefix2.trim()) {
+            const basePrefix = prefix1.trim();
+            const startNum = parseInt(start);
+            const endNum = parseInt(end);
+            const names = [];
+            for (let i = startNum; i <= endNum; i++) {
+                const paddedNum = i.toString().padStart(start.length, '0');
+                names.push(`${basePrefix}${paddedNum}`);
+            }
+            return names;
+        }
+    }
+    // Handle count-based generation
+    if (count && count > 1) {
+        const names = [];
+        // Extract base name and number pattern
+        const match = nameInput.match(/^(.+?)(\d+)$/);
+        if (match) {
+            const [, prefix, startStr] = match;
+            const startNum = parseInt(startStr);
+            for (let i = 0; i < count; i++) {
+                const num = startNum + i;
+                const paddedNum = num.toString().padStart(startStr.length, '0');
+                names.push(`${prefix}${paddedNum}`);
+            }
+            return names;
+        }
+        else {
+            // If no number pattern, append numbers
+            for (let i = 1; i <= count; i++) {
+                const paddedNum = i.toString().padStart(2, '0');
+                names.push(`${nameInput}${paddedNum}`);
+            }
+            return names;
+        }
+    }
+    // Single VM
+    return [nameInput];
+}
+// Helper function to get available cluster nodes
+async function getClusterNodes() {
+    try {
+        const clusters = await api.get("/clusters");
+        const prodCluster = clusters.data.clusters.find((cluster) => cluster.name === "prod01");
+        if (prodCluster && prodCluster.servers) {
+            return prodCluster.servers.map((server) => server.id);
+        }
+    }
+    catch (error) {
+        console.error('Error getting cluster nodes:', error);
+    }
+    // Fallback to known nodes if API fails
+    return [1, 2, 3];
+}
+async function resolveInput({ group, cloud, template, size }) {
+    const [groups, zones, instanceTypes, servicePlans] = await Promise.all([
+        api.get("/groups"),
+        api.get("/zones"),
+        api.get("/instance-types"),
+        api.get("/service-plans")
+    ]);
+    // Find group (case-insensitive)
+    const foundGroup = groups.data.groups.find((g) => g.name.toLowerCase() === group.toLowerCase());
+    // Find zone/cloud (case-insensitive, handle both terms)
+    const foundZone = zones.data.zones.find((z) => z.name.toLowerCase() === cloud.toLowerCase());
+    // In HPE VM Essentials, all VMs use "HPE VM" instance type
+    // The actual OS is determined by the image selection
+    const instanceType = instanceTypes.data.instanceTypes.find((t) => t.name === 'HPE VM');
+    // Find appropriate image based on template using osType properties
+    let selectedImage;
+    const templateLower = template.toLowerCase();
+    // Get available images to find the right one
+    const images = await api.get("/virtual-images");
+    if (templateLower.includes('ubuntu')) {
+        // Find Ubuntu images using osType.category and prefer latest version
+        const ubuntuImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'ubuntu').sort((a, b) => {
+            // Sort by version descending (24.04 > 22.04 > 20.04)
+            const aVersion = parseFloat(a.osType.osVersion || '0');
+            const bVersion = parseFloat(b.osType.osVersion || '0');
+            return bVersion - aVersion;
+        });
+        selectedImage = ubuntuImages[0];
+    }
+    else if (templateLower.includes('rocky')) {
+        // Find Rocky Linux images and prefer latest version (Rocky 9 > Rocky 8)
+        const rockyImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'rocky').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = rockyImages[0];
+    }
+    else if (templateLower.includes('centos')) {
+        // Find CentOS images and prefer latest version (CentOS 9 > CentOS 8)
+        const centosImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'centos').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = centosImages[0];
+    }
+    else if (templateLower.includes('debian')) {
+        // Find Debian images and prefer latest version (Debian 12 > Debian 11)
+        const debianImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'debian').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = debianImages[0];
+    }
+    else if (templateLower.includes('alma')) {
+        // Find AlmaLinux images and prefer latest version (AlmaLinux 9 > AlmaLinux 8)
+        const almaImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'almalinux').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = almaImages[0];
+    }
+    else if (templateLower.includes('rhel') || templateLower.includes('red hat')) {
+        // Find RHEL images and prefer latest version
+        const rhelImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'rhel').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = rhelImages[0];
+    }
+    // Default to latest Ubuntu if no specific match
+    if (!selectedImage) {
+        const ubuntuImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'ubuntu').sort((a, b) => {
+            const aVersion = parseFloat(a.osType.osVersion || '0');
+            const bVersion = parseFloat(b.osType.osVersion || '0');
+            return bVersion - aVersion;
+        });
+        selectedImage = ubuntuImages[0] || images.data.virtualImages[0];
+    }
+    // Find service plan based on size (flexible matching)
+    let plan;
+    const sizeLower = size.toLowerCase();
+    if (sizeLower.includes('8gb') || sizeLower.includes('8 gb') || sizeLower.includes('medium')) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('2 CPU, 8GB Memory'));
+    }
+    else if (sizeLower.includes('4gb') || sizeLower.includes('4 gb') || sizeLower.includes('small')) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('1 CPU, 4GB Memory'));
+    }
+    // Fallback to any available plan
+    if (!plan) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('CPU') && p.name.includes('Memory'));
+    }
+    return {
+        groupId: foundGroup?.id || groups.data.groups[0]?.id,
+        cloudId: foundZone?.id || zones.data.zones[0]?.id,
+        instanceTypeId: instanceType?.id,
+        servicePlanId: plan?.id,
+        imageId: selectedImage?.id,
+        // Return resolved names for better error reporting
+        resolvedGroup: foundGroup?.name || groups.data.groups[0]?.name,
+        resolvedCloud: foundZone?.name || zones.data.zones[0]?.name,
+        resolvedInstanceType: instanceType?.name,
+        resolvedPlan: plan?.name,
+        resolvedImage: selectedImage?.osType?.name || selectedImage?.name,
+        // Available options for error messages
+        availableGroups: groups.data.groups.map((g) => g.name),
+        availableZones: zones.data.zones.map((z) => z.name)
+    };
+}
+function parseVMIntent(naturalLanguageInput) {
+    const input = naturalLanguageInput.toLowerCase().trim();
+    const result = {
+        action: 'unknown',
+        confidence: 0,
+        entities: {},
+        originalText: naturalLanguageInput
+    };
+    // Intent Classification with confidence scoring
+    const intentPatterns = {
+        create: [
+            /\b(create|provision|deploy|launch|start|build|make|setup)\b/,
+            /\bneed\s+(\d+\s+)?(vm|server|machine)/,
+            /\bcan\s+you\s+(create|provision|deploy)/
+        ],
+        modify: [
+            /\b(modify|change|update|edit|alter|resize|scale)\b/,
+            /\badd\s+(more\s+)?(cpu|memory|disk|storage)/,
+            /\bchange\s+the\s+(size|plan|configuration)/
+        ],
+        monitor: [
+            /\b(show|list|display|check|status|monitor|view)\b(?!.*\b(available|options|resources|templates|plans)\b)/,
+            /\bwhat\s+(vm|server|machine)/,
+            /\bhow\s+many\s+(vm|server|machine)/
+        ],
+        destroy: [
+            /\b(delete|remove|destroy|terminate|stop|kill)\b/,
+            /\btear\s+down/,
+            /\bshut\s+down/
+        ],
+        discover: [
+            /\b(available|options|resources|templates|plans)\b/,
+            /\bshow\s+me\s+(all|available)/,
+            /\bwhat\s+(are|is)\s+(available|possible)/,
+            /\bwhat\s+can\s+i\s+(create|do)/
+        ]
+    };
+    // Calculate confidence for each intent
+    let maxConfidence = 0;
+    let detectedAction = 'unknown';
+    for (const [action, patterns] of Object.entries(intentPatterns)) {
+        let matches = 0;
+        for (const pattern of patterns) {
+            if (pattern.test(input)) {
+                matches++;
+            }
+        }
+        const confidence = patterns.length > 0 ? matches / patterns.length : 0;
+        if (confidence > maxConfidence) {
+            maxConfidence = confidence;
+            detectedAction = action;
+        }
+    }
+    result.action = detectedAction;
+    result.confidence = maxConfidence;
+    // Entity Extraction for VM creation
+    if (result.action === 'create') {
+        // Extract VM names and count
+        const namePatterns = [
+            /\b(?:vm|server|machine)s?\s+(?:named\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/,
+            /\b(?:named\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?\s+(?:vm|server|machine)/,
+            /\bcreate\s+(?:(?:vm|server|machine)s?\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/,
+            /\b(?:vm|server|machine)\s+named\s+["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/
+        ];
+        for (const pattern of namePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                const nameInput = match[1] || match[2];
+                result.entities.vmNames = parseVMNames(nameInput);
+                break;
+            }
+        }
+        // Extract count
+        const countMatch = input.match(/\b(\d+)\s+(?:vm|server|machine)/);
+        if (countMatch) {
+            result.entities.count = parseInt(countMatch[1]);
+        }
+        // Extract OS template
+        const osPatterns = [
+            /\b(ubuntu|rocky|centos|debian|rhel|red\s*hat|alma|almalinux)(?:\s+(\d+(?:\.\d+)?))?/,
+            /\busing\s+([a-zA-Z0-9\-_]+)\s+(?:template|os|operating)/,
+            /\b(?:template|os|operating)\s+([a-zA-Z0-9\-_]+)/
+        ];
+        for (const pattern of osPatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.osTemplate = match[0];
+                break;
+            }
+        }
+        // Extract size/memory
+        const sizePatterns = [
+            /\b(small|medium|large|tiny)\b/,
+            /\b(\d+)\s*gb\s+(?:memory|ram)\b/,
+            /\b(\d+)\s*cpu[s]?\s*,?\s*(\d+)\s*gb/,
+            /\bwith\s+(\d+(?:gb|cpu))\b/,
+            /\b(\d+gb)\b/
+        ];
+        for (const pattern of sizePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.size = match[0];
+                break;
+            }
+        }
+        // Extract group/environment
+        const groupPatterns = [
+            /\bin\s+(?:the\s+)?([a-zA-Z0-9\-_]+)\s+(?:group|environment|site)/,
+            /\b(?:group|environment|site)\s+([a-zA-Z0-9\-_]+)/,
+            /\bfor\s+([a-zA-Z0-9\-_]+)\s+(?:environment|testing|production)/
+        ];
+        for (const pattern of groupPatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.group = match[1];
+                break;
+            }
+        }
+        // Extract zone/cloud
+        const zonePatterns = [
+            /\bon\s+([a-zA-Z0-9\-_]+)\s+(?:zone|cloud)/,
+            /\b(?:zone|cloud)\s+([a-zA-Z0-9\-_]+)/,
+            /\bin\s+([a-zA-Z0-9\-_]+)\s+(?:zone|cloud)/,
+            /\b(?:deploy|launch|create)\s+(?:in\s+)?([a-zA-Z0-9\-_]+)\s+zone/
+        ];
+        for (const pattern of zonePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.zone = match[1];
+                break;
+            }
+        }
+        // Extract distribution strategy
+        if (input.includes('spread') || input.includes('distribute') || input.includes('across')) {
+            result.entities.distribution = 'spread';
+        }
+        else if (input.includes('each node') || input.includes('all nodes')) {
+            result.entities.distribution = 'spread';
+        }
+        else if (input.includes('node') && input.match(/node[s]?\s*[\d,\s]+/)) {
+            const nodeMatch = input.match(/node[s]?\s*([\d,\s]+)/);
+            if (nodeMatch) {
+                result.entities.distribution = nodeMatch[1].replace(/\s+/g, '');
+            }
+        }
+        // Boost confidence if we extracted entities
+        const entityCount = Object.keys(result.entities).length;
+        if (entityCount > 0) {
+            result.confidence = Math.min(0.95, result.confidence + (entityCount * 0.1));
+        }
+    }
+    return result;
+}
+// Unified resource discovery function
+async function getResources(type, intent, role) {
+    try {
+        // Fetch all resource types in parallel for comprehensive discovery
+        const [groups, zones, instanceTypes, servicePlans, virtualImages, clusters] = await Promise.all([
+            api.get("/groups"),
+            api.get("/zones"),
+            api.get("/instance-types"),
+            api.get("/service-plans"),
+            api.get("/virtual-images"),
+            api.get("/clusters")
+        ]);
+        const allResources = {
+            groups: groups.data.groups || [],
+            zones: zones.data.zones || [],
+            instanceTypes: instanceTypes.data.instanceTypes || [],
+            servicePlans: servicePlans.data.servicePlans || [],
+            virtualImages: virtualImages.data.virtualImages || [],
+            clusters: clusters.data.clusters || []
+        };
+        // Apply intelligent filtering based on type
+        if (type) {
+            const typeLower = type.toLowerCase();
+            if (typeLower.includes('compute') || typeLower.includes('vm')) {
+                return {
+                    groups: allResources.groups,
+                    zones: allResources.zones,
+                    servicePlans: allResources.servicePlans,
+                    virtualImages: allResources.virtualImages,
+                    clusters: allResources.clusters,
+                    _filtered_for: 'compute/vm resources'
+                };
+            }
+            else if (typeLower.includes('network')) {
+                return {
+                    zones: allResources.zones,
+                    clusters: allResources.clusters,
+                    _filtered_for: 'network resources'
+                };
+            }
+            else if (typeLower.includes('storage')) {
+                return {
+                    servicePlans: allResources.servicePlans,
+                    zones: allResources.zones,
+                    _filtered_for: 'storage resources'
+                };
+            }
+        }
+        // Apply intent-based filtering
+        if (intent) {
+            const intentLower = intent.toLowerCase();
+            if (intentLower.includes('create') || intentLower.includes('provision')) {
+                // For creation intents, focus on templates and plans
+                return {
+                    groups: allResources.groups,
+                    zones: allResources.zones,
+                    servicePlans: allResources.servicePlans,
+                    virtualImages: allResources.virtualImages.map((img) => ({
+                        id: img.id,
+                        name: img.name,
+                        osType: img.osType,
+                        recommended: img.osType?.category === 'ubuntu' ? true : false
+                    })),
+                    _filtered_for: 'creation/provisioning intent'
+                };
+            }
+            else if (intentLower.includes('list') || intentLower.includes('show') || intentLower.includes('discover')) {
+                // For discovery intents, return comprehensive view
+                return {
+                    summary: {
+                        total_groups: allResources.groups.length,
+                        total_zones: allResources.zones.length,
+                        total_service_plans: allResources.servicePlans.length,
+                        total_os_templates: allResources.virtualImages.length,
+                        total_clusters: allResources.clusters.length
+                    },
+                    ...allResources,
+                    _filtered_for: 'discovery/listing intent'
+                };
+            }
+        }
+        // Default: return all resources with semantic organization
+        return {
+            compute: {
+                groups: allResources.groups,
+                servicePlans: allResources.servicePlans,
+                virtualImages: allResources.virtualImages
+            },
+            infrastructure: {
+                zones: allResources.zones,
+                clusters: allResources.clusters,
+                instanceTypes: allResources.instanceTypes
+            },
+            _organization: 'semantic grouping by function'
+        };
+    }
+    catch (error) {
+        return {
+            error: `Failed to fetch resources: ${error.response?.data?.message || error.message}`,
+            available_endpoints: ['/groups', '/zones', '/service-plans', '/virtual-images', '/clusters'],
+            fallback_suggestion: 'Try checking individual resource types with specific API endpoints'
+        };
+    }
+}
+const server = new index_js_1.Server({
+    name: "vm-create-server",
+    version: "1.0.0"
+}, {
+    capabilities: {
+        tools: {
+            list: async () => ([
+                {
+                    name: "get_resources",
+                    description: "Discover and explore available VME infrastructure resources with intelligent filtering",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            type: {
+                                type: "string",
+                                description: "Resource type filter: 'compute', 'network', 'storage', 'vm', or leave empty for all"
+                            },
+                            intent: {
+                                type: "string",
+                                description: "Intent-based filtering: 'create', 'provision', 'list', 'discover', or natural language description"
+                            },
+                            role: {
+                                type: "string",
+                                description: "User role for permission-aware filtering (future enhancement)"
+                            }
+                        },
+                        required: []
+                    }
+                },
+                {
+                    name: "parse_vm_intent",
+                    description: "Parse natural language VM requests into structured parameters with confidence scoring",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            naturalLanguageInput: {
+                                type: "string",
+                                description: "Natural language description of VM provisioning request"
+                            }
+                        },
+                        required: ["naturalLanguageInput"]
+                    }
+                },
+                {
+                    name: "export_training_data",
+                    description: "Export AI training data for model improvement (requires ENABLE_AI_TRAINING_DATA=true)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            format: {
+                                type: "string",
+                                description: "Export format: 'jsonl' or 'csv'",
+                                enum: ["jsonl", "csv"]
+                            },
+                            days: {
+                                type: "number",
+                                description: "Number of days of data to export (default: 7)"
+                            }
+                        },
+                        required: []
+                    }
+                },
+                {
+                    name: "provide_feedback",
+                    description: "Provide feedback on intent parsing accuracy to improve future predictions",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            original_input: {
+                                type: "string",
+                                description: "Original natural language input"
+                            },
+                            parsed_result: {
+                                type: "object",
+                                description: "The parsed result that was incorrect"
+                            },
+                            correct_interpretation: {
+                                type: "object",
+                                description: "What the correct interpretation should have been"
+                            },
+                            feedback_notes: {
+                                type: "string",
+                                description: "Additional notes about what went wrong"
+                            }
+                        },
+                        required: ["original_input", "feedback_notes"]
+                    }
+                },
+                {
+                    name: "create_vm",
+                    description: "Provision a new virtual machine",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            name: {
+                                type: "string",
+                                description: "Name for VM(s). Supports patterns like 'web01' or 'web01->web03' for multiple VMs"
+                            },
+                            group: {
+                                type: "string",
+                                description: "Group/site where VM will be created"
+                            },
+                            cloud: {
+                                type: "string",
+                                description: "Cloud/zone where VM will be provisioned (also accepts 'zone')"
+                            },
+                            zone: {
+                                type: "string",
+                                description: "Zone/cloud where VM will be provisioned (alias for 'cloud')"
+                            },
+                            template: {
+                                type: "string",
+                                description: "VM template or operating system"
+                            },
+                            size: {
+                                type: "string",
+                                description: "VM size (small, medium, 4GB, 8GB, etc.)"
+                            },
+                            distribution: {
+                                type: "string",
+                                description: "VM distribution strategy: 'auto' (default), 'spread' (across all nodes), or 'node1,node2,node3' (specific nodes)"
+                            },
+                            count: {
+                                type: "number",
+                                description: "Number of VMs to create (alternative to name patterns)"
+                            }
+                        },
+                        required: ["name", "group", "template", "size"]
+                    }
+                }
+            ]),
+            call: async (req) => {
+                if (req.tool === "get_resources") {
+                    const { type, intent, role } = req.arguments;
+                    const resources = await getResources(type, intent, role);
+                    return {
+                        toolResult: JSON.stringify(resources, null, 2),
+                        isError: !!resources.error
+                    };
+                }
+                if (req.tool === "parse_vm_intent") {
+                    const startTime = Date.now();
+                    const { naturalLanguageInput } = req.arguments;
+                    const sessionId = generateSessionId();
+                    const parsedIntent = parseVMIntent(naturalLanguageInput);
+                    const parseTime = Date.now() - startTime;
+                    // Log interaction for AI training (respects privacy settings)
+                    logInteraction({
+                        session_id: sessionId,
+                        tool_name: 'parse_vm_intent',
+                        user_input: { naturalLanguageInput },
+                        parsed_output: parsedIntent,
+                        success_metrics: {
+                            operation_success: parsedIntent.action !== 'unknown',
+                            confidence_score: parsedIntent.confidence,
+                            entities_extracted: Object.keys(parsedIntent.entities).length
+                        },
+                        timing: {
+                            parse_duration_ms: parseTime,
+                            total_duration_ms: parseTime
+                        }
+                    });
+                    return {
+                        toolResult: JSON.stringify(parsedIntent, null, 2),
+                        isError: parsedIntent.action === 'unknown' && parsedIntent.confidence < 0.3
+                    };
+                }
+                if (req.tool === "export_training_data") {
+                    if (!AI_TRAINING_ENABLED) {
+                        return {
+                            toolResult: JSON.stringify({
+                                error: "Training data collection is disabled",
+                                message: "Set ENABLE_AI_TRAINING_DATA=true in .env to enable data collection and export"
+                            }, null, 2),
+                            isError: true
+                        };
+                    }
+                    const { format = "jsonl", days = 7 } = req.arguments;
+                    try {
+                        const logsDir = (0, path_1.join)(process.cwd(), 'ai-training-logs');
+                        if (!(0, fs_1.existsSync)(logsDir)) {
+                            return {
+                                toolResult: JSON.stringify({
+                                    message: "No training data found",
+                                    data_count: 0
+                                }, null, 2),
+                                isError: false
+                            };
+                        }
+                        // Collect data from last N days
+                        const cutoffDate = new Date(Date.now() - (days * 24 * 60 * 60 * 1000));
+                        const allData = [];
+                        // Read log files and aggregate data
+                        const { readdirSync } = require('fs');
+                        const logFiles = readdirSync(logsDir).filter((file) => file.startsWith('interactions-') && file.endsWith('.jsonl'));
+                        for (const file of logFiles) {
+                            const fileDate = new Date(file.replace('interactions-', '').replace('.jsonl', ''));
+                            if (fileDate >= cutoffDate) {
+                                const content = (0, fs_1.readFileSync)((0, path_1.join)(logsDir, file), 'utf-8');
+                                const lines = content.trim().split('\n').filter(line => line.trim());
+                                for (const line of lines) {
+                                    try {
+                                        allData.push(JSON.parse(line));
+                                    }
+                                    catch (e) {
+                                        // Skip malformed lines
+                                    }
+                                }
+                            }
+                        }
+                        return {
+                            toolResult: JSON.stringify({
+                                message: `Exported ${allData.length} training data records from last ${days} days`,
+                                format: format,
+                                data_count: allData.length,
+                                data: format === 'jsonl' ? allData : allData.map(item => ({
+                                    timestamp: item.timestamp,
+                                    tool: item.tool_name,
+                                    user_input: JSON.stringify(item.user_input),
+                                    parsed_output: JSON.stringify(item.parsed_output),
+                                    success: item.success_metrics?.operation_success,
+                                    confidence: item.success_metrics?.confidence_score
+                                }))
+                            }, null, 2),
+                            isError: false
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            toolResult: JSON.stringify({
+                                error: "Failed to export training data",
+                                message: error.message
+                            }, null, 2),
+                            isError: true
+                        };
+                    }
+                }
+                if (req.tool === "provide_feedback") {
+                    const { original_input, parsed_result, correct_interpretation, feedback_notes } = req.arguments;
+                    const sessionId = generateSessionId();
+                    // Log feedback for future model improvements
+                    logInteraction({
+                        session_id: sessionId,
+                        tool_name: 'provide_feedback',
+                        user_input: { original_input, feedback_notes },
+                        parsed_output: { parsed_result, correct_interpretation },
+                        user_feedback: feedback_notes,
+                        success_metrics: {
+                            operation_success: false, // This indicates the original parsing was wrong
+                            user_satisfaction: 0 // User had to provide feedback = dissatisfied
+                        }
+                    });
+                    return {
+                        toolResult: JSON.stringify({
+                            message: "Thank you for the feedback! This will help improve future intent recognition.",
+                            feedback_recorded: true,
+                            original_input: original_input,
+                            feedback_notes: feedback_notes
+                        }, null, 2),
+                        isError: false
+                    };
+                }
+                if (req.tool !== "create_vm")
+                    return;
+                const { name, group, cloud, zone, template, size, distribution, count } = req.arguments;
+                // Allow both 'cloud' and 'zone' parameters interchangeably
+                const location = cloud || zone;
+                if (!location) {
+                    return {
+                        error: {
+                            code: "missing_location",
+                            message: "Either 'cloud' or 'zone' parameter is required"
+                        }
+                    };
+                }
+                // Parse VM names and determine distribution strategy
+                const vmNames = parseVMNames(name, count);
+                const nodes = await getClusterNodes();
+                // Determine node assignment strategy
+                let nodeAssignments = [];
+                if (distribution === 'spread' || (vmNames.length > 1 && !distribution)) {
+                    // Distribute VMs across all available nodes
+                    vmNames.forEach((vmName, index) => {
+                        const nodeId = nodes[index % nodes.length];
+                        nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
+                    });
+                }
+                else if (distribution && distribution !== 'auto') {
+                    // Parse specific node assignments like "1,2,3" or "node1,node2,node3"
+                    const specifiedNodes = distribution.split(',').map((n) => {
+                        const trimmed = n.trim();
+                        return trimmed.startsWith('node') ? parseInt(trimmed.replace('node', '')) : parseInt(trimmed);
+                    }).filter((n) => !isNaN(n));
+                    if (specifiedNodes.length > 0) {
+                        vmNames.forEach((vmName, index) => {
+                            const nodeId = specifiedNodes[index % specifiedNodes.length];
+                            nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
+                        });
+                    }
+                    else {
+                        nodeAssignments = vmNames.map(vmName => ({ name: vmName }));
+                    }
+                }
+                else {
+                    // Auto-placement (no kvmHostId specified)
+                    nodeAssignments = vmNames.map(vmName => ({ name: vmName }));
+                }
+                const resolved = await resolveInput({ group, cloud: location, template, size });
+                const { groupId, cloudId, instanceTypeId, servicePlanId, imageId } = resolved;
+                if (!groupId || !cloudId || !instanceTypeId || !servicePlanId || !imageId) {
+                    const errors = [];
+                    if (!groupId)
+                        errors.push(`Group '${group}' not found. Available: ${resolved.availableGroups.join(', ')}`);
+                    if (!cloudId)
+                        errors.push(`Zone/Cloud '${location}' not found. Available: ${resolved.availableZones.join(', ')}`);
+                    if (!instanceTypeId)
+                        errors.push(`Instance type could not be resolved`);
+                    if (!servicePlanId)
+                        errors.push(`Size '${size}' could not be resolved to service plan`);
+                    if (!imageId)
+                        errors.push(`Template '${template}' could not be resolved to OS image`);
+                    return {
+                        error: {
+                            code: "resolution_failed",
+                            message: `Failed to resolve parameters:\n${errors.join('\n')}`
+                        }
+                    };
+                }
+                // Create VMs sequentially
+                const results = [];
+                const errors = [];
+                for (const assignment of nodeAssignments) {
+                    const vmConfig = {
+                        resourcePoolId: 'pool-1',
+                        poolProviderType: 'mvm',
+                        imageId: imageId,
+                        createUser: true
+                    };
+                    // Add kvmHostId only if explicitly specified
+                    if (assignment.kvmHostId) {
+                        vmConfig.kvmHostId = assignment.kvmHostId;
+                    }
+                    const payload = {
+                        zoneId: cloudId,
+                        instance: {
+                            name: assignment.name,
+                            cloud: 'tc-lab',
+                            hostName: assignment.name,
+                            type: 'mvm',
+                            instanceType: {
+                                code: 'mvm'
+                            },
+                            site: {
+                                id: groupId
+                            },
+                            layout: {
+                                id: 2, // Single HPE VM
+                                code: 'mvm-1.0-single'
+                            },
+                            plan: {
+                                id: servicePlanId
+                            }
+                        },
+                        config: vmConfig,
+                        volumes: [
+                            {
+                                id: -1,
+                                rootVolume: true,
+                                name: 'root',
+                                size: 10,
+                                storageType: 1,
+                                datastoreId: 5
+                            }
+                        ],
+                        networkInterfaces: [
+                            {
+                                primaryInterface: true,
+                                ipMode: 'dhcp',
+                                network: {
+                                    id: 'network-2'
+                                },
+                                networkInterfaceTypeId: 10
+                            }
+                        ],
+                        layoutSize: 1
+                    };
+                    try {
+                        const response = await api.post("/instances", payload);
+                        const vm = response.data?.instance;
+                        const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : ' (auto-placed)';
+                        results.push(`✅ '${vm.name}' created (ID: ${vm.id})${nodeInfo}`);
+                    }
+                    catch (err) {
+                        const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : '';
+                        errors.push(`❌ '${assignment.name}' failed${nodeInfo}: ${err.response?.data?.message || err.message}`);
+                    }
+                }
+                // Prepare response
+                const summary = [];
+                if (results.length > 0) {
+                    summary.push(`Successfully created ${results.length} VM(s):`);
+                    summary.push(...results);
+                }
+                if (errors.length > 0) {
+                    summary.push(`\nFailed to create ${errors.length} VM(s):`);
+                    summary.push(...errors);
+                }
+                summary.push(`\nResolved parameters:`);
+                summary.push(`- Group: ${resolved.resolvedGroup}`);
+                summary.push(`- Zone/Cloud: ${resolved.resolvedCloud}`);
+                summary.push(`- Template: ${resolved.resolvedImage}`);
+                summary.push(`- Plan: ${resolved.resolvedPlan}`);
+                if (distribution === 'spread' || (vmNames.length > 1 && !distribution)) {
+                    summary.push(`- Distribution: Spread across nodes ${nodes.join(', ')}`);
+                }
+                else if (nodeAssignments.some(a => a.kvmHostId)) {
+                    summary.push(`- Distribution: Specific node placement`);
+                }
+                else {
+                    summary.push(`- Distribution: Auto-placement`);
+                }
+                return {
+                    toolResult: summary.join('\n'),
+                    isError: errors.length > 0 && results.length === 0
+                };
+            }
+        }
+    }
+});
+const transport = new stdio_js_1.StdioServerTransport();
+server.connect(transport);

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "vme-mcp-server",
+  "version": "0.1.2",
+  "description": "VMware vCenter MCP Server - Natural language infrastructure management for Claude",
+  "main": "dist/server.js",
+  "bin": {
+    "vme-mcp-server": "./dist/server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/server.js",
+    "dev": "tsx watch src/server.ts",
+    "prepublishOnly": "npm run build",
+    "test": "mocha tests/**/*.test.js",
+    "test:unit": "mocha tests/unit/*.test.js",
+    "test:integration": "mocha tests/integration/*.test.js",
+    "test:e2e": "mocha tests/e2e/*.test.js",
+    "test:performance": "mocha tests/performance/*.test.js",
+    "test:coverage": "nyc mocha tests/**/*.test.js"
+  },
+  "keywords": [
+    "mcp",
+    "vmware",
+    "vcenter",
+    "infrastructure",
+    "ai",
+    "claude",
+    "natural-language",
+    "server"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frippe75/vme-mcp-server.git"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "axios": "^1.9.0",
+    "dotenv": "^16.5.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.3.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.29",
+    "mocha": "^10.2.0",
+    "nyc": "^15.1.0"
+  },
+  "description": ""
+}