Skip to main content
Glama
OpenShift 4 MCP Server

OpenShift 4 MCP Server

OpenShift & Kubernetes MCP Server

OpenShift 4 MCP Server MCP server – quality and maintenance score on Glama

OpenShift 4 MCP Server MCP server – quality and maintenance score on Glama

A comprehensive Model Context Protocol (MCP) server that exposes 216 tools, 7 resources, and 10 runbook prompts for cluster operations — all driven by an LLM. Works with OpenShift 4 and vanilla Kubernetes; OpenShift-specific tools (Routes, BuildConfigs, SCCs, OLM, Machines, RHOAI, Virtualization) return a clear error on plain Kubernetes clusters that don't have those APIs.

Connect it to Claude (Desktop, Code, or API) and ask natural-language questions like:

"Why is my pod crashlooping in namespace prod?" "Scale the frontend deployment to 5 replicas." "Show me all firing alerts and create a 4-hour silence for the watchdog." "Live-migrate VM database-0 to another node." "Deploy llama-3 with KServe in the ds-team namespace." "What's the status of my Tekton pipeline run in namespace ci?" "Show me all Konflux components and their latest snapshot status."


Table of Contents


Related MCP server: OpenShift SRE Copilot

Features

Domain

Tools

What you can do

Cluster

17

ClusterVersion, upgrade status, nodes, cordon/drain, namespaces, etcd health, events

Workloads

19

Pods (logs, exec, describe), Deployments (scale, rollout, undo), StatefulSets, DaemonSets, Jobs, CronJobs, DeploymentConfigs

Networking

12

Services, OpenShift Routes (TLS), Ingress, NetworkPolicies, IngressControllers

Storage

10

PVs, PVCs (create/delete), StorageClasses, VolumeSnapshots

Config

8

ConfigMaps, Secrets (keys only — values never exposed), ServiceAccounts

RBAC

13

OCP Users/Groups, Roles, ClusterRoles, RoleBindings, auth can-i checks

Builds

8

BuildConfigs, start/log builds, ImageStreams and tags

Operators (OLM)

10

CSVs, Subscriptions, CatalogSources, InstallPlans (approve), OperatorConditions

Machines

11

MachineSets (scale), Machines, MachineConfigs, MachineConfigPools (pause/unpause)

Monitoring

10

PromQL instant/range queries, Alertmanager alerts/silences (CRUD), PrometheusRules

Security

9

SCCs (list/create/assign), OAuth config, pod security violations

Autoscaling

8

HPA (create/delete), VPA recommendations, ClusterAutoscaler, MachineAutoscaler

GitOps

7

ArgoCD Applications (sync, health, refresh), AppProjects, registered clusters

Pipelines

10

Tekton Pipelines/PipelineRuns/Tasks/TaskRuns, start/cancel, EventListeners

Service Mesh

8

SMCP status, VirtualServices, DestinationRules, PeerAuthentications, Gateways

OpenShift AI

13

DSCI/DSC status, Notebooks (start/stop), KServe InferenceServices, DSP, ModelRegistry

Virtualization

15

VMs (start/stop/restart/pause/create/delete), live migration, DataVolumes, snapshots

Konflux

11

Applications, Components, Snapshots, IntegrationTestScenarios, ReleasePlans

ACM

11

ManagedClusters, Policies, Placements, ManifestWorks (deploy to managed clusters)

Generic

6

apply_manifest, get_resource, run_oc_command, list_crds

MCP Resources

7

Live cluster URIs: ocp://cluster/info, ocp://{ns}/pods, alerts, etc.

MCP Prompts

10

SRE runbooks: troubleshoot pod, upgrade cluster, debug network, deploy ML model, and more


Requirements

  • Python 3.11+

  • oc CLI in PATH (for operations that use it; many tools fall back to direct k8s API calls)

  • virtctl in PATH (for VM pause/unpause; optional)

  • Access to an OpenShift 4.x cluster


Installation

git clone https://github.com/ay-garg/openshift-mcp-server.git
cd openshift-mcp-server

python3 -m venv .venv
.venv/bin/pip install -e .

Authentication

The server supports five auth modes, tried in priority order:

1. OCP_CLUSTERS — multi-cluster JSON (highest priority)

See the Multi-cluster section below.

export OCP_API_URL=https://api.mycluster.example.com:6443
export OCP_TOKEN=sha256~xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Get a long-lived token:

oc create serviceaccount mcp-server -n default
oc adm policy add-cluster-role-to-user cluster-admin -z mcp-server -n default
oc create token mcp-server -n default --duration=8760h

3. Username / Password

export OCP_API_URL=https://api.mycluster.example.com:6443
export OCP_USERNAME=kubeadmin
export OCP_PASSWORD=xxxx-xxxx-xxxx-xxxx

The server runs oc login and extracts the resulting bearer token automatically.

4. kubeconfig (default for local dev)

# Uses ~/.kube/config automatically, or:
export OCP_KUBECONFIG=/path/to/kubeconfig
export OCP_KUBECONFIG_CONTEXT=my-cluster-admin   # optional context name

5. In-cluster (when running inside a pod)

No env vars needed — uses the mounted ServiceAccount token automatically.

TLS verification

# Disable TLS verification for the Kubernetes API connection (k8s client):
export OCP_SKIP_TLS_VERIFY=true   # for self-signed certs in dev/lab clusters

# Disable TLS verification for Prometheus/Alertmanager HTTP calls:
export OCP_VERIFY_SSL=false

These are two independent settings — OCP_SKIP_TLS_VERIFY controls the kubernetes Python client (API calls), OCP_VERIFY_SSL controls HTTP requests to Prometheus and Alertmanager.


Multi-cluster

Set OCP_CLUSTERS to a JSON array of named cluster configs:

export OCP_CLUSTERS='[
  {"name": "prod",    "api_url": "https://api.prod.example.com:6443",    "token": "sha256~prod..."},
  {"name": "staging", "api_url": "https://api.staging.example.com:6443", "token": "sha256~staging..."},
  {"name": "lab",     "api_url": "https://api.lab.example.com:6443",     "token": "sha256~lab...", "skip_tls_verify": true}
]'

Each cluster config object supports:

Field

Required

Description

name

yes

Logical name used in the cluster= tool parameter

api_url

yes

API server URL (https://api.<cluster>:6443)

token

one of token/user+pass

Bearer token

username / password

one of token/user+pass

Credentials for oc login

skip_tls_verify

no

Set true to disable TLS verification for this cluster

Then pass cluster="prod" to any tool:

list_pods(namespace="kube-system", cluster="prod")
scale_deployment(name="api", replicas=3, namespace="default", cluster="staging")

Monitoring / Prometheus

By default the server auto-derives the Alertmanager URL from OCP_PROMETHEUS_URL. Override if needed:

export OCP_PROMETHEUS_URL=https://thanos-querier.openshift-monitoring.svc:9091
export OCP_ALERTMANAGER_URL=https://alertmanager-main.openshift-monitoring.svc:9093
export OCP_PROMETHEUS_TOKEN=sha256~...   # defaults to OCP_TOKEN

Environment variables reference

Variable

Default

Purpose

OCP_API_URL

—

API server URL for single-cluster token/password auth

OCP_TOKEN

—

Bearer token for the service account or user

OCP_USERNAME

—

Username for oc login

OCP_PASSWORD

—

Password for oc login

OCP_SKIP_TLS_VERIFY

false

Set true/1/yes to skip TLS for the k8s API client

OCP_KUBECONFIG

~/.kube/config

Path to a kubeconfig file

OCP_KUBECONFIG_CONTEXT

—

Named context within the kubeconfig

OCP_CLUSTERS

—

JSON array of multi-cluster configs (see above)

OCP_PROMETHEUS_URL

auto-detected

Prometheus/Thanos querier URL

OCP_ALERTMANAGER_URL

auto-derived

Alertmanager URL

OCP_PROMETHEUS_TOKEN

OCP_TOKEN

Token for Prometheus/Alertmanager HTTP calls

OCP_VERIFY_SSL

true

Set false to skip TLS for Prometheus/Alertmanager HTTP calls

MCP_TRANSPORT

stdio

stdio or streamable-http

MCP_HOST

127.0.0.1

Bind address for streamable-http transport

MCP_PORT

8080

Port for streamable-http transport

GRADIO_HOST

0.0.0.0

Bind address for the Gradio web UI

GRADIO_PORT

7860

Port for the Gradio web UI

GRADIO_SHARE

false

Set true for a temporary public Gradio URL

ANTHROPIC_API_KEY

—

Required for the AI Chat tab in the Gradio UI

ANTHROPIC_MODEL

claude-sonnet-5

Model for the AI Chat tab


Usage with Claude

Claude Code (this repository)

The .claude/settings.json already wires the server up. Open this directory in Claude Code and the ocp MCP server is available automatically.

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):

{
  "mcpServers": {
    "ocp": {
      "command": "/path/to/ocp-mcp-server/.venv/bin/python",
      "args": ["-m", "ocp_mcp.server"],
      "env": {
        "PYTHONPATH": "/path/to/ocp-mcp-server/src",
        "OCP_API_URL": "https://api.mycluster.example.com:6443",
        "OCP_TOKEN": "sha256~..."
      }
    }
  }
}

Streamable HTTP transport (for remote use or web apps)

Note: MCP_HOST defaults to 127.0.0.1 (loopback-only, with DNS-rebinding protection enabled by the MCP SDK). Set MCP_HOST=0.0.0.0 explicitly when you need external access.

export MCP_TRANSPORT=streamable-http
export MCP_HOST=0.0.0.0   # bind to all interfaces for remote access
export MCP_PORT=8080
.venv/bin/ocp-mcp-server

