Kubently logo

Kubently

Natural-language Kubernetes troubleshooting across registered clusters through MCP, A2A, outbound executors, and the ask_kubently tool.

Install Kubently

Pick your client, then add it in one click or paste the config.

Streamable HTTP (Remote)
Server URL
http://localhost:8080/mcp/

Remote servers are added in the app, not the config file: Customize → Connectors → Add custom connector, then paste this URL.

Overview

The kubently MCP server gives MCP clients natural-language access to Kubently’s Kubernetes troubleshooting system. It sends questions through Kubently’s API and executor architecture, allowing analysis across registered clusters, including clusters behind firewalls or NAT when executors dial out to the central API. Reach for it when an agent needs cluster diagnosis, root-cause analysis, log or resource inspection, and remediation suggestions. It supports local command-based MCP usage and direct HTTP connections, with Claude Code, Cursor, and Claude Desktop named as clients.

Use cases

  • Diagnose crashlooping Kubernetes pods with a natural-language question
  • Investigate workloads across multiple registered clusters
  • Inspect logs, events, and resource state through an AI client
  • Connect agents to clusters behind firewalls using outbound executors

Key features

  • Natural-language Kubernetes troubleshooting
  • Multi-cluster analysis in parallel
  • Outbound-dial executors
  • MCP access over local command or HTTP
  • Root-cause analysis and solution recommendations
  • Support for Anthropic, OpenAI, and Google Gemini providers

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 3d ago

Recent health check succeeded.

5/5 checks healthy over the last 35d

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars46Stargazers on the source repository.
Last commit4d agoMost recent push to the default branch.
Directory activity1 viewsConfig copies, upvotes, and views on AllMCPs.

How Kubently works

What kubently MCP server does

The kubently MCP server exposes Kubently’s Kubernetes troubleshooting capabilities to MCP-compatible clients. Its primary interaction is the ask_kubently tool, which accepts a natural-language question such as why a pod is crashlooping and returns an agent-generated investigation. The system is intended for self-hosted, vendor-neutral use and can work with multiple registered clusters.

Questions can be analyzed across a fleet in parallel rather than being limited to the cluster configured in a local kubeconfig. Kubently’s broader analysis includes issue detection, root-cause investigation, solution recommendations, log analysis, resource inspection, and kubectl-based operations.

How it works

Kubently separates the central API from cluster access. Executors establish outbound connections to the API, which allows the design to reach clusters behind firewalls or NAT without inbound ingress, a shared kubeconfig, or distributing per-cluster credentials. The API can coordinate analysis across registered executors and maintain conversation context with Redis.

MCP access is available either through the kubently mcp command or through an HTTP endpoint. A client sends a troubleshooting request to Kubently, and the system uses its configured LLM provider and Kubernetes access to investigate the question. The project also supports the A2A protocol for communication between agents.

Setup and configuration

Install Kubently with the project’s CLI and Helm-based deployment flow, then configure an LLM provider. LLM_PROVIDER is required; supported examples are anthropic-claude, openai, and google-gemini. The corresponding provider key can be supplied through ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY. Kubernetes 1.28 or newer and Python 3.13 or newer are listed by the project.

After installation, add the local MCP process to Claude Code with claude mcp add kubently -- kubently mcp. HTTP clients can connect to /mcp/ and send the X-API-Key header. The project’s installer can deploy the Helm chart, configure secrets, install the executor, and port-forward the API.

Tools and capabilities

The kubently MCP server is suited to:

  • Asking Kubernetes troubleshooting questions in natural language.
  • Investigating workloads, logs, events, and resource state.
  • Diagnosing problems across multiple registered clusters.
  • Returning root-cause findings and suggested solutions.
  • Connecting MCP clients to Kubently through stdio or HTTP.
  • Using outbound executors for clusters that are not directly reachable.

Kubently also documents Alertmanager-to-Slack diagnosis, scheduled fleet reports, recurring checks, and deployment verification. These are broader Kubently features and may require additional webhook, Slack, Helm, or scheduling configuration beyond basic MCP use.

Limitations and notes

The kubently MCP server depends on a deployed Kubently API and executor arrangement; MCP alone does not provide Kubernetes access without that backend configuration. HTTP access requires the configured API key.

The system is self-hosted, so operators must deploy and secure its components. TLS, API-key authentication, OAuth/OIDC, and cert-manager support are documented, but their exact configuration depends on the deployment. The README names Claude Code, Cursor, and Claude Desktop as MCP clients; other clients may require their own MCP configuration details.

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Kubently

kubently is an MCP server that connects AI clients to Kubernetes clusters through Kubently’s API and executor architecture. Its main tool, ask_kubently, accepts natural-language troubleshooting questions and can analyze registered clusters. It supports Claude Code, Cursor, and Claude Desktop, with MCP access over a local command or HTTP.

Install Kubently with its CLI and Helm deployment flow, then configure an LLM provider and API key. The documented quick start uses `npm install -g @kubently/cli` followed by `kubently install`; the installer deploys the chart, configures secrets and the executor, and port-forwards the API.

Run `claude mcp add kubently -- kubently mcp` after installing Kubently. You can also connect Claude Code directly to the HTTP endpoint with `--transport http`, the Kubently `/mcp/` URL, and an `X-API-Key` header.

Yes, Cursor is named as a supported MCP client. Configure it using Kubently’s MCP connection details; the project documents both local MCP usage and direct HTTP access, including the API-key header required for the HTTP endpoint.

Kubently requires `LLM_PROVIDER` and an API key for the selected provider. The documented choices are `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, and `GOOGLE_API_KEY`, paired with Anthropic, OpenAI, or Google Gemini provider values.

Related MCP servers

Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewKubently AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/kubently?style=directory)](https://allmcps.com/mcp/kubently)
HTML Embed
<a href="https://allmcps.com/mcp/kubently"><img src="https://allmcps.com/api/badge/kubently?style=directory" alt="Kubently on AllMCPs" /></a>