Coolify MCP Server
The Coolify MCP Server enables AI assistants to fully manage Coolify infrastructure through 64 comprehensive tools covering all API endpoints.
Core Capabilities:
Health & System Monitoring: Check system health and get API version information
Team Management: List, get, and manage teams and their members
Project Management: Create, list, get, delete projects, and manage project environments
Application Lifecycle: Create applications (public, private GitHub, Dockerfile, Docker image), manage state (start/stop/restart), view logs, and handle deployments
Environment Variables: List, create, bulk update, and delete application environment variables with secret handling
Database Management: Create and manage multiple database types (PostgreSQL, MySQL, MongoDB, Redis, MariaDB, etc.) with full lifecycle control
Server Management: Create, list, update, delete, and validate servers, plus manage server domains and resources
Service Management: Create and manage Docker Compose services with complete lifecycle control
Deployment Management: List deployments, get application-specific deployments, and trigger new deployments
Security & Keys: Manage SSH security keys for server authentication and access control
Enables management of Docker applications and containers through Coolify, including creating Dockerfile and Docker image applications, and controlling their deployment lifecycle.
Allows creation and deployment of private GitHub applications through Coolify's platform, enabling automated deployment workflows from GitHub repositories.
Provides tools for creating, managing, and controlling MongoDB databases through Coolify, including database lifecycle operations like start, stop, and restart.
Enables creation and management of MySQL databases through Coolify's platform, with full control over database operations and configuration.
Allows creation, configuration, and management of PostgreSQL databases through Coolify, including database lifecycle management and administrative operations.
Provides tools for creating and managing Redis databases through Coolify's infrastructure, with support for database operations and configuration management.
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 deploy the latest version of my e-commerce app to production"
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.
CoolifyMCP
A comprehensive Model Context Protocol (MCP) server that provides complete access to all Coolify API endpoints. CoolifyMCP enables AI assistants to interact with Coolify for managing applications, databases, servers, deployments, and more.
Built for Coolify - An open-source & self-hostable Heroku / Netlify / Vercel alternative
📖 Table of Contents
Related MCP server: Coolify MCP Tools
✨ Features
🎯 100% API Coverage: Complete implementation of all Coolify API endpoints
🛠️ 18 Consolidated MCP Tools: Streamlined access to Coolify's functionality through MCP protocol
🔒 Type Safety: Built with TypeScript for robust error handling and development experience
🚀 Production Ready: Health checks, proper logging, and monitoring
📦 Modular Architecture: Clean, maintainable codebase with separated concerns
🔧 Comprehensive: Supports all Coolify features including:
👥 Team and Project Management
🚀 Application Lifecycle Management
🗄️ Database Management (PostgreSQL, MySQL, MongoDB, Redis, etc.)
🖥️ Server Management and Validation
🐳 Service Management
📦 Deployment Management
🔐 Environment Variables
🔑 Security Keys Management
🚀 Quick Start
Install in Your AI IDE
CoolifyMCP works with all major AI IDEs that support the Model Context Protocol (MCP). Choose your preferred IDE:
Cursor IDE (Recommended)
Open Cursor and go to Settings → Extensions → MCP
Add this configuration to your
~/.cursor/mcp.json:
{
"mcpServers": {
"coolifymcp": {
"command": "npx",
"args": ["coolifymcp"],
"env": {
"COOLIFY_API_TOKEN": "your_coolify_api_token_here",
"COOLIFY_BASE_URL": "https://your-coolify-instance.com/api/v1"
}
}
}
}Claude Desktop
Open Claude Desktop settings
Add this configuration to your MCP settings:
{
"mcpServers": {
"coolifymcp": {
"command": "npx",
"args": ["coolifymcp"],
"env": {
"COOLIFY_API_TOKEN": "your_coolify_api_token_here",
"COOLIFY_BASE_URL": "https://your-coolify-instance.com/api/v1"
}
}
}
}JetBrains AI Assistant
Open your JetBrains IDE (IntelliJ, WebStorm, etc.)
Go to Settings → Tools → AI Assistant → Model Context Protocol (MCP)
Click "Add" and configure:
Name:
coolifymcpCommand:
npxArguments:
["coolifymcp"]Environment Variables:
COOLIFY_API_TOKEN:your_coolify_api_token_hereCOOLIFY_BASE_URL:https://your-coolify-instance.com/api/v1
Other MCP-Compatible IDEs
LibreChat: Add MCP server configuration in settings
Klavis AI: Configure in your platform's MCP settings
Custom MCP Clients: Use the same configuration format
Local Development
# Clone and install
git clone https://github.com/howieduhzit/coolifymcp.git
cd coolifymcp
npm install
npm run build
# Run with environment variables
COOLIFY_API_TOKEN="your_token_here" COOLIFY_BASE_URL="https://your-coolify-instance.com/api/v1" npm start📋 Prerequisites
Node.js 20+ - Download
npm 9+ or yarn - Package manager
Coolify API token - Get from your Coolify dashboard
Coolify instance URL - Your Coolify instance (default:
https://app.coolify.io/api/v1)
🛠️ Installation
NPM Installation (Recommended)
Install and run with npx (no installation needed):
npx coolifymcpOr install globally:
npm install -g coolifymcp
coolifymcpLocal Development
Clone the repository:
git clone https://github.com/howieduhzit/coolifymcp.git
cd coolifymcpInstall dependencies:
npm installBuild the project:
npm run buildRun with environment variables:
COOLIFY_API_TOKEN="your_token_here" COOLIFY_BASE_URL="https://your-coolify-instance.com/api/v1" npm start⚙️ Configuration
Environment Variables
Variable | Description | Required | Default |
| Your Coolify API token | Yes | - |
| Coolify API base URL | No |
|
| Environment mode | No |
|
| Health check server port | No |
|
MCP Client Configuration
The configuration format is consistent across all MCP-compatible IDEs. Here are the common locations:
Configuration File Locations:
Cursor:
~/.cursor/mcp.jsonClaude Desktop: MCP settings in the app
JetBrains: Settings → Tools → AI Assistant → MCP
LibreChat: Settings → MCP Servers
Custom Clients: Refer to your client's documentation
Standard Configuration:
{
"mcpServers": {
"coolifymcp": {
"command": "npx",
"args": ["coolifymcp"],
"env": {
"COOLIFY_API_TOKEN": "your_token_here",
"COOLIFY_BASE_URL": "https://your-coolify-instance.com/api/v1"
}
}
}
}Environment Variables:
COOLIFY_API_TOKEN(required): Your Coolify API tokenCOOLIFY_BASE_URL(optional): Your Coolify instance URL (defaults tohttps://app.coolify.io/api/v1)
🎯 Available Tools
The Coolify MCP Server provides 18 consolidated tools that cover all Coolify functionality through action-based parameters:
System Management (1 tool)
coolify_system- System health, version, and information managementActions:
health,version,info
Team Management (1 tool)
coolify_teams- Complete team management operationsActions:
list,current,get,members
Project Management (2 tools)
coolify_projects- Project CRUD operationsActions:
list,create,get,update,delete
coolify_project_environments- Project environment managementActions:
list,create,get,delete
Application Management (5 tools)
coolify_applications- Application CRUD operations (all types)Actions:
list,create,update,get,deleteSupports: public, private_github, private_deploy_key, dockerfile, dockerimage, dockercompose
coolify_application_lifecycle- Application lifecycle managementActions:
start,stop,restart
coolify_application_envs- Application environment variablesActions:
list,create,bulk_update,delete
coolify_logs- Application logs retrievalActions:
get
coolify_application_deployments- Application deployment managementActions:
list,get,trigger
Database Management (3 tools)
coolify_databases- Database CRUD operationsActions:
list,create,get,update,delete
coolify_database_lifecycle- Database lifecycle managementActions:
start,stop,restart
coolify_database_types- Specific database type creationActions:
create(PostgreSQL, MySQL, MongoDB, Redis)
Server Management (2 tools)
coolify_servers- Server CRUD operationsActions:
list,create,get,update,delete
coolify_server_management- Server operations and resourcesActions:
validate,domains,resources
Service Management (3 tools)
coolify_services- Service CRUD operationsActions:
list,create,get,update,delete
coolify_service_lifecycle- Service lifecycle managementActions:
start,stop,restart
coolify_service_envs- Service environment variablesActions:
list,create,update,bulk_update,delete
Security Management (1 tool)
coolify_security_keys- Security key managementActions:
list,create,get,update,delete
🏗️ Development
Scripts
npm run build- Build TypeScript to JavaScriptnpm start- Start the production servernpm run dev- Start development server with hot reload
Project Structure
coolify-mcp-server/
├── src/
│ └── index.ts # Main MCP server implementation
├── dist/ # Compiled JavaScript output
├── Dockerfile # Docker configuration
├── docker-compose.yaml # Docker Compose configuration
├── package.json # Dependencies and scripts
├── tsconfig.json # TypeScript configuration
├── config.example.env # Environment variables template
└── README.md # This file🔧 API Coverage
This MCP server provides 100% coverage of the Coolify API with 18 consolidated tools covering all 83+ API endpoints:
✅ System Management (1 tool) - Health, version, and system information
✅ Team Management (1 tool) - Complete team operations
✅ Project Management (2 tools) - Projects and environments
✅ Application Management (5 tools) - All application types and lifecycle
✅ Database Management (3 tools) - All database types and operations
✅ Server Management (2 tools) - Server operations and resources
✅ Service Management (3 tools) - Service operations and lifecycle
✅ Security Management (1 tool) - Security keys and authentication
Key Benefits of Consolidation:
🎯 Reduced Complexity: 18 tools instead of 83+ individual tools
🚀 Better Performance: Fewer tool definitions and cleaner API
🔧 Easier Maintenance: Action-based parameters for better organization
📚 Simplified Documentation: Clear tool categories and actions
🚀 Production Deployment
Health Checks
The server includes a health check endpoint at /health when running in production mode (NODE_ENV=production).
Environment Configuration
For production deployment, ensure:
Set
NODE_ENV=productionProvide valid
COOLIFY_API_TOKENSet correct
COOLIFY_BASE_URLConfigure proper logging
Set up monitoring and alerting
📝 License
MIT License - see LICENSE file for details.
🤝 Contributing
Fork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request
📚 Documentation
README.md - Complete documentation and usage examples
GitHub Repository - Source code and issue tracking
📞 Support
For issues and questions:
📝 Create an issue in the repository
📖 Check the Coolify documentation
💬 Join the Coolify community
🙏 Acknowledgments
This project is built for and powered by Coolify - an amazing open-source platform that makes self-hosting applications incredibly easy. Special thanks to the Coolify team and community for creating such a powerful tool.
🌟 Coolify on GitHub - The main Coolify project
🌐 Coolify Website - Official website and documentation
📚 Coolify Documentation - Complete documentation
💬 Coolify Discord - Community support
📄 License
This project is licensed under the MIT License - see the LICENSE file for details.
Built with ❤️ for the Coolify community
Powered by Coolify - An open-source & self-hostable Heroku / Netlify / Vercel alternative with 45.2k+ stars ⭐
Available Tools
18 toolscoolify_application_deploymentsC
Application deployment management - list, get, and trigger deployments
Inputs: action (required), uuid, deployment_uuid, force_rebuild, +2 more.
coolify_application_envsC
Application environment variables management - list, create, bulk update, and delete environment variables
Inputs: action (required), uuid (required), key, value, +2 more.
coolify_application_lifecycleC
Application lifecycle management - start, stop, and restart applications
Inputs: action (required), uuid (required).
coolify_applicationsC
Application CRUD operations - list, create, update, get, and delete applications of all types
Inputs: action (required), type, uuid, name, +70 more.
coolify_database_lifecycleC
Database lifecycle management - start, stop, and restart databases
Inputs: action (required), uuid (required).
coolify_databasesC
Database CRUD operations - list, create, get, update, and delete databases
Inputs: action (required), uuid, name, description, +6 more.
coolify_database_typesC
Specific database type creation - create PostgreSQL, MySQL, MongoDB, and Redis databases with type-specific parameters
Inputs: action (required), type (required), name (required), server_uuid (required), +15 more.
coolify_logsC
Application logs and monitoring - get application logs
Inputs: action (required), uuid (required), lines.
coolify_project_environmentsC
Project environment management - list, create, get, and delete project environments
Inputs: action (required), project_uuid (required), environment_name_or_uuid, name.
coolify_projectsC
Project CRUD operations - list, create, get, update, and delete projects
Inputs: action (required), uuid, name, description, +2 more.
coolify_security_keysC
Security keys management - list, create, get, update, and delete security keys
Inputs: action (required), uuid, name, description, +3 more.
coolify_server_managementC
Server operations and resources - validate server connection, list domains, and list resources
Inputs: action (required), uuid (required).
coolify_serversC
Server CRUD operations - list, create, get, update, and delete servers
Inputs: action (required), uuid, name, description, +6 more.
coolify_service_envsC
Service environment variables management - list, create, update, bulk update, and delete environment variables
Inputs: action (required), uuid (required), key, value, +7 more.
coolify_service_lifecycleC
Service lifecycle management - start, stop, and restart services
Inputs: action (required), uuid (required).
coolify_servicesC
Service CRUD operations - list, create, get, update, and delete services
Inputs: action (required), uuid, name, description, +6 more.
coolify_systemB
System management operations - health check, version, and system information
Inputs: action (required).
coolify_teamsC
Complete team management - list teams, get current team, get team details, and list team members
Inputs: action (required), team_id.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
Each tool has a clearly distinct purpose targeting specific resources (applications, databases, projects, servers, services, etc.) and actions (CRUD, lifecycle, envs, logs, etc.). There is no ambiguity or overlap; for example, coolify_application_envs and coolify_service_envs are clearly separated by resource type, and lifecycle tools are distinct from CRUD tools.
All tools follow a consistent 'coolify_<resource>_<action>' naming pattern with snake_case throughout. The pattern is predictable and readable, making it easy to identify the resource and operation type, such as coolify_applications for CRUD and coolify_application_lifecycle for lifecycle management.
With 18 tools, the count is slightly high but reasonable for a comprehensive server management system covering applications, databases, projects, servers, services, and more. Each tool earns its place by addressing specific aspects of the domain, though it borders on being heavy.
The tool set provides complete coverage for the Coolify domain, including CRUD operations, lifecycle management, environment variables, logs, security, and system info across all key resources (applications, databases, projects, servers, services). There are no obvious gaps; agents can perform full workflows without dead ends.
Maintenance
Related MCP Connectors
Deploy and manage your apps, databases, storage, and scheduled jobs from your AI agent
The agent-native cloud: database, functions, AI, storage, computers. 53 tools, one API key.
Deploy apps from GitHub, read build/runtime logs, and manage your app's users from your AI agent.
Deploy and run apps in your own AWS, Google Cloud, Azure or DigitalOcean account from any AI agent.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI assistants to interact with Coolify self-hosted instances for application deployment, management, and monitoring. Features 4 unified tools optimized for VS Code's limits, covering app management, environment configuration, system administration, and built-in documentation.41MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to manage Coolify infrastructure including servers, applications, databases, deployments, and 80+ one-click services through 98 comprehensive tools for both cloud and self-hosted instances.MIT
- AlicenseBqualityCmaintenanceEnables control and management of Coolify self-hosted PaaS instances, allowing you to deploy applications, manage databases, monitor servers, and execute operations directly from AI assistants.8916 npm28MIT
- AlicenseBqualityDmaintenanceEnables management of Coolify instances to control applications, databases, and servers through the Model Context Protocol. It provides a comprehensive set of tools for deploying services and monitoring self-hosted infrastructure using natural language.1812 npm3MIT