# Coolify MCP for AI Agents MCP

> Coolify lets you manage your self-hosted private cloud and container deployments using natural conversation. From checking server health to triggering complex build pipelines for PostgreSQL, MySQL, or Redis, you control every aspect of your infrastructure directly from any AI agent.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Tags:** self-hosting, docker, server-monitoring, deployment-automation, infrastructure-as-code, container-management

## Description

Running a private cloud means juggling multiple dashboards: one for networking status, another for application metrics, and yet a third just for database credentials. This MCP lets you bypass the clicking entirely. You connect your Coolify instance to Vinkius and give your AI client full read/write access to your self-hosted environment.

Instead of manually SSHing into nodes or navigating through deployment menus, you talk to your agent. Need to know if a server node has active Docker Swarm status? Just ask. Want to spin up a container that's currently suspended? Tell it to do so. You can manage the entire application lifecycle—starting, stopping, and restarting services—and even initiate full build pipelines for Nixpacks images or pull the latest Git commits. For databases like PostgreSQL and Redis, you instantly get the connection strings needed to link your backend apps. It’s total infrastructure control, conversational style.

## Tools

### get_application
Fetches internal topology metrics for a specific application, showing its mapped GitHub branches and proxy paths.

### get_database
Retrieves the necessary configuration arrays to link newly provisioned web apps to their backend databases.

### get_server
Verifies a specific server node's IP properties, SSH connection status, and active Docker ports across the cluster.

### list_applications
Generates a map of all managed applications by listing their project repositories and UUIDs needed for mutations.

### list_databases
Lists all configured database types, including PostgreSQL, MySQL, and Redis, along with their connection details.

### list_servers
Identifies the raw physical endpoints running Docker swarms that host subsequent applications.

### restart_application
Bounces an application container, ensuring updated environment variables take effect immediately in runtime memory.

### start_application
Restores service by spinning up containers mapped to a previously suspended UUID.

### stop_application
Halts an application's execution, useful for pausing services or restricting web access during maintenance.

### trigger_deployment
Performs a full build pipeline, fetching the latest Git commit and rolling out the updated Docker image over the active version.

## Prompt Examples

**Prompt:** 
```
List all my active servers and tell me which ones are running Swarm mode.
```

**Response:** 
```
**Server Cluster Status**

We have 3 nodes reporting:

*   `main-prod-node`: Active (Swarm Ready) | IP: 192.168.1.5
*   `staging-backup-node`: Idle (Not Swarm Ready) | IP: 10.0.0.7
*   `dev-sandbox-node`: Active (Swarm Ready) | IP: 192.168.1.12

The `main-prod-node` and `dev-sandbox-node` are ready for container orchestration.
```

**Prompt:** 
```
I need the connection string for our main user database.
```

**Response:** 
```
**Database Connection Details**

Found 3 managed data sources:

1.  **PostgreSQL (User DB):** `postgres://user:***@coolify-db-abc:5432/user_db`
2.  **MySQL (Analytics):** `mysql://admin:***@coolify-db-xyz:3306/analytics`
3.  **Redis Cache:** `redis://localhost:6379`
Please remember these URIs are only valid within your internal network.
```

**Prompt:** 
```
Can you check the status of the 'auth' app and restart it if needed?
```

**Response:** 
```
**Application Status Check**

*   **App Name:** Auth Service
*   **Status:** Currently Suspended (Stopped)
*   **Last Update:** 2026-06-10

I've restarted the container for 'Auth Service.' The new state is **Running**. I recommend running a quick health check now to confirm everything settled properly.
```

## Capabilities

### Inventory Server Nodes
Lists all self-hosted nodes and retrieves detailed networking parameters, including IP properties and Docker Swarm status.

### Monitor Application Topology
Retrieves internal metrics for any application, mapping GitHub branches, Traefik proxy paths, and rollout toggles.

### Control Application Lifecycle
Allows you to start, stop, or restart applications by recycling container states instantly.

### Automate Deployments
Triggers raw build pipelines that fetch the latest commits, rebuild Nixpacks images, and roll out updated Docker versions.

### Manage Database Credentials
Lists managed PostgreSQL, MySQL, and Redis configurations and extracts internal connection strings for linking applications to data sources.

## Use Cases

### A new feature requires a backend database link.
The dev asks their agent: 'What's the connection string for our user DB?' The agent runs `list_databases` and returns the internal URI, allowing the developer to immediately update the environment variables without accessing any admin panel.

### A critical server node appears offline.
The ops engineer asks: 'Check the status of the main node.' The agent runs `get_server` and returns IP properties and SSH validation statuses, immediately telling the engineer if the issue is network-related or container-related.

### A code push needs to go live, but we need a full rebuild.
The founder tells their agent: 'Deploy the latest commit for the API.' The agent executes `trigger_deployment`, pulling the newest Git commits and rolling out the updated Docker image instantly.

### We need to test an application's functionality without running it 24/7.
The developer asks: 'Can you temporarily disable the frontend?' The agent runs `stop_application`, suspending the service and preventing web perimeter ingress until testing is complete.

## Benefits

- Get instant status checks on server health. Instead of logging into the dashboard, you ask your agent to run `get_server` and get confirmation that all Docker Swarm services are running fine.
- Automate complex deployment cycles like a human doing it with SSH keys. Triggering raw builds via `trigger_deployment` pulls the latest Git commit and rolls out updated containers without manual steps.
- Never lose track of credentials again. Using `list_databases` instantly provides connection strings for PostgreSQL, MySQL, and Redis so your developer doesn't have to copy-paste from a settings page.
- Control the application state on demand. Need to pause billing or test something? Use `stop_application` to suspend services, then use `start_application` when you’re ready to go.
- Simplify development auditing. You can retrieve connection strings using `get_database` and track which repositories are associated with specific applications via `list_applications`.

## How It Works

The bottom line is you get to use natural language conversation to perform complex infrastructure tasks that normally require multiple logins and manual console work.

1. Subscribe to this MCP on Vinkius.
2. Enter your Coolify Instance URL and API Token (you find this in the Keys & Tokens section of your Coolify dashboard).
3. Use your preferred AI client—whether it's Claude, Cursor, or something else compatible—to issue commands like 'list all servers' or 'restart application X'.

## Frequently Asked Questions

**How does Coolify MCP help me manage my self-hosted containers?**
This MCP lets you control your entire private cloud through conversation. You can start, stop, or restart applications and monitor the health of every server node without ever logging into a dashboard.

**Can I get database credentials using Coolify MCP for AI Agents?**
Yes, you can list all your managed databases (PostgreSQL, MySQL, etc.) and retrieve their internal connection strings instantly. This is vital for linking new backend services.

**What if I need to deploy a massive code update?**
You don't have to do it manually. The MCP triggers the full deployment pipeline, which fetches the latest Git commits and rolls out updated Docker images across your cluster automatically.

**Does Coolify MCP help with server monitoring?**
Absolutely. You can list all attached servers to verify their IP properties and check the live status of the underlying Docker Swarm configuration, ensuring maximum uptime.

**Is this better than using a dashboard for daily tasks?**
It is much faster. Instead of navigating multiple tabs and clicking through menus, you ask your agent to perform complex multi-step actions—like checking server health *and* restarting an app—all in one chat session.