# Pulumi MCP for AI Agents AI Agent Connect

> Pulumi MCP for AI Agents. Manage cloud infrastructure directly through your AI agent. List stacks, track live deployments, audit outputs, and manage tags without leaving your chat interface.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_v2N5nlYKKcBMg7t6tvswP5zOuY1KsfB14QgLHciO/ai-agent-connect
- **Tags:** infrastructure-as-code, cloud-deployment, automation, stack-management, cloud-native, api-integration

## Description

This Pulumi MCP connects your Pulumi account to any AI agent and lets you manage your infrastructure-as-code through natural conversation. Instead of hunting through the Pulumi Console or juggling dozens of CLI commands, you can just ask your agent to do the heavy lifting. It handles the tedious stuff like finding specific resource IDs, checking the status of a failed deployment, or listing all active stacks across your organization. When you connect this Connector through the Vinkius catalog, your AI becomes a dedicated infrastructure operations engineer that stays on top of your environment. You can quickly grab exported URLs, verify member settings, or audit who triggered a specific change. It's about moving from manual clicking to direct action. You get a clear picture of your cloud footprint without the context switching.

## Tools

### create_stack
Create a new, isolated instance of your Pulumi program with a unique name. This makes it easy to spin up new environments.

### delete_stack
Remove a Pulumi stack that is empty or has force deletion turned on. This is a permanent action for cleaning up your environment.

### get_stack_outputs
List the exported values like URLs and IDs from a stack's latest deployment. This is great for finding endpoints.

### list_stack_tags
Display all the key-value metadata tags currently applied to a stack. This helps you see how resources are categorized.

### list_stacks
List every stack in an organization with resource counts and update statuses. Use this to get a high level overview of your infrastructure.

### set_stack_tag
Add or update a specific metadata tag on a Pulumi stack. This helps you manage cost centers and team labels.

### get_current_user
Show the name, email, and GitHub login of the currently authenticated user. Use this to verify your connection is working.

### get_deployment
Pull specific details for a single deployment version in a stack. This helps you audit specific changes.

### get_organization
Retrieve the settings and member info for a specific Pulumi organization. Use this to check team permissions.

### get_stack
Provide the core details and current status for a specific Pulumi stack. Use this to see if an environment is healthy.

### list_deployments
Show the history of all deployments including status, changes, and the triggering user. This is perfect for auditing infrastructure history.

## Prompt Examples

**Prompt:** 
```
Show me all the stacks in my organization.
```

**Response:** 
```
I found 6 stacks in your organization: 

| Stack Name | Last Updated | Resource Count | Status |
| :--- | :--- | :--- | :--- |
| `my-infra/dev` | 2h ago | 24 | Active |
| `my-infra/staging` | yesterday | 24 | Active |
| `my-infra/prod` | 3 days ago | 24 | Active |
| `networking/prod` | last week | 8 | Active |
| `database/dev` | - | 0 | Created |
| `database/prod` | - | 0 | Created |
```

**Prompt:** 
```
What was the result of the latest deployment to my-infra/prod?
```

**Response:** 
```
The latest deployment (v12) to **my-infra/prod** succeeded 3 days ago.

**Summary of changes:**
*   **Created:** 2 resources (new S3 bucket and CloudFront distribution)
*   **Updated:** 1 resource (EC2 instance type changed)
*   **Unchanged:** 21 resources

The deployment took 4 minutes and was triggered by user **alice**.
```

**Prompt:** 
```
Show me the exported outputs from the prod stack.
```

**Response:** 
```
The **prod** stack exports the following outputs:

*   `api_url`: https://api.example.com
*   `cdn_url`: https://cdn.example.com
*   `db_endpoint`: postgres://db.example.com:5432
*   `s3_bucket_arn`: arn:aws:s3:::my-prod-bucket
*   `vpc_id`: vpc-0abc123

Would you like details on any of these?
```

## Capabilities

### List infrastructure stacks
See every stack in your organization with resource counts and update statuses in one view.

