vibops-mcp 0.1.0__tar.gz

vibops_mcp-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.pyc
+.env
+.venv/
+venv/
+*.egg-info/
+.DS_Store
+agent/data/
+dist/
+.connect-env
+charts/*/charts/
+charts/*/*.tgz
+
+# Licence key generator — contains RSA private key, vendor-only
+scripts/gen_licence.py

vibops_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VibOps
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vibops_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: vibops-mcp
+Version: 0.1.0
+Summary: VibOps MCP server — control your GPU infrastructure from Claude Desktop, Cursor, or any MCP client
+Project-URL: Homepage, https://vibops.io
+Project-URL: Repository, https://github.com/vibops/vibops-mcp
+Project-URL: Issues, https://github.com/vibops/vibops-mcp/issues
+License: MIT
+License-File: LICENSE
+Keywords: ai-infrastructure,gpu,kubernetes,mcp,vibops
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp[cli]>=1.0.0
+Description-Content-Type: text/markdown
+
+# vibops-mcp
+
+Control your GPU infrastructure with Claude, Cursor, or any MCP-compatible AI assistant.
+
+## What it does
+
+`vibops-mcp` exposes 26 tools that let an AI assistant:
+
+- **Observe** — GPU utilisation, workload breakdown, MTTR, cost estimates, live K8s deployments
+- **Act** — deploy models, scale clusters, run Helm/kubectl, trigger pipelines
+- **Configure** — set cost rates, manage gateways, store secrets
+
+All operations go through your VibOps instance and are recorded in the audit log.
+
+## Installation
+
+```bash
+pip install vibops-mcp
+```
+
+## Configuration
+
+You need two environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `VIBOPS_URL` | Base URL of your VibOps instance, e.g. `https://vibops.example.com` |
+| `VIBOPS_TOKEN` | API token — create one in VibOps → Settings → API Tokens |
+
+## Claude Desktop
+
+Add to `~/.config/claude/claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "vibops": {
+      "command": "vibops-mcp",
+      "env": {
+        "VIBOPS_URL": "https://vibops.example.com",
+        "VIBOPS_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+## Cursor
+
+Add to `.cursor/mcp.json` in your project root, or to the global config:
+
+```json
+{
+  "mcpServers": {
+    "vibops": {
+      "command": "vibops-mcp",
+      "env": {
+        "VIBOPS_URL": "https://vibops.example.com",
+        "VIBOPS_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+## Claude Code (CLI)
+
+```bash
+claude mcp add vibops vibops-mcp \
+  -e VIBOPS_URL=https://vibops.example.com \
+  -e VIBOPS_TOKEN=your-token-here
+```
+
+## Available tools
+
+### Observation (read-only)
+
+| Tool | Description |
+|------|-------------|
+| `list_clusters` | List clusters and GPU utilisation |
+| `list_kubectl_contexts` | List available kubectl contexts |
+| `get_cluster_deployments` | Live K8s deployment status for a cluster |
+| `get_cluster_rate` | Get configured GPU cost rate for a cluster |
+| `list_jobs` | List recent jobs with optional filters |
+| `get_job` | Get job details and result |
+| `get_gpu_metrics` | Hourly GPU utilisation time-series |
+| `get_workload_breakdown` | Job count by workload type |
+| `get_mttr` | Mean Time To Resolve GPU alerts |
+| `get_cost_estimate` | Estimated GPU spend |
+| `list_gateways` | List registered gateways and status |
+| `list_alerts` | List GPU alerts (open or resolved) |
+| `list_secrets` | List secrets (names only, never values) |
+| `list_providers` | List configured AI/GPU cloud providers |
+| `list_pipelines` | List automation pipelines |
+
+### Actions (write)
+
+| Tool | Description |
+|------|-------------|
+| `scale_cluster` | Scale a K8s deployment or node pool |
+| `deploy_model` | Deploy an AI model onto a GPU cluster |
+| `helm_upgrade` | Run helm upgrade --install |
+| `helm_uninstall` | Uninstall a Helm release |
+| `run_kubectl` | Run an arbitrary kubectl command |
+| `git_clone` | Clone a git repository |
+| `create_secret` | Store an encrypted secret |
+| `trigger_pipeline` | Manually trigger an automation pipeline |
+
+### Configuration
+
+| Tool | Description |
+|------|-------------|
+| `set_cluster_rate` | Set GPU cost rate for a cluster (admin only) |
+| `register_gateway` | Register a new gateway (returns one-time token) |
+| `delete_gateway` | Revoke a gateway |
+
+## Example prompts
+
+```
+"What's our GPU utilisation trend over the last 7 days?"
+"Show me the cost breakdown per cluster this week."
+"Deploy llama3:8b on vibops-dev with 2 replicas."
+"Which clusters have open critical GPU alerts?"
+"Scale the inference namespace to 4 replicas on prod-cluster."
+"What's our MTTR for critical alerts?"
+```
+
+## License
+
+MIT — free to use, modify, and distribute. See [LICENSE](LICENSE).
+
+Built on [FastMCP](https://github.com/anthropics/mcp) and the [VibOps](https://vibops.io) platform.

vibops_mcp-0.1.0/README.md

@@ -0,0 +1,132 @@
+# vibops-mcp
+
+Control your GPU infrastructure with Claude, Cursor, or any MCP-compatible AI assistant.
+
+## What it does
+
+`vibops-mcp` exposes 26 tools that let an AI assistant:
+
+- **Observe** — GPU utilisation, workload breakdown, MTTR, cost estimates, live K8s deployments
+- **Act** — deploy models, scale clusters, run Helm/kubectl, trigger pipelines
+- **Configure** — set cost rates, manage gateways, store secrets
+
+All operations go through your VibOps instance and are recorded in the audit log.
+
+## Installation
+
+```bash
+pip install vibops-mcp
+```
+
+## Configuration
+
+You need two environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `VIBOPS_URL` | Base URL of your VibOps instance, e.g. `https://vibops.example.com` |
+| `VIBOPS_TOKEN` | API token — create one in VibOps → Settings → API Tokens |
+
+## Claude Desktop
+
+Add to `~/.config/claude/claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "vibops": {
+      "command": "vibops-mcp",
+      "env": {
+        "VIBOPS_URL": "https://vibops.example.com",
+        "VIBOPS_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+## Cursor
+
+Add to `.cursor/mcp.json` in your project root, or to the global config:
+
+```json
+{
+  "mcpServers": {
+    "vibops": {
+      "command": "vibops-mcp",
+      "env": {
+        "VIBOPS_URL": "https://vibops.example.com",
+        "VIBOPS_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+## Claude Code (CLI)
+
+```bash
+claude mcp add vibops vibops-mcp \
+  -e VIBOPS_URL=https://vibops.example.com \
+  -e VIBOPS_TOKEN=your-token-here
+```
+
+## Available tools
+
+### Observation (read-only)
+
+| Tool | Description |
+|------|-------------|
+| `list_clusters` | List clusters and GPU utilisation |
+| `list_kubectl_contexts` | List available kubectl contexts |
+| `get_cluster_deployments` | Live K8s deployment status for a cluster |
+| `get_cluster_rate` | Get configured GPU cost rate for a cluster |
+| `list_jobs` | List recent jobs with optional filters |
+| `get_job` | Get job details and result |
+| `get_gpu_metrics` | Hourly GPU utilisation time-series |
+| `get_workload_breakdown` | Job count by workload type |
+| `get_mttr` | Mean Time To Resolve GPU alerts |
+| `get_cost_estimate` | Estimated GPU spend |
+| `list_gateways` | List registered gateways and status |
+| `list_alerts` | List GPU alerts (open or resolved) |
+| `list_secrets` | List secrets (names only, never values) |
+| `list_providers` | List configured AI/GPU cloud providers |
+| `list_pipelines` | List automation pipelines |
+
+### Actions (write)
+
+| Tool | Description |
+|------|-------------|
+| `scale_cluster` | Scale a K8s deployment or node pool |
+| `deploy_model` | Deploy an AI model onto a GPU cluster |
+| `helm_upgrade` | Run helm upgrade --install |
+| `helm_uninstall` | Uninstall a Helm release |
+| `run_kubectl` | Run an arbitrary kubectl command |
+| `git_clone` | Clone a git repository |
+| `create_secret` | Store an encrypted secret |
+| `trigger_pipeline` | Manually trigger an automation pipeline |
+
+### Configuration
+
+| Tool | Description |
+|------|-------------|
+| `set_cluster_rate` | Set GPU cost rate for a cluster (admin only) |
+| `register_gateway` | Register a new gateway (returns one-time token) |
+| `delete_gateway` | Revoke a gateway |
+
+## Example prompts
+
+```
+"What's our GPU utilisation trend over the last 7 days?"
+"Show me the cost breakdown per cluster this week."
+"Deploy llama3:8b on vibops-dev with 2 replicas."
+"Which clusters have open critical GPU alerts?"
+"Scale the inference namespace to 4 replicas on prod-cluster."
+"What's our MTTR for critical alerts?"
+```
+
+## License
+
+MIT — free to use, modify, and distribute. See [LICENSE](LICENSE).
+
+Built on [FastMCP](https://github.com/anthropics/mcp) and the [VibOps](https://vibops.io) platform.

vibops_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vibops-mcp"
+version = "0.1.0"
+description = "VibOps MCP server — control your GPU infrastructure from Claude Desktop, Cursor, or any MCP client"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+keywords = ["mcp", "gpu", "kubernetes", "ai-infrastructure", "vibops"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Systems Administration",
+]
+dependencies = [
+    "mcp[cli]>=1.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.scripts]
+vibops-mcp = "vibops_mcp.server:main"
+
+[project.urls]
+Homepage = "https://vibops.io"
+Repository = "https://github.com/vibops/vibops-mcp"
+Issues = "https://github.com/vibops/vibops-mcp/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["vibops_mcp"]

vibops_mcp-0.1.0/vibops_mcp/__init__.py

@@ -0,0 +1,2 @@
+"""VibOps MCP server — Apache 2.0"""
+__version__ = "0.1.0"

vibops_mcp-0.1.0/vibops_mcp/client.py

@@ -0,0 +1,60 @@
+"""
+Async HTTP client wrapping the VibOps REST API.
+
+Configuration (env vars):
+  VIBOPS_URL    — base URL of your VibOps instance, e.g. https://vibops.example.com
+  VIBOPS_TOKEN  — API token (create one in VibOps → Settings → API Tokens)
+"""
+import os
+import httpx
+
+_TIMEOUT = 60.0
+
+
+def _base_url() -> str:
+    url = os.environ.get("VIBOPS_URL", "").rstrip("/")
+    if not url:
+        raise RuntimeError(
+            "VIBOPS_URL environment variable is not set. "
+            "Set it to your VibOps instance URL, e.g. https://vibops.example.com"
+        )
+    return url
+
+
+def _token() -> str:
+    tok = os.environ.get("VIBOPS_TOKEN", "")
+    if not tok:
+        raise RuntimeError(
+            "VIBOPS_TOKEN environment variable is not set. "
+            "Create an API token in VibOps → Settings → API Tokens."
+        )
+    return tok
+
+
+def _client() -> httpx.AsyncClient:
+    return httpx.AsyncClient(
+        base_url=_base_url(),
+        headers={"Authorization": f"Bearer {_token()}"},
+        timeout=_TIMEOUT,
+    )
+
+
+async def get(path: str, params: dict | None = None) -> dict:
+    async with _client() as c:
+        r = await c.get(path, params=params)
+        r.raise_for_status()
+        return r.json()
+
+
+async def post(path: str, body: dict | None = None) -> dict:
+    async with _client() as c:
+        r = await c.post(path, json=body or {})
+        r.raise_for_status()
+        return r.json()
+
+
+async def delete(path: str) -> dict:
+    async with _client() as c:
+        r = await c.delete(path)
+        r.raise_for_status()
+        return r.json()

vibops_mcp-0.1.0/vibops_mcp/server.py

@@ -0,0 +1,362 @@
+"""
+VibOps MCP server — entry point.
+
+Run via:
+  vibops-mcp              (after pip install vibops-mcp)
+  python -m vibops_mcp    (from source)
+
+Required environment variables:
+  VIBOPS_URL    — base URL of your VibOps instance
+  VIBOPS_TOKEN  — API token (VibOps → Settings → API Tokens)
+
+Claude Desktop configuration (~/.config/claude/claude_desktop_config.json):
+  {
+    "mcpServers": {
+      "vibops": {
+        "command": "vibops-mcp",
+        "env": {
+          "VIBOPS_URL": "https://vibops.example.com",
+          "VIBOPS_TOKEN": "your-token-here"
+        }
+      }
+    }
+  }
+"""
+from mcp.server.fastmcp import FastMCP
+
+from vibops_mcp.tools import observation, actions, config
+
+mcp = FastMCP(
+    name="vibops",
+    instructions=(
+        "You are connected to a VibOps instance that manages GPU infrastructure. "
+        "Use the observation tools to inspect cluster state, GPU metrics, jobs, and cost. "
+        "Use the action tools to deploy models, scale workloads, and run Helm or kubectl operations. "
+        "Use the configuration tools to set cost rates and manage gateways. "
+        "All write operations are recorded in the VibOps audit log."
+    ),
+)
+
+
+# ── Observation tools (15) ─────────────────────────────────────────────────────
+
+@mcp.tool()
+async def list_clusters() -> dict:
+    """List all Kubernetes clusters and their GPU utilisation."""
+    return await observation.list_clusters()
+
+
+@mcp.tool()
+async def get_cluster_deployments(cluster_name: str, namespace: str | None = None) -> dict:
+    """
+    Return live Kubernetes deployment status for a cluster.
+    Polls the cluster via the VibOps gateway (up to 20 s).
+
+    Args:
+        cluster_name: Name of the kubectl context / Kind cluster.
+        namespace: Filter to a specific namespace (optional).
+    """
+    return await observation.get_cluster_deployments(cluster_name, namespace)
+
+
+@mcp.tool()
+async def list_jobs(
+    status: str | None = None,
+    action: str | None = None,
+    limit: int = 20,
+) -> dict:
+    """
+    List recent jobs (operations executed on the infrastructure).
+
+    Args:
+        status: Filter by status — pending | running | success | failed.
+        action: Filter by action name, e.g. scale_cluster, deploy_model.
+        limit: Maximum number of jobs to return (default 20, max 100).
+    """
+    return await observation.list_jobs(status, action, limit)
+
+
+@mcp.tool()
+async def get_job(job_id: str) -> dict:
+    """
+    Get the details and result of a specific job.
+
+    Args:
+        job_id: UUID of the job.
+    """
+    return await observation.get_job(job_id)
+
+
+@mcp.tool()
+async def get_gpu_metrics(hours: int = 24) -> dict:
+    """
+    Return hourly GPU utilisation time-series for the last N hours.
+
+    Args:
+        hours: Look-back window in hours (default 24, max 168).
+    """
+    return await observation.get_gpu_metrics(hours)
+
+
+@mcp.tool()
+async def get_workload_breakdown(hours: int = 24) -> dict:
+    """
+    Return the breakdown of jobs by workload type for the last N hours.
+    Types: inference | training | observation | operations | gitops | maintenance | other.
+
+    Args:
+        hours: Look-back window in hours (default 24).
+    """
+    return await observation.get_workload_breakdown(hours)
+
+
+@mcp.tool()
+async def get_mttr(hours: int = 168) -> dict:
+    """
+    Return Mean Time To Resolve GPU alerts per cluster and severity.
+
+    Args:
+        hours: Look-back window in hours (default 168 = 7 days).
+    """
+    return await observation.get_mttr(hours)
+
+
+@mcp.tool()
+async def get_cost_estimate(hours: int = 24) -> dict:
+    """
+    Return estimated GPU spend for the last N hours.
+    Requires GPU cost rates to be configured per cluster (use set_cluster_rate).
+
+    Args:
+        hours: Look-back window in hours (default 24).
+    """
+    return await observation.get_cost_estimate(hours)
+
+
+@mcp.tool()
+async def list_gateways() -> dict:
+    """List all registered VibOps gateways (remote agents) and their status."""
+    return await observation.list_gateways()
+
+
+@mcp.tool()
+async def list_alerts(severity: str | None = None, resolved: bool | None = None) -> dict:
+    """
+    List GPU alerts.
+
+    Args:
+        severity: Filter by severity — warning | critical.
+        resolved: True for resolved alerts, False for open alerts.
+    """
+    return await observation.list_alerts(severity, resolved)
+
+
+@mcp.tool()
+async def list_secrets(search: str | None = None) -> dict:
+    """
+    List available secrets (names and metadata only, never values).
+
+    Args:
+        search: Filter secrets by name (optional).
+    """
+    return await observation.list_secrets(search)
+
+
+@mcp.tool()
+async def list_providers() -> dict:
+    """List configured custom AI/GPU cloud providers."""
+    return await observation.list_providers()
+
+
+@mcp.tool()
+async def list_pipelines() -> dict:
+    """List automation pipelines (sequences of jobs)."""
+    return await observation.list_pipelines()
+
+
+@mcp.tool()
+async def get_cluster_rate(cluster_name: str) -> dict:
+    """
+    Get the configured GPU cost rate for a cluster.
+
+    Args:
+        cluster_name: Name of the cluster.
+    """
+    return await observation.get_cluster_rate(cluster_name)
+
+
+@mcp.tool()
+async def list_kubectl_contexts() -> dict:
+    """List available kubectl contexts from the kubeconfig."""
+    return await observation.list_kubectl_contexts()
+
+
+# ── Action tools (8) ──────────────────────────────────────────────────────────
+
+@mcp.tool()
+async def scale_cluster(cluster_name: str, replicas: int, namespace: str | None = None) -> dict:
+    """
+    Scale a Kubernetes deployment or node pool.
+
+    Args:
+        cluster_name: Target cluster name.
+        replicas: Desired replica count.
+        namespace: Kubernetes namespace (optional).
+    """
+    return await actions.scale_cluster(cluster_name, replicas, namespace)
+
+
+@mcp.tool()
+async def deploy_model(
+    cluster_name: str,
+    model_name: str,
+    namespace: str | None = None,
+    replicas: int = 1,
+    extra: dict | None = None,
+) -> dict:
+    """
+    Deploy an AI model onto a GPU cluster.
+
+    Args:
+        cluster_name: Target cluster name.
+        model_name: Model identifier (e.g. llama3:8b, mistral:7b).
+        namespace: Kubernetes namespace (optional).
+        replicas: Number of replicas (default 1).
+        extra: Additional deployment parameters (image, resources, env vars…).
+    """
+    return await actions.deploy_model(cluster_name, model_name, namespace, replicas, extra)
+
+
+@mcp.tool()
+async def helm_upgrade(
+    cluster_name: str,
+    release_name: str,
+    chart: str,
+    namespace: str = "default",
+    values: dict | None = None,
+) -> dict:
+    """
+    Run helm upgrade --install on a cluster.
+
+    Args:
+        cluster_name: Target cluster.
+        release_name: Helm release name.
+        chart: Helm chart reference (e.g. bitnami/nginx or ./charts/myapp).
+        namespace: Kubernetes namespace (default: 'default').
+        values: Helm values to override (dict, optional).
+    """
+    return await actions.helm_upgrade(cluster_name, release_name, chart, namespace, values)
+
+
+@mcp.tool()
+async def helm_uninstall(cluster_name: str, release_name: str, namespace: str = "default") -> dict:
+    """
+    Uninstall a Helm release from a cluster.
+
+    Args:
+        cluster_name: Target cluster.
+        release_name: Helm release to remove.
+        namespace: Kubernetes namespace (default: 'default').
+    """
+    return await actions.helm_uninstall(cluster_name, release_name, namespace)
+
+
+@mcp.tool()
+async def run_kubectl(cluster_name: str, command: list[str]) -> dict:
+    """
+    Run an arbitrary kubectl command on a cluster.
+    Example command: ["get", "pods", "-n", "default"]
+
+    Args:
+        cluster_name: Target cluster.
+        command: kubectl arguments as a list (without 'kubectl' prefix).
+    """
+    return await actions.run_kubectl(cluster_name, command)
+
+
+@mcp.tool()
+async def git_clone(repo_url: str, branch: str = "main", cluster_name: str | None = None) -> dict:
+    """
+    Clone a git repository (pull manifests or model configs).
+
+    Args:
+        repo_url: Git repository URL.
+        branch: Branch to clone (default: main).
+        cluster_name: Target cluster if repo contains K8s manifests to apply.
+    """
+    return await actions.git_clone(repo_url, branch, cluster_name)
+
+
+@mcp.tool()
+async def create_secret(name: str, value: str, description: str | None = None) -> dict:
+    """
+    Store an encrypted secret in the VibOps vault.
+
+    Args:
+        name: Secret name (used to reference it in jobs).
+        value: Secret value (stored encrypted, never logged).
+        description: Optional human-readable description.
+    """
+    return await actions.create_secret(name, value, description)
+
+
+@mcp.tool()
+async def trigger_pipeline(pipeline_id: str, payload: dict | None = None) -> dict:
+    """
+    Manually trigger an automation pipeline.
+
+    Args:
+        pipeline_id: UUID of the pipeline to trigger.
+        payload: Optional input payload for the pipeline.
+    """
+    return await actions.trigger_pipeline(pipeline_id, payload)
+
+
+# ── Configuration tools (3) ───────────────────────────────────────────────────
+
+@mcp.tool()
+async def set_cluster_rate(cluster_name: str, rate_per_gpu_hour: float, currency: str = "USD") -> dict:
+    """
+    Set the GPU cost rate for a cluster (organisation admin only).
+
+    Args:
+        cluster_name: Name of the cluster.
+        rate_per_gpu_hour: Cost per GPU per hour (e.g. 2.50).
+        currency: Currency code (default: USD).
+    """
+    return await config.set_cluster_rate(cluster_name, rate_per_gpu_hour, currency)
+
+
+@mcp.tool()
+async def register_gateway(name: str, description: str | None = None, clusters: list[str] | None = None) -> dict:
+    """
+    Register a new VibOps gateway (remote agent).
+    Returns a one-time token to configure the gateway with.
+
+    Args:
+        name: Human-readable name for the gateway.
+        description: Optional description (location, purpose…).
+        clusters: List of cluster names this gateway manages.
+    """
+    return await config.register_gateway(name, description, clusters)
+
+
+@mcp.tool()
+async def delete_gateway(gateway_id: str) -> dict:
+    """
+    Revoke a VibOps gateway and its token.
+
+    Args:
+        gateway_id: UUID of the gateway to delete.
+    """
+    return await config.delete_gateway(gateway_id)
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+def main():
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

vibops_mcp-0.1.0/vibops_mcp/tools/__init__.py

@@ -0,0 +1 @@
+# tools package

vibops_mcp-0.1.0/vibops_mcp/tools/actions.py

@@ -0,0 +1,157 @@
+"""
+Action tools (write operations) — 8 tools.
+
+These tools trigger infrastructure changes via VibOps jobs.
+All operations are recorded in the audit log.
+"""
+from vibops_mcp import client
+
+
+async def _run_job(action: str, payload: dict) -> dict:
+    """Submit a job and return its initial state (async — poll with get_job)."""
+    return await client.post("/api/v1/jobs", body={"action": action, "payload": payload})
+
+
+async def scale_cluster(cluster_name: str, replicas: int, namespace: str | None = None) -> dict:
+    """
+    Scale a Kubernetes deployment or node pool.
+
+    Args:
+        cluster_name: Target cluster name.
+        replicas: Desired replica count.
+        namespace: Kubernetes namespace (optional, defaults to 'default').
+    """
+    payload: dict = {"cluster": cluster_name, "replicas": replicas}
+    if namespace:
+        payload["namespace"] = namespace
+    return await _run_job("scale_cluster", payload)
+
+
+async def deploy_model(
+    cluster_name: str,
+    model_name: str,
+    namespace: str | None = None,
+    replicas: int = 1,
+    extra: dict | None = None,
+) -> dict:
+    """
+    Deploy an AI model onto a GPU cluster.
+
+    Args:
+        cluster_name: Target cluster name.
+        model_name: Model identifier (e.g. llama3:8b, mistral:7b).
+        namespace: Kubernetes namespace (optional).
+        replicas: Number of replicas (default 1).
+        extra: Additional deployment parameters (image, resources, env vars…).
+    """
+    payload: dict = {
+        "cluster": cluster_name,
+        "model": model_name,
+        "replicas": replicas,
+    }
+    if namespace:
+        payload["namespace"] = namespace
+    if extra:
+        payload.update(extra)
+    return await _run_job("deploy_model", payload)
+
+
+async def helm_upgrade(
+    cluster_name: str,
+    release_name: str,
+    chart: str,
+    namespace: str = "default",
+    values: dict | None = None,
+) -> dict:
+    """
+    Run helm upgrade --install on a cluster.
+
+    Args:
+        cluster_name: Target cluster.
+        release_name: Helm release name.
+        chart: Helm chart reference (e.g. bitnami/nginx or ./charts/myapp).
+        namespace: Kubernetes namespace (default: 'default').
+        values: Helm values to override (dict, optional).
+    """
+    payload: dict = {
+        "cluster": cluster_name,
+        "release": release_name,
+        "chart": chart,
+        "namespace": namespace,
+    }
+    if values:
+        payload["values"] = values
+    return await _run_job("helm_upgrade", payload)
+
+
+async def helm_uninstall(cluster_name: str, release_name: str, namespace: str = "default") -> dict:
+    """
+    Uninstall a Helm release from a cluster.
+
+    Args:
+        cluster_name: Target cluster.
+        release_name: Helm release to remove.
+        namespace: Kubernetes namespace (default: 'default').
+    """
+    return await _run_job("helm_uninstall", {
+        "cluster": cluster_name,
+        "release": release_name,
+        "namespace": namespace,
+    })
+
+
+async def run_kubectl(cluster_name: str, command: list[str]) -> dict:
+    """
+    Run an arbitrary kubectl command on a cluster.
+    The command is a list of arguments (without 'kubectl' prefix).
+    Example: ["get", "pods", "-n", "default"]
+
+    Args:
+        cluster_name: Target cluster.
+        command: kubectl arguments as a list.
+    """
+    return await _run_job("kubectl_exec", {
+        "cluster": cluster_name,
+        "command": command,
+    })
+
+
+async def git_clone(repo_url: str, branch: str = "main", cluster_name: str | None = None) -> dict:
+    """
+    Clone a git repository (used to pull manifests or model configs).
+
+    Args:
+        repo_url: Git repository URL.
+        branch: Branch to clone (default: main).
+        cluster_name: Target cluster if repo contains K8s manifests to apply.
+    """
+    payload: dict = {"repo": repo_url, "branch": branch}
+    if cluster_name:
+        payload["cluster"] = cluster_name
+    return await _run_job("git_clone", payload)
+
+
+async def create_secret(name: str, value: str, description: str | None = None) -> dict:
+    """
+    Store an encrypted secret in the VibOps vault.
+
+    Args:
+        name: Secret name (used to reference it in jobs).
+        value: Secret value (stored encrypted, never logged).
+        description: Optional human-readable description.
+    """
+    body: dict = {"name": name, "value": value}
+    if description:
+        body["description"] = description
+    return await client.post("/api/v1/secrets", body=body)
+
+
+async def trigger_pipeline(pipeline_id: str, payload: dict | None = None) -> dict:
+    """
+    Manually trigger an automation pipeline.
+
+    Args:
+        pipeline_id: UUID of the pipeline to trigger.
+        payload: Optional input payload for the pipeline.
+    """
+    return await client.post(f"/api/v1/pipelines/{pipeline_id}/trigger", body=payload or {})

vibops_mcp-0.1.0/vibops_mcp/tools/config.py

@@ -0,0 +1,48 @@
+"""
+Configuration tools — 3 tools.
+
+These tools let the LLM read and update VibOps configuration.
+"""
+from vibops_mcp import client
+
+
+async def set_cluster_rate(cluster_name: str, rate_per_gpu_hour: float, currency: str = "USD") -> dict:
+    """
+    Set the GPU cost rate for a cluster (organisation admin only).
+    Used to calculate cost estimates in get_cost_estimate.
+
+    Args:
+        cluster_name: Name of the cluster.
+        rate_per_gpu_hour: Cost per GPU per hour (e.g. 2.50).
+        currency: Currency code (default: USD).
+    """
+    return await client.post(f"/api/v1/clusters/{cluster_name}/rate", body={
+        "rate_per_gpu_hour": rate_per_gpu_hour,
+        "currency": currency.upper(),
+    })
+
+
+async def register_gateway(name: str, description: str | None = None, clusters: list[str] | None = None) -> dict:
+    """
+    Register a new VibOps gateway (remote agent).
+    Returns a one-time token to configure the gateway with.
+
+    Args:
+        name: Human-readable name for the gateway.
+        description: Optional description (location, purpose…).
+        clusters: List of cluster names this gateway manages.
+    """
+    body: dict = {"name": name, "clusters": clusters or []}
+    if description:
+        body["description"] = description
+    return await client.post("/api/v1/gateways", body=body)
+
+
+async def delete_gateway(gateway_id: str) -> dict:
+    """
+    Revoke a VibOps gateway and its token.
+
+    Args:
+        gateway_id: UUID of the gateway to delete.
+    """
+    return await client.delete(f"/api/v1/gateways/{gateway_id}")

vibops_mcp-0.1.0/vibops_mcp/tools/observation.py

@@ -0,0 +1,158 @@
+"""
+Observation tools (read-only) — 15 tools.
+
+These tools let the LLM inspect the state of the infrastructure
+without triggering any side effects.
+"""
+from vibops_mcp import client
+
+
+async def list_clusters() -> dict:
+    """List all Kubernetes clusters and their GPU utilisation."""
+    return await client.get("/api/v1/gateways")
+
+
+async def get_cluster_deployments(cluster_name: str, namespace: str | None = None) -> dict:
+    """
+    Return live Kubernetes deployment status for a cluster.
+    Polls the cluster via the VibOps gateway (up to 20 s).
+
+    Args:
+        cluster_name: Name of the kubectl context / Kind cluster.
+        namespace: Filter to a specific namespace (optional).
+    """
+    params = {}
+    if namespace:
+        params["namespace"] = namespace
+    return await client.get(f"/api/v1/clusters/{cluster_name}/deployments", params=params)
+
+
+async def list_jobs(
+    status: str | None = None,
+    action: str | None = None,
+    limit: int = 20,
+) -> dict:
+    """
+    List recent jobs (operations executed on the infrastructure).
+
+    Args:
+        status: Filter by status — pending | running | success | failed.
+        action: Filter by action name, e.g. scale_cluster, deploy_model.
+        limit: Maximum number of jobs to return (default 20, max 100).
+    """
+    params: dict = {"limit": min(limit, 100)}
+    if status:
+        params["status"] = status
+    if action:
+        params["action"] = action
+    return await client.get("/api/v1/jobs", params=params)
+
+
+async def get_job(job_id: str) -> dict:
+    """
+    Get the details and result of a specific job.
+
+    Args:
+        job_id: UUID of the job.
+    """
+    return await client.get(f"/api/v1/jobs/{job_id}")
+
+
+async def get_gpu_metrics(hours: int = 24) -> dict:
+    """
+    Return hourly GPU utilisation time-series for the last N hours.
+    Aggregated across all clusters for the organisation.
+
+    Args:
+        hours: Look-back window in hours (default 24, max 168).
+    """
+    return await client.get("/api/v1/metrics/gpu", params={"hours": hours})
+
+
+async def get_workload_breakdown(hours: int = 24) -> dict:
+    """
+    Return the breakdown of jobs by workload type for the last N hours.
+    Types: inference | training | observation | operations | gitops | maintenance | other.
+
+    Args:
+        hours: Look-back window in hours (default 24, max 168).
+    """
+    return await client.get("/api/v1/metrics/workloads", params={"hours": hours})
+
+
+async def get_mttr(hours: int = 168) -> dict:
+    """
+    Return Mean Time To Resolve GPU alerts per cluster and severity.
+
+    Args:
+        hours: Look-back window in hours (default 168 = 7 days).
+    """
+    return await client.get("/api/v1/metrics/mttr", params={"hours": hours})
+
+
+async def get_cost_estimate(hours: int = 24) -> dict:
+    """
+    Return estimated GPU spend for the last N hours.
+    Requires GPU cost rates to be configured per cluster.
+
+    Args:
+        hours: Look-back window in hours (default 24).
+    """
+    return await client.get("/api/v1/metrics/cost", params={"hours": hours})
+
+
+async def list_gateways() -> dict:
+    """List all registered VibOps gateways (remote agents) and their status."""
+    return await client.get("/api/v1/gateways")
+
+
+async def list_alerts(severity: str | None = None, resolved: bool | None = None) -> dict:
+    """
+    List GPU alerts.
+
+    Args:
+        severity: Filter by severity — warning | critical.
+        resolved: True to show only resolved alerts, False for open alerts.
+    """
+    params: dict = {}
+    if severity:
+        params["severity"] = severity
+    if resolved is not None:
+        params["resolved"] = str(resolved).lower()
+    return await client.get("/api/v1/alerts", params=params)
+
+
+async def list_secrets(search: str | None = None) -> dict:
+    """
+    List available secrets (names and metadata only, never values).
+
+    Args:
+        search: Filter secrets by name (optional).
+    """
+    params = {"search": search} if search else {}
+    return await client.get("/api/v1/secrets", params=params)
+
+
+async def list_providers() -> dict:
+    """List configured custom AI/GPU cloud providers."""
+    return await client.get("/api/v1/providers")
+
+
+async def list_pipelines() -> dict:
+    """List automation pipelines (sequences of jobs)."""
+    return await client.get("/api/v1/pipelines")
+
+
+async def get_cluster_rate(cluster_name: str) -> dict:
+    """
+    Get the configured GPU cost rate for a cluster.
+
+    Args:
+        cluster_name: Name of the cluster.
+    """
+    return await client.get(f"/api/v1/clusters/{cluster_name}/rate")
+
+
+async def list_kubectl_contexts() -> dict:
+    """List available kubectl contexts from the kubeconfig."""
+    return await client.get("/api/v1/clusters/contexts")