@vectorchat/mcp-server
Version:
VectorChat MCP Server - Encrypted AI-to-AI communication with hardware security (YubiKey/TPM). 45+ MCP tools for Windsurf, Claude, and AI assistants. Model-based identity with EMDM encryption. Dynamic AI playbook system, communication zones, message relay
345 lines (303 loc) • 11.1 kB
JavaScript
// VectorChat System Detection Module
// Detects hardware capabilities, available models, and optimal configuration
// ============================================================================
// MODEL DETECTION
// ============================================================================
async function modelExists(modelPath) {
try {
const response = await fetch('/api/model-exists', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ path: modelPath })
});
const data = await response.json();
return data.exists;
} catch (error) {
console.error('Model check failed:', error);
return false;
}
}
async function scanGGUFCompatibleSystemModels() {
try {
const response = await fetch('/api/scan-models', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
paths: [
'~/.lmstudio/models',
'~/.ollama/models',
'~/.vectorchat/models'
]
})
});
const data = await response.json();
return data.models || [];
} catch (error) {
console.error('Model scan failed:', error);
return [];
}
}
async function modelList() {
const defaultModels = [
{
id: 'qwen3-1.7b',
name: 'Qwen 3 1.7B (Default)',
size: '1.6 GB',
format: 'GGUF (Q6_K)',
ipfsCid: 'QmXmPxxtLxtDgh4CYscgTDXyCbNfVWdzhG2UgS6fcX6mXS',
description: 'Fast, efficient, recommended for most users',
isDefault: true,
minRAM: 4,
recommendedRAM: 8
},
{
id: 'qwen2.5-7b',
name: 'Qwen 2.5 7B',
size: '7.0 GB',
format: 'GGUF (Q4_K_M)',
ipfsCid: 'QmAbCdEfGhIjKlMnOpQrStUvWxYz1234567890',
description: 'Larger model, better quality, requires more VRAM',
isDefault: false,
minRAM: 8,
recommendedRAM: 16
},
{
id: 'llama2-7b',
name: 'Llama 2 7B',
size: '7.0 GB',
format: 'GGUF (Q4_K_M)',
ipfsCid: 'QmXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXx',
description: 'Open source, good general purpose model',
isDefault: false,
minRAM: 8,
recommendedRAM: 16
},
{
id: 'mistral-7b',
name: 'Mistral 7B',
size: '7.0 GB',
format: 'GGUF (Q4_K_M)',
ipfsCid: 'QmYyYyYyYyYyYyYyYyYyYyYyYyYyYyYyYyYyYyYyYy',
description: 'Fast and efficient 7B model',
isDefault: false,
minRAM: 8,
recommendedRAM: 16
}
];
// Scan for system models
const systemModels = await scanGGUFCompatibleSystemModels();
// Combine and deduplicate
const allModels = [...defaultModels];
for (const sysModel of systemModels) {
const exists = allModels.some(m => m.id === sysModel.id);
if (!exists) {
allModels.push({
id: sysModel.id,
name: sysModel.name,
size: sysModel.size,
format: 'GGUF',
path: sysModel.path,
description: 'Found on your system',
isDefault: false,
isLocal: true
});
}
}
return allModels;
}
// ============================================================================
// HARDWARE DETECTION
// ============================================================================
async function detectCuda() {
try {
const response = await fetch('/api/detect-cuda');
const data = await response.json();
// If running in Docker and nvidia-smi not found, check for CUDA environment
if (!data.available && data.message && data.message.includes('not found')) {
// Check if we can detect CUDA from environment or libraries
try {
const envCheck = await fetch('/api/detect-cuda-env');
const envData = await envCheck.json();
if (envData.available) {
return envData;
}
} catch (e) {
// Fall through to return original data
}
}
return {
available: data.available,
version: data.version,
devices: data.devices || [],
totalVRAM: data.totalVRAM,
message: data.message
};
} catch (error) {
console.error('CUDA detection failed:', error);
return { available: false, message: 'CUDA detection unavailable' };
}
}
async function detectROCm() {
try {
const response = await fetch('/api/detect-rocm');
const data = await response.json();
return {
available: data.available,
version: data.version,
devices: data.devices || [],
totalVRAM: data.totalVRAM,
message: data.message
};
} catch (error) {
console.error('ROCm detection failed:', error);
return { available: false, message: 'ROCm detection unavailable' };
}
}
async function detectNPU() {
try {
const response = await fetch('/api/detect-npu');
const data = await response.json();
return {
available: data.available,
type: data.type,
devices: data.devices || [],
message: data.message
};
} catch (error) {
console.error('NPU detection failed:', error);
return { available: false, message: 'NPU detection unavailable' };
}
}
async function detectCPU() {
try {
const response = await fetch('/api/detect-cpu');
const data = await response.json();
// Calculate optimal thread allocation
const totalCores = data.cores;
let allocatedThreads = 1; // Minimum
if (totalCores >= 4 && totalCores <= 6) {
allocatedThreads = 4;
} else if (totalCores > 6) {
allocatedThreads = totalCores - 2; // Leave 2 cores for system
}
return {
cores: totalCores,
model: data.model,
frequency: data.frequency,
allocatedThreads: allocatedThreads,
message: `${totalCores} cores detected, allocating ${allocatedThreads} threads to daemon`
};
} catch (error) {
console.error('CPU detection failed:', error);
return { cores: 1, allocatedThreads: 1, message: 'CPU detection unavailable' };
}
}
// ============================================================================
// SYSTEM ANALYSIS
// ============================================================================
async function analyzeSystem() {
const analysis = {
cpu: await detectCPU(),
cuda: await detectCuda(),
rocm: await detectROCm(),
npu: await detectNPU(),
models: await modelList()
};
// Determine optimal configuration
analysis.recommendation = determineOptimalConfig(analysis);
return analysis;
}
function determineOptimalConfig(analysis) {
const config = {
gpuAcceleration: 'none',
gpuLayers: 0,
threads: analysis.cpu.allocatedThreads,
contextSize: 2048,
modelRecommendation: 'qwen3-1.7b'
};
// GPU acceleration preference
if (analysis.cuda.available) {
config.gpuAcceleration = 'cuda';
config.gpuLayers = Math.floor((analysis.cuda.totalVRAM || 0) / 2); // Use half VRAM for safety
} else if (analysis.rocm.available) {
config.gpuAcceleration = 'rocm';
config.gpuLayers = Math.floor((analysis.rocm.totalVRAM || 0) / 2);
} else if (analysis.npu.available) {
config.gpuAcceleration = 'npu';
}
// Context size based on available resources
if (config.gpuAcceleration !== 'none') {
config.contextSize = 4096; // GPU can handle larger context
}
return config;
}
// ============================================================================
// UI INTEGRATION
// ============================================================================
async function populateModelList() {
const models = await modelList();
const modelSelect = document.getElementById('modelType');
if (!modelSelect) return;
// Clear existing options
modelSelect.innerHTML = '';
// Add models
for (const model of models) {
const option = document.createElement('option');
option.value = model.id;
option.textContent = model.name;
if (model.isDefault) {
option.selected = true;
}
modelSelect.appendChild(option);
}
}
async function displaySystemInfo() {
const analysis = await analyzeSystem();
// Display CPU info
const cpuInfo = document.getElementById('cpuInfo');
if (cpuInfo) {
cpuInfo.innerHTML = `
<strong>CPU:</strong> ${analysis.cpu.model}<br>
<strong>Cores:</strong> ${analysis.cpu.cores}<br>
<strong>Allocated Threads:</strong> ${analysis.cpu.allocatedThreads}<br>
<em>${analysis.cpu.message}</em>
`;
}
// Display GPU info
const gpuInfo = document.getElementById('gpuInfo');
if (gpuInfo) {
let gpuHtml = '<strong>GPU Acceleration:</strong> ';
if (analysis.cuda.available) {
gpuHtml += `CUDA ${analysis.cuda.version}<br>
<strong>VRAM:</strong> ${analysis.cuda.totalVRAM} GB<br>
<em>${analysis.cuda.message}</em>`;
} else if (analysis.rocm.available) {
gpuHtml += `ROCm ${analysis.rocm.version}<br>
<strong>VRAM:</strong> ${analysis.rocm.totalVRAM} GB<br>
<em>${analysis.rocm.message}</em>`;
} else if (analysis.npu.available) {
gpuHtml += `NPU (${analysis.npu.type})<br>
<em>${analysis.npu.message}</em>`;
} else {
gpuHtml += 'None detected (CPU only)';
}
gpuInfo.innerHTML = gpuHtml;
}
// Display recommendation
const recommendation = document.getElementById('systemRecommendation');
if (recommendation) {
recommendation.innerHTML = `
<strong>Recommended Configuration:</strong><br>
Model: ${analysis.recommendation.modelRecommendation}<br>
GPU Acceleration: ${analysis.recommendation.gpuAcceleration}<br>
Context Size: ${analysis.recommendation.contextSize}<br>
Threads: ${analysis.recommendation.threads}
`;
}
return analysis;
}
// Initialize on page load
window.addEventListener('DOMContentLoaded', async () => {
await populateModelList();
await displaySystemInfo();
});