vme-mcp-server
Version:
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
929 lines (928 loc) • 44 kB
JavaScript
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import axios from "axios";
import dotenv from "dotenv";
import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
import { join } from "path";
dotenv.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 = join(process.cwd(), 'ai-training-logs');
if (!existsSync(logsDir)) {
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 = join(logsDir, `interactions-${new Date().toISOString().split('T')[0]}.jsonl`);
const logEntry = JSON.stringify(filteredInteraction) + '\n';
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.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 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 = join(process.cwd(), 'ai-training-logs');
if (!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 = readFileSync(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 StdioServerTransport();
server.connect(transport);