openshift-installer-checker
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@openshift-installer-checker Check if https://github.com/nvidia/NeMo-Microservices can be installed on my cluster"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
OpenShift/Kubernetes Installer Checker - MCP Server
An MCP (Model Context Protocol) server that analyzes git repositories to extract application installation requirements and validates them against OpenShift/Kubernetes clusters.
Features
š Repository Analysis
Git Repository Support: Fetches README and deployment files from GitHub/GitLab repositories
YAML Parsing: Extracts resource requirements from Helm charts, Kubernetes manifests, ConfigMaps, and CRDs
Smart Extraction: Identifies CPU, memory, GPU, storage requirements, and node selectors
CRD Detection: Extracts Custom Resource Definition requirements from deployment manifests
š„ļø Cluster Scanning
Resource Discovery: Scans connected OpenShift/Kubernetes clusters for available resources
Node Analysis: Detects CPU, memory, GPU capacity and allocatable resources
Current Usage Tracking: Monitors real-time resource consumption (via metrics-server)
GPU Model Detection: Identifies specific GPU models (A100, H100, MI250, etc.) from node labels
GPU Memory Detection: Extracts GPU VRAM from node labels (e.g., 24GB for A10G, 80GB for A100)
Targeted Scanning: Optimized scanning that only fetches resources needed for validation (30-50% faster)
Storage Classes: Lists available storage classes and default configurations
Operator Detection: Scans for installed operators (OpenShift OLM)
CRD Inventory: Lists all Custom Resource Definitions in the cluster
ā Feasibility Checking
Resource Validation: Compares requirements against cluster capacity
GPU Class Validation: Validates GPU models/classes, not just quantity
Datacenter-class requirements (A100, H100, H200, MI250, etc.)
Specific model matching (e.g., "A100/L4", "H100 or newer")
Rejects consumer GPUs (RTX, GTX, T4) for datacenter requirements
GPU Memory Validation: Validates GPU VRAM requirements (critical for LLM workloads)
Compares required vs available GPU memory (e.g., 24Gi vs 80GB A100)
Clear error messages when GPU memory is insufficient
CRD Conflict Detection: Checks for CRD name conflicts, API group mismatches, and version compatibility
Available Resource Calculation: Uses current usage to determine actually available resources
Confidence Scoring: Provides high/medium/low confidence based on available data
š¤ MCP Integration
Claude Code: Works seamlessly with Claude CLI
Cursor: Integrates as MCP tool in Cursor IDE
Multi-Platform: Supports both GitHub and GitLab repositories
Related MCP server: Sentinel Solutions MCP Server
Installation
Clone this repository:
git clone https://github.com/Hadar301/mcp-openshift-installer-checker.git
cd mcp-openshift-installer-checkerInstall dependencies using
uv:
uv sync(Optional) Set up GitHub/GitLab tokens to avoid rate limits:
cp .env.example .env
# Edit .env and add your tokens(Optional) Log in to your OpenShift/Kubernetes cluster for scanning features:
# For OpenShift
oc login <cluster-url>
# For Kubernetes
kubectl config use-context <context-name>Prerequisites
Required
Python 3.10+
uv package manager:
pip install uv
Optional (for cluster scanning)
oc (OpenShift CLI) or kubectl (Kubernetes CLI)
metrics-server installed in cluster (for current usage tracking)
Active cluster connection (
oc loginorkubectl config use-context)
Usage
As an MCP Server (with Claude Code or Cursor)
Configure for Claude Code
First, clone the repository:
git clone https://github.com/Hadar301/mcp-openshift-installer-checker.git
cd mcp-openshift-installer-checker
uv syncThen edit ~/.claude.json and add the MCP server configuration to the project where you want to use it. For example, to configure it for your home directory (/Users/yourusername):
{
"projects": {
"/Users/yourusername": {
"mcpServers": {
"openshift-installer-checker": {
"type": "stdio",
"command": "uv",
"args": [
"--directory",
"/path/to/mcp-openshift-installer-checker",
"run",
"python",
"main.py"
],
"env": {
"GITHUB_TOKEN": "<your-github-token>"
}
}
}
}
}
}Note:
Replace
/Users/yourusernamewith your actual home directory pathReplace
/path/to/mcp-openshift-installer-checkerwith the actual path where you cloned the repositoryReplace
<your-github-token>with your GitHub personal access token
Then use Claude Code:
claude chatAsk Claude:
"Can I install https://github.com/nvidia/NeMo-Microservices on my cluster?"
"Check if https://github.com/kubeflow/kubeflow will fit on my cluster"
Configure for Cursor
First, clone the repository:
git clone https://github.com/Hadar301/mcp-openshift-installer-checker.git
cd mcp-openshift-installer-checker
uv syncThen edit ~/.cursor/mcp.json:
{
"mcpServers": {
"openshift-installer-checker": {
"command": "uv",
"args": [
"--directory",
"/path/to/mcp-openshift-installer-checker",
"run",
"python",
"main.py"
],
"cwd": "/path/to/mcp-openshift-installer-checker",
"env": {
"GITHUB_TOKEN": "<your-github-token>"
}
}
}
}Note: Replace /path/to/mcp-openshift-installer-checker with the actual path where you cloned the repository, and <your-github-token> with your GitHub personal access token.
Then ask in Cursor chat: "Analyze installation requirements for https://github.com/your/repo and check if it can be installed"
How It Works
Phase 1: Repository Analysis
URL Parsing: Extracts platform (GitHub/GitLab), owner, and repository name
README Fetching: Downloads README.md via GitHub/GitLab API
Deployment File Discovery: Searches common paths (
helm/,deploy/,k8s/,manifests/, etc.)YAML Parsing: Extracts resource specifications from Kubernetes manifests
CRD Extraction: Identifies Custom Resource Definitions to be installed
Requirement Aggregation: Combines requirements from multiple sources
Phase 2: Cluster Scanning (if cluster available)
CLI Detection: Tries
ocfirst (OpenShift), falls back tokubectlTargeted Scanning: Only fetches resources needed based on requirements (performance optimization)
Node Scanning: Collects capacity, allocatable resources, GPU models, and GPU memory
Usage Tracking: Fetches current resource consumption (requires metrics-server)
Storage Classes: Lists available storage provisioners (only if storage required)
Software Inventory: Scans for installed operators and CRDs (only if needed)
Available Calculation: Computes free resources (allocatable - used)
Phase 3: Feasibility Checking
Resource Validation: Compares CPU, memory, GPU against cluster capacity
GPU Model Validation: Validates GPU class/model requirements
Datacenter-class: A100, H100, H200, L4, L40, MI250, MI300, etc.
Consumer GPUs rejected: T4, RTX, GTX, Quadro, Titan
GPU Memory Validation: Validates GPU VRAM requirements
Compares required memory (e.g., 24Gi, 80GB) against available GPU memory
Critical for LLM deployments (Llama-70B needs 80GB, DeepSeek-V3 needs 600GB+)
Storage Validation: Checks for available storage classes
CRD Conflict Detection: Identifies potential CRD conflicts
Confidence Scoring: Assigns confidence level based on available data
Phase 4: LLM Analysis
Returns structured data for Claude/Cursor to analyze and present to user
Project Structure
mcp-openshift-installer-checker/
āāā main.py # MCP server entry point
āāā .env.example # Example environment variables
āāā pyproject.toml # Project dependencies (uv)
āāā uv.lock # Dependency lock file
āāā LICENSE # MIT license
āāā README.md # This file
āāā src/
ā āāā __init__.py
ā āāā cluster_analyzer/
ā ā āāā scanner.py # Cluster resource scanner (with targeted scanning)
ā ā āāā __init__.py
ā āāā cluster_checker/
ā ā āāā feasibility.py # Requirement validation (with GPU memory checks)
ā ā āāā __init__.py
ā āāā requirements_extractor/
ā āāā extractor.py # Main orchestrator
ā āāā git_handler.py # GitHub/GitLab API client
ā āāā __init__.py
ā āāā parser/
ā ā āāā yaml_parser.py # YAML resource extraction
ā ā āāā __init__.py
ā āāā models/
ā ā āāā requirements.py # Pydantic data models
ā ā āāā __init__.py
ā āāā utils/
ā āāā resource_comparisons.py # CPU/memory comparison utilities
ā āāā __init__.py
āāā test/
āāā test_crd_detection.py # CRD conflict detection tests
āāā test_gpu_model_validation.py # GPU model validation tests
āāā test_command_injection_protection.py # Security tests
āāā test_extraction.py # Requirement extraction tests
āāā test_usage_tracking.py # Resource usage tracking tests
āāā failed_attempt.md # Test documentation
āāā successful_attempt.md # Test documentationExample Queries for Claude/Cursor
Once configured as an MCP server, you can ask Claude or Cursor:
Basic Analysis:
"What are the requirements for https://github.com/prometheus/prometheus?"
"Analyze hardware needs for https://github.com/argoproj/argo-cd"
Feasibility Checking (requires cluster connection):
"Can I install https://github.com/nvidia/NeMo-Microservices on my cluster?"
"Will https://github.com/kubeflow/kubeflow fit on my cluster?"
"Check if my cluster can handle https://github.com/ray-project/kuberay"
GPU Validation:
"Does my cluster have the right GPUs for https://github.com/vllm-project/vllm?"
"Can I run this ML workload with my current GPU setup?"
CRD Conflict Detection:
"Will installing this operator conflict with my existing CRDs?"
"What CRDs will be created by this application?"
Claude/Cursor will automatically:
Call the
analyze_app_requirementstoolScan the connected cluster (if available)
Validate requirements against cluster capacity
Check for CRD conflicts
Present results in a clear, formatted output
System Requirements for Scanning
Cluster Access
Active connection to OpenShift/Kubernetes cluster
oc(OpenShift CLI) orkubectlinstalled and in PATHUser logged in with read permissions
Troubleshooting
Cluster Not Available
If cluster scanning fails:
Verify CLI tool is installed:
oc versionorkubectl versionCheck cluster connection:
oc whoamiorkubectl cluster-infoThe tool continues to work for repository analysis even without cluster access
Metrics Server Not Available
If usage tracking fails:
Install metrics-server:
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yamlFeasibility checks fall back to allocatable resources (still functional)
GPU Models Not Detected
If GPU models show as empty:
Check if nodes have GPU labels:
kubectl get nodes -o json | jq '.items[].metadata.labels'GPU device plugins (NVIDIA, AMD) add these labels automatically
Manual labeling:
kubectl label node <node-name> nvidia.com/gpu.product=NVIDIA-A100-SXM4-40GB
MCP Server Not Connecting
Check the MCP config file path is correct
Verify
uvis installed:uv --versionTry running manually:
uv run python main.pyUse the MCP Inspector to debug:
npx @modelcontextprotocol/inspector uv run python main.py
Contributing
Contributions welcome! This project focuses on building practical MCP servers for DevOps automation.
Development Setup
git clone https://github.com/Hadar301/mcp-openshift-installer-checker.git
cd mcp-openshift-installer-checker
uv syncRunning Tests
# Test CRD detection
PYTHONPATH=. uv run python test/test_crd_detection.py
# Test GPU validation
PYTHONPATH=. uv run python test/test_gpu_model_validation.pyCode Structure
src/cluster_analyzer/- Cluster resource scanning with targeted optimizationsrc/cluster_checker/- Feasibility validation with GPU memory checkssrc/requirements_extractor/- Repository analysis and requirement extractiontest/- Test scriptsmain.py- MCP server entry point
License
MIT
Available Tools
3 toolscheck_feasibilityA
Check if an application CAN BE DEPLOYED on the user's cluster.
ā ļø ONLY USE THIS when user explicitly asks about deployment/installation:
- "can I deploy X on my cluster?"
- "can I install X?"
- "is my cluster compatible with X?"
- "will X work on my cluster?"
ā DO NOT USE when user only asks about requirements without mentioning deployment.
For "what are the requirements?" questions, use fetch_repo_content instead.
This tool scans BOTH the repository AND the cluster, then compares them.
Args:
repo_url: Full GitHub or GitLab repository URL
Examples:
- https://github.com/nvidia/nemo
- https://gitlab.com/project/repo
Returns:
Dictionary with the following keys:
- success (bool): Always check this first! If False, check the 'error' field.
- _summary (dict): **READ THIS FIRST!** Quick overview with:
- readme_found (bool): True if README exists with substantial content
- readme_length_chars (int): Character count of all markdown files
- deployment_files_count (int): Number of K8s/Helm files found
- deployment_file_paths (list): First 10 deployment file paths
- has_cluster_info (bool): Whether cluster scan succeeded
- has_feasibility_check (bool): Whether feasibility analysis is available
- readme_content (str): Combined content of ALL markdown files from the repository.
This field will ALWAYS be populated (may say "No README found" if truly empty).
Length typically 10,000-500,000 chars for real projects.
- deployment_files (list): List of Kubernetes/Helm YAML files found.
Each item has: {"path": "...", "content": "...", "parsed_resources": {...}}
This list will contain 0+ items. Empty list means no K8s manifests found.
- yaml_extracted_requirements (dict): Structured requirements from YAML parsing.
Contains hardware/software/CRD requirements extracted automatically.
- cluster_info (dict|null): Cluster scan results (nodes, GPUs, storage, etc.).
Will be null if cluster not accessible.
- feasibility_check (dict|null): Detailed YES/NO analysis comparing repo vs cluster.
Will be null if cluster not accessible.
- instructions_for_llm (str): Read this! It contains important context and warnings.
CRITICAL - HOW TO USE THE RESPONSE:
1. CHECK 'success' field first
2. **READ '_summary' FIELD** - it shows what data is available at a glance
3. Use _summary.readme_found to determine if README exists
4. Use _summary.deployment_files_count to see how many K8s files were found
5. READ 'readme_content' - it contains all documentation (README, guides, etc.)
6. CHECK 'deployment_files' - if empty, repo may not have K8s manifests
7. READ 'instructions_for_llm' - it has important warnings and cluster info
8. USE 'feasibility_check' for automated comparison results
9. NEVER say "no README" if _summary.readme_found is True
10. NEVER say "no deployment files" if _summary.deployment_files_count > 0
OUTPUT FORMATTING RULES:
1. Summarize all requirements vs cluster resources in a table
2. Consider every deployment option (don't group into categories)
3. Provide final YES/NO answer for each installation type
4. Don't add installation instructions
Example response structure:
{
"success": True,
"readme_content": "# MyApp[12,000+ chars of documentation]...", "deployment_files": [ {"path": "helm/values.yaml", "content": "...", "parsed_resources": {...}}, {"path": "k8s/deployment.yaml", "content": "...", "parsed_resources": {...}} ], "yaml_extracted_requirements": { "hardware": {"cpu": "4", "memory": "8Gi", "gpu": {"nvidia.com/gpu": "1"}}, "software_inferred": ["NVIDIA GPU Operator"] }, "cluster_info": {"nodes": {...}, "gpu_resources": {...}}, "feasibility_check": {"can_install": False, "reasons": [...]} }
Inputs: repo_url (required).
fetch_repo_contentA
Extract and list application requirements from a repository. NO cluster involvement.
ā ļø ALWAYS USE THIS TOOL when user asks about requirements WITHOUT mentioning cluster:
- "what are the requirements for X?"
- "what does X need to run?"
- "analyze requirements for X"
- "list the requirements for X"
- "what hardware/software does X need?"
KEY: If the question is ONLY about the app's needs (not about "can I install it?"), use this tool.
ā DO NOT USE when user asks about deployment/installation/compatibility with their cluster.
For those questions, use check_feasibility instead.
This tool ONLY analyzes the repository. It does NOT:
- Scan any cluster
- Check cluster compatibility
- Determine if installation is possible
Args:
repo_url: Full GitHub or GitLab repository URL
Examples:
- https://github.com/nvidia/nemo
- https://gitlab.com/project/repo
Returns:
Dictionary containing:
- success: Boolean indicating if the operation was successful
- repo_info: Repository metadata (platform, owner, repo name)
- readme_content: README text for LLM to analyze
- deployment_files: List of deployment YAML files with content and parsed resources
- yaml_extracted_requirements: Summary of requirements found in YAML files
- instructions_for_llm: Guidance for the LLM on how to analyze the data
Example:
>>> fetch_repo_content("https://github.com/kubernetes/kubernetes")
{
"success": True,
"repo_info": {...},
"readme_content": "# Kubernetes...",
"deployment_files": [...],
"yaml_extracted_requirements": {...}
}
Inputs: repo_url (required).
scan_clusterA
Scan the connected OpenShift/Kubernetes cluster for available resources.
This performs a FULL cluster scan, returning all available resources.
USE THIS TOOL WHEN:
- User asks "what resources are available in my cluster?"
- User asks "what does my cluster have?"
- User asks "scan my cluster"
- User wants to know their cluster's capabilities WITHOUT comparing to any app
For Example, questions like:
- "How many available GPUs are on the cluster?"
- "How many available CPU cores are on the cluster?"
And also question that might regard other cluster resources.
DO NOT USE when user asks about installing/deploying an app (use check_feasibility instead)
DO NOT USE when user asks about app requirements (use fetch_repo_content instead)
Returns comprehensive cluster information including:
- Node resources (CPU, memory, allocatable, available, usage)
- GPU availability, models, and memory (VRAM)
- Storage classes
- Installed operators (OpenShift only)
- Custom Resource Definitions (CRDs)
Fails with clear error if cluster is not accessible.
Returns:
Dictionary containing:
- success: Boolean indicating if the operation was successful
- cluster_info: Node resources, GPU info, storage classes, operators, CRDs
- error: Error message if cluster not accessible
Example:
>>> scan_cluster()
{
"success": True,
"cluster_info": {
"nodes": {...},
"gpu_resources": {
"total_gpus": 4,
"gpu_models": ["NVIDIA-A10G"],
"gpu_memory_mb": 23028
},
"storage_classes": [...],
"operators": [...],
"crds": [...]
}
}
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogā¦
TDQS
Scored across 3 tools
Each tool has a clearly distinct purpose: fetching repo requirements, scanning cluster resources, and comparing the two for feasibility. The descriptions include explicit usage rules and 'DO NOT USE' guidance, so an agent should not confuse them.
All tool names follow the same imperative verb_noun pattern: fetch_repo_content, scan_cluster, check_feasibility. Naming style is consistent and predictable.
Three tools is appropriate for a single focused workflow: gather repo requirements, gather cluster state, and assess feasibility. Each tool is necessary and none feels redundant.
The server covers the full lifecycle of its purpose: extracting requirements from a repository, scanning the cluster, and combining the two in a feasibility check. No obvious dead ends or missing operations for the stated domain.
Related MCP Connectors
Screens public GitHub repos and PRs to generate risk maps, findings, and merge-readiness signals.
Evaluates any GitHub repository for license risk, maintenance velocity, stars/forks, and security.
Evaluates any GitHub repository for license risk, maintenance velocity, stars/forks, and supply-c.
Generate SBOMs, scan vulnerabilities, and analyze dependencies from local projects or Git repos.
Related MCP Servers
- FlicenseBqualityDmaintenanceEnables analysis and querying of Git repository content (both public and private) through a unified tool that provides repository summaries, file structures, and full content optimized for LLM consumption.1-
- AlicenseAqualityDmaintenanceAnalyzes Microsoft Sentinel solutions from GitHub repositories to map data connectors to Log Analytics tables and query security content like detections and playbooks. It provides instant access to the official Content Hub or private repositories through a high-performance pre-built index.2312 npm1MIT
- FlicenseNot gradedqualityDmaintenanceEnables analysis of local Git repositories via standard git commands, providing insights like line authorship, commit frequency, code churn, and co-changed files.-
- FlicenseAqualityBmaintenanceClones and inspects public GitHub repositories to extract evidence like manifests, dependencies, and version hints, and can run allow-listed repos in isolated Docker containers for reproducible verification.4-