Skip to main content
Glama

coolify_projects

Manage Coolify projects by listing, creating, retrieving, updating, or deleting them through CRUD operations.

Instructions

Project CRUD operations - list, create, get, update, and delete projects

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
actionYesAction to perform: list (list all projects), create (create new project), get (get project by UUID), update (update project), delete (delete project)
uuidNoProject UUID (required for get, update, delete actions)
nameNoProject name (required for create, optional for update)
descriptionNoProject description (optional for create and update)
pageNoPage number (optional for list action)
per_pageNoItems per page (optional for list action)

Implementation Reference

  • The handler function that executes the coolify_projects tool logic, handling list, create, get, update, and delete actions via API calls to Coolify projects endpoint.
    async projects(action: string, args: any) {
      switch (action) {
        case 'list':
          const queryString = this.apiClient.buildQueryString(args);
          const response = await this.apiClient.get(`/projects?${queryString}`);
          return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
        case 'create':
          const createResponse = await this.apiClient.post('/projects', { 
            name: args.name, 
            description: args.description 
          });
          return { content: [{ type: 'text', text: JSON.stringify(createResponse.data, null, 2) }] };
        case 'get':
          if (!args.uuid) throw new Error('Project UUID is required for get action');
          const getResponse = await this.apiClient.get(`/projects/${args.uuid}`);
          return { content: [{ type: 'text', text: JSON.stringify(getResponse.data, null, 2) }] };
        case 'update':
          if (!args.uuid) throw new Error('Project UUID is required for update action');
          const updateResponse = await this.apiClient.patch(`/projects/${args.uuid}`, {
            name: args.name,
            description: args.description,
          });
          return { content: [{ type: 'text', text: JSON.stringify(updateResponse.data, null, 2) }] };
        case 'delete':
          if (!args.uuid) throw new Error('Project UUID is required for delete action');
          await this.apiClient.delete(`/projects/${args.uuid}`);
          return { content: [{ type: 'text', text: 'Project deleted successfully' }] };
        default:
          throw new Error(`Unknown projects action: ${action}`);
      }
    }
  • The input schema definition for the coolify_projects tool, specifying parameters for various CRUD actions.
    {
      name: 'coolify_projects',
      description: 'Project CRUD operations - list, create, get, update, and delete projects',
      inputSchema: {
        type: 'object',
        properties: {
          action: { 
            type: 'string', 
            enum: ['list', 'create', 'get', 'update', 'delete'],
            description: 'Action to perform: list (list all projects), create (create new project), get (get project by UUID), update (update project), delete (delete project)'
          },
          uuid: { 
            type: 'string', 
            description: 'Project UUID (required for get, update, delete actions)' 
          },
          name: { 
            type: 'string', 
            description: 'Project name (required for create, optional for update)' 
          },
          description: { 
            type: 'string', 
            description: 'Project description (optional for create and update)' 
          },
          page: { 
            type: 'number', 
            description: 'Page number (optional for list action)' 
          },
          per_page: { 
            type: 'number', 
            description: 'Items per page (optional for list action)' 
          },
        },
        required: ['action'],
      },
    },
  • src/index.ts:96-97 (registration)
    The switch case in handleToolCall that registers and dispatches calls to the coolify_projects handler.
    case 'coolify_projects':
      return await this.handlers.projects(args.action, args);
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It mentions CRUD operations but lacks behavioral details: it doesn't specify permissions needed, whether deletions are irreversible, rate limits, or what the output looks like (e.g., format of listed projects). This is inadequate for a mutation-heavy tool with no annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose (CRUD operations on projects) and enumerates the five actions. Every word earns its place with zero waste, making it easy to scan and understand quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It covers the basic actions but misses critical context: behavioral traits (e.g., destructive effects of delete), usage scenarios, and output expectations. This leaves significant gaps for an agent to operate safely and effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds no parameter-specific information beyond the high-level action list, which is already covered in the schema's enum description. Baseline 3 is appropriate as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs 'CRUD operations' on 'projects', specifying the five actions (list, create, get, update, delete). It distinguishes the resource (projects) and verbs, but doesn't explicitly differentiate from sibling tools like 'coolify_applications' or 'coolify_servers' that might handle similar operations on different resources.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description lists actions but doesn't indicate context, prerequisites, or exclusions. For example, it doesn't clarify if this is the primary tool for project management or if siblings like 'coolify_project_environments' should be used for specific aspects.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/HowieDuhzit/CoolifyMCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server