Which integrations are available for this server?

Provides authentication and user role management via Authentik, enabling user identity and access control for the platform. Allows deploying Docker images and Docker Compose applications to managed infrastructure. Enables CI/CD integration by generating GitHub Actions workflows for automated deployments. Generates GitHub Actions workflows for automated deployment on push to specified branches.

How do I use PlugLayer MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@PlugLayer MCP Server Deploy image ghcr.io/myorg/api:latest to production project." 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.

de en es ja ko ru zh

PlugLayer MCP Server

Official

by pluglayer

Overview Schema Related Servers Score Discussions

Python

Hybrid

PlugLayer MCP Server

Deploy and manage your infrastructure through natural language with any MCP-compatible AI assistant.

Installation

Option 1: uvx (recommended — no install needed)

PLUGLAYER_API_KEY=your-pluglayer-api-token uvx pluglayer-mcp

This local command mode uses the MCP stdio transport by default, which is the right mode for Cursor, Claude Code, and other editor-launched command servers. The pluglayer-mcp command now always uses stdio so editor clients cannot accidentally switch it into HTTP mode.

Option 2: pip

pip install pluglayer-mcp
PLUGLAYER_API_KEY=your-pluglayer-api-token pluglayer-mcp

Related MCP server: CloudStack MCP Server

Configuration

Claude Desktop

Add to ~/.config/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "pluglayer": {
      "command": "uvx",
      "type": "stdio",
      "args": ["pluglayer-mcp"],
      "env": {
        "PLUGLAYER_API_KEY": "your-pluglayer-api-token"
      }
    }
  }
}

Cursor

Add to ~/.cursor/mcp.json:

{
  "pluglayer": {
    "command": "uvx",
    "type": "stdio",
    "args": ["pluglayer-mcp"],
    "env": {
      "PLUGLAYER_API_KEY": "your-pluglayer-api-token"
    }
  }
}

Remote HTTP (hosted)

The remote MCP server runs at mcp.pluglayer.com. Pass your token as:

Authorization: Bearer your-pluglayer-api-token

If you intentionally want to run the package itself as an HTTP MCP server, use:

pluglayer-mcp-http

Release Checklist

Before publishing a new pluglayer-mcp build:

Confirm local command mode still uses stdio by default.
Confirm PLUGLAYER_API_URL override works when pointed at a dev API.
Confirm package version will be unique for the publish run.
Publish from the public repo main branch after reviewing the dev -> main PR.

After publishing:

Restart Cursor, Claude Code, or the MCP client you are testing.
If the editor still behaves like an older MCP build, remove and re-add the MCP server entry, then restart the editor.
Re-test with a simple command such as:
- get_current_user
- list_projects
- get_compute_summary

Cursor Notes

For command-based MCP setup, use uvx pluglayer-mcp.
Do not force HTTP transport for local editor usage.
pluglayer-mcp always uses stdio, which is the correct transport for Cursor-launched command servers.
Only use pluglayer-mcp-http when you intentionally want to run the package itself as an HTTP MCP server.

Available Tools

The MCP calls the PlugLayer FastAPI backend instead of re-implementing backend business logic. Auth, roles, ownership, compute guards, and k3s orchestration remain in the backend. MCP and editor plugins should authenticate with a PlugLayer API token created in the PlugLayer Settings page, not the browser/session auth token.

Managed registries are configured by PlugLayer admins in the platform UI/API. When deploy_image uses mirroring, the backend picks a registry the current user is allowed to use and keeps Kubernetes pull secrets in sync automatically.

Databases are a first-class Data Layer workflow in MCP. When a user needs a new database, wants to know whether one already exists, asks for a connection string, or needs env vars to wire an app to a database, the preferred MCP path is:

list_user_databases
if needed, list_database_templates
check_slug_availability
optionally check_database_slug_availability
create_database
- the MCP tool resolves required deploy-time database env vars itself
- password/secret/token/key fields are generated there when the template expects a random value
- database-name placeholders are filled from the chosen app name
get_task_status
get_database_connection_details
optionally get_database_logs when troubleshooting
use update_database_access, restart_database, or remove_database for follow-up lifecycle actions

After provisioning a database, the assistant should proactively suggest or apply exact env var updates for dependent apps instead of leaving the user with only a raw connection string.

Marketplace template deployment through MCP now supports both:

deploying into an existing project by project_id
creating a new project inline by passing project_name

