# Cloudify MCP MCP

> Cloudify MCP lets your AI agent manage multi-cloud infrastructure directly from natural conversation. You can audit complex blueprints, track live deployment states across AWS and GCP, monitor workflow executions in real time, and inspect deeply nested nodes without logging into the manager UI.

## Overview
- **Category:** cloud-infrastructure
- **Price:** Free
- **Tags:** multi-cloud, orchestration, tosca, workflow-automation, infrastructure-management, deployment-tracking

## Description

This connector gives you full control over complex cloud deployments via Cloudify Manager. Instead of navigating deep menus or running CLI commands for every state check, your agent handles it all conversationally. You can list available blueprints to find a specific template, track whether a deployment is finished by pulling its runtime schema, and monitor the live status of any installation or healing workflow. It also lets you inspect individual infrastructure nodes, checking properties like 'started' or 'deleted', and audit which cloud plugins are installed for AWS or GCP. Connecting this MCP through Vinkius makes it available to your AI agent alongside thousands of other services, keeping all your operational tools in one place.

## Tools

### list_blueprints
Identifies logical arrays containing all top-level orchestration schemas available in the system.

### get_blueprint
Extracts the structural properties that define active blueprint schemas for analysis.

### list_deployments
Retrieves a structural match verifying all actualized runtime schemas currently deployed.

### get_deployment
Pulls explicit internal structural states to get a precise topology of an execution.

### list_executions
Identifies precise, active cluster limits that define the boundaries of deployment workflows.

### list_nodes
Finds exact literal limits representing specific instances within the orchestration ruleset.

### list_plugins
Extracts a list of explicit capabilities mapping for native cloud integrations like AWS and GCP.

## Prompt Examples

**Prompt:** 
```
List all blueprints in Cloudify Manager
```

**Response:** 
```
I found 5 blueprints. The active ones are: 'aws-three-tier', 'gcp-k8s-cluster', and 'hybrid-db-template'. Which one would you like to inspect?
```

**Prompt:** 
```
Show me the execution history for deployment 'web-app-prod'
```

**Response:** 
```
Retrieving executions for 'web-app-prod'... The last workflow was 'install' which finished successfully. There is a 'heal' execution from yesterday that was triggered automatically.
```

**Prompt:** 
```
What nodes are currently in the 'started' state for deployment 'db-cluster'?
```

**Response:** 
```
Analyzing nodes for 'db-cluster'... I found 3 nodes in 'started' state: 'primary-node-1', 'replica-node-1', and 'load-balancer-internal'. All instances are healthy.
```

## Capabilities

### Audit Infrastructure Blueprints
Retrieve and list the structural properties that drive your multi-cloud orchestration templates.

### Check Deployment Status
Pull precise execution topologies to verify the current state of a live deployment.

### Monitor Workflow Events
View real-time records of installation, uninstallation, and healing transactions across environments.

### Inspect Cloud Nodes
Resolve deeply nested infrastructure elements and audit their specific lifecycle properties (created, deleted, etc.).

### Catalog Installed Plugins
Discover which Python abstractions are currently mapped for AWS, GCP, or other cloud services.

## Use Cases

### Post-incident root cause analysis
The SRE team needs to know why the 'web-app' deployment failed yesterday. They ask their agent to run `list_executions` for that service. The agent finds a recent 'heal' transaction, proving the failure was transient and fixed automatically.

### Pre-deployment schema validation
A Platform Architect is setting up a new hybrid database template. They run `list_blueprints` to confirm the base template exists, then use `get_blueprint` to pull its structural properties before committing code.

### Inventorying cloud capabilities
A developer joining the team needs to know what services are connected. They ask their agent to run `list_plugins`, getting a list of all available Python abstractions for GCP and AWS in seconds.

### Troubleshooting resource visibility
The DevOps engineer sees an error but doesn't know which specific node is broken. They use `list_nodes` to get the exact name and status of all instances related to the failing service, pinpointing the issue immediately.

## Benefits

- Instantly audit your templates. Instead of manually listing blueprints, use `list_blueprints` to get a quick overview of every top-level schema you're running.
- Track live changes without clicking through tabs. You can monitor installation or healing transactions by calling `list_executions`, getting real-time event logs immediately.
- Deep dive into infrastructure elements. Need to know if a specific resource started, failed, or was deleted? Use `list_nodes` to audit its precise lifecycle properties.
- Verify deployed state quickly. Don't trust the dashboard; run `list_deployments` to pull the exact structural match and confirm your runtime schemas are correct.
- Understand cloud connectivity. You can use `list_plugins` to see which AWS or GCP abstractions are configured, making auditing multi-cloud setups simple.

## How It Works

The bottom line is you get operational visibility into your entire multi-cloud stack without ever touching the Cloudify Manager UI.

1. Subscribe to this MCP and provide your Cloudify Manager URL and API Token credentials.
2. Your AI agent uses the connection data to query specific infrastructure components (blueprints, deployments) through natural language prompts.
3. The agent returns structured JSON containing the requested state—whether it's a list of nodes or an execution history.

## Frequently Asked Questions

**How do I check active deployments using list_deployments?**
Run `list_deployments` to retrieve the structural match and verify all actualized runtime schemas. This gives you a definitive, up-to-date view of everything currently deployed.

**What is the difference between list_nodes and get_deployment?**
`list_nodes` identifies specific instances (literal limits) for auditing lifecycle properties. `get_deployment` pulls the broader, explicit structural states for an entire execution topology.

**Can I audit my cloud plugins using list_plugins?**
Yes. Use `list_plugins` to extract a map of all installed Python abstractions for various cloud integrations like AWS and GCP.

**Does list_executions show me failed deployments?**
Yes, it identifies precise active cluster limits spanning deployment workflow bounds. This allows you to see the history, including any 'heal' or 'uninstall' events that occurred.

**What specific properties can I extract about a blueprint schema using get_blueprint?**
It pulls the structural definition of your blueprints. You'll get details on the properties that drive active schemas, allowing you to verify the template structure before deploying anything.

**How does running get_deployment provide a deeper view than just list_deployments?**
While list_deployments gives you the names of active deployments, get_deployment extracts the precise internal structural states. This shows the full execution topology for that specific deployment.

**When using list_nodes, what lifecycle properties can I audit?**
list_nodes lets you check the complete lifecycle status of your infrastructure nodes. You can see if a node is started, created, or deleted, helping you track its exact current state.

**What kinds of cloud integrations are available using list_plugins?**
list_plugins finds the installed Python abstractions for various clouds. It confirms which major services, like AWS and GCP, your infrastructure can connect to right out of the box.

**Can my agent list all active cloud deployments?**
Yes. Use the 'list_deployments' tool. Your agent will retrieve the exact structural matching of your actualized runtime schemas, showing you every environment currently managed by Cloudify.

**How do I check the lifecycle state of a specific infrastructure node?**
Provide the deployment ID to your agent and use the 'list_nodes' tool. The agent will resolve deeply nested nodes and identify whether instances are in 'started', 'created', or 'deleted' states.

**Can I monitor pending workflow executions through the agent?**
Absolutely. The 'list_executions' tool surfaces active mapping for install, uninstall, and heal workflows. This allows you to track transactions and deployment events strictly within Cloudify limits.