The Coolify MCP Server enables comprehensive programmatic management and automation of Coolify instances through the Coolify API, providing control over infrastructure and application lifecycle operations.
System Health & Monitoring: Check Coolify version information, API health status, retrieve application logs, and monitor deployment status and history
Team Management: List teams, get team details, view members, and access current authenticated team context
Project & Environment Organization: Create and list projects to organize resources; create and list environments within projects for different deployment stages (production, staging, development)
Server Infrastructure: Create servers with SSH configuration, list and validate servers, monitor server resources and connectivity, view deployed applications, and manage server domains and proxy settings (Nginx/Caddy)
Application Lifecycle Management: Create applications from Git repositories, start/stop/restart applications, execute commands in running containers, configure exposed ports for external access, and retrieve logs for troubleshooting
Service Management: Create services (MySQL, Redis, PostgreSQL, MongoDB, or custom Docker Compose), start/stop/restart services, list all services, and deploy with custom Docker Compose configurations
Deployment Operations: List all deployments, get detailed deployment information, and track deployment history
Security & Access: Create and manage SSH private keys for server authentication and Git repository access
Enhanced Features: Improved error reporting, UUID format compatibility, and automatic version detection for Coolify 4.0.0-beta.380+
Allows creating and managing ClickHouse databases in Coolify.
Allows deploying applications using Dockerfiles, Docker images, or Docker Compose configurations.
Allows integrating GitHub repositories and managing GitHub Apps for automatic deployments.
Allows provisioning and managing Hetzner cloud servers, including creating servers with various configurations.
Allows creating and managing MariaDB databases in Coolify.
Allows creating and managing MongoDB databases in Coolify.
Allows creating and managing MySQL databases in Coolify.
Allows creating and managing PostgreSQL databases in Coolify.
Allows creating and managing Redis databases in Coolify.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Coolify MCP Server list my projects and show their current environments"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server providing full coverage of the Coolify v4.3.1 REST API. Manage applications, databases, services, servers, deployments, and more — all from any MCP-compatible AI client.
Compatibility: Coolify v4.x. API base:
https://<your-coolify-instance>/api/v1
Coolify v4.2.0 made state-changing endpoints POST-only; the former GET routes now
return This endpoint has changed to a POST request. This server issues POST for
all of them. Lifecycle and deploy operations remain compatible with earlier v4.x
releases, which accepted both methods. Three tools — enable_api, disable_api
and validate_server — call endpoints that were GET-only before v4.2.0 and so
require Coolify v4.2.0 or newer.
Node.js 18 or higher
A running Coolify v4 instance (v4.2.0+ for the three tools noted above)
A Coolify API token (from Security → API Tokens in the dashboard)
Related MCP server: Enhanced Coolify MCP Server
# Install globally
npm install -g coolify-mcp-server
# Or use with npx (no install needed)
npx coolify-mcp-serverSet two environment variables:
Variable | Description |
| Base URL of your Coolify instance (e.g. |
| Your Coolify API Bearer token |
{
"mcpServers": {
"coolify": {
"command": "npx",
"args": ["-y", "coolify-mcp-server"],
"env": {
"COOLIFY_BASE_URL": "https://your-coolify-instance",
"COOLIFY_TOKEN": "your-api-token"
}
}
}
}Windows users (Cline/cmd):
{
"mcpServers": {
"coolify": {
"command": "cmd",
"args": ["/c", "npx", "-y", "coolify-mcp-server"],
"env": {
"COOLIFY_BASE_URL": "https://your-coolify-instance",
"COOLIFY_TOKEN": "your-api-token"
}
}
}
}get_version — Get Coolify version
health_check — API health check (no auth)
enable_api / disable_api — Enable/disable the API (root token)
enable_mcp / disable_mcp — Enable/disable built-in MCP endpoint (root token)
list_teams, get_team, get_team_members
get_current_team, get_current_team_members
list_servers, get_server, create_server, update_server, delete_server
validate_server, get_server_resources, get_server_domains
create_hetzner_server
list_projects, get_project, create_project, update_project, delete_project
list_environments, get_environment, create_environment, delete_environment
list_applications, get_application
create_public_application, create_private_github_app_application, create_private_deploy_key_application
create_dockerfile_application, create_dockerimage_application
update_application, delete_application
start_application, stop_application, restart_application
get_application_logs
list_application_envs, create_application_env, update_application_env, bulk_update_application_envs, delete_application_env
list_application_storages, create_application_storage, delete_application_storage
list_application_scheduled_tasks, create_application_scheduled_task, delete_application_scheduled_task
To create a resource from a raw Docker Compose file, use
create_servicewithdocker_compose_raw. Coolify has no application-level compose creation endpoint.
list_databases, get_database, update_database, delete_database
create_postgresql_database, create_mysql_database, create_mariadb_database, create_mongodb_database
create_redis_database, create_keydb_database, create_dragonfly_database, create_clickhouse_database
start_database, stop_database, restart_database
get_database_backups, create_database_backup, list_database_backup_executions
list_database_envs, create_database_env, delete_database_env
list_services, get_service, create_service, update_service, delete_service
start_service, stop_service, restart_service
list_service_envs, create_service_env, delete_service_env
list_service_scheduled_tasks, create_service_scheduled_task, delete_service_scheduled_task
list_deployments, get_deployment, cancel_deployment
list_deployments_by_application, deploy_by_tag_or_uuid
list_private_keys, get_private_key, create_private_key, update_private_key, delete_private_key
list_github_apps, create_github_app, delete_github_app, list_github_app_repositories
list_cloud_tokens, create_cloud_token, delete_cloud_token
get_hetzner_locations, get_hetzner_server_types, get_hetzner_images, get_hetzner_ssh_keys
create_hetzner_server
list_resources — All resources across the instance
MIT
Create a new application in Coolify. Applications are deployable units that can be sourced from Git repositories.
Inputs: destination_uuid (required), environment_name (required), project_uuid (required), environment_uuid, +2 more.
Create a new environment within a project.
Inputs: name (required), project_uuid (required), description.
Create a new SSH private key in Coolify for server authentication or Git repository access.
Inputs: name (required), private_key (required), description.
Create a new project to organize applications and services.
Inputs: name (required), description.
Create a new server in Coolify. Requires SSH access details and a private key for authentication.
Inputs: ip (required), name (required), port (required), private_key_uuid (required), +5 more.
Create a new service on a specified server. Services are containerized applications that run on your Coolify servers. Either "type" or "docker_compose_raw" must be provided - you cannot specify both.
Inputs: name (required), project_uuid (required), server_uuid (required), description, +4 more.
Execute a command inside a running application container. Useful for debugging, maintenance, or running one-off tasks. Note: This endpoint may not be available in all Coolify versions.
Inputs: command (required), uuid (required).
Get application logs by UUID. Essential for debugging and monitoring application behavior, errors, and performance issues. Retrieve logs from running applications to troubleshoot deployment issues and monitor application health.
Inputs: uuid (required), lines.
Get details of the currently authenticated team. This is the team associated with your API token.
Inputs: no named parameters.
Get a list of all members in the currently authenticated team. Shows who has access to team resources.
Inputs: no named parameters.
Get detailed information about a specific deployment. Use this to monitor deployment status and troubleshoot issues.
Inputs: uuid (required).
Get details of a specific project including its environments.
Inputs: project_uuid (required).
Get a list of domains configured for a server. These domains are used for routing traffic to applications and services.
Inputs: uuid (required).
Get a list of applications and services running on a server. This provides an overview of all resources deployed on the specified server.
Inputs: uuid (required).
Get details of a specific team. Requires a team ID obtained from list_teams.
Inputs: team_id (required).
Get Coolify version information. Returns the current version of the Coolify instance.
Inputs: no named parameters.
Check Coolify API health status. Note: This endpoint may not be available in all Coolify versions.
Inputs: no named parameters.
List all applications across your Coolify instance. Applications are deployable units sourced from Git repositories.
Inputs: no named parameters.
List all deployments across your Coolify instance. Deployments represent the history of application and service deployments.
Inputs: no named parameters.
List all environments in a project. Environments separate different deployment stages like production, staging, development.
Inputs: project_uuid (required).
List all SSH private keys stored in Coolify. These keys are used for server authentication and Git repository access.
Inputs: no named parameters.
List all projects accessible by the current user. Projects organize applications and services into logical groups.
Inputs: no named parameters.
List all servers registered in your Coolify instance. Use this to get server UUIDs needed for other operations.
Inputs: no named parameters.
List all services across your Coolify instance. Services are containerized applications running on your servers.
Inputs: no named parameters.
List all teams the authenticated user has access to. Use this to get team UUIDs needed for other operations.
Inputs: no named parameters.
Restart an application by stopping and starting it again. Useful for applying configuration changes or recovering from issues.
Inputs: uuid (required).
Restart a service by stopping and starting it again. Useful for applying configuration changes or recovering from issues.
Inputs: uuid (required).
Start a previously created application. This will initialize the application container and make it accessible.
Inputs: uuid (required).
Start a previously created service. This will initialize the service container and make it accessible.
Inputs: uuid (required).
Stop a running application. This will gracefully shut down the application container.
Inputs: uuid (required).
Stop a running service. This will gracefully shut down the service container.
Inputs: uuid (required).
Validate a server's configuration and connectivity. Use this to verify server setup and troubleshoot connection issues.
Inputs: uuid (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 32 tools
Most tools have distinct purposes targeting specific resources (applications, services, servers, projects, teams) and actions (create, get, list, restart, start, stop), with clear boundaries. However, some overlap exists between application and service tools (e.g., restart_application vs restart_service) that could cause confusion if the distinction between 'applications' and 'services' isn't fully understood, though descriptions help clarify.
Tool names follow a highly consistent verb_noun pattern throughout, such as create_application, list_servers, get_project, restart_service, and stop_application. All tools use snake_case without deviations, making them predictable and easy to parse for agents.
With 32 tools, the count is borderline high for a deployment management server, potentially feeling heavy and overwhelming. While it covers many operations, it might include redundant or overly granular tools that could be consolidated, such as separate start/stop/restart for applications and services.
The tool set provides comprehensive CRUD and lifecycle coverage for the Coolify domain, including creation, listing, retrieval, management (start/stop/restart), logging, deployment tracking, and validation. No obvious gaps exist; it supports full workflows from server setup to application deployment and monitoring.
Devopness MCP server for DevOps happiness! Empower AI Agents to deploy apps and infra, to any cloud.
A MCP server built for developers enabling Git based project management with project and personal…
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