Then point your MCP client at http://your-host:8080/mcp.

Web UI (Gradio)

A browser-based UI with two tabs — no MCP client required.

Install UI dependencies:

.venv/bin/pip install -e ".[ui]"

Run:

export OCP_API_URL=https://api.mycluster.example.com:6443
export OCP_TOKEN=sha256~...
.venv/bin/ocp-mcp-ui
# Opens at http://localhost:7860

Tab 1 — Tool Playground: Select any of the 216 tools from a searchable dropdown, fill in parameters, and run it directly against your cluster. Results appear instantly — no AI in the loop.

Tab 2 — AI Chat: Natural-language chat backed by Claude. Set ANTHROPIC_API_KEY and ask anything — Claude will automatically call the right OCP tools and show you what it did.


Interactive Chat Client (mcp_chat.py)

mcp_chat.py is a standalone terminal chat client that connects to any running MCP server and drives an agentic loop using the LLM of your choice. All configuration is prompted at startup — no environment variables required, though they are used as defaults when present.

Supported LLM providers

Provider

Auth

Anthropic API

API key

Google Vertex AI

GCP project ID + region (GCP ADC — gcloud auth application-default login)

Ollama

Base URL (local or remote)

OpenAI-compatible

Base URL + optional API key (OpenAI, LM Studio, vLLM, llama.cpp, …)

Install

pip install mcp anthropic "anthropic[vertex]" openai httpx

Run

python mcp_chat.py

The script walks you through setup interactively:

╔══════════════════════════════════════════════════════════════╗
║                  MCP Chat — Setup                           ║
╚══════════════════════════════════════════════════════════════╝

MCP server URL [http://localhost:8080/mcp]:

LLM provider
  1. Anthropic API  (API key)
  2. Google Vertex AI  (GCP project ID + region, GCP ADC auth)
  3. Ollama  (local or remote)
  4. OpenAI-compatible  (OpenAI / LM Studio / vLLM / llama.cpp / …)
Choice:

Self-signed / internal CA certificates

When an HTTPS URL is entered (for the MCP server or the model endpoint) the script asks whether the certificate is CA-signed or self-signed:

  The MCP server URL is using HTTPS.
  Does it use a valid CA-signed certificate? (answer 'n' for self-signed / internal CA) [Y/n]:

Answering n disables SSL verification for that endpoint automatically. This is the correct answer for:

  • CRC (CodeReady Containers) — uses a self-signed router CA

  • Self-hosted OpenShift clusters with internal PKI

  • Local Ollama or OpenAI-compatible servers fronted by nginx with a self-signed cert

Note: For the MCP server connection, SSL verification is disabled by patching httpx.AsyncClient for the duration of the session (the MCP SDK does not expose a verify= parameter directly). For Ollama/OpenAI-compatible clients, httpx.Client(verify=False) is passed directly. Anthropic API and Google Vertex AI always use CA-signed certificates and are never prompted.

Environment variable defaults

All prompts use environment variables as pre-filled defaults so repeat runs need fewer keystrokes:

Prompt

Env var

MCP server URL

MCP_SERVER_URL

Anthropic API key

ANTHROPIC_API_KEY

Model (Anthropic / Vertex)

ANTHROPIC_MODEL

GCP project ID

ANTHROPIC_VERTEX_PROJECT_ID or GOOGLE_CLOUD_PROJECT

GCP region

CLOUD_ML_REGION or ANTHROPIC_VERTEX_REGION

Ollama base URL

OLLAMA_HOST

Ollama model

OLLAMA_MODEL

OpenAI base URL

OPENAI_BASE_URL

OpenAI API key

OPENAI_API_KEY

OpenAI model

OPENAI_MODEL

Example session (Vertex AI + CRC cluster)

# Port-forward the deployed MCP server
oc port-forward svc/ocp-mcp-server 8080:8080 -n ocp-mcp &

python mcp_chat.py
# MCP server URL [http://localhost:8080/mcp]: https://ocp-mcp-server-ocp-mcp.apps-crc.testing/mcp
#   The MCP server URL is using HTTPS.
#   Does it use a valid CA-signed certificate? [Y/n]: n
#   ⚠  SSL verification disabled for MCP server (self-signed cert).
# LLM provider → 2 (Google Vertex AI)
# GCP project ID: my-gcp-project
# Region [us-east5]:
# Model [claude-opus-4-8]:
# Ready — 216 tools available | provider: vertex | model: claude-opus-4-8

You: What nodes are in my cluster and are any under memory pressure?
  → list_nodes({})
  → get_node_conditions({"node":"crc-xxxxx-master-0"})

Container & OpenShift Deployment

This section covers building the container image and deploying to OpenShift or any Kubernetes cluster.

Prerequisites

  • Podman or Docker for building/pushing the image

  • Access to a container registry (Quay.io, OpenShift internal registry, etc.)

  • oc CLI logged in to your cluster


1. Build the image

# Clone and enter the repo
git clone https://github.com/ay-garg/openshift-mcp-server.git
cd openshift-mcp-server

# Build with Podman (recommended for OpenShift)
podman build -f Containerfile -t quay.io/your-org/ocp-mcp-server:latest .

# Multi-arch build (amd64 + arm64)
podman buildx build \
  --platform linux/amd64,linux/arm64 \
  -f Containerfile \
  -t quay.io/your-org/ocp-mcp-server:latest .
podman push quay.io/your-org/ocp-mcp-server:latest

Build arguments:

Argument

Default

Description

OC_VERSION

stable

OpenShift CLI version; e.g. 4.16.3 to pin a release

VIRTCTL_VERSION

v1.4.0

KubeVirt virtctl version

TARGETARCH

amd64

CPU architecture: amd64 or arm64 (set automatically by BuildKit)

# Pin specific CLI versions
podman build -f Containerfile \
  --build-arg OC_VERSION=4.16.3 \
  --build-arg VIRTCTL_VERSION=v1.4.0 \
  -t quay.io/your-org/ocp-mcp-server:4.16.3 .

2. Push the image

podman push quay.io/your-org/ocp-mcp-server:latest

For the OpenShift internal registry:

# Log in to the internal registry
oc registry login
IMAGE="$(oc registry info)/ocp-mcp/ocp-mcp-server:latest"
podman build -f Containerfile -t "$IMAGE" .
podman push "$IMAGE"

3. Deploy to OpenShift

3a. Create the namespace

oc new-project ocp-mcp
# or:
oc apply -f deploy/namespace.yaml

3b. Create the credentials Secret

The Secret holds cluster auth and the optional Anthropic API key. Never commit real values.

In-cluster deployment (server manages the same cluster it runs in — no credentials needed):

# Only set ANTHROPIC_API_KEY if you want the Gradio AI Chat tab
oc create secret generic ocp-mcp-server-credentials \
  --from-literal=ANTHROPIC_API_KEY=sk-ant-xxxxxxxx \
  -n ocp-mcp

# If no Anthropic key either, create an empty secret:
oc create secret generic ocp-mcp-server-credentials -n ocp-mcp

External cluster (server is deployed elsewhere and manages a remote cluster):

# Single cluster — token auth (recommended)
oc create secret generic ocp-mcp-server-credentials \
  --from-literal=OCP_API_URL=https://api.cluster.example.com:6443 \
  --from-literal=OCP_TOKEN=sha256~xxxxxxxxxxxxxxxxxxxxxxxx \
  --from-literal=ANTHROPIC_API_KEY=sk-ant-xxxxxxxx \
  -n ocp-mcp

# Multi-cluster
oc create secret generic ocp-mcp-server-credentials \
  --from-literal=OCP_CLUSTERS='[
    {"name":"prod",    "api_url":"https://api.prod.example.com:6443",    "token":"sha256~prod..."},
    {"name":"staging", "api_url":"https://api.staging.example.com:6443", "token":"sha256~staging..."}
  ]' \
  --from-literal=ANTHROPIC_API_KEY=sk-ant-xxxxxxxx \
  -n ocp-mcp

Tip: Generate a long-lived ServiceAccount token for the MCP server:

oc create serviceaccount mcp-server -n default
oc adm policy add-cluster-role-to-user cluster-admin -z mcp-server -n default
oc create token mcp-server -n default --duration=8760h

3c. Edit the image reference

Open deploy/deployment.yaml and replace the placeholder image:

image: quay.io/your-org/ocp-mcp-server:latest

3d. Apply all resources

# Using kustomize (recommended)
oc apply -k deploy/

# Or apply individually
oc apply -f deploy/serviceaccount.yaml
oc apply -f deploy/clusterrolebinding.yaml
oc apply -f deploy/configmap.yaml
oc apply -f deploy/deployment.yaml
oc apply -f deploy/service.yaml
oc apply -f deploy/route.yaml

3e. Verify the deployment

# Check pod status
oc get pods -n ocp-mcp -l app.kubernetes.io/name=ocp-mcp-server

# Check logs
oc logs -n ocp-mcp -l app.kubernetes.io/name=ocp-mcp-server -f

# Get the public MCP URL
oc get route ocp-mcp-server -n ocp-mcp -o jsonpath='{.spec.host}'

The server is ready when you see a line like:

INFO:     Started server process
INFO:     Uvicorn running on http://0.0.0.0:8080

3b. Deploy to vanilla Kubernetes

The same manifests work on any Kubernetes cluster. The differences from the OpenShift steps above:

  • Use kubectl instead of oc

  • Use deploy/ingress.yaml instead of deploy/route.yaml (Ingress requires an ingress controller such as nginx-ingress)

  • Skip deploy/namespace.yaml if your cluster auto-creates namespaces; otherwise kubectl create namespace ocp-mcp

