@masonator/coolify-mcp 1.5.0 → 1.6.0

package/README.md

@@ -9,27 +9,27 @@
 [![codecov](https://codecov.io/gh/StuMason/coolify-mcp/branch/main/graph/badge.svg)](https://codecov.io/gh/StuMason/coolify-mcp)
 [![MseeP.ai Security Assessment Badge](https://mseep.net/pr/stumason-coolify-mcp-badge.png)](https://mseep.ai/app/stumason-coolify-mcp)
 
-> **The most comprehensive MCP server for Coolify** - 67 tools, 7 workflow prompts, smart diagnostics, and batch operations for managing your self-hosted PaaS through AI assistants.
+> **The most comprehensive MCP server for Coolify** - 75 tools, 7 workflow prompts, smart diagnostics, and batch operations for managing your self-hosted PaaS through AI assistants.
 
 A Model Context Protocol (MCP) server for [Coolify](https://coolify.io/), enabling AI assistants to manage and debug your Coolify instances through natural language.
 
 ## Features
 
-This MCP server provides **67 tools** and **7 workflow prompts** for **debugging, management, and deployment**:
-
-| Category             | Tools                                                                                                    |
-| -------------------- | -------------------------------------------------------------------------------------------------------- |
-| **Infrastructure**   | overview, mcp_version (all resources at once)                                                            |
-| **Diagnostics**      | diagnose_app, diagnose_server, find_issues (smart lookup by name/domain/IP)                              |
-| **Batch Operations** | restart_project_apps, bulk_env_update, stop_all_apps, redeploy_project                                   |
-| **Servers**          | list, get, validate, resources, domains                                                                  |
-| **Projects**         | list, get, create, update, delete                                                                        |
-| **Environments**     | list, get, create, delete                                                                                |
-| **Applications**     | list, get, update, delete, start, stop, restart, logs, env vars (CRUD), create (private-gh, private-key) |
-| **Databases**        | list, get, delete, start, stop, restart, backups (list, get), backup executions (list, get)              |
-| **Services**         | list, get, create, update, delete, start, stop, restart, env vars (list, create, delete)                 |
-| **Deployments**      | list, get, deploy, cancel, list by application                                                           |
-| **Private Keys**     | list, get, create, update, delete                                                                        |
+This MCP server provides **75 tools** and **7 workflow prompts** for **debugging, management, and deployment**:
+
+| Category             | Tools                                                                                                         |
+| -------------------- | ------------------------------------------------------------------------------------------------------------- |
+| **Infrastructure**   | overview, mcp_version (all resources at once)                                                                 |
+| **Diagnostics**      | diagnose_app, diagnose_server, find_issues (smart lookup by name/domain/IP)                                   |
+| **Batch Operations** | restart_project_apps, bulk_env_update, stop_all_apps, redeploy_project                                        |
+| **Servers**          | list, get, validate, resources, domains                                                                       |
+| **Projects**         | list, get, create, update, delete                                                                             |
+| **Environments**     | list, get, create, delete                                                                                     |
+| **Applications**     | list, get, update, delete, start, stop, restart, logs, env vars (CRUD), create (private-gh, private-key)      |
+| **Databases**        | list, get, create (8 types), delete, start, stop, restart, backups (list, get), backup executions (list, get) |
+| **Services**         | list, get, create, update, delete, start, stop, restart, env vars (list, create, delete)                      |
+| **Deployments**      | list, get, deploy, cancel, list by application                                                                |
+| **Private Keys**     | list, get, create, update, delete                                                                             |
 
 ### Workflow Prompts
 

package/dist/__tests__/coolify-client.test.js

@@ -794,6 +794,87 @@ describe('CoolifyClient', () => {
             expect(result).toEqual(mockExecution);
             expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/db-uuid/backups/backup-uuid/executions/exec-uuid', expect.any(Object));
         });
+        it('should create a PostgreSQL database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'pg-uuid' }));
+            const result = await client.createPostgresql({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                environment_name: 'production',
+                postgres_user: 'myuser',
+                postgres_db: 'mydb',
+            });
+            expect(result).toEqual({ uuid: 'pg-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/postgresql', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a MySQL database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'mysql-uuid' }));
+            const result = await client.createMysql({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                mysql_user: 'myuser',
+                mysql_database: 'mydb',
+            });
+            expect(result).toEqual({ uuid: 'mysql-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/mysql', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a MariaDB database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'mariadb-uuid' }));
+            const result = await client.createMariadb({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+            });
+            expect(result).toEqual({ uuid: 'mariadb-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/mariadb', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a MongoDB database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'mongo-uuid' }));
+            const result = await client.createMongodb({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                mongo_initdb_root_username: 'admin',
+            });
+            expect(result).toEqual({ uuid: 'mongo-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/mongodb', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a Redis database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'redis-uuid' }));
+            const result = await client.createRedis({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                redis_password: 'secret',
+            });
+            expect(result).toEqual({ uuid: 'redis-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/redis', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a KeyDB database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'keydb-uuid' }));
+            const result = await client.createKeydb({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+            });
+            expect(result).toEqual({ uuid: 'keydb-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/keydb', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a ClickHouse database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'clickhouse-uuid' }));
+            const result = await client.createClickhouse({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                clickhouse_admin_user: 'admin',
+            });
+            expect(result).toEqual({ uuid: 'clickhouse-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/clickhouse', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a Dragonfly database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'dragonfly-uuid' }));
+            const result = await client.createDragonfly({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                dragonfly_password: 'secret',
+            });
+            expect(result).toEqual({ uuid: 'dragonfly-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/dragonfly', expect.objectContaining({ method: 'POST' }));
+        });
     });
     // =========================================================================
     // Service endpoints - extended coverage

