Coolify MCP. Control your entire self-hosted cloud from chat.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Coolify MCP Server manages your self-hosted cloud infrastructure through natural language. Use this server to list nodes, check Docker Swarm status, get connection strings for PostgreSQL/MySQL/Redis, and trigger full application deployments—all from your AI agent.
What your AI agents can do
Get application
Gets detailed topology metrics for a specific app, including its GitHub branches and proxy paths.
Get database
Extracts the internal configuration arrays and connection details for a given database.
Get server
Validates a server node's IP properties, SSH connection status, and active Docker ports.
Retrieves a list of all attached Coolify Server Nodes, showing their physical endpoints and operational status.
Verifies a specific server node's IP properties, SSH connection status, and active Docker ports across the cluster.
Generates a map of all active frontend and backend applications, including their unique UUIDs needed for management actions.
Retrieves internal metrics for an application, including its mapped GitHub branches and its Traefik proxy path.
Identifies all PostgreSQL, MySQL, and Redis configurations and their connection details for linking apps.
Extracts the internal configuration arrays and connection URIs for a specified database.
Starts, stops, or restarts any managed application, allowing instant state changes and configuration rollouts.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Coolify MCP Server: 10 Tools for Cloud Management
Use these tools to monitor servers, list applications, get connection strings, and automate deployments across your entire self-hosted environment.
019d757bget application
Gets detailed topology metrics for a specific app, including its GitHub branches and proxy paths.
019d757bget database
Extracts the internal configuration arrays and connection details for a given database.
019d757bget server
Validates a server node's IP properties, SSH connection status, and active Docker ports.
019d757blist applications
Lists all active frontend and backend applications managed by Coolify, providing their UUIDs.
019d757blist databases
Lists all managed PostgreSQL, MySQL, and Redis configurations, showing their connection status.
019d757blist servers
Lists all self-hosted Coolify Server Nodes that run Docker Swarms.
019d757brestart application
Restarts a specific application container, forcing it to reload updated environment variables.
019d757bstart application
Starts a suspended application container using its UUID.
019d757bstop application
Halts an application's execution, useful for maintenance or restricting web access.
019d757btrigger deployment
Triggers a raw build pipeline to fetch the latest Git commits and roll out a new Docker version.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Coolify, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Coolify MCP Server - Self-Hosted Cloud Management
Yo, this server lets your AI client handle all the heavy lifting on your private cloud setup. You don't gotta touch the dashboard to manage everything—you just tell your agent what you want, and it does it.
Managing Your Servers
Your agent can pull a list of every Coolify Server Node you've attached, showing you their endpoints and if they're actually running. When you need to check a specific node, your agent validates its IP properties, checks the SSH connection status, and sees what Docker ports are active across the cluster.
You can use the get_server tool to run these checks.
Handling Applications
It'll give your agent a full map of every frontend and backend application you're running, along with their unique UUIDs. You can use list_applications to pull this list. When you need to know the deep guts of an app, your agent calls get_application, giving you detailed topology metrics, the app's mapped GitHub branches, and its Traefik proxy path.
You can also use restart_application to force a specific container to reload updated environment variables, or start_application to bring back a suspended container using its UUID. If you gotta shut something down, stop_application halts the app's execution, which is handy for maintenance or if you wanna restrict web access.
Deploying Updates
Need to roll out a new version? Your agent runs trigger_deployment, which kicks off a raw build pipeline. This fetches the latest Git commits and rolls out a new Docker version for the whole thing. You can also use list_applications and the app's UUID to associate project repositories for auditing and changes.
Database Oversight
Your agent can list all your PostgreSQL, MySQL, and Redis configurations using list_databases, showing their connection status. If you need the actual credentials, get_database extracts the internal configuration arrays and connection details for any specific database. You can get the connection URIs by using get_database.
This gives your AI client total control: checking server status, managing the app lifecycle, pushing deployments, and securing your database connections—all through natural language commands.
How Coolify MCP Works
- 1 Subscribe to the server, then provide your Coolify Instance URL and API Token (find the token in Keys & Tokens > API Tokens).
- 2 Your AI agent sends a natural language request, asking for a specific action (e.g., 'Restart the payments API').
- 3 The server invokes the correct tool, executes the command against your Coolify instance, and returns the status or required data.
The bottom line is you manage your entire self-hosted cloud stack using conversational commands.
Who Is Coolify MCP For?
This is for the DevOps Engineer who gets sick of clicking through multiple dashboards just to check a service status. It’s for the Full-stack Developer who needs to trigger a build or grab a connection string without leaving their IDE. It targets anyone who manages a private cloud stack and needs command-line control via natural language.
Monitors server node health, checks application lifecycle states across multiple environments, and audits Docker Swarm configurations.
Triggers builds, restarts containers, and retrieves database connection strings directly from the chat window when debugging an issue.
Audits the entire Docker Swarm setup, verifies server connectivity, and manages application states across the physical infrastructure.
What Changes When You Connect
- Triggering a build is simple. Instead of going through the Coolify dashboard, you call
trigger_deploymentand the server handles thegit fetch, Nixpacks rebuild, and rollout process automatically. - When debugging, you don't need to manually check multiple tabs. You can call
get_databaseto instantly retrieve the internal connection string for PostgreSQL, MySQL, or Redis. - Need to confirm the health of your cluster? Use
list_serversto get all node UUIDs, thenget_serverto validate specific IPs, SSH status, and running Docker ports. - Stopping or restarting services is instant. Use
stop_applicationto pause an app for billing or maintenance, orrestart_applicationto apply fresh config variables. - Debugging application dependencies is easier. Use
list_applicationsto get all UUIDs, and thenget_applicationto confirm the required GitHub branches or Traefik paths. - The server handles complex operations. If you need to replicate an environment, you can use
list_databasesto map all necessary data sources before starting the process.
Real-World Use Cases
Need to verify database credentials?
A dev needs the connection string for the staging database. They ask their agent: 'What's the connection string for user-db-staging?'. The agent runs get_database and returns the full, internal URI, saving them from logging into the dashboard.
Rolling out a hotfix to production?
The team finds a critical bug and needs to push an update immediately. The user instructs the agent: 'Trigger a deployment for the backend API.' The agent executes trigger_deployment, pulling the latest commit and rolling the updated Docker image live.
Diagnosing a downed service?
An outage occurs. The user asks the agent to 'Check the status of the main web node.' The agent runs list_servers and get_server, verifying the IP properties and Docker Swarm status across the entire cluster to pinpoint the failure point.
Pausing an app for maintenance?
A planned maintenance window requires taking an app offline. The user tells the agent: 'Stop the billing application.' The agent calls stop_application, immediately suspending the application's execution and web perimeter ingress.
The Tradeoffs
Calling tools out of sequence
Trying to call restart_application without first confirming the app exists. The system fails because it doesn't know which UUID to target, forcing the user to manually run list_applications first.
→
Always start with a list tool. First, run list_applications to get the required UUID. Then, use get_application to verify the app's current state. Finally, execute the action: restart_application.
Ignoring resource dependencies
A developer tries to deploy an app, but forgets to check if the necessary database was provisioned first. The deployment fails silently because the connection string is missing.
→
Before deploying, always run list_databases to verify all needed datastores are present. If they are, run get_database to retrieve the connection string needed for the build process.
Assuming a service is running
A user thinks a service is active but doesn't know its current state. They try to run a function that requires the service to be running, only to find an error.
→
Always confirm the current state first. Run get_application to check the app's mapped GitHub branches and proxy paths before attempting to use it or restart it.
When It Fits, When It Doesn't
Use this if you need to treat your self-hosted cloud like a command line interface. This is for people who need to monitor infrastructure status and perform deployment actions without GUI clicks. If your workflow involves repeatedly checking resource states (like server health or database connection details), this server is essential. Don't use this if you just need to view documentation or read logs—use a standard logging tool for that. If you need to build a dependency graph (i.e., 'App A depends on DB B which runs on Server C'), this tool only gives you the pieces; you'll need a dedicated observability platform to model those relationships.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Coolify. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Managing a self-hosted cloud shouldn't require jumping between a dozen dashboards.
Today, managing a private cloud means logging into the main dashboard, then switching tabs to check server nodes. You copy a UUID from the 'Applications' section into a separate 'Database' tab to get a connection string. Then, if you need to check the networking status, you jump to a third section and manually cross-reference IPs and Docker Swarm statuses. It's a painful, clicking mess.
With the Coolify MCP Server, you just tell your agent what you need. 'Check the status of the payments node and get the DB credentials.' The server runs the necessary tools (`list_servers`, `get_server`, `get_database`) and spits out the full, actionable data set in one chat response.
Coolify MCP Server: Deploy apps and manage infrastructure from chat.
Manual deployments involve running `git fetch`, then manually building a Nixpacks image, and finally clicking a 'Rollout' button. If anything fails, you have to manually check the logs and repeat the process. This is slow and error-prone.
Now, you just tell your agent to 'Deploy the new version.' The server executes `trigger_deployment`, handles the entire build pipeline, and rolls the updated Docker image out. The whole process runs automatically, giving you immediate confirmation.
Common Questions About Coolify MCP
How do I use the `list_applications` tool with Coolify MCP Server? +
The list_applications tool generates a map of all active frontend and backend apps. It returns their unique UUIDs, which you must use when calling tools like restart_application or get_application.
Does `get_database` provide live credentials? +
No, get_database extrapolates the internal configuration arrays and connection URIs. This information is for linking services and is only accessible within your internal Docker network.
What is the difference between `restart_application` and `trigger_deployment`? +
Use restart_application when you need the container to reload new environment variables. Use trigger_deployment when you need to pull new code from Git, rebuild the image (Nixpacks), and roll out a completely new version.
How do I check server health with `get_server`? +
The get_server tool validates a specific Coolify Server Node's IP properties, SSH connection status, and Docker executing ports across the cluster.
How do I use `list_servers` to check all connected endpoints? +
The list_servers tool lists all Coolify Server Nodes attached to your instance. This lets you see the raw physical endpoints running Docker swarms, confirming your entire cluster is online.
What happens if I call `stop_application` on a running app? +
Calling stop_application immediately halts the application's execution. This is useful for pausing billing or restricting web access during an incident, without deleting the configuration.
Can I use `get_application` to verify which branches are deployed? +
Yes, get_application retrieves the mapped GitHub branches and deployment status for an application. You can confirm if automatic rollout toggles (push to deploy) are active for that app.
Does `get_database` provide enough info to connect a new service? +
The get_database tool extracts the internal configuration arrays for a database. This provides the necessary connection strings for linking newly provisioned Web Apps to Backend Datastores.
Can my agent trigger a new deployment for a Coolify application? +
Yes. Use the 'trigger_deployment' tool with the application UUID. The agent will initiate a full build pipeline, fetching the latest commit and rolling out the updated version directly on your server.
How do I retrieve the internal connection string for a managed database? +
Provide the database UUID to the 'get_database' tool. Your agent will extrapolate the internal network URI (e.g., for PostgreSQL or MySQL), allowing you to securely link your apps without external port exposure.
Can I restart an application to apply new environment variables? +
Absolutely. Use the 'restart_application' tool. The agent will execute an overlapping bounce, destroying old instances and initializing fresh replicas with the latest configuration and environment variables.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Upstash
Manage serverless Redis via Upstash REST API — execute commands, manage data structures and monitor your database from any AI agent.
Miro
Manage Miro boards, items and comments via API — create boards, add sticky notes, browse items and manage members from any AI agent.
JSON5 Resilient Parser
Parse malformed JSON with trailing commas, comments, and single quotes into perfect strict JSON. Powered by JSON5 (32M+ weekly downloads).
You might also like
Dev.to (Forem)
Manage Dev.to and Forem articles — list posts, create content, and inspect user profiles directly from any AI agent.
Messari
Crypto market intelligence via Messari — track assets, metrics, and blockchain news.
Leiga
Manage agile projects with AI-assisted sprint planning, task prioritization, and team workload balancing that adapts in real time.