Skip to main content
Glama

mc_gradle

Run Gradle build, test, or client/server tasks in Minecraft projects using the gradlew wrapper. Reports exit codes in results instead of failing on non-zero exits.

Instructions

Run a Gradle task in a Minecraft project via its wrapper (gradlew). Reports exit code in result instead of failing on non-zero exits. Use to build, test, or run client/server tasks.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "projectDir": "<projectDir>",
      "task": "<task>"
    },
    "name": "mc_gradle"
  }
}

Input Schema

NameRequiredDescriptionDefault
argsNoExtra arguments, e.g. --no-daemon, -Pfoo=bar
taskYesGradle task, e.g. build, clean, runClient, runServer
tailCharsNoOutput chars to keep, head+tail (default 12000)
timeoutMsNoTimeout in ms (default 600000)
projectDirYesAbsolute path of the Gradle project root (must contain gradlew)

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.0.0

TDQS

A3.8/5.0
Behavior3/5

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

With no annotations, the description carries the full behavioral burden and does disclose one genuinely important trait: non-zero exits are reported as an exit code in the result rather than surfacing as tool failures, which changes how an agent must interpret output. It says nothing about side effects (build artifacts written to disk), duration or long-running behavior, or whether a Gradle daemon is used, leaving mutation/latency expectations unstated for a process-spawning tool.

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

Conciseness4/5

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

Three short sentences, front-loaded with the core action, then the non-obvious exit-code behavior, then usage. No filler; only mild redundancy between 'run client/server tasks' in the last sentence and the earlier task description.

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

Completeness3/5

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

There is no output schema, and the description only tells the agent that an exit code appears in the result – not what else the result holds (presumably captured stdout, subject to tailChars). For a process-execution tool with zero annotations, that leaves the return shape and side-effect profile underspecified.

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%, and each parameter already carries examples (task names, --no-daemon, -Pfoo=bar, tailChars/timeout defaults), so the schema does the heavy lifting. The description adds no per-parameter meaning beyond confirming that the wrapper is invoked from the given project root, which matches the schema's 'must contain gradlew'.

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

Purpose5/5

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

States a specific verb and resource ('Run a Gradle task in a Minecraft project via its wrapper (gradlew)') plus the scope of typical targets (build, test, client/server runs). Among the listed siblings – version listing, reference/skill reading, scaffolding – this is unambiguously the execution tool, so differentiation is achieved without naming an alternative.

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

Usage Guidelines4/5

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

The final sentence gives concrete when-to-use contexts: building, testing, and running client/server tasks. It stops short of exclusions or of pointing at any other tool for adjacent needs, so it is clear context without routing rules.

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