Potencia tu agente
El comando propio del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
npx -y [email protected]Claude Code no tiene enlace de instalación para un comando local. Copia el comando de abajo y ejecútalo en una terminal.
claude mcp add gameye-mcp -- npx -y gameye-mcp@0.5.3Ejecútalo en una terminal.
{ "mcpServers": { "gameye-mcp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDel publicador
A Model Context Protocol server for the Gameye game server orchestration API. It lets an AI agent (Claude Code, Claude Desktop, Cursor, or any MCP client) launch and inspect game server sessions, check image tags and regions, and fetch logs and artifacts. You talk to it in plain language, and you don't have to leave your editor.
MCP server for the Gameye game server orchestration API: launch and inspect sessions, check image tags, fetch logs and artifacts from any MCP client
Status: beta (
0.x). Tools, inputs and outputs may change between releases, and there may be bugs. The server says so to every client that connects, on startup, and ingameye_context. It is published on npm asgameye-mcp, as a container image atghcr.io/gameye/gameye-mcp, and in the MCP Registry asio.github.Gameye/gameye-mcp; see the changelog for what changed in each release.
GAMEYE_API_TOKEN=<your-token> npx -y gameye-mcp
It needs Node.js 22 or newer. The server speaks MCP over stdio. Normally your MCP client starts it for you (see Install), so you rarely need to run it by hand.
Gameye has two public API hosts. The server targets sandbox by default.
The environment is a property of the server process. No tool takes an environment argument, so an agent can't switch to production partway through a conversation. If you need both, configure two named server entries (for example gameye-sandbox and gameye-production), each with its own token.
claude mcp add gameye --env GAMEYE_API_TOKEN=<your-token> -- npx -y gameye-mcp
For production, add --env GAMEYE_ENV=production and use a production token.
Most clients (Claude Desktop, Cursor, Windsurf and others) accept an mcpServers block:
{
"mcpServers": {
"gameye": {
"command": "npx",
"args": ["-y", "gameye-mcp"],
"env": {
"GAMEYE_API_TOKEN": "<your-token>",
"GAMEYE_ENV": "sandbox"
}
}
}
}
Restart the client after you change its configuration.
npx -y gameye-mcp runs the latest release. To stay on one version, name it: npx -y [email protected] (or "args": ["-y", "[email protected]"]).
The server runs on Windows with Node.js 22 or newer. We've tested it on Windows 11, through Claude Code and over plain stdio. If something breaks on Windows, please open an issue.
Many Windows MCP clients can't start npx directly, because it's a .cmd script. Start it through cmd /c instead:
"command": "cmd",
"args": ["/c", "npx", "-y", "gameye-mcp"]
With Claude Code: claude mcp add gameye --env GAMEYE_API_TOKEN=<your-token> -- cmd /c npx -y gameye-mcp. Claude Code 2.1.296 and later also start plain npx.
In PowerShell, type npx.cmd instead of npx when you run the server by hand. A new Windows install blocks the npx PowerShell script with "running scripts is disabled on this system".
The first start downloads the package and can take 10 to 40 seconds. Later starts take about a second.
gameye_update_skills reports outdated skills on Windows but doesn't run the update. It prints the commands for you to run.
gameye_create_token writes the token file with owner-only permissions on macOS and Linux. On Windows those permissions don't apply, and the file gets the access rules of its folder. Write it inside your user profile.
No Node.js on the machine? Run the published image instead. It works on amd64 and arm64:
{
"mcpServers": {
"gameye": {
"command": "docker",
"args": ["run", "-i", "--rm", "-e", "GAMEYE_API_TOKEN", "-e", "GAMEYE_ENV", "ghcr.io/gameye/gameye-mcp"],
"env": {
"GAMEYE_API_TOKEN": "<your-token>",
"GAMEYE_ENV": "sandbox"
}
}
}
}
With Claude Code: claude mcp add gameye --env GAMEYE_API_TOKEN=<your-token> -- docker run -i --rm -e GAMEYE_API_TOKEN ghcr.io/gameye/gameye-mcp.
-e NAME (no value), so Docker copies it from the client's environment and the token never appears in the command line.-i and never add -t: a terminal mangles the JSON-RPC messages on stdout.ghcr.io/gameye/gameye-mcp:0.4.0.--rm deletes them:
gameye_get_artifacts saves its download under the temp directory. To keep it, mount a directory and point the temp directory at it: -v /absolute/dir:/out -e TMPDIR=/out. The path the tool reports is the container path; the file is in /absolute/dir on the host.gameye_create_token writes to the outputPath you give it. Mount a directory the same way and pass an outputPath under /out.Give the server a token with only the scopes it needs.
Never pass your Gameye API token into a game server's environment. A game server doesn't need it, and anything inside the container can read it.
Every tool result starts with the environment and host it used, for example [sandbox · api.sandbox-gameye.gameye.net].
Every tool carries MCP annotations: read tools set readOnlyHint, gameye_stop_session and gameye_edit_application set destructiveHint, and every tool that calls the Gameye API sets openWorldHint.
The tool set covers every operation in the Gameye client API. tests/parity.test.ts checks this against the vendored spec in spec/.
These behave the same on sandbox and production, because sandbox runs live matches for self-serve customers.
gameye_launch_session, gameye_stop_session, gameye_enable_tag and the application and token tools accept dryRun: true. The tool returns the exact request (method, host, path and body) with the API token masked, and sends nothing.ttl gets a 30m TTL, and the result says the default was applied. Every launch sends the label launched-by: gameye-mcp, replacing any launched-by value the caller passes, so agent-launched sessions can be found with gameye_list_sessions and filter: { "launched-by": "gameye-mcp" }. When a warm pool serves the image and region, the Gameye API ignores request labels (and env and args), so warm-pool sessions do not carry this label.***, in case log output, labels or an error message echo it.gameye_stop_session stops exactly one session by its exact ID. There is no bulk stop, and empty, wildcard or list IDs are refused. With GAMEYE_STOP_OWN_ONLY=1 it also refuses any session this server did not launch.GAMEYE_MAX_SESSIONS), each with a TTL of at most 4h (GAMEYE_MAX_TTL), and at most 20 launches per server run (GAMEYE_MAX_LAUNCHES). That caps one run at 20 sessions of 4 hours, 80 session-hours, and 5 at a time. Before each launch the server lists the launched-by: gameye-mcp sessions to see which of its own have ended; if that list fails, the launch is refused. Warm-pool sessions carry no label, so they count until their TTL ends. A launch that timed out or got a 5xx may have started, so it counts too. The limits apply to one server process: sessions launched by other agents or tools in your organization don't count, and a restart starts from zero, so set an organization quota in Gameye as well. gameye_context shows the limits in force.The Gameye skills change as the Gameye API does. gameye_update_skills reads the latest pack version from the gameye skill on GitHub (Pack version: in skills/gameye/SKILL.md on main) and compares it with what is installed:
~/.agents/.skill-lock.json with source gameye/gameye-skills.skills-lock.json in the server's working directory.gameye@gameye in ~/.claude/plugins/installed_plugins.json.Without apply it only reports. With apply: true, and only when the server was started with GAMEYE_ENABLE_SKILLS_UPDATE=1, it runs each outdated install's own updater: npx -y [email protected] update <the Gameye skills> -g -y (or -p -y), or claude plugin marketplace update gameye then claude plugin update gameye@gameye. Otherwise it lists those commands for you to run. The updaters get a minimal environment: paths, home, temp, locale, proxy and CA settings and npm and Claude config, never GAMEYE_* variables or anything named like a token, secret, password or key. It only updates skills whose lock-file source is gameye/gameye-skills, and it never downloads or follows skill text itself. Each command runs with stdin closed and a 90-second limit. On Windows it prints the commands instead of running them. The running agent session keeps the skills it loaded; the next session uses the update. The gameye skill tells agents to run the check once per conversation and ask before applying.
Every request to the Gameye API sends User-Agent: gameye-mcp/<version>, plus the MCP client's name once it has connected, e.g. gameye-mcp/0.1.0 (claude-code), so Gameye can count MCP usage. Only this server's version and the client name are sent, nothing else: no token, env values, paths or other data. There is no other telemetry.
gameye_create_application, gameye_edit_application and gameye_create_token are always registered. What the agent can actually do is set by the token's scopes: they need application:write or token:write, and a token without them gets a 403 naming the missing scope. To keep an agent from changing applications or minting tokens, give it a token without those scopes.
gameye_create_token never returns the new token. It writes the token to the file you name in outputPath and returns only the path, the scopes and the expiry:
outputPath must be an absolute path outside any git working tree, so the token can't be committed by accident.overwrite: true. A symlink is always refused.0600 permissions and without following symlinks. The file is reserved before the token is minted, so a bad path never creates a token.expires_after defaults to 24h. Requested scopes must be a subset of the server token's own scopes.gameye_edit_application sends only the fields you give. regions and ports, when given, replace the whole list.
A port with tls: true has TLS terminated by Gameye on the host. Set it with gameye_create_application: gameye_edit_application doesn't apply tls, and any ports sent through edit are stored with tls=false, so omit ports when editing an application that uses TLS.
To teach your agent how to integrate Gameye (session lifecycle, matchmaking, webhooks and more), install the sister project gameye-skills. The skills use these MCP tools when they are available, and fall back to plain HTTP when they aren't.
See CONTRIBUTING.md.
npm ci
npm test
npx tsc --noEmit -p tsconfig.test.json
npm run build
spec/client.yaml is a snapshot of the public sandbox /openapi.yaml, and spec/overrides.yaml holds the MCP tool name for each operation: the tools: map from gameye-skills' spec/overrides.yaml, reduced by scripts/reduce-overrides.mjs (gameye-skills keeps the full file, which records where the server differs from the spec). Refresh both with npm run sync-spec [path-or-url-to-overrides.yaml]. npm run check-spec exits 1 when either snapshot has drifted.
Gameye is a managed hosting platform for multiplayer game servers. You bring a container image, and Gameye starts a dedicated server for each match through one API.
Please report vulnerabilities privately. See SECURITY.md.
MIT © Gameye B.V.
MCP server for the Gameye game server orchestration API: launch and inspect sessions, check image tags, fetch logs and artifacts from any MCP client
{ "mcpServers": { "gameye-mcp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
Gameye se ejecuta localmente por stdio.
Última comprobación: 2026-11-15. MCP server for the Gameye game server orchestration API: launch and inspect sessions, check image tags, fetch logs and artifacts from any MCP client