Create the namespace and credentials

kubectl create namespace ocp-mcp

# Token auth (replace with your cluster API URL and token)
kubectl create secret generic ocp-mcp-server-credentials \
  --from-literal=OCP_API_URL=https://api.k8s.example.com:6443 \
  --from-literal=OCP_TOKEN=<serviceaccount-token> \
  -n ocp-mcp

Generate a long-lived ServiceAccount token:

kubectl create serviceaccount mcp-server -n default
kubectl create clusterrolebinding mcp-server-admin \
  --clusterrole=cluster-admin --serviceaccount=default:mcp-server
kubectl create token mcp-server -n default --duration=8760h

Apply the manifests

# Apply all resources except the OpenShift Route
kubectl apply -f deploy/serviceaccount.yaml
kubectl apply -f deploy/clusterrolebinding.yaml
kubectl apply -f deploy/configmap.yaml
kubectl apply -f deploy/deployment.yaml
kubectl apply -f deploy/service.yaml
kubectl apply -f deploy/ingress.yaml   # Kubernetes Ingress (not Route)

Edit deploy/ingress.yaml first to set the correct hostname for your cluster.

Verify

kubectl get pods -n ocp-mcp -l app.kubernetes.io/name=ocp-mcp-server
kubectl logs -n ocp-mcp -l app.kubernetes.io/name=ocp-mcp-server -f
kubectl get ingress -n ocp-mcp

Kubernetes compatibility note: Core tools (workloads, networking, storage, RBAC, config, monitoring, Tekton Pipelines) work on any Kubernetes cluster. Tools for OpenShift-specific APIs (Routes, BuildConfigs, SCCs, OLM, Machines, OpenShift AI, Virtualization, Service Mesh, ACM) return a clear "API not available" message on clusters where those CRDs are absent — they do not crash the server.


4. Connect an MCP client

Once deployed, point your MCP client at the Route URL:

https://<route-host>/mcp

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "ocp": {
      "transport": "http",
      "url": "https://<route-host>/mcp"
    }
  }
}

Claude Code (.claude/settings.json in your project):

{
  "mcpServers": {
    "ocp": {
      "type": "http",
      "url": "https://<route-host>/mcp"
    }
  }
}

5. MCP Inspector

The MCP Inspector is a browser-based UI for exploring MCP tools, resources, and prompts at the protocol level.

Route access is not possible with the standard inspector package. Its proxy backend binds to 127.0.0.1 (loopback) by design, and the browser-side JS connects to the proxy at localhost:SERVER_PORT. Via a Route, localhost resolves to the user's machine — not the pod — so the proxy is never reachable. oc port-forward is required.

For remote browser-based tool exploration without port-forward, use the Gradio web UI instead (see section 7 below) — it has a Tool Playground tab covering all 216 tools and works via a standard Route.

Deploy:

oc apply -f deploy/inspector.yaml -n ocp-mcp

Access via port-forward (required):

# Forward both ports — UI (6274) and proxy backend (6277)
oc port-forward svc/mcp-inspector 6274:6274 6277:6277 -n ocp-mcp

Open http://localhost:6274 in your browser, then connect with:

Field

Value

Transport

Streamable HTTP

URL

http://ocp-mcp-server:8080/mcp

Use the internal ClusterIP service name — the inspector proxy (inside the pod) makes the actual connection to the MCP server, not the browser.

Remove when done:

oc delete -f deploy/inspector.yaml -n ocp-mcp

6. Deploy the Gradio web UI

The Gradio UI runs as a separate Deployment using the same image with OCP_MODE=ui.

Edit deploy/deployment.yaml, add a second Deployment (or patch the existing one):

# Add to the container's env section:
- name: OCP_MODE
  value: "ui"
# Change containerPort to 7860 and update the Service/Route accordingly.

Or run it locally:

docker compose --profile ui up

7. Environment variables reference (container)

All variables from Environment variables reference apply. Container-specific additions:

Variable

Default

Purpose

OCP_MODE

server

server — MCP server; ui — Gradio web UI

MCP_TRANSPORT

stdio

Always set to streamable-http in Kubernetes/OpenShift

MCP_HOST

127.0.0.1

Set to 0.0.0.0 in containers (already in ConfigMap)


8. Production checklist

  • Image pushed to a private registry with image pull secret configured

  • Credentials Secret created with real values (not the template YAML)

  • OCP_SKIP_TLS_VERIFY and OCP_VERIFY_SSL set correctly for your cluster's TLS posture

  • ClusterRoleBinding scoped to the minimum permissions your use case needs (see deploy/clusterrolebinding.yaml)

  • Route has TLS edge termination with insecureEdgeTerminationPolicy: Redirect

  • MCP Inspector NOT deployed (or behind port-forward only) in production

  • ANTHROPIC_API_KEY rotated on the schedule required by your org's secret management policy

  • Resource requests/limits tuned to observed usage (check oc top pod)

  • NetworkPolicy applied to restrict ingress to the MCP port from known LLM clients only


MCP Resources

Resources expose live cluster state as URI-addressable read-only content. MCP clients can subscribe to them and display them alongside tool results.

URI

Description

ocp://cluster/info

Cluster version, infrastructure name, API URL, platform, topology, upgrade history, and available updates

ocp://cluster/nodes

All nodes with role, ready status, OS image, kubelet version, and age

ocp://cluster/operators

All ClusterOperators sorted degraded-first with Available/Progressing/Degraded columns

ocp://cluster/alerts

Currently firing Alertmanager alerts, severity-sorted, with summary

ocp://{namespace}/pods

Pods in a namespace: phase, ready containers, restarts, IP, node, age

ocp://{namespace}/events

Last 50 events in a namespace sorted most-recent-first

ocp://{namespace}/deployments

Deployments in a namespace: desired/ready/available/updated replicas and health conditions


MCP Prompts

Prompts are pre-built operational runbooks that the LLM can invoke to get step-by-step guidance. Each prompt returns a structured multi-step plan that chains together the right tools automatically.

Prompt

Parameters

Purpose

troubleshoot_pod

pod_name, namespace

Diagnose a failing or crashlooping pod: inspect status, read logs, check events, diagnose by failure pattern (CrashLoopBackOff, OOMKilled, ImagePullBackOff, Pending)

debug_network_connectivity

source_pod, target_service, namespace

Diagnose network connectivity between pods/services: verify selectors, check endpoints, test DNS, test TCP, inspect NetworkPolicies, check Routes

investigate_node_pressure

node_name

Diagnose node MemoryPressure/DiskPressure/PIDPressure: check conditions, review resource usage, surface events, cordon/drain if needed

plan_cluster_upgrade

target_version

Safe upgrade pre-flight + procedure: verify operators, nodes, etcd, alerts; pause MCPs; initiate upgrade; monitor rollout; verify completion

setup_new_project

project_name, team

Provision a new OpenShift project with ResourceQuota, LimitRange, default-deny NetworkPolicy, RoleBindings, and a dedicated ServiceAccount

deploy_ml_model

model_name, namespace, model_format

Deploy an ML model via OpenShift AI/RHOAI: verify RHOAI, find serving runtime, create InferenceService, monitor readiness, test endpoint, configure HPA

investigate_cluster_degradation

—

Systematic triage for a degraded cluster: survey operators, check nodes, verify etcd, list alerts, scan events, deep-dive degraded operators

migrate_vm_workload

vm_name, namespace, target_node

Live-migrate a KubeVirt VM: verify running state, check RWX storage, initiate VMIM, monitor progress, verify success, troubleshoot if stuck

debug_operator_install

operator_name, namespace

Diagnose a stuck operator install: inspect Subscription, InstallPlan, CSV status, approve pending plans, check pod logs, verify CatalogSource

configure_gitops_application

app_name, repo_url, namespace

Deploy via ArgoCD: verify GitOps operator, create AppProject, configure namespace access, create Application CR, trigger sync, verify health


Example prompts

# Cluster health
"Give me a full health summary of the cluster"
"Which ClusterOperators are degraded and why?"
"Are there any nodes in NotReady state?"

# Workloads
"List all crashlooping pods across all namespaces"
"Scale the checkout deployment to 10 replicas in namespace shop"
"Get the last 200 log lines from pod api-xyz-abc in namespace backend"
"Roll back the frontend deployment to the previous version"

# Monitoring
"Show me all critical alerts currently firing"
"Query: rate(http_requests_total[5m]) for the last hour"
"Create a 2-hour silence for AlertName=Watchdog"

# RBAC / Security
"What permissions does user john.doe have in namespace dev?"
"Grant the edit role to group platform-team in namespace staging"
"List all SCCs and which service accounts use them"
"Create a non-privileged SCC for a workload that needs setuid binaries"

# OpenShift AI
"What's the status of the DataScienceCluster?"
"List all running notebooks in the ml-team namespace"
"Deploy a scikit-learn model from s3://models/lr-v1 using KServe"

# Virtualization
"List all VMs and their current status"
"Live-migrate VM postgres-main to node worker-3"
"Take a snapshot of VM database-0 before the upgrade"

# Konflux
"What's the build status of my component frontend in workspace team-a?"
"Show me the latest snapshot and its integration test results"

# ACM
"Which managed clusters are not compliant with the security policy?"
"Show me all placements and which clusters they selected"

Repository structure

