# Porter PaaS MCP for AI Agents AI Agent Connect

> Porter PaaS MCP lets you manage your Kubernetes infrastructure directly through your AI agent. You can list projects, deploy image tags, restart crashing pods, and inspect Helm charts without touching a terminal or a dashboard. It puts full programmatic control over your Porter account into your chat window.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_97HRl70OC90xV4WamIvMCoFpPgzxIQZ45L5KjFmm/ai-agent-connect
- **Tags:** kubernetes, paas, container-orchestration, deployment-automation, cluster-management, infrastructure-as-code

## Description

Managing Kubernetes clusters usually involves a lot of context switching. You have to keep a terminal open, remember your kubeconfig context, and navigate through a cloud console just to check if a deployment succeeded or why a pod is stuck in a crash loop. This Connector changes that by bringing your Porter infrastructure directly into your conversation. Instead of hunting for a specific project or environment, you just ask your agent to show you what is running. You can see your EKS or GKE clusters, check resource limits on your web services, and find out exactly which image tags are currently live. If a deployment breaks, you do not have to dig through logs to find the right command; you just tell your agent to roll back the tag or restart the app. It handles the heavy lifting of interacting with the Porter API so you can stay focused on shipping code. By using this with the Vinkius catalog, you get a centralized way to keep your orchestration in one place. It is about moving from manual clicks to natural language commands for your production environment.

## Tools

### deploy_app_tag
Assigns a raw docker registry digest or tag to force a fresh deployment state. This ensures the cluster pulls the correct image.

### get_app
Pulls CPU metrics, RAM limits, and internal image hashes for a specific app. Use this to debug resource issues.

### get_cluster
Inspects the deep cloud credentials and configuration for a K8s cluster. It helps you understand your underlying infrastructure.

### get_project
Extracts the metadata linked to a specific Porter project. This gives you a high level view of your project scope.

### list_apps
Shows which apps are exposing porter.run subdomains or custom apex mappings. It is great for inventorying your live services.

### list_clusters
Lists the target cloud Kubernetes definitions and memory nodes. Use this to see your available execution zones.

### list_environments
Pulls the logic isolation environments for a specific cluster. This helps you distinguish between staging and production.

### list_projects
Fetches the project IDs coordinating your AWS or GCP clusters. It identifies your base organizational scopes.

### list_helm_releases
Lists the operational Helm configurations inside a specific namespace. This is vital for checking third party apps like Postgres.

### restart_app
Tells the Kubernetes API to bounce the app deployment replicas. This is the fastest way to clear connection leaks.

## Prompt Examples

**Prompt:** 
```
Show me all the apps running in my production cluster.
```

**Response:** 
```
I found 4 applications bound to the production cluster namespace:

| App Name | Subdomain | Status |
| :--- | :--- | :--- |
| core-api | api.porter.run | Healthy |
| web-frontend | web.porter.run | Healthy |
| cron-worker | internal | Running |
| redis-cache | internal | Healthy |

Would you like me to pull the resource limits for any of these?
```

**Prompt:** 
```
The async-worker is stuck. Restart it for me.
```

**Response:** 
```
I have sent the signal to recycle the pod replicas for `async-worker` across cluster 4. Kubernetes is now performing a rolling flush. It should take about 15 seconds to stand up new instances and attach them to the queue.
```

**Prompt:** 
```
What is the current image tag for the portal-frontend?
```

**Response:** 
```
The `portal-frontend` application is currently running with the following configuration:

*   **Image Tag:** `d83a1b1`
*   **Registry Hash:** `sha256:e3b0c442...`
*   **CPU Limit:** 1.0 Cores
*   **RAM Limit:** 2GiB

It is currently pulling the fresh digest from the registry.
```

## Capabilities

### Restart hanging pods
Instruct your agent to bounce app replicas when processes leak or hang.

### Deploy specific image tags
Force a fresh deployment state by mutating the executed Docker image.

### Audit cluster architecture
List high-level organizational bounds and execution zones across your account.

### Inspect Helm configurations
Verify third-party app installations like Postgres or Redis.

### Map app identities
Discover which subdomains or custom apex mappings are currently live.

## Use Cases

### Fixing a hanging worker
A queue worker hangs and the dev uses restart_app to bounce the pods immediately without searching for the correct pod name or terminal.

### Emergency hotfix rollback
A bad tag goes live; the dev uses deploy_app_tag to force the previous stable image and restore service in seconds.

### Infrastructure auditing
An engineering lead uses list_clusters and list_projects to map out all production environments during a security audit.

### Resource bottleneck check
A developer uses get_app to see if their Node instances are hitting RAM limits before they crash during a traffic spike.

## Benefits

- Stop hunting for KUBECONFIG files because your agent handles the authentication and connection to Porter automatically.
- Fix crashing services faster by using restart_app to bounce replicas without having to find the right CLI command.
- Ensure deployment consistency by using deploy_app_tag to force specific image tags across your entire cluster.
- Audit your infrastructure easily by using list_clusters and list_projects to see your entire organizational scope.
- Verify your database state by using list_helm_releases to check if third party components like Postgres are healthy.

## How It Works

The bottom line is you get full Kubernetes management via chat without ever touching a KUBECONFIG file.

1. Subscribe to the Porter PaaS MCP on Vinkius.
2. Provide your Porter API Token in your client configuration.
3. Start managing clusters and apps directly from your AI client.

## Frequently Asked Questions

**Can Porter PaaS MCP manage my EKS clusters?**
Yes, it provides programmatic control over EKS and GKE clusters hosted on Porter. You can list them, inspect their credentials, and manage the apps inside them via your AI agent.

**How do I use Porter PaaS MCP to restart an app?**
You can simply ask your agent to restart a specific app by name. It will instruct the Kubernetes API to bounce the replicas for you without changing any of your underlying code or tags.

**Does Porter PaaS MCP support Helm charts?**
Yes, it can list the operational Helm configurations inside a namespace. This is especially useful for verifying that third party apps like Postgres or Redis were installed correctly.

**Can I use Porter PaaS MCP to roll back a deployment?**
You can use it to force a specific image tag or digest onto an application. This allows you to roll back to a previous stable version instantly through a chat command.

**Is Porter PaaS MCP safe for production?**
Yes, it uses your Porter API Token to perform authorized actions. It gives your AI agent the ability to perform specific operations like restarting pods or listing projects based on the permissions you grant.

**Can my AI automatically deploy an urgent hotfix tag?**
Yes. If a specific commit tag needs to be rolled out bypassing regular CI delays, simply command the AI to `deploy_app_tag` providing the target container suffix. It issues direct orchestration commands triggering an absolute image update inside Kubernetes immediately.

**Can the agent check internal Helm variables for external addons?**
Absolutely. Using the `list_helm_releases` tool, your agent analyzes raw orchestrator chart variables inside the cluster's namespace. It is invaluable for diagnosing why your Postgres Helm initialization is misbehaving.

**Is it safe to orchestrate infrastructure boundaries with AI?**
Yes! The token you provide is inherently scoped to the exact projects authorized in the Porter Dashboard. The AI strictly respects the platform's isolation, ensuring you only restart or query bounded namespace assets.