Overview

The Gcore MCP (Model Context Protocol) Server exposes Gcore Cloud API capabilities as tools that can be invoked by LLM-based assistants. Rather than writing low-level API calls, developers can register this MCP server with an LLM client (Cursor, Claude Code, etc.) and let the assistant call high-level operations for CDN, GPU/cloud instances, AI inference, video streaming, WAAP, networking, billing, and more.

The server acts as an adapter between the Gcore SDK and MCP-capable clients. It supports selective tool loading (so you can expose only the API surface your assistant needs) and can run either as a persistent process or one-off in a temporary environment using the uvx launcher.

GitHub: https://github.com/G-Core/gcore-mcp-server

Features

Exposes Gcore Cloud API methods as MCP tools usable by LLM assistants
Selective tool loading via a single GCORE_TOOLS environment variable (toolsets + wildcard patterns)
Predefined toolsets for common workflows (instances, management, ai_ml, networking, etc.)
Pattern matching for granular API method selection (e.g., cloud.instances., waap.)
Works with multiple transports: stdio and HTTP
Can run in a temporary environment (uvx) for one-off execution
Integrates well with clients that support deferred schema loading (e.g., Claude Code)

Installation / Configuration

Prerequisites: a Gcore API Key. See Gcore docs for how to create a permanent API token.

Basic environment variables:

export GCORE_API_KEY="your_api_key_here"
# Optional
export GCORE_BASE_URL="https://api.gcore.com"
export GCORE_CLOUD_PROJECT_ID="1"
export GCORE_CLOUD_REGION_ID="76"
export GCORE_CLIENT_ID="2"

Typical GCORE_TOOLS usage:

# Mixed predefined toolsets and patterns
export GCORE_TOOLS="instances,management,cloud.gpu_baremetal.clusters.*,dns.records.create"

# Or minimal
export GCORE_TOOLS="instances"

# Or all cloud-related methods (use with caution)
export GCORE_TOOLS="cloud.*,waap.*"

Cursor IDE integration (add to ~/.cursor/mcp.json):

{
  "mcpServers": {
    "gcore-mcp-server": {
      "command": "uvx",
      "args": ["--from", "gcore-mcp-server@git+https://github.com/G-Core/gcore-mcp-server.git", "gcore-mcp-server"],
      "env": {
        "GCORE_API_KEY": "4***1",
        "GCORE_TOOLS": "instances,management,cloud.gpu_baremetal.clusters.*"
      }
    }
  }
}

Claude Code integration (deferred tool schema loading):

{
  "mcpServers": {
    "gcore-mcp-server": {
      "command": "uvx",
      "args": ["--from", "gcore-mcp-server@git+https://github.com/G-Core/gcore-mcp-server.git", "gcore-mcp-server"],
      "env": {
        "GCORE_API_KEY": "4***1",
        "GCORE_TOOLS": "*"
      }
    }
  }
}

Running one-off with uvx:

uvx --from gcore-mcp-server@git+https://github.com/G-Core/gcore-mcp-server.git gcore-mcp-server

Available Resources (Toolsets)

The server exposes grouped toolsets to simplify selection. Use toolset names in GCORE_TOOLS or combine with wildcard patterns.

Toolset	Purpose
management	Account, project and access management
instances	Virtual machine lifecycle (create, list, delete)
baremetal	Bare metal server operations
gpu_baremetal	GPU baremetal cluster management
gpu_virtual	Virtual GPU cluster management
networking	Networks, Floating IPs, Load Balancers
security	Security groups, SSH keys, secrets
storage	Volumes, file shares
ai	AI cluster orchestration
ai_ml	AI/ML inference endpoints and serving
billing	Cost reports and billing data
containers	Container registry actions
cleanup	Bulk deletion and cleanup helpers
list	Read-only listing operations (safe for discovery)

Pattern matching examples:

Exact: cloud.instances.create
Wildcard: cloud.instances.*
Broad wildcard: cloud.*

Priority rules when mixing toolsets and patterns:

Tools from named toolsets are included first.
Pattern-matched tools are appended.
Duplicates are removed while preserving order.

Use Cases

Manage CDN and streaming: Ask the assistant to create/update CDN rules, purge caches, or inspect streaming endpoints without writing API calls.
Provision GPU infrastructure: Use AI-focused toolsets to create GPU baremetal clusters, inspect node status, and deploy inference workloads.
AI inference orchestration: Create inference endpoints, scale replicas, and get utilization stats via LLM-driven workflows.
Network and security ops: Create VPCs, assign Floating IPs, configure load balancers and WAAP rules through conversational prompts.
Cost and billing insights: Query billing reports and cost breakdowns for projects to guide budget decisions.
Cleanups and automation: Run cleanup toolsets to safely delete test instances, volumes, and resources.

Concrete example:

“Create a GPU cluster named ‘ml-training-eu’ with 4 nodes and NVIDIA A100, and return the cluster ID.” The assistant will invoke gpu_baremetal toolset methods to provision and report results.

Tips & Best Practices

Limit tools to only what the assistant needs — passing all tools can overwhelm many LLM clients.
Use patterns for fine-grained control (e.g., cloud.instances.* plus a few management methods).
Claude Code supports registering “*” because it defers schema loading; other clients may not and can hit context limits.
For interactive testing, run the server with uvx to avoid a global install.

This MCP server is intended for developers who want to expose Gcore cloud operations to LLM assistants while keeping control over the available API surface.

Gcore MCP Server for CDN, GPU, AI Inference