Tool	Description
`get_current_user`	Show the Authentik-backed user and `roles`
`get_user_context`	Load the caller's stored user memory/context
`update_user_context`	Update the caller's stored user memory/context
`list_projects`	List authenticated user's projects
`get_my_projects`	Alias for listing the current user's projects
`create_project`	Create a new project namespace
`get_project`	Get project details, current apps in the project, and attached custom-domain state
`remove_project`	Remove one of the user's projects by deleting its apps first, requesting namespace cleanup, and then archiving the project record/history
`delete_project`	Alias for `remove_project`
`get_compute_summary`	Show account-level personal + shared compute capacity; estimate first when sizing is still unclear
`get_my_available_compute`	Show the current user's available compute capacity; pair with estimate first for planning
`get_my_available_computes`	Alias for available compute capacity
`estimate_compute`	Estimate required compute, monthly price, and a tailored offer link; preferred before purchase/allocation decisions
`list_nodes`	List accessible compute nodes
`list_registries`	List the registries currently available to the user
`deploy_image`	Mirror a Docker image into PlugLayer's managed Docker Hub namespace, then deploy it after backend compute checks; if a similar app already exists and the namespace is full, use update/replace flow instead of a brand-new app
`upload_image_archive_and_deploy`	Upload a locally built image archive from the user's machine; if the target app already exists, switch to the app upload-first redeploy flow, otherwise create and deploy a new app
`upload_image_archive_and_redeploy_app`	Upload a newly rebuilt image archive for an existing app, push it with a new tag, keep the slug unchanged, and redeploy that app
`deploy_compose`	Analyze docker-compose.yml, split it into separate deploy units, route known databases through Data Layer templates, deploy remaining services as separate apps, and require uploaded archives for local-build services
`analyze_compose_deploy_plan`	Preview how PlugLayer will split a docker-compose stack into Data Layer databases, separate compose apps, and local-build image services
`get_compose_local_build_commands`	Generate exact `docker buildx`, smoke-test, and OCI export commands for local-build compose services before they are uploaded and deployed
`list_deployments`	List running apps/deployments
`get_apps_by_project`	List apps inside a specific project; use this before deploy when you need to clarify update vs replace vs separate new app, especially when a full namespace should block duplicate new-app deploys
`check_slug_availability`	Check whether a PlugLayer slug is free inside a project before deploy or rename
`get_deployment_status`	Check app status and URL
`get_logs`	Get app logs
`get_app_logs`	Alias for getting app logs
`get_app_connection_env_vars`	Get concrete connection env vars and connection strings for an app/database so dependent apps can be updated correctly
`list_marketplace_templates`	List deployable marketplace templates before choosing one for a project
`get_marketplace_template`	Inspect one marketplace template, including its required env vars
`deploy_marketplace_template`	Deploy a marketplace template into an existing project or create a new project inline during the same MCP flow
`exec_app_terminal`	Execute a command in the caller's own deployed app container with a fixed 360-second timeout; keep terminal input at or below 10,000 characters and about 350 lines
`redeploy`	Redeploy an app after confirming the exact app name; the existing slug stays unchanged
`restart_app`	Alias for restarting an app by redeploying it
`rollback`	Roll back to previous version
`remove_app`	Remove one of the user's apps, tear down its runtime workload, revoke active routing, and mark it as removed
`delete_app`	Alias for `remove_app`
`delete_deployment`	Alias for `remove_app`
`list_database_templates`	List ready-to-deploy database templates
`list_user_databases`	List the caller's provisioned databases, optionally by project
`check_database_slug_availability`	Check whether a Data Layer slug is free in a project before provisioning or renaming a database
`create_database`	Provision a database from a template after backend compute and project checks, resolving password-like env vars inside the MCP flow first
`get_database_connection_details`	Get connection strings, env vars, and docs for a provisioned database
`sync_database_env_to_app`	Patch one app's env vars from a provisioned database's concrete connection fields, then restart the existing app
`get_database_logs`	Read logs from a provisioned database app
`update_database_access`	Update the public TCP IP allowlist for a provisioned database
`restart_database`	Restart a provisioned database by queueing its restart flow
`remove_database`	Remove a provisioned database and tear down its runtime workload/routing
`delete_database`	Alias for `remove_database`
`list_project_domains`	List custom domains for a project
`get_domains_by_project`	Alias for project-domain lookup; use this before asking which domain the user wants so existing project domains can be offered as options
`detect_custom_domain_provider`	Detect the likely DNS/domain provider so the user can confirm it before DNS instructions are shown
`add_custom_domain`	Add a single or wildcard custom domain and return DNS records in a provider-friendly table
`verify_custom_domain`	Verify TXT/CNAME DNS and activate if attached
`attach_custom_domain`	Attach a verified custom domain to an app
`detach_custom_domain`	Detach a domain while keeping verification
`get_task_status`	Poll async operation progress
`inspect_local_github_repo`	Check whether the local repo has git plus a GitHub `origin` configured
`generate_github_actions`	Get GitHub Actions YAML for a 3-step PlugLayer CI/CD flow: build OCI image, upload it to the same app id, then merge env vars and restart/redeploy

Example Conversations

Deploy your first app:

"I have a FastAPI app at ghcr.io/myorg/api:latest that runs on port 8000. Deploy it into my production project in my cloud."

Convert docker-compose:

"Here's my docker-compose.yml: [paste]. Deploy this to PlugLayer."

CI/CD setup:

"Generate a GitHub Actions workflow for my api app so every push rebuilds it, uploads it to PlugLayer, and redeploys the same app id."

The generated workflow expects:

public reusable actions from pluglayer/actions
required secrets:
- PLUGLAYER_API_KEY
optional secrets:
- PLUGLAYER_API_URL (defaults to https://api.pluglayer.com)
- PLUGLAYER_BUILD_ENV_JSON (JSON object of build-time env vars/build args to inject during image build)

Add a custom domain:

"Add api.example.com to my production project, detect the provider, show me the DNS records in a table, then verify it and attach it to my API app."

Provision a database and wire the backend to it:

"Create a Postgres database in my marketplace project, check whether the slug postgres is available first, and after it finishes show me the connection env vars so we can update my backend."

Reuse an existing database instead of creating a new one:

"Check whether I already have a Mongo or Postgres database in my project. If I do, show me the connection details and suggest the backend env vars I should update."

Getting Your API Key

Go to PlugLayer Settings
Create a PlugLayer API token
Copy it once and store it safely
Use it as PLUGLAYER_API_KEY for MCP, editor plugins, and the 3-step CI/CD actions flow

This server cannot be installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
open source
OpenAI
Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security

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/pluglayer/mcp'

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