# Heroku (PaaS) MCP for AI Agents AI Agent Connect

> Heroku (PaaS) MCP lets you manage your cloud applications using natural language. You can list apps, restart dynos, toggle maintenance modes, and audit environment variables directly through your AI client. It bridges the gap between your terminal and the Heroku dashboard, giving you a way to orchestrate deployments and monitor health without manual clicks.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_HWnMOgL2zYPCutqVNumPjbm95CPIrkddpZrkVKOV/ai-agent-connect
- **Tags:** paas, dyno-management, app-deployment, runtime-configuration, cloud-hosting, infrastructure-management

## Description

Managing cloud infrastructure usually means jumping between browser tabs, hunting for the right dashboard, and squinting at configuration strings. This Connector changes that by letting your agent handle the heavy lifting for you. Instead of manually hunting for a stalled worker or checking if a database add-on is active, you just tell your AI client what needs to happen. It connects your Heroku account to your workflow, so you can audit decrypted environment variables or check regional datacenter placements in seconds. You'll find it's a huge time-saver when you need to perform a hard reboot on a cluster or quickly toggle maintenance mode during a database migration. Because Vinkius makes it easy to connect these tools, you can move from "I think something is wrong with the worker" to "restart the specific worker instance" in one sentence. It's about getting back to writing code while the agent handles the operational overhead of your PaaS environment.

## Tools

### delete_app
Permanently wipes an active app from Heroku. Use this only when you are sure you want to remove the app and all its traffic.

### get_app_info
Fetches runtime constraints, URL mapping, and regional datacenter placements. Use it to verify where your app is actually running.

### list_addons
Retrieves all third-party platform add-ons mapped to an app. This helps you see which Postgres or Redis instances are attached.

### list_apps
Lists all standard applications hosted on Heroku. Use this to find the correct App IDs for other commands.

### list_dynos
Lists discrete containerized dynos and their current statuses. This shows if your workers are up, crashed, or starting.

### list_config_vars
Dumps decrypted application environment variables. This is how you check your database tokens or SendGrid passwords.

### restart_specific_dyno
Reboots one isolated dyno instance like a worker. This is great for unsticking a single hung queue worker.

### restart_all_dynos
Hard reboots all containers tied to an entire application. Use this to clear out memory leaks across the whole cluster.

### toggle_maintenance_mode
Switches an application's maintenance mode on or off. This is vital for blocking requests during database migrations.

### create_app
Provisions a fresh structural app container on Heroku. Use this to start a new deployment boundary quickly.

## Prompt Examples

**Prompt:** 
```
Which of my Heroku apps are currently running in the US?
```

**Response:** 
```
I've checked your Heroku apps. Here are the ones currently hosted in US datacenters:

| App Name | Region | Status |
| :--- | :--- | :--- |
| production-api | US | Up |
| staging-web | US | Up |

Your 'worker-service' is currently hosted in the EU region.
```

**Prompt:** 
```
I need to run a migration on the production-api. Can you put it in maintenance mode?
```

**Response:** 
```
I've toggled the maintenance mode for **production-api** to **ON**. All inbound requests will now be blocked while you perform your migration. Let me know when you're finished and want me to turn it off.
```

**Prompt:** 
```
Is there a problem with the worker dynos?
```

**Response:** 
```
I checked the dynos for your applications. Most are healthy, but I found one issue:

* **worker-service**: 1 dyno is currently in a **crashed** state.

Would you like me to restart that specific dyno for you?
```

## Capabilities

### List all active applications
See your full fleet of Heroku apps at once.

### Reboot specific dynos
Restart a single hung worker without touching the rest of the traffic.

### Audit environment variables
Retrieve decrypted config vars like database tokens or API keys.

### Toggle maintenance mode
Switch your app to maintenance mode during migrations instantly.

### Check dyno health
Get real-time status on whether containers are up, crashed, or idle.

### Provision new apps
Create fresh app containers on the Heroku platform via chat.

## Use Cases

### Fixing a hung worker
A worker is stuck in a loop. Ask the agent to use restart_specific_dyno to reboot worker.2 without affecting the web frontend.

### Running a database migration
Tell the agent to toggle_maintenance_mode so users don't see errors while the database is updating.

### Verifying add-on status
Ask the agent to list_addons for the production-api to confirm the Redis connection is active.

### Checking regional placement
Use get_app_info to verify current datacenter placement before initiating a regional move.

## Benefits

- Stop manual dashboard navigation by using list_apps to see your entire fleet in one place.
- Fix hung workers faster by using restart_specific_dyno to target only the problematic instance.
- Protect your data during migrations by quickly toggling maintenance mode with a single command.
- Audit your secrets easily by using list_config_vars to see decrypted environment variables.
- Verify your global latency strategy by checking regional datacenter placements with get_app_info.
- Scale your deployment faster by using create_app to provision new containers without manual setup.

## How It Works

The bottom line is you get a natural language interface for your entire Heroku cloud infrastructure.

1. Subscribe to the Heroku (PaaS) MCP on the Vinkius marketplace.
2. Provide your Heroku API Key to authorize the connection.
3. Ask your AI client to list apps or restart dynos to begin managing your infrastructure.

## Frequently Asked Questions

**Can I use the Heroku (PaaS) MCP to restart my workers?**
Yes, you can restart specific dynos or all dynos for an app using natural language. This is perfect for unsticking hung workers without having to log into the Heroku dashboard.

**Does the Heroku (PaaS) MCP allow me to see my secrets?**
Yes, it can retrieve decrypted environment variables like database URLs and API keys. You can ask your agent to list the config vars for any of your hosted apps.

**How do I put my app into maintenance mode using this Connector?**
You can simply ask your agent to toggle the maintenance mode for a specific app. It will instantly block inbound requests, which is helpful during database migrations.

**Can I use the Heroku (PaaS) MCP to see which region my app is in?**
Yes, the Connector can fetch details on regional datacenter placements. You can ask your agent to check the app info to see if your traffic is being routed to the US or EU.

**Is the Heroku (PaaS) MCP safe for production environments?**
Yes, it's designed for production use to manage dynos and app statuses. It follows the same permissions as your Heroku API key to perform actions like restarting containers or checking configs.

**Can I create new apps with the Heroku (PaaS) MCP?**
Yes, you can provision new app containers on Heroku by asking your agent to create a new app. This helps you set up new deployment boundaries quickly.

**Can I see the status of my dynos through my agent?**
Yes. Use the `list_dynos` tool to see the real-time status of each container process (e.g. web.1, worker.1). You'll know exactly if a dyno is up, crashed, starting, or idle.

**How do I check my application's environment variables?**
The `list_config_vars` tool allows your agent to dump the full dictionary of environment variables injected into your dynos, including sensitive keys like DATABASE_URL or API tokens.

**Can my agent restart a specific hung worker without affecting the web traffic?**
Absolutely. Use the `restart_specific_dyno` tool to reboot a single instance (e.g. worker.2). This is perfect for unsticking hung asynchronous queue workers without impacting your primary frontend traffic.