# Cloudify MCP for AI Agents AI Agent Connect

> Cloudify MCP lets you manage multi-cloud infrastructure blueprints and deployments using natural language. It connects your Cloudify Manager to your AI client so you can audit nodes, track workflow executions, and manage TOSCA blueprints without jumping between tabs.

## Overview
- **Category:** cloud-infrastructure
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_YIdeRn0hAqBloQdQ3tH0JMinN2MrEDBkMrsxMQwv/ai-agent-connect
- **Tags:** multi-cloud, orchestration, tosca, workflow-automation, infrastructure-management, deployment-tracking

## Description

You're tired of digging through the Cloudify Manager UI to find out why a deployment stalled or which nodes are actually active. This Connector changes that by putting your infrastructure data directly into your AI agent's hands. Instead of manually searching for specific execution IDs or drilling down into nested properties, you can just ask your agent to summarize the current state of your multi-cloud environment. It handles the heavy lifting of parsing complex schemas and finding the exact structural matches you need for your runtime. It's a lot easier to maintain consistency when you can audit your blueprints and plugins through a simple conversation. By connecting this to the Vinkius catalog, you get a direct line into your orchestration layer, making it way faster to spot failed transactions or verify that your latest infrastructure changes actually landed. You stop hunting for data and start actually managing your cloud.

## Tools

### list_deployments
See the exact structural matching for your actualized runtime schemas. It's the quickest way to verify that your deployments are running as intended.

### get_deployment
Get the internal structural states and precise execution topologies for a specific deployment. This reveals the underlying layout of your live infrastructure.

### list_nodes
See the literal limits and specific instances routing your orchestration rules. This lets you pinpoint exactly where a node sits in the hierarchy.

### list_plugins
See the explicit capabilities and native orchestration limits for your installed plugins. It helps you audit what your current integrations can actually do.

### list_blueprints
View all the bounded logical arrays that manage your top-level orchestration schemas. This helps you see every blueprint available in your manager at a glance.

### get_blueprint
Pull the specific properties that drive your active blueprint schemas. You can use this to see the exact rules governing a specific piece of infrastructure.

### list_executions
Find the active cluster limits across your deployment workflow bounds. Use this to track the progress and limits of ongoing tasks.

## Prompt Examples

**Prompt:** 
```
Show me all the blueprints in my manager.
```

**Response:** 
```
I've retrieved the blueprints from your Cloudify Manager. Here they are:

| Blueprint Name | Status | Type |
| :--- | :--- | :--- |
| **aws-three-tier** | Active | Production |
| **gcp-k8s-cluster** | Active | Development |
| **hybrid-db-template** | Pending | Staging |

Which one would you like to inspect?
```

**Prompt:** 
```
What's the status of the web-app-prod deployment?
```

**Response:** 
```
Checking the status for **web-app-prod**...

*   **Current State:** Active
*   **Last Execution:** `install` (Success)
*   **Recent Activity:** A `heal` execution was triggered automatically yesterday.
*   **Runtime Topology:** The deployment is currently utilizing 3 primary nodes across two regions.
```

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

**Response:** 
```
I'm analyzing the nodes for the **db-cluster** deployment. I found 3 nodes in the `started` state:

*   **primary-node-1**
*   **replica-node-1**
*   **load-balancer-internal**

All instances are currently reporting as healthy.
```

## Capabilities

### Audit TOSCA blueprints
Use list_blueprints to see all the bounded logical arrays managing your top-level orchestration schemas.

### Extract blueprint properties
Use get_blueprint to perform structural extraction of properties driving active schemas.

### Verify runtime schemas
Use list_deployments to retrieve the exact structural matching of actualized runtime schemas.

### Pull execution topologies
Use get_deployment to extract explicitly attached internal structural states and execution topologies.

### Check cluster limits
Use list_executions to identify precise active cluster limits spanning deployment workflow bounds.

### Identify routing instances
Use list_nodes to identify exact literal limits pushing specific instances and routing rules.

### Map orchestration capabilities
Use list_plugins to extract explicit capabilities mapping native orchestration limits.

## Use Cases

### Debugging a stalled deployment
An engineer asks the agent to check the web-app-prod deployment. The agent uses list_deployments to find the status and list_executions to pinpoint the failed task.

### Auditing cloud integrations
A platform architect asks what plugins are active for AWS. The agent uses list_plugins to show all native orchestration capabilities and limits.

### Verifying node hierarchy
An SRE needs to see which nodes are in the started state for a database cluster. The agent uses list_nodes to show the exact instances and routing rules.

### Schema property extraction
A developer needs to know the rules for a specific blueprint. The agent uses get_blueprint to pull the properties driving that active schema.

## Benefits

- Stop manual UI navigation by using list_blueprints to see your entire orchestration library in one chat.
- Get instant visibility into deployment states with list_deployments instead of refreshing browser pages.
- Quickly identify failed transactions by monitoring workflow limits with list_executions.
- Audit your multi-cloud plugins easily using list_plugins to ensure all integrations are up to date.
- Drill down into nested infrastructure details with list_nodes to find specific instance properties.
- Verify blueprint rules instantly with get_blueprint to ensure your schemas match your requirements.

## How It Works

The bottom line is you get a conversational interface for your entire cloud orchestration layer.

1. Subscribe to the Cloudify MCP on Vinkius.
2. Enter your Cloudify Manager URL and API Token in your AI client settings.
3. Ask your agent to list deployments, check node statuses, or audit your blueprints.

## Frequently Asked Questions

**Can I use Cloudify MCP to see my multi-cloud blueprints?**
Yes, you can use this Connector to list and audit all the blueprints in your Cloudify Manager. It lets your agent show you the top-level orchestration schemas you have available without you having to log into the dashboard.

**How does Cloudify MCP help with deployment tracking?**
It provides a direct way to see the actual runtime schemas of your deployments. You can ask your agent to pull specific execution topologies to see exactly how your infrastructure is laid out.

**Can I audit my plugins with Cloudify MCP?**
Yes, you can use the list_plugins tool to see all the native orchestration limits and capabilities for your installed Python abstractions across AWS, GCP, and other providers.

**Can I check node states using Cloudify MCP?**
Absolutely. You can ask your agent to identify specific instances and routing rules. It helps you pinpoint exactly which nodes are active or in a specific state like 'started'.

**Does Cloudify MCP work with my existing Cloudify Manager?**
Yes, it connects directly to your existing Cloudify Manager. You just need to provide your Manager URL and your API Token to get started.

**Can I see failed workflow executions with Cloudify MCP?**
Yes, you can identify active cluster limits and monitor workflow bounds. This makes it much faster to see which part of an install or heal transaction failed.

**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.