ocp-mcp-server/
├── pyproject.toml                  # package metadata and dependencies
├── .env.example                    # environment variable reference
├── Containerfile                   # multi-stage UBI9 container image build
├── entrypoint.sh                   # container entrypoint (server or Gradio UI mode)
├── mcp_chat.py                     # universal interactive chat client (multi-provider)
├── deploy/                         # OpenShift / Kubernetes manifests
│   ├── kustomization.yaml
│   ├── namespace.yaml
│   ├── serviceaccount.yaml
│   ├── clusterrolebinding.yaml
│   ├── configmap.yaml
│   ├── secret.yaml                 # template only — create via oc create secret
│   ├── deployment.yaml
│   ├── service.yaml
│   ├── route.yaml
│   └── inspector.yaml              # optional MCP Inspector pod (port-forward access)
├── .claude/
│   └── settings.json               # Claude Code MCP configuration
└── src/
    └── ocp_mcp/
        ├── __init__.py
        ├── app.py                  # shared FastMCP server instance + port/host config
        ├── server.py               # entry point — imports all tool modules
        ├── ui.py                   # Gradio web UI entry point (ocp-mcp-ui)
        ├── client.py               # multi-cluster k8s client management
        ├── tools/
        │   ├── cluster.py          # ClusterVersion, nodes, namespaces, etcd
        │   ├── workloads.py        # Pods, Deployments, StatefulSets, Jobs
        │   ├── networking.py       # Services, Routes, Ingress, NetworkPolicies
        │   ├── storage.py          # PVs, PVCs, StorageClasses, VolumeSnapshots
        │   ├── config.py           # ConfigMaps, Secrets, ServiceAccounts
        │   ├── rbac.py             # Users, Groups, Roles, RoleBindings
        │   ├── builds.py           # BuildConfigs, Builds, ImageStreams
        │   ├── operators.py        # OLM — CSVs, Subscriptions, InstallPlans
        │   ├── machines.py         # MachineSets, MachineConfigs, MCPs
        │   ├── monitoring.py       # Prometheus queries, Alertmanager
        │   ├── security.py         # SCCs, OAuth, pod security
        │   ├── autoscaling.py      # HPA, VPA, ClusterAutoscaler
        │   ├── gitops.py           # ArgoCD Applications, AppProjects
        │   ├── pipelines.py        # Tekton Pipelines, PipelineRuns, Tasks
        │   ├── service_mesh.py     # SMCP, VirtualServices, DestinationRules
        │   ├── ocp_ai.py           # RHOAI, Notebooks, KServe, ModelRegistry
        │   ├── virtualization.py   # KubeVirt VMs, live migration, snapshots
        │   ├── konflux.py          # Konflux Applications, Components, Releases
        │   ├── acm.py              # ACM ManagedClusters, Policies, ManifestWorks
        │   └── generic.py          # apply_manifest, run_oc_command, list_crds
        ├── resources/
        │   └── __init__.py         # MCP resource URIs (ocp://cluster/info, etc.)
        └── prompts/
            └── __init__.py         # SRE runbook prompt templates

Architecture

LLM (Claude)
    │
    │  MCP protocol (stdio or streamable-http)
    ▼
