# Porter PaaS MCP

> Porter PaaS lets you take full command of your Kubernetes infrastructure through natural conversation. Use your AI client to map organizational projects, check cluster health, manage environments, and force rollouts—all without opening a dashboard or running complex CLI commands. It’s programmatic control over your entire deployed application stack.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** kubernetes, paas, container-orchestration, deployment-automation, cluster-management, infrastructure-as-code

## Description

Managing complex cloud deployments usually means jumping between dashboards, remembering arcane command flags, and dealing with brittle YAML files. This MCP changes that. You connect your account once to Vinkius and give your AI client deep access to your Kubernetes infrastructure. Instead of running `kubectl` commands or navigating resource trees, you simply ask the question. Your agent handles the complex orchestration: listing out all organizational scopes, checking which environments are active, mapping web services, and even forcing a container mutation with a fresh image tag if something breaks.

It lets you audit an entire cluster's architecture—from high-level projects down to specific Helm charts behind your core databases. You can instruct the system to gracefully restart a hanging application pod or get precise metrics on CPU limits for a service, all from a single chat window. It’s direct control over state, not just reading logs.

## Tools

### deploy_app_tag
Forcefully updates an app's running container image to a specific version or tag, triggering a fresh deployment.

### get_app
Retrieves deep metrics and resource limits for a specific deployed application.

### get_cluster
Inspects the foundational cloud credentials used by a given Kubernetes cluster.

### get_project
Pulls structural metadata related to an entire organizational project scope.

### list_apps
Finds all running applications exposed under specific subdomains or custom target mappings.

### list_clusters
Lists the available cloud definitions and boundaries that host your Kubernetes nodes.

### list_environments
Extracts all distinct isolation environments (like staging or pre-prod) within a cluster.

### list_projects
Retrieves the unique organizational identifiers for all major projects under your account.

### list_helm_releases
Checks if third-party components, like databases or monitoring tools, successfully installed in a specific area.

### restart_app
Instructs the system to cycle the application's container replicas without changing the underlying code.

## Prompt Examples

**Prompt:** 
```
List all applications currently running in cluster ID 5 on the Production environment.
```

**Response:** 
```
I found 4 applications bound to the cluster namespace. We have `core-api`, `cron-sync-worker`, `redis-cache`, and `web-frontend`. The core API is serving on a porter.run subdomain mapping. Would you like me to get architectural configs for `core-api`?
```

**Prompt:** 
```
The queue worker is completely hung. Please perform a forceful restart of the `async-worker` app.
```

**Response:** 
```
Command received. I've sent the signal to recycle the pod replicas for `async-worker` across cluster 4. Kubernetes is now performing a rolling flush seamlessly. It will take roughly 15 seconds to stand out new instances and attach them.
```

**Prompt:** 
```
We just built a hotfix on main. Deploy the image tag `d83a1b1` strictly onto `portal-frontend`.
```

**Response:** 
```
I've successfully forced the container mutation! The `portal-frontend` application was patched to image tag `d83a1b1`. The cloud runner is pulling the fresh digest and orchestrating a replacement. Check the frontend in 1 minute.
```

## Capabilities

### Audit Organizational Scope
Retrieves the structural metadata that defines your major organizational projects.

### Map Cluster Boundaries
Inspects the core cloud credentials and definitions for an entire Kubernetes cluster.

### Inventory Deployed Services
Discovers all active applications, including those mapped to specific subdomains or custom routes.

### Force Application Rollbacks
Instructs the system to pull and deploy a specific image tag, overriding any current running container version.

### Manage Environments
Separates and lists out distinct isolation environments (like staging or pre-prod) within a single cluster.

## Use Cases

### The weekend emergency rollback
A backend developer pushed a minor change that caused the main API to fail. They immediately use `deploy_app_tag` to force the application back to the stable image tag from last week, minimizing downtime and preventing manual effort.

### Auditing architecture boundaries
An engineering lead needs to know how many separate testing environments exist before a major launch. They use `list_environments` to get an instant list of all isolated zones, confirming that the staging area is fully separated from production.

### Troubleshooting a hanging worker
The queue processing service stops responding. An ops engineer uses `restart_app` on the specific worker app to force its pods to recycle, bringing the service back online without needing root access or SSHing into machines.

### Mapping a new microservice
A team is launching a brand-new component. They use `list_apps` first to see what subdomains are currently active, then use `get_app` on the new service name to map out its exact resource requirements (CPU/RAM) before deployment.

## Benefits

- Bypass dashboards and CLIs. Instead of running complex `kubectl` commands, you tell your agent to check the status or restart a pod, getting instant results in text form.
- Safety during deployments is built-in. If an app crashes, use `restart_app` to cycle its replicas without having to modify the core code deployment tag first.
- Full visibility across all resource types. Use `list_projects` and `get_project` to map out organizational boundaries instantly, giving you a high-level view of your infrastructure's scope.
- Debugging hotfixes is fast. With `deploy_app_tag`, you can force an application to run a specific image tag immediately—perfect for emergency rollbacks without manual intervention.
- Check everything required. You don't just see the web app; you use `list_helm_releases` to verify if crucial dependencies, like Postgres or Redis, actually installed correctly.

## How It Works

The bottom line is you get programmatic control over complex cluster operations without ever leaving the chat window.

1. Subscribe to this MCP and provide your Porter API token.
2. Your AI client uses the credentials to access your cloud infrastructure data.
3. You interact using natural language, asking your agent to perform specific actions like listing projects or restarting pods.

## Frequently Asked Questions

**How do I use Porter PaaS MCP to check my cluster health?**
You can inspect the core credentials of a specific K8s Cluster by calling `get_cluster`. This gives you visibility into the foundational cloud definitions powering your deployments.

**Can I use Porter PaaS MCP to roll back an app version?**
Yes. Use the `deploy_app_tag` tool and provide the specific image tag or digest. This forces Kubernetes to pull that exact container version, overriding what's currently running.

**What if my service is hanging? How do I fix it with Porter PaaS MCP?**
Use `restart_app`. This instructs the system to cycle the application's pod replicas across the cluster. It’s a non-disruptive way to clear connection leaks without changing the underlying code.

**Does Porter PaaS MCP help me see all my projects?**
Absolutely. Call `list_projects` to retrieve all the unique organizational IDs (the `projectId` arrays) that define your major operational scopes within AWS or GCP clusters.

**What is the difference between list_apps and list_clusters in Porter PaaS MCP?**
`list_clusters` gives you the boundaries of the physical cloud zones hosting your nodes. `list_apps` focuses on the logical layer, telling you which specific web services are running inside those clusters.