package/dist/__tests__/mcp-server.test.js

@@ -16,6 +16,14 @@ const mockDiagnoseApplication = jest.fn();
 const mockDiagnoseServer = jest.fn();
 const mockFindInfrastructureIssues = jest.fn();
 const mockDeleteDatabase = jest.fn();
+const mockCreatePostgresql = jest.fn();
+const mockCreateMysql = jest.fn();
+const mockCreateMariadb = jest.fn();
+const mockCreateMongodb = jest.fn();
+const mockCreateRedis = jest.fn();
+const mockCreateKeydb = jest.fn();
+const mockCreateClickhouse = jest.fn();
+const mockCreateDragonfly = jest.fn();
 // Mock the CoolifyClient module
 jest.mock('../lib/coolify-client.js', () => ({
     CoolifyClient: jest.fn().mockImplementation(() => ({
@@ -28,6 +36,14 @@ jest.mock('../lib/coolify-client.js', () => ({
         diagnoseServer: mockDiagnoseServer,
         findInfrastructureIssues: mockFindInfrastructureIssues,
         deleteDatabase: mockDeleteDatabase,
+        createPostgresql: mockCreatePostgresql,
+        createMysql: mockCreateMysql,
+        createMariadb: mockCreateMariadb,
+        createMongodb: mockCreateMongodb,
+        createRedis: mockCreateRedis,
+        createKeydb: mockCreateKeydb,
+        createClickhouse: mockCreateClickhouse,
+        createDragonfly: mockCreateDragonfly,
         getVersion: jest.fn(),
     })),
 }));
@@ -317,6 +333,71 @@ describe('CoolifyMcpServer', () => {
                 expect(mockDeleteDatabase).toHaveBeenCalledWith('db-uuid-123', { deleteVolumes: true });
             });
         });
+        describe('database creation tools', () => {
+            const baseParams = {
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                environment_name: 'production',
+            };
+            it('should call createPostgresql with correct params', async () => {
+                mockCreatePostgresql.mockResolvedValue({ uuid: 'pg-uuid' });
+                await mockCreatePostgresql({ ...baseParams, postgres_user: 'myuser' });
+                expect(mockCreatePostgresql).toHaveBeenCalledWith({
+                    ...baseParams,
+                    postgres_user: 'myuser',
+                });
+            });
+            it('should call createMysql with correct params', async () => {
+                mockCreateMysql.mockResolvedValue({ uuid: 'mysql-uuid' });
+                await mockCreateMysql({ ...baseParams, mysql_user: 'myuser' });
+                expect(mockCreateMysql).toHaveBeenCalledWith({
+                    ...baseParams,
+                    mysql_user: 'myuser',
+                });
+            });
+            it('should call createMariadb with correct params', async () => {
+                mockCreateMariadb.mockResolvedValue({ uuid: 'mariadb-uuid' });
+                await mockCreateMariadb(baseParams);
+                expect(mockCreateMariadb).toHaveBeenCalledWith(baseParams);
+            });
+            it('should call createMongodb with correct params', async () => {
+                mockCreateMongodb.mockResolvedValue({ uuid: 'mongo-uuid' });
+                await mockCreateMongodb({ ...baseParams, mongo_initdb_root_username: 'admin' });
+                expect(mockCreateMongodb).toHaveBeenCalledWith({
+                    ...baseParams,
+                    mongo_initdb_root_username: 'admin',
+                });
+            });
+            it('should call createRedis with correct params', async () => {
+                mockCreateRedis.mockResolvedValue({ uuid: 'redis-uuid' });
+                await mockCreateRedis({ ...baseParams, redis_password: 'secret' });
+                expect(mockCreateRedis).toHaveBeenCalledWith({
+                    ...baseParams,
+                    redis_password: 'secret',
+                });
+            });
+            it('should call createKeydb with correct params', async () => {
+                mockCreateKeydb.mockResolvedValue({ uuid: 'keydb-uuid' });
+                await mockCreateKeydb(baseParams);
+                expect(mockCreateKeydb).toHaveBeenCalledWith(baseParams);
+            });
+            it('should call createClickhouse with correct params', async () => {
+                mockCreateClickhouse.mockResolvedValue({ uuid: 'clickhouse-uuid' });
+                await mockCreateClickhouse({ ...baseParams, clickhouse_admin_user: 'admin' });
+                expect(mockCreateClickhouse).toHaveBeenCalledWith({
+                    ...baseParams,
+                    clickhouse_admin_user: 'admin',
+                });
+            });
+            it('should call createDragonfly with correct params', async () => {
+                mockCreateDragonfly.mockResolvedValue({ uuid: 'dragonfly-uuid' });
+                await mockCreateDragonfly({ ...baseParams, dragonfly_password: 'secret' });
+                expect(mockCreateDragonfly).toHaveBeenCalledWith({
+                    ...baseParams,
+                    dragonfly_password: 'secret',
+                });
+            });
+        });
     });
     describe('version tools', () => {
         it('get_mcp_version should return correct version format', () => {

package/dist/lib/coolify-client.d.ts

@@ -2,7 +2,7 @@
  * Coolify API Client
  * Complete HTTP client for the Coolify API v1
  */
-import type { CoolifyConfig, DeleteOptions, MessageResponse, UuidResponse, Server, ServerResource, ServerDomain, ServerValidation, CreateServerRequest, UpdateServerRequest, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest, Application, CreateApplicationPublicRequest, CreateApplicationPrivateGHRequest, CreateApplicationPrivateKeyRequest, CreateApplicationDockerfileRequest, CreateApplicationDockerImageRequest, CreateApplicationDockerComposeRequest, UpdateApplicationRequest, ApplicationActionResponse, EnvironmentVariable, EnvVarSummary, CreateEnvVarRequest, UpdateEnvVarRequest, BulkUpdateEnvVarsRequest, Database, UpdateDatabaseRequest, DatabaseBackup, BackupExecution, Service, CreateServiceRequest, UpdateServiceRequest, ServiceCreateResponse, Deployment, Team, TeamMember, PrivateKey, CreatePrivateKeyRequest, UpdatePrivateKeyRequest, CloudToken, CreateCloudTokenRequest, UpdateCloudTokenRequest, CloudTokenValidation, Version, ApplicationDiagnostic, ServerDiagnostic, InfrastructureIssuesReport, BatchOperationResult } from '../types/coolify.js';
+import type { CoolifyConfig, DeleteOptions, MessageResponse, UuidResponse, Server, ServerResource, ServerDomain, ServerValidation, CreateServerRequest, UpdateServerRequest, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest, Application, CreateApplicationPublicRequest, CreateApplicationPrivateGHRequest, CreateApplicationPrivateKeyRequest, CreateApplicationDockerfileRequest, CreateApplicationDockerImageRequest, CreateApplicationDockerComposeRequest, UpdateApplicationRequest, ApplicationActionResponse, EnvironmentVariable, EnvVarSummary, CreateEnvVarRequest, UpdateEnvVarRequest, BulkUpdateEnvVarsRequest, Database, UpdateDatabaseRequest, CreatePostgresqlRequest, CreateMysqlRequest, CreateMariadbRequest, CreateMongodbRequest, CreateRedisRequest, CreateKeydbRequest, CreateClickhouseRequest, CreateDragonflyRequest, CreateDatabaseResponse, DatabaseBackup, BackupExecution, Service, CreateServiceRequest, UpdateServiceRequest, ServiceCreateResponse, Deployment, Team, TeamMember, PrivateKey, CreatePrivateKeyRequest, UpdatePrivateKeyRequest, CloudToken, CreateCloudTokenRequest, UpdateCloudTokenRequest, CloudTokenValidation, Version, ApplicationDiagnostic, ServerDiagnostic, InfrastructureIssuesReport, BatchOperationResult } from '../types/coolify.js';
 export interface ListOptions {
     page?: number;
     per_page?: number;
@@ -114,6 +114,14 @@ export declare class CoolifyClient {
     startDatabase(uuid: string): Promise<MessageResponse>;
     stopDatabase(uuid: string): Promise<MessageResponse>;
     restartDatabase(uuid: string): Promise<MessageResponse>;
+    createPostgresql(data: CreatePostgresqlRequest): Promise<CreateDatabaseResponse>;
+    createMysql(data: CreateMysqlRequest): Promise<CreateDatabaseResponse>;
+    createMariadb(data: CreateMariadbRequest): Promise<CreateDatabaseResponse>;
+    createMongodb(data: CreateMongodbRequest): Promise<CreateDatabaseResponse>;
+    createRedis(data: CreateRedisRequest): Promise<CreateDatabaseResponse>;
+    createKeydb(data: CreateKeydbRequest): Promise<CreateDatabaseResponse>;
+    createClickhouse(data: CreateClickhouseRequest): Promise<CreateDatabaseResponse>;
+    createDragonfly(data: CreateDragonflyRequest): Promise<CreateDatabaseResponse>;
     listServices(options?: ListOptions): Promise<Service[] | ServiceSummary[]>;
     getService(uuid: string): Promise<Service>;
     createService(data: CreateServiceRequest): Promise<ServiceCreateResponse>;

package/dist/lib/coolify-client.js

@@ -414,6 +414,55 @@ export class CoolifyClient {
             method: 'POST',
         });
     }
+    // Database creation methods
+    async createPostgresql(data) {
+        return this.request('/databases/postgresql', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async createMysql(data) {
+        return this.request('/databases/mysql', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async createMariadb(data) {
+        return this.request('/databases/mariadb', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async createMongodb(data) {
+        return this.request('/databases/mongodb', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async createRedis(data) {
+        return this.request('/databases/redis', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async createKeydb(data) {
+        return this.request('/databases/keydb', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async createClickhouse(data) {
+        return this.request('/databases/clickhouse', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async createDragonfly(data) {
+        return this.request('/databases/dragonfly', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
     // ===========================================================================
     // Service endpoints
     // ===========================================================================

package/dist/lib/mcp-server.js

@@ -20,7 +20,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { CoolifyClient, } from './coolify-client.js';
-const VERSION = '1.5.0';
+const VERSION = '1.6.0';
 /** Wrap tool handler with consistent error handling */
 function wrapHandler(fn) {
     return fn()
@@ -222,7 +222,7 @@ export class CoolifyMcpServer extends McpServer {
             env_uuid: z.string().describe('Env variable UUID'),
         }, async ({ uuid, env_uuid }) => wrapHandler(() => this.client.deleteApplicationEnvVar(uuid, env_uuid)));
         // =========================================================================
-        // Databases (6 tools)
+        // Databases (14 tools)
         // =========================================================================
         this.tool('list_databases', 'List all databases (returns summary: uuid, name, type, status). Use get_database for full details.', {
             page: z.number().optional().describe('Page number for pagination'),
@@ -236,6 +236,78 @@ export class CoolifyMcpServer extends McpServer {
             uuid: z.string().describe('Database UUID'),
             delete_volumes: z.boolean().optional().describe('Delete volumes (default: false)'),
         }, async ({ uuid, delete_volumes }) => wrapHandler(() => this.client.deleteDatabase(uuid, { deleteVolumes: delete_volumes })));
+        // Database creation tools - shared schema for base fields
+        const databaseBaseSchema = {
+            server_uuid: z.string().describe('Server UUID'),
+            project_uuid: z.string().describe('Project UUID'),
+            environment_name: z.string().optional().describe('Environment name'),
+            environment_uuid: z.string().optional().describe('Environment UUID'),
+            destination_uuid: z.string().optional().describe('Destination UUID'),
+            name: z.string().optional().describe('Database name'),
+            description: z.string().optional().describe('Database description'),
+            image: z.string().optional().describe('Docker image'),
+            is_public: z.boolean().optional().describe('Make database publicly accessible'),
+            public_port: z.number().optional().describe('Public port'),
+            limits_memory: z.string().optional().describe('Memory limit'),
+            limits_memory_swap: z.string().optional().describe('Memory swap limit'),
+            limits_memory_swappiness: z.number().optional().describe('Memory swappiness'),
+            limits_memory_reservation: z.string().optional().describe('Memory reservation'),
+            limits_cpus: z.string().optional().describe('CPU limit'),
+            limits_cpuset: z.string().optional().describe('CPU set'),
+            limits_cpu_shares: z.number().optional().describe('CPU shares'),
+            instant_deploy: z.boolean().optional().describe('Deploy immediately after creation'),
+        };
+        this.tool('create_postgresql', 'Create a new PostgreSQL database', {
+            ...databaseBaseSchema,
+            postgres_user: z.string().optional().describe('PostgreSQL user'),
+            postgres_password: z.string().optional().describe('PostgreSQL password'),
+            postgres_db: z.string().optional().describe('PostgreSQL database name'),
+            postgres_initdb_args: z.string().optional().describe('PostgreSQL initdb args'),
+            postgres_host_auth_method: z.string().optional().describe('PostgreSQL host auth method'),
+            postgres_conf: z.string().optional().describe('PostgreSQL configuration'),
+        }, async (args) => wrapHandler(() => this.client.createPostgresql(args)));
+        this.tool('create_mysql', 'Create a new MySQL database', {
+            ...databaseBaseSchema,
+            mysql_root_password: z.string().optional().describe('MySQL root password'),
+            mysql_user: z.string().optional().describe('MySQL user'),
+            mysql_password: z.string().optional().describe('MySQL password'),
+            mysql_database: z.string().optional().describe('MySQL database name'),
+            mysql_conf: z.string().optional().describe('MySQL configuration'),
+        }, async (args) => wrapHandler(() => this.client.createMysql(args)));
+        this.tool('create_mariadb', 'Create a new MariaDB database', {
+            ...databaseBaseSchema,
+            mariadb_root_password: z.string().optional().describe('MariaDB root password'),
+            mariadb_user: z.string().optional().describe('MariaDB user'),
+            mariadb_password: z.string().optional().describe('MariaDB password'),
+            mariadb_database: z.string().optional().describe('MariaDB database name'),
+            mariadb_conf: z.string().optional().describe('MariaDB configuration'),
+        }, async (args) => wrapHandler(() => this.client.createMariadb(args)));
+        this.tool('create_mongodb', 'Create a new MongoDB database', {
+            ...databaseBaseSchema,
+            mongo_initdb_root_username: z.string().optional().describe('MongoDB root username'),
+            mongo_initdb_root_password: z.string().optional().describe('MongoDB root password'),
+            mongo_initdb_database: z.string().optional().describe('MongoDB database name'),
+            mongo_conf: z.string().optional().describe('MongoDB configuration'),
+        }, async (args) => wrapHandler(() => this.client.createMongodb(args)));
+        this.tool('create_redis', 'Create a new Redis database', {
+            ...databaseBaseSchema,
+            redis_password: z.string().optional().describe('Redis password'),
+            redis_conf: z.string().optional().describe('Redis configuration'),
+        }, async (args) => wrapHandler(() => this.client.createRedis(args)));
+        this.tool('create_keydb', 'Create a new KeyDB database', {
+            ...databaseBaseSchema,
+            keydb_password: z.string().optional().describe('KeyDB password'),
+            keydb_conf: z.string().optional().describe('KeyDB configuration'),
+        }, async (args) => wrapHandler(() => this.client.createKeydb(args)));
+        this.tool('create_clickhouse', 'Create a new ClickHouse database', {
+            ...databaseBaseSchema,
+            clickhouse_admin_user: z.string().optional().describe('ClickHouse admin user'),
+            clickhouse_admin_password: z.string().optional().describe('ClickHouse admin password'),
+        }, async (args) => wrapHandler(() => this.client.createClickhouse(args)));
+        this.tool('create_dragonfly', 'Create a new Dragonfly database (Redis-compatible)', {
+            ...databaseBaseSchema,
+            dragonfly_password: z.string().optional().describe('Dragonfly password'),
+        }, async (args) => wrapHandler(() => this.client.createDragonfly(args)));
         // =========================================================================
         // Services (11 tools)
         // =========================================================================

package/dist/types/coolify.d.ts

@@ -451,6 +451,72 @@ export interface UpdateDatabaseRequest {
     clickhouse_admin_password?: string;
     dragonfly_password?: string;
 }
+export interface CreateDatabaseBaseRequest {
+    server_uuid: string;
+    project_uuid: string;
+    environment_name?: string;
+    environment_uuid?: string;
+    destination_uuid?: string;
+    name?: string;
+    description?: string;
+    image?: string;
+    is_public?: boolean;
+    public_port?: number;
+    limits_memory?: string;
+    limits_memory_swap?: string;
+    limits_memory_swappiness?: number;
+    limits_memory_reservation?: string;
+    limits_cpus?: string;
+    limits_cpuset?: string;
+    limits_cpu_shares?: number;
+    instant_deploy?: boolean;
+}
+export interface CreatePostgresqlRequest extends CreateDatabaseBaseRequest {
+    postgres_user?: string;
+    postgres_password?: string;
+    postgres_db?: string;
+    postgres_initdb_args?: string;
+    postgres_host_auth_method?: string;
+    postgres_conf?: string;
+}
+export interface CreateMysqlRequest extends CreateDatabaseBaseRequest {
+    mysql_root_password?: string;
+    mysql_user?: string;
+    mysql_password?: string;
+    mysql_database?: string;
+    mysql_conf?: string;
+}
+export interface CreateMariadbRequest extends CreateDatabaseBaseRequest {
+    mariadb_root_password?: string;
+    mariadb_user?: string;
+    mariadb_password?: string;
+    mariadb_database?: string;
+    mariadb_conf?: string;
+}
+export interface CreateMongodbRequest extends CreateDatabaseBaseRequest {
+    mongo_initdb_root_username?: string;
+    mongo_initdb_root_password?: string;
+    mongo_initdb_database?: string;
+    mongo_conf?: string;
+}
+export interface CreateRedisRequest extends CreateDatabaseBaseRequest {
+    redis_password?: string;
+    redis_conf?: string;
+}
+export interface CreateKeydbRequest extends CreateDatabaseBaseRequest {
+    keydb_password?: string;
+    keydb_conf?: string;
+}
+export interface CreateClickhouseRequest extends CreateDatabaseBaseRequest {
+    clickhouse_admin_user?: string;
+    clickhouse_admin_password?: string;
+}
+export interface CreateDragonflyRequest extends CreateDatabaseBaseRequest {
+    dragonfly_password?: string;
+}
+export interface CreateDatabaseResponse {
+    uuid: string;
+}
 export interface DatabaseBackup {
     id: number;
     uuid: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masonator/coolify-mcp",
   "scope": "@masonator",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "MCP server implementation for Coolify",
   "type": "module",
   "main": "./dist/index.js",