llm-checker 3.1.0 → 3.1.1

package/README.md

@@ -23,6 +23,7 @@
 <p align="center">
   <a href="#installation">Installation</a> &bull;
   <a href="#quick-start">Quick Start</a> &bull;
+  <a href="#claude-code-mcp">Claude MCP</a> &bull;
   <a href="#commands">Commands</a> &bull;
   <a href="#scoring-system">Scoring</a> &bull;
   <a href="#supported-hardware">Hardware</a>
@@ -91,6 +92,58 @@ llm-checker search qwen --use-case coding
 
 ---
 
+## Claude Code MCP
+
+LLM Checker includes a built-in [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) server, allowing **Claude Code** and other MCP-compatible AI assistants to analyze your hardware and manage local models directly.
+
+### Setup (One Command)
+
+```bash
+# Install globally first
+npm install -g llm-checker
+
+# Add to Claude Code
+claude mcp add llm-checker -- llm-checker-mcp
+```
+
+Or with npx (no global install needed):
+
+```bash
+claude mcp add llm-checker -- npx llm-checker-mcp
+```
+
+Restart Claude Code and you're done.
+
+### Available MCP Tools
+
+Once connected, Claude can use these tools:
+
+| Tool | Description |
+|------|-------------|
+| `hw_detect` | Detect your hardware (CPU, GPU, RAM, acceleration backend) |
+| `check` | Full compatibility analysis with all models ranked by score |
+| `recommend` | Top model picks by category (coding, reasoning, multimodal, etc.) |
+| `installed` | Rank your already-downloaded Ollama models |
+| `search` | Search the Ollama model catalog with filters |
+| `smart_recommend` | Advanced recommendations using the full scoring engine |
+| `ollama_list` | List all downloaded Ollama models |
+| `ollama_pull` | Download a model from the Ollama registry |
+| `ollama_run` | Run a prompt against a local Ollama model |
+
+### Example Prompts
+
+After setup, you can ask Claude things like:
+
+- *"What's the best coding model for my hardware?"*
+- *"What models do I have installed and how do they rank?"*
+- *"Pull the top reasoning model for my system"*
+- *"Search for multimodal models under 8GB"*
+- *"Run this prompt on qwen2.5-coder"*
+
+Claude will automatically call the right tools and give you actionable results.
+
+---
+
 ## Commands
 
 ### Core Commands

package/bin/CLAUDE.md

@@ -9,4 +9,13 @@
 |----|------|---|-------|------|
 | #3492 | 10:24 PM | 🔵 | Enhanced CLI Structure - Lazy Loading with ASCII Art Branding | ~456 |
 | #3436 | 9:57 PM | 🔵 | Enhanced CLI Implementation - Command-Line Interface with ASCII Art and Ollama Integration | ~575 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4341 | 6:49 PM | 🟣 | MCP server implementation committed to llm-checker repository | ~431 |
+| #4339 | " | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
+| #4338 | " | ✅ | MCP server validated in llm-checker repository structure | ~245 |
+| #4333 | 6:48 PM | 🟣 | MCP server integrated into llm-checker package distribution | ~409 |
 </claude-mem-context>

