Skip to main content
Glama

CoolifyMCP

Install MCP Server

License: MIT Node.js Version TypeScript

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)

  1. Open Cursor and go to Settings → Extensions → MCP

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

  1. Open Claude Desktop settings

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

  1. Open your JetBrains IDE (IntelliJ, WebStorm, etc.)

  2. Go to Settings → Tools → AI Assistant → Model Context Protocol (MCP)

  3. Click "Add" and configure:

    • Name: coolifymcp

    • Command: npx

    • Arguments: ["coolifymcp"]

    • Environment Variables:

      • COOLIFY_API_TOKEN: your_coolify_api_token_here

      • COOLIFY_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

  1. Install and run with npx (no installation needed):

npx coolifymcp
  1. Or install globally:

npm install -g coolifymcp
coolifymcp

Local Development

  1. Clone the repository:

git clone https://github.com/howieduhzit/coolifymcp.git
cd coolifymcp
  1. Install dependencies:

npm install
  1. Build the project:

npm run build
  1. Run 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

COOLIFY_API_TOKEN

Your Coolify API token

Yes

-

COOLIFY_BASE_URL

Coolify API base URL

No

https://app.coolify.io/api/v1

NODE_ENV

Environment mode

No

development

PORT

Health check server port

No

3000

MCP Client Configuration

The configuration format is consistent across all MCP-compatible IDEs. Here are the common locations:

Configuration File Locations:

  • Cursor: ~/.cursor/mcp.json

  • Claude 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 token

  • COOLIFY_BASE_URL (optional): Your Coolify instance URL (defaults to https://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 management

    • Actions: health, version, info

Team Management (1 tool)

  • coolify_teams - Complete team management operations

    • Actions: list, current, get, members

Project Management (2 tools)

  • coolify_projects - Project CRUD operations

    • Actions: list, create, get, update, delete

  • coolify_project_environments - Project environment management

    • Actions: list, create, get, delete

Application Management (5 tools)

  • coolify_applications - Application CRUD operations (all types)

    • Actions: list, create, update, get, delete

    • Supports: public, private_github, private_deploy_key, dockerfile, dockerimage, dockercompose

  • coolify_application_lifecycle - Application lifecycle management

    • Actions: start, stop, restart

  • coolify_application_envs - Application environment variables

    • Actions: list, create, bulk_update, delete

  • coolify_logs - Application logs retrieval

    • Actions: get

  • coolify_application_deployments - Application deployment management

    • Actions: list, get, trigger

Database Management (3 tools)

  • coolify_databases - Database CRUD operations

    • Actions: list, create, get, update, delete

  • coolify_database_lifecycle - Database lifecycle management

    • Actions: start, stop, restart

  • coolify_database_types - Specific database type creation

    • Actions: create (PostgreSQL, MySQL, MongoDB, Redis)

Server Management (2 tools)

  • coolify_servers - Server CRUD operations

    • Actions: list, create, get, update, delete

  • coolify_server_management - Server operations and resources

    • Actions: validate, domains, resources

Service Management (3 tools)

  • coolify_services - Service CRUD operations

    • Actions: list, create, get, update, delete

  • coolify_service_lifecycle - Service lifecycle management

    • Actions: start, stop, restart

  • coolify_service_envs - Service environment variables

    • Actions: list, create, update, bulk_update, delete

Security Management (1 tool)

  • coolify_security_keys - Security key management

    • Actions: list, create, get, update, delete

🏗️ Development

Scripts

  • npm run build - Build TypeScript to JavaScript

  • npm start - Start the production server

  • npm 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:

  1. Set NODE_ENV=production

  2. Provide valid COOLIFY_API_TOKEN

  3. Set correct COOLIFY_BASE_URL

  4. Configure proper logging

  5. Set up monitoring and alerting

📝 License

MIT License - see LICENSE file for details.

🤝 Contributing

  1. Fork the repository

  2. Create a feature branch

  3. Make your changes

  4. Add tests if applicable

  5. Submit a pull request

📚 Documentation

  • README.md - Complete documentation and usage examples

  • GitHub Repository - Source code and issue tracking

📞 Support

For issues and questions:

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

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.


Built with ❤️ for the Coolify community

GitHub stars GitHub forks GitHub issues


Powered by Coolify - An open-source & self-hostable Heroku / Netlify / Vercel alternative with 45.2k+ stars ⭐

Available Tools

18 tools
coolify_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

    B3.4/5.0

    Scored across 18 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    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.

    Tool Count4/5

    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.

    Completeness5/5

    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

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables 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.
      4
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables 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
    • A
      license
      B
      quality
      C
      maintenance
      Enables 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.
      89
      16 npm
      28
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables 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.
      18
      12 npm
      3
      MIT