Porter PaaS MCP. Control your K8s clusters from chat, not the dashboard.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Porter PaaS lets your AI agent manage Kubernetes clusters natively. It gives you programmatic control over apps, projects, and container tags across all your deployment environments.
You can list zones, check service requirements, restart pods gracefully, or force-deploy specific image versions directly from chat.
What your AI agents can do
Deploy app tag
Forces Kubernetes to pull a specific Docker image tag, executing an absolute fresh deployment across all replicas.
Get app
Retrieves detailed architectural metrics for a single application, including mapped CPU and RAM limits.
Get cluster
Inspections deep cloud credentials that generate a specific Kubernetes cluster instance.
Retrieves deep cloud credentials and structural information for a specific Kubernetes cluster.
Fetches the core metadata and IDs coordinating resources across different AWS or GCP clusters.
Discovers which applications are running, mapping their dedicated subdomains or custom apex mappings within a cluster.
Extracts the defined logical environments (like staging or pre-prod) that overlap with the main cluster.
Lists specific operational Helm configurations inside a namespace, useful for verifying third-party apps like databases.
Triggers an immediate deployment by forcing Kubernetes to pull and run a specified Docker image tag across all replicas.
Instructs the Kubernetes API to cycle the application pods, restarting services without changing the underlying code version.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Porter PaaS MCP Server: 10 Tools for Platform Operations
Run all infrastructure commands—from listing projects to deploying new container tags—using these ten dedicated tools.
019d75f8deploy app tag
Forces Kubernetes to pull a specific Docker image tag, executing an absolute fresh deployment across all replicas.
019d75f8get app
Retrieves detailed architectural metrics for a single application, including mapped CPU and RAM limits.
019d75f8get cluster
Inspections deep cloud credentials that generate a specific Kubernetes cluster instance.
019d75f8get project
Extracts the full metadata details linked to a defined Porter Project scope.
019d75f8list apps
Discovers all running applications, identifying which subdomains or custom mappings they use within a cluster.
019d75f8list clusters
Lists the underlying target cloud Kubernetes definitions and execution zones available to Porter PaaS.
019d75f8list environments
Extracts a list of defined logical isolation environments that exist within a given cluster.
019d75f8list helm releases
Verifies the status and configurations of dependent third-party apps (like Redis or Postgres) deployed via Helm charts.
019d75f8list projects
Fetches the core organizational scopes, identifying base Porter PaaS projects coordinating resources across clouds.
019d75f8restart app
Instructs the Kubernetes API to bounce all replicas of a specified application deployment without changing its underlying code tag.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Porter PaaS, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Porter PaaS MCP Server - Manage K8s Deployments
You've got a complex Kubernetes setup running across multiple clouds, and you don't wanna mess around with CLIs or web dashboards just to check a service status. This server gives your AI agent direct, programmatic control over everything in Porter PaaS. You manage deployments and audit cluster states by telling your agent exactly what you need.
Scope and Inventory: Mapping Out Your Stack
You gotta know where the rubber meets the road before you fix anything. Start by identifying the big picture scope using list_projects; it fetches the core organizational metadata, showing you all base Porter PaaS projects coordinating resources across different cloud environments.
To figure out which clusters are in play, call list_clusters. This lists every underlying target cloud Kubernetes definition and tells you what execution zones are available to your agent. Once you know the cluster, run get_cluster to inspect deep cloud credentials and get all the structural information for that specific instance.
Next, narrow down where things are running. You can check list_environments to pull a list of defined logical isolation environments—think staging or pre-production zones—that overlap with your main cluster. Then, run list_apps to discover every application currently running within the scope; this function maps out which dedicated subdomains or custom apex mappings those apps use.
Deep Auditing and Resource Checks
When you're ready for details, you can drill down into specific components. If you need to know what third-party services are bolted onto your stack—like Postgres or Redis that run via Helm charts—use list_helm_releases to verify their status and configurations within a namespace.
To understand resource needs, call get_app. This retrieves detailed architectural metrics for a single application instance, giving you specific data points on its mapped CPU limits and RAM usage. It’s key for capacity planning or diagnosing resource contention.
Need to know the organizational container? Run get_project to extract all the full metadata details linked to a defined Porter Project scope.
Action: Fixing Problems Without Hands-On CLI Work
Things break. Your agent needs to fix them without you opening a terminal. If an app is running fine but acting weird, use restart_app. This instructs the Kubernetes API to bounce all replicas of that specified application deployment—it cycles the pods and restarts services without changing the underlying code tag.
If restarting doesn't cut it, you gotta force a new build. Use deploy_app_tag when you need an absolute fresh deployment; this forces Kubernetes to pull a specific Docker image tag across all replicas immediately.
You got this coverage: You can list out every running application using list_apps, verify the status of supporting infrastructure with list_helm_releases, and get deep insights into resource usage via get_app—all from one conversation with your agent.
How Porter PaaS MCP Works
- 1 Subscribe to this server and provide your Porter API Token.
- 2 Tell your AI agent exactly what state you need to check (e.g., 'What apps run in the staging cluster?').
- 3 The agent executes the relevant tool call, returning real-time data on clusters, projects, or service deployments.
The bottom line is that your AI client handles all authentication and API calls; you just talk to it like it's sitting right next to you.
Who Is Porter PaaS MCP For?
The DevOps Engineer who gets paid to babysit dashboards. This tool is for the SRE tired of jumping between cloud CLIs, Kubernetes dashboard UIs, and internal wikis just to run a simple health check or roll back a bad image tag.
Uses list_apps and restart_app on the fly to audit cluster architecture or quickly stabilize a crashing service.
Runs deploy_app_tag when they need to force-roll out a hotfix image tag immediately, bypassing standard CI/CD gates for emergencies.
Uses list_environments and get_project to scope out distinct staging environments or map resource boundaries before planning a major feature launch.
What Changes When You Connect
- Instant Rollbacks: When
core-apibreaks, you don't log into a console. You just tell your agent to runrestart_app, and it cycles the pods instantly. - Deep Auditing: Need to know if Postgres or Redis is running correctly? Use
list_helm_releases. It checks those underlying operational configurations without needing direct access to the Helm CLI. - Scope Mapping: Don't get lost in resource IDs. Run
get_projectfirst to map out the high-level organizational boundaries before you even check which clusters are involved. - Zero-Guesswork Deployments: Forget guessing if the new image is ready. Use
deploy_app_tagto force a deployment with an exact digest, guaranteeing the right code hits production. - Environment Isolation Check: Before touching anything, run
list_environments. This confirms that your staging environment hasn't accidentally bled into prod or vice versa.
Real-World Use Cases
The Hotfix Emergency
The frontend service fails right before launch. Instead of manually grabbing the deployment YAML, the developer tells their agent to run deploy_app_tag with the known good image digest. The agent forces the mutation and begins the rollout immediately.
Auditing a Failed Rollout
A service is running slowly, but logs are vague. An engineer runs get_app to check the current resource utilization (CPU/RAM limits). Then they run list_helm_releases to confirm if all dependent services like message queues are healthy.
Mapping Resources
A new team is spun up and needs access. The lead runs list_projects first, then uses get_project on the required scope ID to verify exactly which cloud clusters and resource boundaries they need permissions for.
Debugging Inter-Service Dependencies
The web app fails intermittently. The agent runs list_apps to confirm all expected services are listed, then uses restart_app on the primary service while checking get_cluster credentials to rule out cloud connectivity issues.
The Tradeoffs
Trying to audit everything with one tool.
The user tries to run a general 'show me all infra' command, which fails because the infrastructure is too complex and requires multiple data points (e.g., projects AND environments).
→
Don't try to gather metadata in one shot. First, run list_projects for scope boundaries. Then, use get_project with the resulting ID. Finally, list specific resources like list_environments or list_clusters.
Assuming a restart fixes everything.
A service keeps crashing immediately after running restart_app. The user thinks it's just a network blip and retries the command, wasting time.
→
If restart_app fails to resolve the issue, run get_app first. Check the reported RAM/CPU limits against what you expect; this helps pinpoint if the underlying resource allocation is wrong.
Bypassing environment checks.
A developer executes a deployment using only an app name, assuming it runs in staging when they meant to deploy to production.
→
Always run list_environments first. This shows you the available isolation zones, ensuring your subsequent actions (like targeted deployments) hit the correct target.
When It Fits, When It Doesn't
Use this server if your job requires constantly switching between API calls, dashboards, and CLI commands to understand or modify a Kubernetes deployment state. You need visibility into resource boundaries (list_projects), current service versions (list_apps), or immediate fixes (restart_app).
Don't use it if you are simply writing boilerplate code that doesn't interact with the live infrastructure, or if your task is purely data transformation (like simple JSON parsing). For those cases, a basic file I/O tool works better. If you only need to read static configuration details and don't require active deployment commands, list_clusters might be enough. But for true operational control—that’s where this server shines.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Porter. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Debugging K8s infrastructure shouldn't mean opening five different terminal windows.
Right now, finding out what apps are running in a specific environment means logging into the cloud dashboard, navigating to the correct cluster view, then clicking through multiple namespaces and service definitions. If you need to check if dependent services like Postgres or Redis even got deployed, you're guessing, because nothing shows that status clearly.
With Porter PaaS, your agent handles all those clicks for you. You simply ask: 'What are the Helm releases in this namespace?' The agent runs `list_helm_releases` and gives you a definitive list of every third-party component—no guesswork required.
Porter PaaS MCP Server gives you direct control with deploy_app_tag.
Manual deployments often involve `kubectl set image` commands, which are great but brittle. You have to remember the exact service name and the full container digest. If your CI/CD pipeline gets interrupted, manually re-running that complex command is a pain, and you might miss a dependency.
Now, you just tell your agent: 'Force deploy image tag `d83a1b1` to `portal-frontend`.' The tool executes the container mutation directly through Kubernetes, making it fast, reliable, and auditable.
Common Questions About Porter PaaS MCP
How do I check if a cluster is properly configured using get_cluster? +
The get_cluster tool inspects the deep cloud credentials that define your K8s Cluster. It confirms the structural integrity and underlying cloud resource definitions, so you know what you're working with.
Can I use list_apps to see which service is running on a subdomain? +
Yes. list_apps discovers exactly which deployed applications are exposing specific subdomains or custom apex mappings, giving you the exact routing identity of your services.
What's the difference between restart_app and deploying a new tag? +
Running restart_app just cycles the pod replicas—it’s a quick bounce for connection leaks. If you need to fix code, use deploy_app_tag to force an image mutation.
Should I check list_projects before anything else? +
Yeah. It's best practice. Start with list_projects to get the high-level organizational scope IDs, and then use get_project to pull down all the specific metadata for that project.
When should I use list_helm_releases to audit my stack? +
You check this when you need to verify third-party apps that aren't part of your main service. It lists operational Helm configurations, confirming if dependencies like Postgres or Redis successfully installed.
What detailed resource metrics can I analyze using get_app? +
It goes beyond basic status checks. You retrieve specific CPU metrics requested, mapped RAM limits for JVM/Node instances, and the internal registry image hashes running at that time.
How does list_environments help me manage scope isolation? +
This tool extracts logic separation environments overlapping a cluster. It lets you see distinct isolated zones within your larger Kubernetes infrastructure.
What credentials information does get_cluster provide? +
It inspects the deep cloud credentials that generate and manage a specific K8s Cluster instance. This confirms the underlying identity boundaries for your deployment zone.
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Contentstack
Equip your AI agent to instantly retrieve digital content and schemas using the Contentstack Delivery API.
Juhe Data / 聚合数据
China's leading API aggregator — access weather, ID verification, IP lookup, and news via AI.
Railway
Equip your AI with direct access to your Railway infrastructure — manage projects, deployments, services, and environment variables.
You might also like
Salesforce Marketing Cloud
Manage campaigns, track member engagement, measure marketing ROI, and optimize lead generation through natural conversation.
Rappi API
Automate LatAm's largest super-app via Rappi — track active deliveries, request support, and manage logistics from your agent.
Swiftype
Connect your AI to Elastic Swiftype. Query your search engines, manage documents, and retrieve deep analytical insights natively from the terminal.