package/bin/mcp-server.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * LLM Checker MCP Server
+ *
+ * Model Context Protocol server that exposes llm-checker tools to Claude Code
+ * and other MCP-compatible AI assistants.
+ *
+ * Usage:
+ *   claude mcp add llm-checker -- npx llm-checker-mcp
+ *   # or
+ *   claude mcp add llm-checker -- node node_modules/llm-checker/bin/mcp-server.mjs
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const exec = promisify(execFile);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Use the CLI from this package
+const CLI_PATH = join(__dirname, "enhanced_cli.js");
+
+// Strip ANSI escape codes for clean output
+function clean(text) {
+  return text
+    .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
+    .replace(/\x1B\[\?[0-9;]*[a-zA-Z]/g, "")
+    .replace(/\x1B\([A-Z]/g, "")
+    .trim();
+}
+
+async function run(args, timeout = 120000) {
+  try {
+    const { stdout, stderr } = await exec("node", [CLI_PATH, ...args], {
+      timeout,
+      env: { ...process.env, NODE_NO_WARNINGS: "1" },
+    });
+    return clean(stdout || stderr);
+  } catch (err) {
+    if (err.stdout) return clean(err.stdout);
+    throw new Error(`llm-checker failed: ${err.message}`);
+  }
+}
+
+const server = new McpServer({
+  name: "llm-checker",
+  version: "3.1.0",
+});
+
+// --- Tool: hw_detect ---
+server.tool(
+  "hw_detect",
+  "Detect hardware capabilities: CPU, GPU, RAM, acceleration backends, and recommended tier for running local LLMs",
+  {},
+  async () => {
+    const result = await run(["hw-detect"]);
+    return { content: [{ type: "text", text: result }] };
+  }
+);
+
+// --- Tool: check ---
+server.tool(
+  "check",
+  "Full system analysis: detect hardware, scan Ollama catalog, and return all compatible models ranked by score with memory estimates",
+  {},
+  async () => {
+    const result = await run(["check"], 180000);
+    return { content: [{ type: "text", text: result }] };
+  }
+);
+
+// --- Tool: recommend ---
+server.tool(
+  "recommend",
+  "Get top model recommendations for a specific use case category, ranked by the 4D scoring engine (Quality, Speed, Fit, Context)",
+  {
+    category: z
+      .enum(["general", "coding", "reasoning", "multimodal", "embedding", "small"])
+      .optional()
+      .describe("Use case category (omit for all categories)"),
+  },
+  async ({ category }) => {
+    const args = ["recommend"];
+    if (category) args.push(category);
+    const result = await run(args, 180000);
+    return { content: [{ type: "text", text: result }] };
+  }
+);
+
+// --- Tool: installed ---
+server.tool(
+  "installed",
+  "List and rank all locally installed Ollama models by compatibility score against current hardware",
+  {},
+  async () => {
+    const result = await run(["installed"], 60000);
+    return { content: [{ type: "text", text: result }] };
+  }
+);
+
+// --- Tool: search ---
+server.tool(
+  "search",
+  "Search the Ollama model catalog by keyword (e.g. 'code', 'vision', 'small'). Requires sql.js.",
+  {
+    query: z.string().describe("Search keyword (model name, family, or capability)"),
+    use_case: z
+      .enum(["general", "coding", "chat", "reasoning", "creative", "fast"])
+      .optional()
+      .describe("Optimize results for a specific use case"),
+    max_size: z.number().optional().describe("Maximum model size in GB"),
+  },
+  async ({ query, use_case, max_size }) => {
+    const args = ["search", query];
+    if (use_case) args.push("--use-case", use_case);
+    if (max_size) args.push("--max-size", String(max_size));
+    const result = await run(args, 60000);
+    return { content: [{ type: "text", text: result }] };
+  }
+);
+
+// --- Tool: smart_recommend ---
+server.tool(
+  "smart_recommend",
+  "Advanced recommendation using the full scoring engine with database integration. Requires sql.js.",
+  {
+    use_case: z
+      .enum(["general", "coding", "chat", "reasoning", "creative", "fast", "quality"])
+      .optional()
+      .describe("Use case to optimize for"),
+  },
+  async ({ use_case }) => {
+    const args = ["smart-recommend"];
+    if (use_case) args.push("--use-case", use_case);
+    const result = await run(args, 180000);
+    return { content: [{ type: "text", text: result }] };
+  }
+);
+
+// --- Tool: ollama_list ---
+server.tool(
+  "ollama_list",
+  "List all models currently downloaded in Ollama with their sizes",
+  {},
+  async () => {
+    try {
+      const { stdout } = await exec("ollama", ["list"], { timeout: 10000 });
+      return { content: [{ type: "text", text: clean(stdout) }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Ollama not running or not installed: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Tool: ollama_pull ---
+server.tool(
+  "ollama_pull",
+  "Download/pull a model from the Ollama registry to local storage",
+  {
+    model: z.string().describe("Model name to pull (e.g. 'qwen2.5-coder:7b', 'llama3.2:3b')"),
+  },
+  async ({ model }) => {
+    try {
+      const { stdout } = await exec("ollama", ["pull", model], { timeout: 600000 });
+      return { content: [{ type: "text", text: clean(stdout) || `Successfully pulled ${model}` }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Failed to pull ${model}: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Tool: ollama_run ---
+server.tool(
+  "ollama_run",
+  "Run a prompt against a local Ollama model and return the response",
+  {
+    model: z.string().describe("Model name (e.g. 'qwen2.5-coder:7b')"),
+    prompt: z.string().describe("The prompt to send to the model"),
+  },
+  async ({ model, prompt }) => {
+    try {
+      const { stdout } = await exec("ollama", ["run", model, prompt], { timeout: 300000 });
+      return { content: [{ type: "text", text: clean(stdout) }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Failed to run ${model}: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "llm-checker",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Intelligent CLI tool with AI-powered model selection that analyzes your hardware and recommends optimal LLM models for your system",
   "bin": {
     "llm-checker": "bin/enhanced_cli.js",
-    "ollama-checker": "bin/enhanced_cli.js"
+    "ollama-checker": "bin/enhanced_cli.js",
+    "llm-checker-mcp": "bin/mcp-server.mjs"
   },
   "main": "src/index.js",
   "scripts": {
@@ -27,13 +28,15 @@
     "postinstall": "echo 'LLM Checker installed. Run: llm-checker hw-detect'"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "inquirer": "^8.2.6",
     "node-fetch": "^2.7.0",
     "ora": "^5.4.1",
     "systeminformation": "^5.21.0",
-    "table": "^6.8.1"
+    "table": "^6.8.1",
+    "zod": "^3.23.0"
   },
   "optionalDependencies": {
     "sql.js": "^1.14.0"
@@ -63,7 +66,10 @@
     "performance",
     "benchmark",
     "apple-silicon",
-    "memory-optimization"
+    "memory-optimization",
+    "mcp",
+    "claude",
+    "model-context-protocol"
   ],
   "author": "Pavelevich (https://github.com/Pavelevich)",
   "license": "MIT",

package/src/CLAUDE.md

@@ -9,4 +9,10 @@
 |----|------|---|-------|------|
 | #3485 | 10:23 PM | 🔵 | Dead Code in Main Analysis Method - Lines 73-214 Unreachable | ~555 |
 | #3435 | 9:57 PM | 🔵 | Main LLMChecker Class Architecture - Platform-Specific Analysis Engine | ~630 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>

package/src/data/CLAUDE.md

@@ -8,4 +8,10 @@
 | ID | Time | T | Title | Read |
 |----|------|---|-------|------|
 | #3464 | 10:03 PM | 🔵 | SQL Database Schema - Indexed Model Repository with Benchmarks | ~555 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>

package/src/hardware/CLAUDE.md

@@ -9,4 +9,10 @@
 |----|------|---|-------|------|
 | #3490 | 10:24 PM | 🔵 | Hardware Detector Cache Implementation - 5-Minute TTL Without Force Refresh Option | ~536 |
 | #3440 | 9:58 PM | 🔵 | Hardware Detection System - Multi-GPU Support with Intelligent Selection | ~611 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>

package/src/hardware/backends/CLAUDE.md

@@ -8,4 +8,10 @@
 | ID | Time | T | Title | Read |
 |----|------|---|-------|------|
 | #3453 | 10:01 PM | 🔵 | CUDA Detector Implementation - NVIDIA GPU Detection via nvidia-smi | ~497 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>

package/src/hardware/backends/rocm-detector.js

@@ -1,25 +1,75 @@
 /**
  * ROCm Detector
- * Detects AMD GPUs using rocm-smi
+ * Detects AMD GPUs using rocm-smi, rocminfo, lspci, and sysfs
  * Supports multi-GPU setups and ROCm capabilities
+ * Falls back to lspci/sysfs when ROCm tools are not installed
  */
 
 const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
 
 class ROCmDetector {
     constructor() {
         this.cache = null;
         this.isAvailable = null;
+        this.detectionMethod = null;  // 'rocm-smi', 'rocminfo', 'lspci', 'sysfs'
     }
 
+    // AMD PCI device IDs for model name resolution
+    static AMD_DEVICE_IDS = {
+        // RDNA 3 (RX 7000 series)
+        '744c': { name: 'AMD Radeon RX 7900 XTX', vram: 24 },
+        '7448': { name: 'AMD Radeon RX 7900 XT', vram: 20 },
+        '7460': { name: 'AMD Radeon RX 7900 GRE', vram: 16 },
+        '7480': { name: 'AMD Radeon RX 7800 XT', vram: 16 },
+        '7481': { name: 'AMD Radeon RX 7700 XT', vram: 12 },
+        '7483': { name: 'AMD Radeon RX 7600', vram: 8 },
+        '7484': { name: 'AMD Radeon RX 7600 XT', vram: 16 },
+        // RDNA 2 (RX 6000 series)
+        '73a5': { name: 'AMD Radeon RX 6950 XT', vram: 16 },
+        '73bf': { name: 'AMD Radeon RX 6900 XT', vram: 16 },
+        '73a3': { name: 'AMD Radeon RX 6800 XT', vram: 16 },
+        '73a2': { name: 'AMD Radeon RX 6800', vram: 16 },
+        '73df': { name: 'AMD Radeon RX 6700 XT', vram: 12 },
+        '73ff': { name: 'AMD Radeon RX 6600 XT', vram: 8 },
+        '73e3': { name: 'AMD Radeon RX 6600', vram: 8 },
+        // CDNA / Instinct
+        '740f': { name: 'AMD Instinct MI300X', vram: 192 },
+        '740c': { name: 'AMD Instinct MI300A', vram: 128 },
+        '7408': { name: 'AMD Instinct MI250X', vram: 128 },
+        '740a': { name: 'AMD Instinct MI250', vram: 64 },
+        '738c': { name: 'AMD Instinct MI210', vram: 64 },
+        '7388': { name: 'AMD Instinct MI100', vram: 32 },
+    };
+
     /**
-     * Check if ROCm is available
+     * Check if AMD GPU is available (ROCm tools, lspci, or sysfs)
      */
     checkAvailability() {
         if (this.isAvailable !== null) {
             return this.isAvailable;
         }
 
+        // Only check on Linux
+        if (process.platform !== 'linux') {
+            // On non-Linux, only ROCm tools matter
+            try {
+                execSync('rocm-smi --version', {
+                    encoding: 'utf8',
+                    timeout: 5000,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                });
+                this.isAvailable = true;
+                this.detectionMethod = 'rocm-smi';
+                return true;
+            } catch (e) {
+                this.isAvailable = false;
+                return false;
+            }
+        }
+
+        // 1. Try rocm-smi
         try {
             execSync('rocm-smi --version', {
                 encoding: 'utf8',
@@ -27,21 +77,66 @@ class ROCmDetector {
                 stdio: ['pipe', 'pipe', 'pipe']
             });
             this.isAvailable = true;
+            this.detectionMethod = 'rocm-smi';
+            return true;
         } catch (e) {
-            // Try alternative rocminfo command
-            try {
-                execSync('rocminfo', {
-                    encoding: 'utf8',
-                    timeout: 5000,
-                    stdio: ['pipe', 'pipe', 'pipe']
-                });
+            // Continue to next method
+        }
+
+        // 2. Try rocminfo
+        try {
+            execSync('rocminfo', {
+                encoding: 'utf8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            this.isAvailable = true;
+            this.detectionMethod = 'rocminfo';
+            return true;
+        } catch (e) {
+            // Continue to next method
+        }
+
+        // 3. Try lspci for AMD GPUs (vendor ID 1002)
+        try {
+            const lspci = execSync('lspci | grep -i "VGA\\|3D\\|Display" | grep -i "AMD\\|ATI\\|Radeon"', {
+                encoding: 'utf8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            if (lspci.trim().length > 0) {
                 this.isAvailable = true;
-            } catch (e2) {
-                this.isAvailable = false;
+                this.detectionMethod = 'lspci';
+                return true;
             }
+        } catch (e) {
+            // Continue to next method
+        }
+
+        // 4. Try sysfs for AMD GPUs (vendor 0x1002)
+        try {
+            const drmPath = '/sys/class/drm';
+            const entries = fs.readdirSync(drmPath);
+            const hasAMD = entries.some(node => {
+                try {
+                    const vendorPath = path.join(drmPath, node, 'device/vendor');
+                    const vendor = fs.readFileSync(vendorPath, 'utf8').trim();
+                    return vendor === '0x1002';  // AMD vendor ID
+                } catch (e) {
+                    return false;
+                }
+            });
+            if (hasAMD) {
+                this.isAvailable = true;
+                this.detectionMethod = 'sysfs';
+                return true;
+            }
+        } catch (e) {
+            // No sysfs access
         }
 
-        return this.isAvailable;
+        this.isAvailable = false;
+        return false;
     }
 
     /**
@@ -66,7 +161,7 @@ class ROCmDetector {
     }
 
     /**
-     * Get detailed GPU information using rocm-smi
+     * Get detailed GPU information using best available method
      */
     getGPUInfo() {
         const result = {
@@ -78,6 +173,45 @@ class ROCmDetector {
             speedCoefficient: 0
         };
 
+        // Try methods in order of detail level
+        let detected = false;
+
+        // 1. Try rocm-smi (most detailed)
+        if (this.detectionMethod === 'rocm-smi' || !this.detectionMethod) {
+            detected = this._detectViaRocmSmi(result);
+        }
+
+        // 2. Try rocminfo
+        if (!detected && (this.detectionMethod === 'rocminfo' || !this.detectionMethod)) {
+            detected = this._detectViaRocmInfo(result);
+        }
+
+        // 3. Try lspci
+        if (!detected && (this.detectionMethod === 'lspci' || !this.detectionMethod)) {
+            detected = this._detectViaLspci(result);
+        }
+
+        // 4. Try sysfs
+        if (!detected && (this.detectionMethod === 'sysfs' || !this.detectionMethod)) {
+            detected = this._detectViaSysfs(result);
+        }
+
+        if (!detected || result.gpus.length === 0) {
+            return null;
+        }
+
+        result.isMultiGPU = result.gpus.length > 1;
+        result.speedCoefficient = result.gpus.length > 0
+            ? Math.max(...result.gpus.map(g => g.speedCoefficient))
+            : 0;
+
+        return result;
+    }
+
+    /**
+     * Detect GPUs via rocm-smi
+     */
+    _detectViaRocmSmi(result) {
         // Get ROCm version
         try {
             const versionOutput = execSync('rocm-smi --version', {
@@ -89,7 +223,7 @@ class ROCmDetector {
                 result.rocmVersion = match[1];
             }
         } catch (e) {
-            // Continue without version
+            return false;
         }
 
         try {
@@ -157,7 +291,7 @@ class ROCmDetector {
                     name: name,
                     memory: {
                         total: vram,
-                        free: vram,  // ROCm doesn't always report free memory
+                        free: vram,
                         used: 0
                     },
                     temperature: temps[i] || 0,
@@ -169,44 +303,231 @@ class ROCmDetector {
                 result.gpus.push(gpu);
                 result.totalVRAM += vram;
             }
+
+            return result.gpus.length > 0;
         } catch (e) {
-            // Fallback to rocminfo
-            try {
-                const rocmInfo = execSync('rocminfo', {
-                    encoding: 'utf8',
-                    timeout: 10000
+            return false;
+        }
+    }
+
+    /**
+     * Detect GPUs via rocminfo
+     */
+    _detectViaRocmInfo(result) {
+        try {
+            const rocmInfo = execSync('rocminfo', {
+                encoding: 'utf8',
+                timeout: 10000
+            });
+
+            const agentMatches = rocmInfo.matchAll(/Name:\s*(gfx\d+|AMD.*)/gi);
+            let idx = 0;
+            for (const match of agentMatches) {
+                const name = match[1].trim();
+                if (name.toLowerCase().includes('gfx') || name.toLowerCase().includes('amd')) {
+                    const vram = this.estimateVRAMFromGfxName(name);
+
+                    result.gpus.push({
+                        index: idx,
+                        name: name,
+                        memory: { total: vram, free: vram, used: 0 },
+                        capabilities: this.getGPUCapabilities(name),
+                        speedCoefficient: this.calculateSpeedCoefficient(name, vram)
+                    });
+                    result.totalVRAM += vram;
+                    idx++;
+                }
+            }
+
+            return result.gpus.length > 0;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Detect GPUs via lspci (fallback when ROCm is not installed)
+     */
+    _detectViaLspci(result) {
+        try {
+            const lspciOutput = execSync('lspci -nn | grep -i "VGA\\|3D\\|Display"', {
+                encoding: 'utf8',
+                timeout: 10000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+
+            const lines = lspciOutput.trim().split('\n');
+            let idx = 0;
+
+            for (const line of lines) {
+                // Match AMD/ATI VGA devices: "03:00.0 VGA compatible controller [0300]: Advanced Micro Devices, Inc. [AMD/ATI] Navi 31 [Radeon RX 7900 XT/7900 XTX/7900M] [1002:744c]"
+                const amdMatch = line.match(/\[(?:AMD|ATI)\].*?\[([0-9a-f]{4}):([0-9a-f]{4})\]/i) ||
+                                 line.match(/(?:AMD|ATI|Radeon).*?\[([0-9a-f]{4}):([0-9a-f]{4})\]/i);
+
+                if (!amdMatch) continue;
+
+                const vendorId = amdMatch[1].toLowerCase();
+                if (vendorId !== '1002') continue;  // Not AMD
+
+                const deviceId = amdMatch[2].toLowerCase();
+
+                // Try to get model name from device ID map
+                const deviceInfo = ROCmDetector.AMD_DEVICE_IDS[deviceId];
+
+                // Also try to extract name from lspci line itself
+                let lspciName = null;
+                const nameMatch = line.match(/\[(?:AMD|ATI)\]\s*(.+?)\s*\[/);
+                if (nameMatch) {
+                    lspciName = nameMatch[1].trim();
+                }
+
+                const name = deviceInfo?.name || this._resolveAMDModelName(lspciName, deviceId) || `AMD GPU (${deviceId})`;
+                const vram = deviceInfo?.vram || this.estimateVRAMFromModel(name);
+
+                // Try to get VRAM from sysfs for this specific device
+                const sysfsVram = this._getVRAMFromSysfsForDevice(deviceId);
+
+                result.gpus.push({
+                    index: idx,
+                    name: name,
+                    memory: {
+                        total: sysfsVram || vram,
+                        free: sysfsVram || vram,
+                        used: 0
+                    },
+                    capabilities: this.getGPUCapabilities(name),
+                    speedCoefficient: this.calculateSpeedCoefficient(name, sysfsVram || vram)
                 });
+                result.totalVRAM += sysfsVram || vram;
+                idx++;
+            }
 
-                // Parse AMD GPUs from rocminfo
-                const agentMatches = rocmInfo.matchAll(/Name:\s*(gfx\d+|AMD.*)/gi);
-                let idx = 0;
-                for (const match of agentMatches) {
-                    const name = match[1].trim();
-                    if (name.toLowerCase().includes('gfx') || name.toLowerCase().includes('amd')) {
-                        const vram = this.estimateVRAMFromGfxName(name);
-
-                        result.gpus.push({
-                            index: idx,
-                            name: name,
-                            memory: { total: vram, free: vram, used: 0 },
-                            capabilities: this.getGPUCapabilities(name),
-                            speedCoefficient: this.calculateSpeedCoefficient(name, vram)
-                        });
-                        result.totalVRAM += vram;
-                        idx++;
+            return result.gpus.length > 0;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Detect GPUs via sysfs (last resort fallback)
+     */
+    _detectViaSysfs(result) {
+        try {
+            const drmPath = '/sys/class/drm';
+            const cards = fs.readdirSync(drmPath).filter(f => f.startsWith('card') && !f.includes('-'));
+            let idx = 0;
+
+            for (const card of cards) {
+                try {
+                    const vendorPath = path.join(drmPath, card, 'device/vendor');
+                    const vendor = fs.readFileSync(vendorPath, 'utf8').trim();
+                    if (vendor !== '0x1002') continue;  // Not AMD
+
+                    const devicePath = path.join(drmPath, card, 'device/device');
+                    const deviceId = fs.readFileSync(devicePath, 'utf8').trim().replace('0x', '').toLowerCase();
+
+                    const deviceInfo = ROCmDetector.AMD_DEVICE_IDS[deviceId];
+                    const name = deviceInfo?.name || `AMD GPU (${deviceId})`;
+                    let vram = deviceInfo?.vram || 8;
+
+                    // Try to read VRAM from sysfs
+                    const vramPaths = [
+                        path.join(drmPath, card, 'device/mem_info_vram_total'),
+                        path.join(drmPath, card, 'device/resource'),
+                    ];
+
+                    for (const vramPath of vramPaths) {
+                        try {
+                            if (vramPath.endsWith('mem_info_vram_total')) {
+                                const bytes = parseInt(fs.readFileSync(vramPath, 'utf8').trim());
+                                if (bytes > 0) {
+                                    vram = Math.round(bytes / (1024 * 1024 * 1024));
+                                    break;
+                                }
+                            }
+                        } catch (e) {
+                            continue;
+                        }
                     }
+
+                    result.gpus.push({
+                        index: idx,
+                        name: name,
+                        memory: { total: vram, free: vram, used: 0 },
+                        capabilities: this.getGPUCapabilities(name),
+                        speedCoefficient: this.calculateSpeedCoefficient(name, vram)
+                    });
+                    result.totalVRAM += vram;
+                    idx++;
+                } catch (e) {
+                    continue;
                 }
-            } catch (e2) {
-                return null;
             }
+
+            return result.gpus.length > 0;
+        } catch (e) {
+            return false;
         }
+    }
 
-        result.isMultiGPU = result.gpus.length > 1;
-        result.speedCoefficient = result.gpus.length > 0
-            ? Math.max(...result.gpus.map(g => g.speedCoefficient))
-            : 0;
+    /**
+     * Try to get VRAM from sysfs for a specific device ID
+     */
+    _getVRAMFromSysfsForDevice(deviceId) {
+        try {
+            const drmPath = '/sys/class/drm';
+            const cards = fs.readdirSync(drmPath).filter(f => f.startsWith('card') && !f.includes('-'));
+
+            for (const card of cards) {
+                try {
+                    const devPath = path.join(drmPath, card, 'device/device');
+                    const devId = fs.readFileSync(devPath, 'utf8').trim().replace('0x', '').toLowerCase();
+                    if (devId !== deviceId) continue;
+
+                    const vramPath = path.join(drmPath, card, 'device/mem_info_vram_total');
+                    const bytes = parseInt(fs.readFileSync(vramPath, 'utf8').trim());
+                    if (bytes > 0) {
+                        return Math.round(bytes / (1024 * 1024 * 1024));
+                    }
+                } catch (e) {
+                    continue;
+                }
+            }
+        } catch (e) {
+            // sysfs not available
+        }
+        return null;
+    }
 
-        return result;
+    /**
+     * Resolve AMD model name from lspci description and device ID
+     */
+    _resolveAMDModelName(lspciName, deviceId) {
+        if (!lspciName) return null;
+
+        // lspci often shows names like "Navi 31 [Radeon RX 7900 XT/7900 XTX/7900M]"
+        // Extract the bracketed name if present
+        const bracketMatch = lspciName.match(/\[(.+?)\]/);
+        if (bracketMatch) {
+            const bracketName = bracketMatch[1];
+            // If it contains multiple variants separated by /, pick based on device ID
+            if (bracketName.includes('/')) {
+                const variants = bracketName.split('/').map(v => v.trim());
+                // Try to match device ID to specific variant
+                const deviceInfo = ROCmDetector.AMD_DEVICE_IDS[deviceId];
+                if (deviceInfo) return deviceInfo.name;
+                // Default to first variant with "AMD Radeon" prefix
+                return `AMD Radeon ${variants[0]}`;
+            }
+            return `AMD Radeon ${bracketName}`;
+        }
+
+        // If name already looks like a GPU model, use it
+        if (lspciName.match(/R[X5-9]\s*\d+/i) || lspciName.match(/MI\d+/i)) {
+            return `AMD ${lspciName}`;
+        }
+
+        return null;
     }
 
     /**

package/src/hardware/detector.js

@@ -244,11 +244,17 @@ class HardwareDetector {
     isIntegratedGPU(model) {
         if (!model) return false;
         const modelLower = model.toLowerCase();
+
+        // Explicitly NOT integrated: dedicated AMD Radeon RX/Instinct cards
+        if (modelLower.includes('radeon rx') || modelLower.includes('radeon pro') ||
+            modelLower.includes('instinct') || modelLower.includes(' rx ')) {
+            return false;
+        }
+
         // Check if GPU is integrated (on-chip or shared memory, not discrete)
-        // Note: && has higher precedence than ||, each line is grouped with ()
         return (modelLower.includes('intel') && !modelLower.includes('arc')) ||
             (modelLower.includes('amd') && modelLower.includes('graphics') && !modelLower.includes(' rx ')) ||
-            (modelLower.includes('radeon') && modelLower.includes('graphics')) ||
+            (modelLower.includes('radeon') && modelLower.includes('graphics') && !modelLower.includes('rx')) ||
             modelLower.includes('iris') ||
             modelLower.includes('uhd') ||
             modelLower.includes('hd graphics') ||

package/src/models/CLAUDE.md

@@ -14,4 +14,10 @@
 | ID | Time | T | Title | Read |
 |----|------|---|-------|------|
 | #3699 | 12:05 AM | ✅ | Git Push Consolidated Architecture Changes to GitHub | ~367 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>

package/src/ollama/CLAUDE.md

@@ -21,4 +21,10 @@
 | #3484 | 10:23 PM | 🔵 | Ollama Client Timeout Implementation - Mixed Patterns with AbortController | ~554 |
 | #3443 | 9:59 PM | 🔵 | Ollama Native Scraper - Web Scraping with Dual Cache Strategy | ~594 |
 | #3437 | 9:58 PM | 🔵 | Ollama Client Implementation - HTTP API Wrapper with Connection Management | ~605 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>

package/src/plugins/CLAUDE.md

@@ -8,4 +8,10 @@
 | ID | Time | T | Title | Read |
 |----|------|---|-------|------|
 | #3462 | 10:02 PM | 🔵 | Plugin System Architecture - Hook-Based Extensibility Framework | ~648 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>

package/src/utils/CLAUDE.md

@@ -8,4 +8,10 @@
 | ID | Time | T | Title | Read |
 |----|------|---|-------|------|
 | #3438 | 9:58 PM | 🔵 | Configuration Management System - Comprehensive Settings with Environment Overrides | ~580 |
+
+### Feb 14, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
 </claude-mem-context>