ocp-mcp-server
    │
    ├── client.py  ──────────────────────────────────────────┐
    │   ClusterRegistry                                        │
    │   ├── ClusterClient("prod")   → kubernetes Python SDK   │
    │   ├── ClusterClient("staging")                          │
    │   └── ClusterClient("lab")                              │
    │                                                          │
    ├── tools/*.py  → @mcp.tool()                             │
    │   All 216 tools call get_client(cluster) ───────────────┘
    │   then use: k8s typed APIs (CoreV1, AppsV1, …)
    │             CustomObjectsApi for OCP/OLM/RHOAI/Virt CRDs
    │             subprocess oc CLI for operations not in k8s API
    │
    ├── resources/__init__.py → @mcp.resource("ocp://…")
    │   Live cluster state as URI-addressable content
    │
    └── prompts/__init__.py → @mcp.prompt()
        SRE runbook templates the LLM can invoke

Auth flow

ClusterRegistry._load() — tried in order, first success wins:
  1. OCP_CLUSTERS  → JSON array → one ClusterClient per entry
  2. OCP_API_URL + OCP_TOKEN  → bearer-token ClusterClient
  3. OCP_API_URL + OCP_USERNAME + OCP_PASSWORD  → oc login → extract token
  4. OCP_KUBECONFIG / OCP_KUBECONFIG_CONTEXT → load_kube_config
  5. In-cluster ServiceAccount token

Design principles

  • No mock data — every tool makes real API calls or runs oc.

  • Safe defaults — secrets never expose values, only key names. Destructive tools have WARNING in their docstrings so the LLM knows to confirm before executing.

  • Graceful degradation — tools catch ApiException and return readable errors. Missing CRDs (e.g. KubeVirt not installed) return a helpful message instead of crashing.

  • Multi-cluster first — every tool accepts a cluster parameter. The default cluster is whichever config loaded first.

  • Escape hatches — apply_manifest, run_oc_command, and list_custom_resources let the LLM reach anything not covered by a typed tool.


Adding a new tool

  1. Find the relevant module in src/ocp_mcp/tools/ or create a new one.

  2. Add a function decorated with @mcp.tool():

from ocp_mcp.app import mcp
from ocp_mcp.client import format_error, get_client

@mcp.tool()
def my_new_tool(name: str, namespace: str = "default", cluster: str = "") -> str:
    """One-sentence description shown to the LLM."""
    c = get_client(cluster)
    try:
        result = c.core_v1.read_namespaced_something(name, namespace)
        return f"Result: {result.metadata.name}"
    except Exception as e:
        return format_error(e)
  1. If you created a new file, add import ocp_mcp.tools.your_module to server.py.

Conventions:

  • Always accept cluster: str = "" as the last parameter before any cluster-specific args.

  • Call get_client(cluster) and use c.oc_args() when building run_oc invocations — never call run_oc without the cluster auth args, or multi-cluster calls will silently target the wrong cluster.

  • Return strings only — tool output is text surfaced directly to the LLM.

  • Catch all exceptions and return format_error(e) rather than letting them propagate.


Tool highlights

Security tools (security.py)

Tool

Description

list_sccs

List all SCCs sorted by priority

get_scc

Full SCC detail: volumes, capabilities, users, groups

create_scc

Create a custom SCC with parameters: privileged, host_network, host_pid, run_as_any, allow_privilege_escalation

add_scc_to_service_account

Grant an SCC to a ServiceAccount via oc adm policy

remove_scc_from_service_account

Revoke an SCC from a ServiceAccount

add_cluster_role_to_user

Grant a ClusterRole to a user

add_cluster_role_to_group

Grant a ClusterRole to a group

get_oauth_config

Get OAuth configuration and identity providers

list_pod_security_violations

Surface FailedCreate events matching SCC/security keywords

create_scc parameters:

Parameter

Default

Description

name

required

SCC name

privileged

false

Allow containers to run as fully privileged (root with all capabilities)

host_network

false

Allow containers to use the host network namespace

host_pid

false

Allow containers to use the host PID namespace

run_as_any

false

Sets RunAsAny for runAsUser and fsGroup (required for some legacy workloads)

allow_privilege_escalation

false

Allow processes to gain more privileges than their parent (required for setuid binaries like sudo, ping, newgrp) — independent of privileged

cluster

""

Named cluster to target

Generic escape-hatch tools (generic.py)

Tool

Description

apply_manifest

Apply YAML/JSON manifest via oc apply -f -

get_resource

Get any resource in YAML, JSON, wide, or describe format

delete_resource

Delete any resource by type and name

list_custom_resources

List any CRD by group/version/plural

run_oc_command

Escape hatch: run any oc command (blocked verbs: delete, exec, replace)

list_crds

List all CustomResourceDefinitions

Tekton Pipelines (pipelines.py)

Works on any Kubernetes cluster with Tekton installed (including OpenShift Pipelines).

Tool

Description

list_pipelines

List Pipelines in a namespace

get_pipeline

Full Pipeline spec: tasks, params, workspaces

list_pipeline_runs

List PipelineRuns with status; filter by label selector

get_pipeline_run

PipelineRun detail: task statuses, params, start/end time, duration

start_pipeline_run

Trigger a new PipelineRun with optional params and workspaces

cancel_pipeline_run

Cancel a running PipelineRun

list_tasks

List Tasks in a namespace

list_task_runs

List TaskRuns with status

list_trigger_templates

List TriggerTemplates (webhook-driven pipeline triggers)

list_event_listeners

List EventListeners and their trigger bindings

Example prompts:

"List all pipeline runs in namespace ci and show me which ones failed"
"Get the full log context for pipeline run build-frontend-xyz"
"Start pipeline build-and-push in namespace ci with IMAGE=quay.io/org/app:latest"
"Cancel the running pipeline run deploy-staging-abc"
"What triggers are configured in the platform namespace?"

Konflux / RHTAP (konflux.py)

Konflux (Red Hat Trusted Application Pipeline) tools. Requires the Konflux CRDs (appstudio.redhat.com) installed on your cluster.

Tool

Description

list_konflux_applications

List Konflux Applications in a workspace/namespace

get_konflux_application

Application detail: components, environments, status

list_components

List Components; filter by application

get_component

Component detail: source repo, build pipeline, container image

create_component

Register a new Component from a git repository

list_snapshots

List Snapshots; filter by application

get_snapshot_status

Snapshot status including all integration test results

list_integration_test_scenarios

List IntegrationTestScenarios for an application

list_release_plans

List ReleasePlans; filter by application

list_releases

List Releases with status and target environment

list_component_pipeline_runs

List PipelineRuns for a component (build history)

Example prompts:

"What Konflux applications exist in namespace team-a?"
"Show me the latest snapshot for application frontend and its integration test results"
"List all components in application backend-api and their source repos"
"What's the build history for component api-gateway?"
"Are there any failed releases in namespace platform?"
"Show me all integration test scenarios configured for application my-app"

Dependencies

Package

Purpose

mcp>=1.6.0

Model Context Protocol SDK (FastMCP + streamable-http transport)

kubernetes>=29.0.0

Kubernetes Python client (typed APIs + dynamic client)

httpx>=0.27.0

HTTP client for Prometheus/Alertmanager API calls

pyyaml>=6.0

YAML parsing for apply_manifest and ManifestWork creation

python-dateutil>=2.9.0

Timestamp parsing for age_string()

tabulate>=0.9.0

Alternative table formatting

gradio

Browser-based web UI (optional — pip install ocp-mcp-server[ui])

anthropic

Claude AI for the Chat tab (optional — included in [ui])


Security considerations

  • Secrets — get_secret_keys lists key names only. list_secrets shows type and count. Values are never returned.

  • Destructive ops — delete_namespace, drain_node, delete_virtual_machine, etc. include DESTRUCTIVE warnings in their docstrings so the LLM knows to confirm before executing.

  • run_oc_command — uses shlex.split (no shell=True) so shell metacharacters (|, >, ;) are inert literal arguments. Blocked verbs: delete, rm, exec, replace — these have typed tools with confirmation prompts.

  • apply_manifest — applies arbitrary YAML; the LLM should show the manifest to the user before calling this in agentic contexts. The -n namespace flag does not restrict cluster-scoped resources.

  • Bearer token redaction — run_oc redacts --token <value> to --token <redacted> in all error messages, preventing credential exposure in LLM context or logs.

  • Multi-cluster routing — all oc CLI calls prepend c.oc_args() (injects --server and --token) so the correct cluster is always targeted when multiple clusters are configured.

  • RBAC — create a minimal ServiceAccount with only the permissions your use case needs. The tools work with whatever RBAC the token has.


License

Apache License 2.0 — see LICENSE for details.


Contributing

Issues and PRs welcome. The tool modules are intentionally kept flat and simple — one domain per file, one @mcp.tool() per operation, no shared state between tools.

Available Tools

216 tools
add_cluster_role_to_groupB

Grant a ClusterRole to a group via 'oc adm policy add-cluster-role-to-group'.

Inputs: role (required), group (required), cluster. Returns: result

add_cluster_role_to_userB

Grant a ClusterRole to a user via 'oc adm policy add-cluster-role-to-user'.

Inputs: role (required), username (required), cluster. Returns: result

add_scc_to_service_accountA

Grant an SCC to a ServiceAccount via 'oc adm policy add-scc-to-user'. Equivalent to: oc adm policy add-scc-to-user system:serviceaccount::

Inputs: scc_name (required), namespace (required), service_account (required), cluster. Returns: result

add_user_to_groupB

Add a user to an OpenShift Group (atomic — uses oc adm groups add-users).

Inputs: username (required), group_name (required), cluster. Returns: result

apply_manifestC

Apply a YAML or JSON manifest to the cluster via 'oc apply -f -'. WARNING: This applies resources directly. Review manifests before applying.

Inputs: yaml_content (required), cluster, namespace. Returns: result

approve_install_planC

Approve a Manual InstallPlan by patching spec.approved=True.

Inputs: name (required), cluster, namespace. Returns: result

cancel_pipeline_runC

Cancel a running Tekton PipelineRun.

Inputs: name (required), cluster, namespace. Returns: result

cordon_nodeA

Cordon a node so that no new pods are scheduled on it.

Inputs: name (required), cluster. Returns: result

create_componentC

Create a Konflux Component.

Inputs: name (required), namespace (required), source_repo_url (required), application_name (required), +3 more. Returns: result

create_configmapB

Create a ConfigMap. data is KEY=VALUE pairs separated by newlines or commas. Example: KEY1=value1\nKEY2=value2

Inputs: data (required), name (required), namespace (required), cluster. Returns: result

create_groupC

Create an empty OpenShift Group.

Inputs: name (required), cluster. Returns: result

create_hpaC

Create an HPA using 'oc autoscale'. target_ref format: 'Deployment/my-app' or 'DeploymentConfig/my-dc'. cpu_percent: target CPU utilisation percentage (default 80).

Inputs: name (required), namespace (required), target_ref (required), max_replicas (required), +3 more. Returns: result

create_inference_serviceC

Create a KServe InferenceService CR.

Inputs: name (required), namespace (required), storage_uri (required), model_format (required), +3 more. Returns: result

create_job_from_cronjobA

Create a Job immediately from a CronJob template (manual trigger).

Args: cronjob_name: Source CronJob name. job_name: Name for the newly created Job. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: job_name (required), cronjob_name (required), cluster, namespace. Returns: result

create_machine_autoscalerA

Create a MachineAutoscaler CR targeting a MachineSet in openshift-machine-api. Requires a ClusterAutoscaler to be configured for this to take effect.

Inputs: name (required), max_replicas (required), min_replicas (required), machineset_name (required), +1 more. Returns: result

create_manifest_workC

Create a ManifestWork to deploy resources to a ManagedCluster.

Inputs: name (required), cluster_name (required), manifests_yaml (required), cluster. Returns: result

create_namespaceB

Create a new namespace, optionally with labels.

Args: name: Namespace name. labels: Comma-separated KEY=VALUE pairs (e.g. "env=prod,team=platform"). cluster: Named cluster to target (empty = default).

Inputs: name (required), labels, cluster. Returns: result

create_pvcB

Create a PersistentVolumeClaim. storage_request example: 10Gi access_mode: ReadWriteOnce, ReadOnlyMany, ReadWriteMany, ReadWriteOncePod.

Inputs: name (required), namespace (required), storage_request (required), cluster, +2 more. Returns: result

create_role_bindingC

Create a RoleBinding in a namespace. subject_kind: User, Group, or ServiceAccount. cluster_role: if True, references a ClusterRole instead of a Role.

Inputs: name (required), namespace (required), role_name (required), subject_kind (required), +4 more. Returns: result

create_routeA

Create an OpenShift Route by exposing a Service.

Uses 'oc expose' to create a basic route and then patches TLS termination and path if required.

Args: name: Route name. namespace: Namespace. service: Name of the Service to expose. host: Hostname for the route (empty = let the router assign one). path: URL path prefix (default "/"). tls_termination: TLS termination type: "edge", "passthrough", "reencrypt", or "" (no TLS). port: Target port name or number (empty = first port from Service). cluster: Named cluster to target (empty = default).

Inputs: name (required), service (required), namespace (required), host, +4 more. Returns: result

create_sccB

Create a custom SecurityContextConstraint CR. run_as_any: if True, sets RunAsAny for runAsUser and fsGroup. allow_privilege_escalation: if True, allows processes to gain more privileges than their parent (required for setuid binaries).

Inputs: name (required), cluster, host_pid, privileged, +3 more. Returns: result

create_silenceA

Create an Alertmanager silence. matchers: comma-separated key=value or key=~regex pairs. Example: 'alertname=Watchdog,severity=~warning|critical' duration_hours: silence duration in hours (default 4).

Inputs: comment (required), matchers (required), cluster, duration_hours. Returns: result

create_subscriptionA

Create an OLM Subscription to install an operator from a CatalogSource. install_mode is informational only (set via OperatorGroup, not Subscription spec).

Inputs: name (required), source (required), channel (required), package (required), +4 more. Returns: result

create_virtual_machineC

Create a VirtualMachine. Provide image_url (HTTP) or pvc_name (existing PVC).

Inputs: name (required), memory (required), cpu_cores (required), namespace (required), +4 more. Returns: result

create_vm_snapshotC

Create a VirtualMachineSnapshot of a VM.

Inputs: name (required), vm_name (required), namespace (required), cluster. Returns: result

create_volume_snapshotB

Create a VolumeSnapshot from a PersistentVolumeClaim.

Inputs: name (required), pvc_name (required), namespace (required), cluster, +1 more. Returns: result

delete_configmapC

Delete a ConfigMap.

Inputs: name (required), cluster, namespace. Returns: result

delete_hpaC

Delete a HorizontalPodAutoscaler.

Inputs: name (required), cluster, namespace. Returns: result

delete_inference_serviceC

Delete a KServe InferenceService.

Inputs: name (required), namespace (required), cluster. Returns: result

delete_machineA

Delete a Machine — the Machine controller will drain and terminate the underlying node. WARNING: Destructive. The node will be cordoned, drained, and terminated.

Inputs: name (required), cluster. Returns: result

delete_namespaceA

DESTRUCTIVE: Delete a namespace and ALL resources within it.

This action is irreversible. All pods, services, persistent volume claims, and other objects in the namespace will be permanently deleted.

Args: name: Namespace to delete. cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster. Returns: result

delete_network_policyB

Delete a NetworkPolicy.

Args: name: NetworkPolicy name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

delete_podC

Delete a pod.

Args: name: Pod name. namespace: Namespace (default: "default"). force: Force-delete immediately (grace-period=0). cluster: Named cluster to target (empty = default).

Inputs: name (required), force, cluster, namespace. Returns: result

delete_pvB

Delete a PersistentVolume. WARNING: ensure no PVC is bound before deleting.

Inputs: name (required), cluster. Returns: result

delete_pvcB

Delete a PersistentVolumeClaim. WARNING: data loss may occur if PVC is in use.

Inputs: name (required), cluster, namespace. Returns: result

delete_resourceC

Delete any Kubernetes/OpenShift resource by type and name. WARNING: Destructive operation. Confirm the resource name before proceeding.

Inputs: name (required), resource_type (required), force, cluster, +1 more. Returns: result

delete_role_bindingC

Delete a RoleBinding.

Inputs: name (required), cluster, namespace. Returns: result

delete_routeC

Delete an OpenShift Route.

Args: name: Route name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

delete_serviceC

Delete a Service.

Args: name: Service name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

delete_silenceB

Delete an Alertmanager silence by its ID.

Inputs: silence_id (required), cluster. Returns: result

delete_subscriptionA

Delete an OLM Subscription. Set also_delete_csv=True to also remove the currently installed CSV.

Inputs: name (required), cluster, namespace, also_delete_csv. Returns: result

delete_virtual_machineC

Delete a VirtualMachine (stop it first if running).

Inputs: name (required), namespace (required), cluster. Returns: result

describe_podB

Run 'oc describe pod' for detailed pod information including events.

Args: name: Pod name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

drain_nodeA

Drain a node by evicting all evictable pods (cordons the node first).

Args: name: Name of the node to drain. ignore_daemonsets: Ignore DaemonSet-managed pods (default True). delete_emptydir_data: Allow deletion of pods with emptyDir volumes (default False). force: Force eviction of pods not managed by a controller (default False). grace_period: Seconds for graceful termination; -1 uses pod default. cluster: Named cluster to target (empty = default).

Inputs: name (required), force, cluster, grace_period, +2 more. Returns: result

exec_in_podB

Execute a command inside a pod via oc exec. command is split with shlex — shell metacharacters (pipes, redirects) are not interpreted.

Inputs: name (required), command (required), cluster, container, +1 more. Returns: result

get_alert_detailsB

Get full labels, annotations, status, and silence info for all instances of a named alert.

Inputs: alert_name (required), cluster. Returns: result

get_buildC

Get detailed Build information: phase, reason, output image, and timing.

Inputs: name (required), cluster, namespace. Returns: result

get_build_configB

Describe a BuildConfig in detail using oc describe bc.

Inputs: name (required), cluster, namespace. Returns: result

get_build_logsA

Retrieve logs for a Build. Set follow=True to stream (returns available output).

Inputs: name (required), follow, cluster, namespace. Returns: result

get_cluster_autoscalerB

Get the ClusterAutoscaler 'default' resource limits and scale-down configuration.

Inputs: cluster. Returns: result

get_cluster_infoB

Get high-level cluster information: name, API URL, version, channel, and platform type.

Inputs: cluster. Returns: result

get_cluster_network_configA

Get the cluster-wide Network configuration from config.openshift.io/v1 networks/cluster.

Shows network type, cluster networks, service networks, and machine networks.

Inputs: cluster. Returns: result

get_cluster_operator_detailsC

Get detailed conditions, versions, and related objects for a single ClusterOperator.

Inputs: name (required), cluster. Returns: result

get_cluster_operatorsB

List all ClusterOperators with Available/Progressing/Degraded/Version columns; degraded operators are listed first.

Inputs: cluster. Returns: result

get_cluster_versionB

Show ClusterVersion history, conditions (Available/Progressing/Degraded), and available updates.

Inputs: cluster. Returns: result

get_componentB

Get detailed Konflux Component info including GitOps repo and nudges.

Inputs: name (required), namespace (required), cluster. Returns: result

get_configmapA

Get ConfigMap keys and values. Values longer than 200 characters are truncated.

Inputs: name (required), cluster, namespace. Returns: result

get_data_science_clusterC

Get DataScienceCluster status: component management states.

Inputs: cluster. Returns: result

get_dsciC

Get DSCInitialization status: phase, conditions, and component enablement.

Inputs: cluster. Returns: result

get_etcd_statusC

Get ETCD cluster status from operator.openshift.io/v1 etcds/cluster.

Inputs: cluster. Returns: result

get_gitops_applicationA

Get ArgoCD Application details: sync/health/repo/path/destination + resources table.

Inputs: name (required), cluster, namespace. Returns: result

get_gitops_application_healthA

Get per-resource health status for an ArgoCD Application.

Inputs: name (required), cluster, namespace. Returns: result

get_infrastructure_configC

Get Infrastructure and Network configuration CRDs from config.openshift.io/v1.

Inputs: cluster. Returns: result

get_ingress_controllerA

Get an OpenShift IngressController from operator.openshift.io/v1.

Args: name: IngressController name (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name, cluster. Returns: result

get_konflux_applicationC

Get Konflux Application details including conditions.

Inputs: name (required), namespace (required), cluster. Returns: result

get_machineB

Get detailed Machine info: phase, nodeRef, providerID, addresses, conditions.

Inputs: name (required), cluster. Returns: result

get_machine_config_poolC

Get MachineConfigPool detail: conditions and machine counts.

Inputs: name (required), cluster. Returns: result

get_machine_setB

Describe a MachineSet showing all spec and status details.

Inputs: name (required), cluster. Returns: result

get_managed_clusterB

Get detailed ManagedCluster info: capacity, conditions, labels.

Inputs: name (required), cluster. Returns: result

get_monitoring_configB

Read the cluster-monitoring-config ConfigMap from the openshift-monitoring namespace.

Inputs: cluster. Returns: result

get_namespace_resource_quotaC

List ResourceQuotas and LimitRanges in a namespace.

Inputs: namespace (required), cluster. Returns: result

get_nodeA

Get capacity, allocatable resources, conditions, and taints for a node.

Inputs: name (required), cluster. Returns: result

get_oauth_configC

Get the cluster OAuth configuration and identity providers from config.openshift.io/v1.

Inputs: cluster. Returns: result

get_operator_statusB

Get ClusterServiceVersion status: phase, conditions, and owned CRDs. If namespace is empty, all namespaces are searched for a CSV whose name matches.

Inputs: name (required), cluster, namespace. Returns: result

get_pipelineB

Get Tekton Pipeline details: tasks with dependencies, params, and workspaces.

Inputs: name (required), cluster, namespace. Returns: result

get_pipeline_runC

Get Tekton PipelineRun details: status, duration, and child task run references.

Inputs: name (required), cluster, namespace. Returns: result

get_placement_decisionsA

List PlacementDecisions for a Placement showing selected clusters.

Inputs: namespace (required), placement_name (required), cluster. Returns: result

get_podA

Show detailed information for a pod: phase, node, IP, QoS class, container states, and conditions.

Args: name: Pod name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

get_pod_logsA

Fetch logs from a pod container.

Args: name: Pod name. namespace: Namespace (default: "default"). container: Container name (empty = first/only container). previous: Return logs from the previous container instance. tail_lines: Number of lines from the end (default 100, 0 = unlimited). since_seconds: Only return logs newer than this many seconds. cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, previous, container, +3 more. Returns: result

get_policy_complianceC

Show per-cluster compliance status for an ACM Policy.

Inputs: name (required), namespace (required), cluster. Returns: result

get_pvC

Get detailed PersistentVolume info including CSI, NFS, HostPath, or EBS source.

Inputs: name (required), cluster. Returns: result

get_pvcB

Get detailed PersistentVolumeClaim info including conditions.

Inputs: name (required), cluster, namespace. Returns: result

get_resourceB

Get any resource in YAML, JSON, or wide format. Use output='describe' for oc describe.

Inputs: name (required), resource_type (required), output, cluster, +1 more. Returns: result

get_rhoai_component_statusB

Check RHOAI/OpenShift AI overall health: pods in RHOAI namespaces, DSC/DSCI status, CRD presence.

Inputs: cluster. Returns: result

get_routeA

Get detailed information for an OpenShift Route including admitted status and TLS config.

Args: name: Route name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

get_sccA

Get full SCC detail: volumes, capabilities, allowedCapabilities, users, and groups.

Inputs: name (required), cluster. Returns: result

get_secret_keysA

List the key names of a Secret. Values are never shown for security.

Inputs: name (required), cluster, namespace. Returns: result

get_serviceB

Show detailed info for a Service including selector, ports, and current Endpoints.

Args: name: Service name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

get_smcp_statusA

Get ServiceMeshControlPlane status: conditions and component readiness breakdown.

Inputs: name (required), namespace (required), cluster. Returns: result

get_snapshot_statusC

Get Snapshot with integration test results and component images.

Inputs: name (required), namespace (required), cluster. Returns: result

get_userA

Get OpenShift user details: full name, identities, and group memberships.

Inputs: name (required), cluster. Returns: result

get_user_accessB

List all actions a user can perform using 'oc auth can-i --list --as='. Specify namespace to scope the check; omit for cluster-wide actions.

Inputs: username (required), cluster, namespace. Returns: result

get_virtual_machineB

Get detailed VM info: running state, resources, interfaces, disks, conditions.

Inputs: name (required), namespace (required), cluster. Returns: result

get_vpa_recommendationB

Show VPA recommendations per container: lowerBound/target/upperBound/uncappedTarget.

Inputs: name (required), cluster, namespace. Returns: result

list_alerting_rulesB

List PrometheusRules (monitoring.coreos.com/v1) with rule group count.

Inputs: cluster, namespace. Returns: result

list_alertsB

List active alerts from Alertmanager, optionally filtered by severity and/or state. severity: critical | warning | info state: active | suppressed | unprocessed

Inputs: state, cluster, severity. Returns: result

list_app_projectsB

List ArgoCD AppProjects with source repos, destinations, and cluster resource access.

Inputs: cluster, namespace. Returns: result

list_build_configsC

List BuildConfigs with strategy type, source, last version, and age.

Inputs: cluster, namespace. Returns: result

list_buildsC

List Builds with phase, duration, reason, and age.

Inputs: cluster, namespace, label_selector. Returns: result

list_catalog_sourcesC

List CatalogSources with display name, type, publisher, and connection state.

Inputs: cluster, namespace. Returns: result

list_cluster_claimsC

List ACM ClusterClaims with pool and resolved cluster.

Inputs: cluster. Returns: result

list_cluster_contextsC

Show all configured MCP clusters and the active oc kubeconfig contexts.

Inputs: cluster. Returns: result

list_cluster_role_bindingsC

List ClusterRoleBindings with role reference and bound subjects.

Inputs: cluster, label_selector. Returns: result

list_cluster_rolesB

List ClusterRoles with the number of policy rules.

Inputs: cluster, label_selector. Returns: result

list_cluster_setsC

List ACM ManagedClusterSets.

Inputs: cluster. Returns: result

list_component_pipeline_runsB

List Tekton PipelineRuns associated with Konflux components.

Inputs: namespace (required), cluster, component_name. Returns: result

list_componentsB

List Konflux Components with source repo, branch, and build status.

Inputs: namespace (required), cluster, application_name. Returns: result

list_configmapsC

List ConfigMaps with namespace, name, key count, and age.

Inputs: cluster, namespace, label_selector. Returns: result

list_crdsB

List all CustomResourceDefinitions with group, stored versions, and scope.

Inputs: cluster, label_selector. Returns: result

list_cronjobsA

List CronJobs with NAMESPACE, NAME, SCHEDULE, SUSPEND, ACTIVE, LAST RUN, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector to filter CronJobs. cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, label_selector. Returns: result

list_custom_resourcesC

List any custom resource by group/version/plural — works for any CRD.

Inputs: group (required), plural (required), version (required), cluster, +2 more. Returns: result

list_daemonsetsA

List DaemonSets with NAMESPACE, NAME, DESIRED, CURRENT, READY, UP-TO-DATE, AVAILABLE, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector to filter DaemonSets. cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, label_selector. Returns: result

list_data_science_pipelinesB

List DataSciencePipelinesApplications with readiness, storage, and API endpoint.

Inputs: cluster, namespace. Returns: result

list_data_science_projectsB

List OpenShift AI Data Science Projects (namespaces with opendatahub.io/dashboard=true label).

Inputs: cluster. Returns: result

list_data_volumesC

List DataVolumes with phase, progress, capacity, and source type.

Inputs: cluster, namespace. Returns: result

list_deployment_configsA

List OpenShift DeploymentConfigs (apps.openshift.io/v1) with NAMESPACE, NAME, REVISION, DESIRED, CURRENT, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace. Returns: result

list_deploymentsA

List Deployments with NAMESPACE, NAME, READY, UP-TO-DATE, AVAILABLE, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector to filter deployments. cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, label_selector. Returns: result

list_destination_rulesC

List Istio DestinationRules with host, subsets, TLS mode, and age.

Inputs: cluster, namespace. Returns: result

list_event_listenersB

List Tekton EventListeners with readiness, URL, and age.

Inputs: cluster, namespace. Returns: result

list_eventsA

List the most recent 50 events, optionally filtered by namespace, field selector, or involved object name.

Args: namespace: Namespace to query (empty = all namespaces). field_selector: Kubernetes field selector (e.g. "reason=BackOff"). involved_object: Filter by involvedObject.name (appended to field_selector). cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, field_selector, involved_object. Returns: result

list_gatewaysB

List Istio Gateways with selector, ports, servers count, and age.

Inputs: cluster, namespace. Returns: result

list_gitops_applicationsC

List ArgoCD Applications with sync/health status, repo, revision, destination, and age.

Inputs: cluster, namespace. Returns: result

list_gitops_clustersB

List ArgoCD registered clusters from Secrets with label argocd.argoproj.io/secret-type=cluster.

Inputs: cluster, namespace. Returns: result

list_groupsB

List OpenShift Groups with member count and up to 5 member names.

Inputs: cluster. Returns: result

list_hpasC

List HorizontalPodAutoscalers with min/max/current/desired replicas and metrics.

Inputs: cluster, namespace. Returns: result

list_image_streamsC

List ImageStreams with their internal Docker repository and tag count.

Inputs: cluster, namespace. Returns: result

list_image_stream_tagsC

List tags for an ImageStream with image digest and creation timestamp.

Inputs: image_stream (required), cluster, namespace. Returns: result

list_inference_servicesC

List InferenceServices with readiness, model format, storage URI, URL, and age.

Inputs: cluster, namespace. Returns: result

list_ingressesA

List Kubernetes Ingress objects with NAMESPACE, NAME, CLASS, HOSTS, ADDRESS, PORTS, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector to filter Ingresses. cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, label_selector. Returns: result

list_installed_operatorsB

List installed operators (ClusterServiceVersions) with display name, version, and phase.

Inputs: cluster, namespace. Returns: result

list_install_plansC

List InstallPlans with approval mode, approved status, phase, and CSV names.

Inputs: cluster, namespace. Returns: result

list_integration_test_scenariosC

List Konflux IntegrationTestScenarios.

Inputs: namespace (required), cluster, application_name. Returns: result

list_jobsA

List Jobs with NAMESPACE, NAME, COMPLETIONS, ACTIVE, SUCCEEDED, FAILED, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector to filter Jobs. cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, label_selector. Returns: result

list_konflux_applicationsC

List Konflux Applications in a workspace namespace.

Inputs: namespace (required), cluster. Returns: result

list_machine_autoscalersC

List MachineAutoscalers in openshift-machine-api with target MachineSet, min, max, and age.

Inputs: cluster. Returns: result

list_machine_config_poolsC

List MachineConfigPools with rendered config, machine counts, and status flags.

Inputs: cluster. Returns: result

list_machine_configsC

List MachineConfigs with role label (machineconfiguration.openshift.io/role), generation, and age.

Inputs: cluster, label_selector. Returns: result

list_machinesC

List Machines with phase, node ref, provider ID, and age.

Inputs: cluster, label_selector. Returns: result

list_machine_setsA

List MachineSets with desired/ready/available replica counts, instance type, and age.

Inputs: cluster. Returns: result

list_managed_cluster_addonsC

List ManagedClusterAddons on a specific managed cluster.

Inputs: cluster_name (required), cluster. Returns: result

list_managed_clustersB

List ACM ManagedClusters with status, OCP version, cloud provider, and region.

Inputs: cluster. Returns: result

list_manifest_worksB

List ManifestWorks deployed to a ManagedCluster (namespace=cluster_name).

Inputs: cluster_name (required), cluster. Returns: result

list_model_registriesC

List ModelRegistries with availability, REST port, gRPC port, and age.

Inputs: cluster, namespace. Returns: result

list_model_serversC

List ServingRuntimes and ClusterServingRuntimes with scope, formats, multi-model, and age.

Inputs: cluster, namespace. Returns: result

list_namespacesA

List all namespaces with STATUS, LABELS, and AGE.

Inputs: cluster, label_selector. Returns: result

list_network_policiesA

List NetworkPolicies with NAMESPACE, NAME, POD-SELECTOR, POLICY-TYPES, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace. Returns: result

list_nodesC

List all nodes with ROLES, STATUS, OS image, KUBELET version, and AGE.

Inputs: cluster, label_selector. Returns: result

list_notebooksC

List Kubeflow Notebooks with state, image, CPU/memory requests, and age.

Inputs: cluster, namespace. Returns: result

list_operator_conditionsC

List OperatorConditions (operators.coreos.com/v2) with active condition summary.

Inputs: cluster, namespace. Returns: result

list_operator_groupsC

List OperatorGroups with their target namespaces and service account.

Inputs: cluster, namespace. Returns: result

list_peer_authenticationsC

List Istio PeerAuthentications with mTLS mode, selector, and age.

Inputs: cluster, namespace. Returns: result

list_pipeline_runsC

List Tekton PipelineRuns with pipeline name, status, duration, and age.

Inputs: cluster, namespace, label_selector. Returns: result

list_pipelinesB

List Tekton Pipelines with task count and age.

Inputs: cluster, namespace. Returns: result

list_placementsC

List ACM Placements with predicates and satisfaction status.

Inputs: cluster, namespace. Returns: result

list_podsA

List pods with NAMESPACE, NAME, STATUS, READY, RESTARTS, NODE, and AGE columns.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector (e.g. "app=nginx"). field_selector: Field selector (e.g. "status.phase=Running"). cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, field_selector, label_selector. Returns: result

list_pod_security_violationsB

List events that indicate pod security or SCC violations (FailedCreate + security keywords).

Inputs: cluster, namespace. Returns: result

list_policiesC

List ACM Policies with remediation action and compliance status.

Inputs: cluster, namespace. Returns: result

list_prometheus_rulesC

List PrometheusRules with counts of alerting rules and recording rules per resource.

Inputs: cluster, namespace. Returns: result

list_pvcsB

List PersistentVolumeClaims with status, volume, capacity, access modes, and storage class.

Inputs: cluster, namespace, label_selector. Returns: result

list_pvsC

List PersistentVolumes with capacity, access modes, storage class, reclaim policy, status, and claim.

Inputs: cluster, label_selector. Returns: result

list_release_plansC

List Konflux ReleasePlans with target workspace.

Inputs: namespace (required), cluster, application_name. Returns: result

list_releasesC

List Konflux Releases with snapshot, status, and target workspace.

Inputs: namespace (required), cluster, application_name. Returns: result

list_role_bindingsA

List RoleBindings in a namespace with role reference and bound subjects.

Inputs: cluster, namespace. Returns: result

list_rolesB

List Roles in a namespace with the number of policy rules.

Inputs: cluster, namespace. Returns: result

list_routesA

List OpenShift Routes (route.openshift.io/v1) with NAMESPACE, NAME, HOST/PATH, TLS, SERVICE, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace. Returns: result

list_sccsB

List all SecurityContextConstraints sorted by priority descending.

Inputs: cluster. Returns: result

list_secretsB

List Secrets showing type and key count only — secret values are never displayed.

Inputs: cluster, namespace, label_selector. Returns: result

list_service_accountsC

List ServiceAccounts with number of secrets and image pull secrets.

Inputs: cluster, namespace. Returns: result

list_service_entriesC

List Istio ServiceEntries with hosts, location, ports, and age.

Inputs: cluster, namespace. Returns: result

list_service_mesh_control_planesC

List ServiceMeshControlPlanes with generation, version, readiness, and age.

Inputs: cluster, namespace. Returns: result

list_service_mesh_membersC

List ServiceMeshMemberRolls and the namespaces enrolled in each mesh.

Inputs: cluster, namespace. Returns: result

list_servicesA

List Services with NAMESPACE, NAME, TYPE, CLUSTER-IP, EXTERNAL-IP, PORT(S), and AGE.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector to filter Services. cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, label_selector. Returns: result

list_silencesB

List Alertmanager silences with ID, state, matchers, comment, creator, and end time.

Inputs: cluster. Returns: result

list_snapshotsC

List Konflux Snapshots with components and integration test status.

Inputs: namespace (required), cluster, application_name. Returns: result

list_statefulsetsA

List StatefulSets with NAMESPACE, NAME, READY, SERVICE, and AGE.

Args: namespace: Namespace to query (empty = all namespaces). label_selector: Label selector to filter StatefulSets. cluster: Named cluster to target (empty = default).

Inputs: cluster, namespace, label_selector. Returns: result

list_storage_classesC

List StorageClasses. The cluster default is marked with (default).

Inputs: cluster. Returns: result

list_subscriptionsC

List OLM Subscriptions with package, channel, source, current CSV, and age.

Inputs: cluster, namespace. Returns: result

list_task_runsC

List Tekton TaskRuns with task name, status, duration, and age.

Inputs: cluster, namespace, label_selector. Returns: result

list_tasksC

List Tekton Tasks with step count and age.

Inputs: cluster, namespace. Returns: result

list_trigger_templatesB

List Tekton TriggerTemplates with template count and age.

Inputs: cluster, namespace. Returns: result

list_usersB

List OpenShift users with their identities and group memberships.

Inputs: cluster. Returns: result

list_virtual_machine_instancesA

List running VirtualMachineInstances with node, IP, and phase.

Inputs: cluster, namespace. Returns: result

list_virtual_machinesC

List VirtualMachines with status, vCPU, memory, and age.

Inputs: cluster, namespace, label_selector. Returns: result

list_virtual_servicesA

List Istio VirtualServices with hosts, gateways, HTTP/TCP route counts, and age.

Inputs: cluster, namespace. Returns: result

list_vm_snapshotsC

List VirtualMachineSnapshots with phase, source VM, and ready status.

Inputs: cluster, namespace. Returns: result

list_volume_snapshotsB

List VolumeSnapshots (snapshot.storage.k8s.io/v1) with source PVC, class, and ready status.

Inputs: cluster, namespace. Returns: result

list_vpasB

List VerticalPodAutoscalers with update mode and target workload.

Inputs: cluster, namespace. Returns: result

live_migrate_vmC

Live migrate a VirtualMachineInstance to another node.

Inputs: name (required), namespace (required), cluster. Returns: result

pause_machine_config_poolC

Pause a MachineConfigPool — prevents config updates from rolling out to nodes.

Inputs: name (required), cluster. Returns: result

pause_virtual_machineC

Pause a running VirtualMachine using virtctl.

Inputs: name (required), namespace (required), cluster. Returns: result

query_prometheusA

Execute a PromQL instant query against Thanos Querier and return results as a table.

Inputs: expr (required), cluster. Returns: result

query_prometheus_rangeA

Execute a PromQL range query. start/end in ISO8601 or Unix timestamp; step e.g. '5m'.

Inputs: end (required), expr (required), start (required), step, +1 more. Returns: result

refresh_gitops_applicationB

Force-refresh an ArgoCD Application by patching the argocd.argoproj.io/refresh annotation.

Inputs: name (required), cluster, namespace. Returns: result

remove_scc_from_service_accountC

Revoke an SCC from a ServiceAccount via 'oc adm policy remove-scc-from-user'.

Inputs: scc_name (required), namespace (required), service_account (required), cluster. Returns: result

remove_user_from_groupA

Remove a user from an OpenShift Group (atomic — uses oc adm groups remove-users).

Inputs: username (required), group_name (required), cluster. Returns: result

restart_virtual_machineC

Restart a VirtualMachine using virtctl.

Inputs: name (required), namespace (required), cluster. Returns: result

restore_vm_snapshotC

Restore a VM from a VirtualMachineSnapshot.

Inputs: vm_name (required), namespace (required), restore_name (required), snapshot_name (required), +1 more. Returns: result

rollout_deployment_configC

Trigger a new rollout of an OpenShift DeploymentConfig (oc rollout latest dc/).

Args: name: DeploymentConfig name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

rollout_restart_deploymentB

Trigger a rolling restart of a Deployment (equivalent to 'oc rollout restart').

Args: name: Deployment name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

rollout_status_deploymentA

Show the rollout status of a Deployment (equivalent to 'oc rollout status').

Args: name: Deployment name. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, namespace. Returns: result

rollout_undo_deploymentA

Undo a Deployment rollout, optionally to a specific revision.

Args: name: Deployment name. namespace: Namespace (default: "default"). revision: Target revision number (0 = previous revision). cluster: Named cluster to target (empty = default).

Inputs: name (required), cluster, revision, namespace. Returns: result

run_oc_commandA

Escape hatch: run any oc command. args is a space-separated string of arguments. WARNING: Use carefully. Destructive commands should be confirmed first.

Inputs: args (required), cluster. Returns: result

scale_deploymentB

Scale a Deployment to the specified number of replicas.

Args: name: Deployment name. replicas: Desired replica count. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), replicas (required), cluster, namespace. Returns: result

scale_machine_setA

Scale a MachineSet to the given number of replicas by patching spec.replicas. WARNING: Scaling down will cause machines (and their nodes) to be deleted.

Inputs: name (required), replicas (required), cluster. Returns: result

scale_statefulsetA

Scale a StatefulSet to the specified number of replicas.

Args: name: StatefulSet name. replicas: Desired replica count. namespace: Namespace (default: "default"). cluster: Named cluster to target (empty = default).

Inputs: name (required), replicas (required), cluster, namespace. Returns: result

start_buildC

Start a new build from a BuildConfig. Optionally supply from_dir to use a local directory as the binary source.

Inputs: build_config_name (required), cluster, from_dir, namespace. Returns: result

start_notebookA

Start a stopped Notebook by removing the kubeflow-resource-stopped annotation.

Inputs: name (required), namespace (required), cluster. Returns: result

start_pipeline_runB

Start a Tekton PipelineRun. params is a comma-separated list of KEY=VALUE pairs.

Inputs: pipeline_name (required), params, cluster, namespace. Returns: result

start_virtual_machineB

Start a VirtualMachine by setting spec.running=true.

Inputs: name (required), namespace (required), cluster. Returns: result

stop_notebookC

Stop a running Notebook by setting the kubeflow-resource-stopped annotation.

Inputs: name (required), namespace (required), cluster. Returns: result

stop_virtual_machineB

Stop a VirtualMachine by setting spec.running=false.

Inputs: name (required), namespace (required), cluster. Returns: result

sync_gitops_applicationC

Trigger a sync on an ArgoCD Application by patching the operation field.

Inputs: name (required), prune, cluster, dry_run, +1 more. Returns: result

uncordon_nodeA

Uncordon a node to allow new pods to be scheduled on it again.

Inputs: name (required), cluster. Returns: result

unpause_machine_config_poolB

Unpause a MachineConfigPool — allows pending config updates to roll out to nodes.

Inputs: name (required), cluster. Returns: result

unpause_virtual_machineC

Unpause a paused VirtualMachine using virtctl.

Inputs: name (required), namespace (required), cluster. Returns: result

update_configmapC

Set or update a single key in a ConfigMap using strategic merge patch.

Inputs: key (required), name (required), value (required), namespace (required), +1 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 216 tools

    Disambiguation5/5

    Every tool name includes a specific action and resource type (e.g., list_pods, get_pod, scale_deployment), making each tool's purpose clear and distinct. Even with 216 tools, the consistent naming prevents ambiguity, and generic escape hatches like run_oc_command are explicitly labeled.

    Naming Consistency5/5

    All tools follow a consistent verb_noun pattern (list_, get_, create_, delete_, scale_, rollout_*, etc.), with resource types as the noun. Deviations like apply_manifest and get_resource still adhere to the same structure, ensuring predictability.

    Tool Count1/5

    216 tools is extreme and far exceeds any reasonable scope for an MCP server. Even for a comprehensive OpenShift management platform, this count is overwhelming and will likely confuse agents, making tool selection difficult. It falls into the 'extreme mismatch' category.

    Completeness4/5

    The tool set covers an extensive range of OpenShift domains including compute, networking, storage, security, operators, machine management, monitoring, service mesh, OpenShift AI, virtualization, GitOps, Tekton, and ACM. However, some resource types lack individual get/update/delete operations (e.g., Deployments have no get or delete), relying on generic tools like get_resource and delete_resource, creating minor gaps.

    Maintenance

    ActivitySlowing
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      An open source MCP server empowering SREs with intelligent observability, predictive analytics, and AI-driven automation across Kubernetes, OpenShift, and Tekton environments.
      22 PyPI
      11
      Apache 2.0
    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server exposing Kubernetes-style diagnostic tools to an LLM agent, with a safety approval gate for destructive actions, all backed by a mock cluster for local testing.
      -