kubectl-mcp-server 1.13.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

kubectl_mcp_tool/tools/core.py

@@ -1,11 +1,24 @@
 import logging
+import subprocess
 from typing import Any, Dict, List, Optional
 
 from mcp.types import ToolAnnotations
 
+from ..k8s_config import (
+    get_k8s_client,
+    get_apiextensions_client,
+)
+
 logger = logging.getLogger("mcp-server")
 
 
+def _get_kubectl_context_args(context: str) -> List[str]:
+    """Get kubectl context arguments if context is specified."""
+    if context:
+        return ["--context", context]
+    return []
+
+
 def register_core_tools(server, non_destructive: bool):
     """Register core Kubernetes resource tools."""
 
@@ -15,15 +28,18 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_namespaces() -> Dict[str, Any]:
-        """Get all Kubernetes namespaces."""
+    def get_namespaces(context: str = "") -> Dict[str, Any]:
+        """Get all Kubernetes namespaces.
+
+        Args:
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
             namespaces = v1.list_namespace()
             return {
                 "success": True,
+                "context": context or "current",
                 "namespaces": [ns.metadata.name for ns in namespaces.items]
             }
         except Exception as e:
@@ -36,18 +52,25 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_services(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get all services in the specified namespace."""
+    def get_services(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get all services in the specified namespace.
+
+        Args:
+            namespace: Namespace to list services from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
             if namespace:
                 services = v1.list_namespaced_service(namespace)
             else:
                 services = v1.list_service_for_all_namespaces()
             return {
                 "success": True,
+                "context": context or "current",
                 "services": [
                     {
                         "name": svc.metadata.name,
@@ -67,15 +90,18 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_nodes() -> Dict[str, Any]:
-        """Get all nodes in the cluster."""
+    def get_nodes(context: str = "") -> Dict[str, Any]:
+        """Get all nodes in the cluster.
+
+        Args:
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
             nodes = v1.list_node()
             return {
                 "success": True,
+                "context": context or "current",
                 "nodes": [
                     {
                         "name": node.metadata.name,
@@ -104,18 +130,25 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_configmaps(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get all ConfigMaps in the specified namespace."""
+    def get_configmaps(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get all ConfigMaps in the specified namespace.
+
+        Args:
+            namespace: Namespace to list ConfigMaps from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
             if namespace:
                 cms = v1.list_namespaced_config_map(namespace)
             else:
                 cms = v1.list_config_map_for_all_namespaces()
             return {
                 "success": True,
+                "context": context or "current",
                 "configmaps": [
                     {
                         "name": cm.metadata.name,
@@ -134,18 +167,25 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_secrets(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get all Secrets in the specified namespace."""
+    def get_secrets(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get all Secrets in the specified namespace.
+
+        Args:
+            namespace: Namespace to list Secrets from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
             if namespace:
                 secrets = v1.list_namespaced_secret(namespace)
             else:
                 secrets = v1.list_secret_for_all_namespaces()
             return {
                 "success": True,
+                "context": context or "current",
                 "secrets": [
                     {
                         "name": secret.metadata.name,
@@ -164,18 +204,25 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_events(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get Kubernetes events."""
+    def get_events(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get Kubernetes events.
+
+        Args:
+            namespace: Namespace to list events from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
             if namespace:
                 events = v1.list_namespaced_event(namespace)
             else:
                 events = v1.list_event_for_all_namespaces()
             return {
                 "success": True,
+                "context": context or "current",
                 "events": [
                     {
                         "name": event.metadata.name,
@@ -197,11 +244,19 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_resource_usage(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get resource usage metrics for pods."""
+    def get_resource_usage(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get resource usage metrics for pods.
+
+        Args:
+            namespace: Namespace to get metrics from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            import subprocess
             cmd = ["kubectl", "top", "pods"]
+            cmd.extend(_get_kubectl_context_args(context))
             if namespace:
                 cmd.extend(["-n", namespace])
             else:
@@ -233,7 +288,11 @@ def register_core_tools(server, non_destructive: bool):
                             "memory": parts[3]
                         })
 
-            return {"success": True, "pods": pods}
+            return {
+                "success": True,
+                "context": context or "current",
+                "pods": pods
+            }
         except subprocess.TimeoutExpired:
             return {"success": False, "error": "Metrics retrieval timed out"}
         except Exception as e:
@@ -246,12 +305,18 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_service_accounts(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get service accounts in a namespace or cluster-wide."""
+    def get_service_accounts(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get service accounts in a namespace or cluster-wide.
+
+        Args:
+            namespace: Namespace to list service accounts from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
 
             if namespace:
                 sas = v1.list_namespaced_service_account(namespace)
@@ -260,6 +325,7 @@ def register_core_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "serviceAccounts": [
                     {
                         "name": sa.metadata.name,
@@ -281,12 +347,18 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_crds(group: Optional[str] = None) -> Dict[str, Any]:
-        """Get Custom Resource Definitions in the cluster."""
+    def get_crds(
+        group: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get Custom Resource Definitions in the cluster.
+
+        Args:
+            group: Filter CRDs by API group
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            api = client.ApiextensionsV1Api()
+            api = get_apiextensions_client(context)
 
             crds = api.list_custom_resource_definition()
 
@@ -307,7 +379,11 @@ def register_core_tools(server, non_destructive: bool):
                     )
                 })
 
-            return {"success": True, "crds": result}
+            return {
+                "success": True,
+                "context": context or "current",
+                "crds": result
+            }
         except Exception as e:
             logger.error(f"Error getting CRDs: {e}")
             return {"success": False, "error": str(e)}
@@ -318,12 +394,18 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_resource_quotas(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get resource quotas for namespaces."""
+    def get_resource_quotas(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get resource quotas for namespaces.
+
+        Args:
+            namespace: Namespace to list resource quotas from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
 
             if namespace:
                 quotas = v1.list_namespaced_resource_quota(namespace)
@@ -332,6 +414,7 @@ def register_core_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "quotas": [
                     {
                         "name": q.metadata.name,
@@ -352,12 +435,18 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_limit_ranges(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Get limit ranges for namespaces."""
+    def get_limit_ranges(
+        namespace: Optional[str] = None,
+        context: str = ""
+    ) -> Dict[str, Any]:
+        """Get limit ranges for namespaces.
+
+        Args:
+            namespace: Namespace to list limit ranges from (all namespaces if not specified)
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
 
             if namespace:
                 limits = v1.list_namespaced_limit_range(namespace)
@@ -366,6 +455,7 @@ def register_core_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "limitRanges": [
                     {
                         "name": lr.metadata.name,
@@ -394,17 +484,24 @@ def register_core_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_priority_classes() -> Dict[str, Any]:
-        """Get priority classes in the cluster."""
+    def get_priority_classes(context: str = "") -> Dict[str, Any]:
+        """Get priority classes in the cluster.
+
+        Args:
+            context: Kubernetes context to use (uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            api = client.SchedulingV1Api()
+            from kubernetes import client
+            from ..k8s_config import _load_config_for_context
+
+            api_client = _load_config_for_context(context)
+            api = client.SchedulingV1Api(api_client=api_client)
 
             pcs = api.list_priority_class()
 
             return {
                 "success": True,
+                "context": context or "current",
                 "priorityClasses": [
                     {
                         "name": pc.metadata.name,

kubectl_mcp_tool/tools/cost.py

@@ -2,13 +2,22 @@ import logging
 import subprocess
 import re
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from mcp.types import ToolAnnotations
 
+from ..k8s_config import get_k8s_client, get_apps_client
+
 logger = logging.getLogger("mcp-server")
 
 
+def _get_kubectl_context_args(context: str) -> List[str]:
+    """Get kubectl context arguments if context is specified."""
+    if context:
+        return ["--context", context]
+    return []
+
+
 def _parse_cpu(cpu_str: str) -> int:
     """Parse CPU string to millicores."""
     try:
@@ -67,13 +76,19 @@ def register_cost_tools(server, non_destructive: bool):
     )
     def get_resource_recommendations(
         namespace: Optional[str] = None,
-        resource_type: str = "all"
+        resource_type: str = "all",
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Analyze resource usage and provide optimization recommendations for pods/deployments."""
+        """Analyze resource usage and provide optimization recommendations for pods/deployments.
+
+        Args:
+            namespace: Target namespace (optional, all namespaces if not specified)
+            resource_type: Type of resource to analyze
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            from kubernetes import client
+            v1 = get_k8s_client(context)
 
             recommendations = []
 
@@ -135,6 +150,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "totalAnalyzed": len(pods),
                 "issuesFound": len(recommendations),
                 "recommendations": recommendations[:50]
@@ -152,11 +168,19 @@ def register_cost_tools(server, non_destructive: bool):
     def get_idle_resources(
         namespace: Optional[str] = None,
         cpu_threshold: float = 10.0,
-        memory_threshold: float = 10.0
+        memory_threshold: float = 10.0,
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Find underutilized pods using less than threshold percentage of requested resources."""
+        """Find underutilized pods using less than threshold percentage of requested resources.
+
+        Args:
+            namespace: Target namespace (optional, all namespaces if not specified)
+            cpu_threshold: CPU usage threshold percentage
+            memory_threshold: Memory usage threshold percentage
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            cmd = ["kubectl", "top", "pods", "--no-headers"]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["top", "pods", "--no-headers"]
             if namespace:
                 cmd.extend(["-n", namespace])
             else:
@@ -196,6 +220,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "thresholds": {
                     "cpu": f"{cpu_threshold}%",
                     "memory": f"{memory_threshold}%"
@@ -215,12 +240,15 @@ def register_cost_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_resource_quotas_usage(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Show resource quota usage and availability across namespaces."""
+    def get_resource_quotas_usage(namespace: Optional[str] = None, context: str = "") -> Dict[str, Any]:
+        """Show resource quota usage and availability across namespaces.
+
+        Args:
+            namespace: Target namespace (optional, all namespaces if not specified)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
 
             if namespace:
                 quotas = v1.list_namespaced_resource_quota(namespace).items
@@ -250,6 +278,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "count": len(quota_usage),
                 "quotas": quota_usage
             }
@@ -263,12 +292,15 @@ def register_cost_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_cost_analysis(namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Analyze resource costs by namespace and workload based on resource requests."""
+    def get_cost_analysis(namespace: Optional[str] = None, context: str = "") -> Dict[str, Any]:
+        """Analyze resource costs by namespace and workload based on resource requests.
+
+        Args:
+            namespace: Target namespace (optional, all namespaces if not specified)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
 
             if namespace:
                 pods = v1.list_namespaced_pod(namespace).items
@@ -325,6 +357,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "note": "Cost estimates based on resource requests. Integrate with cloud billing for actual costs.",
                 "byNamespace": ns_summary,
                 "topWorkloads": sorted(workload_costs, key=lambda x: x["cpuMillicores"], reverse=True)[:20]
@@ -341,15 +374,20 @@ def register_cost_tools(server, non_destructive: bool):
     )
     def get_overprovisioned_resources(
         namespace: Optional[str] = None,
-        threshold: float = 50.0
+        threshold: float = 50.0,
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Find pods using significantly less resources than requested (over-provisioned)."""
+        """Find pods using significantly less resources than requested (over-provisioned).
+
+        Args:
+            namespace: Target namespace (optional, all namespaces if not specified)
+            threshold: Utilization threshold percentage below which resources are considered over-provisioned
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
 
-            cmd = ["kubectl", "top", "pods", "--no-headers"]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["top", "pods", "--no-headers"]
             if namespace:
                 cmd.extend(["-n", namespace])
             else:
@@ -418,6 +456,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "threshold": f"{threshold}%",
                 "count": len(overprovisioned),
                 "overprovisioned": overprovisioned[:50]
@@ -436,14 +475,21 @@ def register_cost_tools(server, non_destructive: bool):
     )
     def get_resource_trends(
         namespace: Optional[str] = None,
-        resource_type: str = "pods"
+        resource_type: str = "pods",
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Get current resource usage snapshot for trend analysis (requires metrics-server)."""
+        """Get current resource usage snapshot for trend analysis (requires metrics-server).
+
+        Args:
+            namespace: Target namespace (optional, all namespaces if not specified)
+            resource_type: Type of resource to analyze (pods or nodes)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
             if resource_type == "nodes":
-                cmd = ["kubectl", "top", "nodes", "--no-headers"]
+                cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["top", "nodes", "--no-headers"]
             else:
-                cmd = ["kubectl", "top", "pods", "--no-headers"]
+                cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["top", "pods", "--no-headers"]
                 if namespace:
                     cmd.extend(["-n", namespace])
                 else:
@@ -501,6 +547,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "timestamp": datetime.utcnow().isoformat() + "Z",
                 "resourceType": resource_type,
                 "summary": {
@@ -523,12 +570,14 @@ def register_cost_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def get_namespace_cost_allocation() -> Dict[str, Any]:
-        """Calculate resource allocation percentages across all namespaces."""
+    def get_namespace_cost_allocation(context: str = "") -> Dict[str, Any]:
+        """Calculate resource allocation percentages across all namespaces.
+
+        Args:
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            v1 = client.CoreV1Api()
+            v1 = get_k8s_client(context)
 
             pods = v1.list_pod_for_all_namespaces().items
 
@@ -573,6 +622,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "clusterTotals": {
                     "totalCpuMillicores": total_cpu,
                     "totalMemoryMi": round(total_memory / (1024 * 1024), 2),
@@ -592,21 +642,26 @@ def register_cost_tools(server, non_destructive: bool):
     )
     def optimize_resource_requests(
         namespace: str,
-        deployment_name: Optional[str] = None
+        deployment_name: Optional[str] = None,
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Suggest optimal resource requests based on current usage patterns."""
+        """Suggest optimal resource requests based on current usage patterns.
+
+        Args:
+            namespace: Target namespace
+            deployment_name: Specific deployment to analyze (optional, all deployments if not specified)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            from kubernetes import client, config
-            config.load_kube_config()
-            apps = client.AppsV1Api()
-            v1 = client.CoreV1Api()
+            apps = get_apps_client(context)
+            v1 = get_k8s_client(context)
 
             if deployment_name:
                 deployments = [apps.read_namespaced_deployment(deployment_name, namespace)]
             else:
                 deployments = apps.list_namespaced_deployment(namespace).items
 
-            cmd = ["kubectl", "top", "pods", "-n", namespace, "--no-headers"]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["top", "pods", "-n", namespace, "--no-headers"]
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
 
             usage_map = {}
@@ -669,6 +724,7 @@ def register_cost_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "namespace": namespace,
                 "note": "Suggestions based on current usage + 20% buffer. Monitor over time for accuracy.",
                 "suggestions": suggestions