### Create new environments
Spin up new, isolated instances of your Pulumi program instantly.

### Delete empty stacks
Remove stacks that no longer have resources or have force deletion enabled.

### View deployment history
Track who triggered a change and see the status of every past deployment.

### Extract exported outputs
Pull URLs, IP addresses, and other resource IDs directly from your stacks.

### Manage resource tags
Apply and update metadata labels like cost centers or team names across your stacks.

### Verify account identity
Check the name and email of the currently authenticated user to confirm your connection.

## Use Cases

### Incident Response
A deployment fails and the engineer asks the agent to list_deployments to see the error logs and the user who triggered it.

### Resource Discovery
A developer needs a database endpoint and asks the agent to get_stack_outputs for the production stack.

### Organization Auditing
A platform lead asks the agent to list_stacks and list_stack_tags to ensure all teams are using the correct cost center labels.

### Environment Cleanup
An engineer asks the agent to delete_stack for a decommissioned project that no longer needs to exist.

## Benefits

- Get instant visibility into your cloud footprint by using list_stacks to see all environments in one glance.
- Stop hunting for production URLs by using get_stack_outputs to pull exported values directly into your chat.
- Audit your infrastructure history faster with list_deployments to see who changed what and when.
- Organize your resources better by using set_stack_tag to apply cost centers and team labels.
- Speed up environment setup by using create_stack to spin up new isolated instances on command.
- Verify your connection instantly with get_current_user to ensure your agent has the right permissions.

## How It Works

The bottom line is you get an AI-powered interface for your entire Pulumi infrastructure.

1. Subscribe to the Pulumi MCP on Vinkius.
2. Enter your Pulumi Access Token in the configuration.
3. Start asking your AI client to manage your stacks and deployments.

## Frequently Asked Questions

**What can I do with the Pulumi MCP?**
You can use your AI agent to manage your cloud infrastructure directly. This includes listing stacks, creating new environments, checking deployment histories, and pulling exported resource values like URLs and IP addresses.

**How do I use Pulumi MCP to check my cloud status?**
You can simply ask your AI agent to check the status of a specific stack or list all your stacks. It will pull the latest data from Pulumi and summarize the resource counts and update statuses for you.

**Can the Pulumi MCP help with infrastructure tagging?**
Yes, it allows you to set and list metadata tags on your stacks. You can use your AI agent to apply labels like cost centers or team names to keep your infrastructure organized.

**How does Pulumi MCP handle deployment history?**
The Connector can retrieve a list of all past deployments for a stack. It shows you the version number, success status, the time it happened, and which user triggered the change.

**Can I use Pulumi MCP to find my production endpoints?**
Exactly. You can ask your agent to fetch the exported outputs from your production stack, and it will provide you with the specific URLs, IDs, and connection strings you need.

**Is the Pulumi MCP safe for managing my stacks?**
It uses your Pulumi Access Token to perform actions. You have full control over what the AI does, and you can verify your identity and permissions before running any commands.

**How do I get a Pulumi Access Token?**
Log in to the [**Pulumi Console**](https://app.pulumi.com), go to **Account Settings > Access Tokens**, click **Create Token**, give it a name and copy the token immediately — it starts with `pul_` and won't be shown again.

**What is a Pulumi stack?**
A stack is an isolated, independently configurable instance of your Pulumi program. Stacks typically represent different environments like dev, staging and prod. Each stack has its own configuration, state, outputs and deployment history. Use list_stacks to discover all stacks in an organization.

**Can I see the deployment history of a stack?**
Yes! Use `list_deployments` with the org name, project name and stack name. It returns the update history showing version number, status (succeeded, failed, in-progress), start/end time and resource change counts. Use `get_deployment` with a specific version for detailed logs and error messages.

**Can I view the outputs of a stack?**
Yes! Use `get_stack_outputs` with the org name, project name and stack name. It returns all exported output values from the latest successful deployment, such as URLs, IP addresses, resource IDs and connection strings. This is useful for discovering endpoint addresses after infrastructure deployment.