Minecraft RCON MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have clearly distinct purposes: checking plugin status, querying databases, reading server logs, reading test logs, and executing commands. However, run_command and run_command_with_log have some overlap—both execute RCON commands—but their descriptions clarify that the latter is specifically for capturing log output, which helps differentiate them.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern (e.g., check_plugin_status, query_database, read_server_log). There are no deviations in naming conventions, making the set predictable and easy to understand.
Tool Count5/5
With 6 tools, the server is well-scoped for managing a Minecraft RCON server. Each tool serves a specific function—monitoring, logging, database queries, and command execution—without feeling excessive or insufficient for the domain.
Completeness4/5
The toolset covers core operations for Minecraft server management: health checks, log reading, database queries, and command execution. A minor gap is the lack of tools for writing to the database or managing server configurations, but agents can work around this using existing tools like run_command.
Average 4.6/5 across 6 of 6 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover key behavioral traits (read-only, non-destructive, idempotent, closed-world). The description adds useful context by specifying it reads from the 'end of the log' and includes a default value, enhancing understanding beyond annotations. No contradiction with annotations is present.
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 front-loaded with the core purpose in the first sentence, followed by a concise parameter explanation. Every sentence earns its place with no wasted words, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity, single parameter, rich annotations, and presence of an output schema, the description is nearly complete. It covers purpose and parameter semantics adequately, though could benefit from more explicit usage guidelines relative to siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining the 'lines' parameter meaning ('Number of lines to read from the end of the log') and providing the default value (50). This adds significant semantic value beyond the bare schema.
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?
The description clearly states the specific action ('Read the last N lines') and resource ('Minecraft server log file'), distinguishing it from sibling tools like read_test_log. It precisely defines what the tool does without being vague or tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for reading server logs but does not explicitly state when to use this tool versus alternatives like read_test_log or run_command_with_log. No guidance on exclusions or prerequisites is provided, leaving usage context implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds valuable behavioral context beyond annotations: it explains the filtering logic (only lines with LOG_PREFIX), default prefix '[TEST]', incremental reading mechanism, and event filtering syntax, which are not captured in annotations.
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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by key behavioral details, and ends with a structured 'Args' section. Every sentence adds value without redundancy, making it efficient and well-organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (filtered, incremental reading), annotations cover safety aspects, and an output schema exists (so return values need not be explained), the description is complete. It adequately explains purpose, usage, behavior, and parameters, leaving no significant gaps for the agent to operate correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries full burden. It effectively compensates by detailing both parameters: 'since_position' is explained as a byte offset for incremental reading with default 0, and 'event_filter' is described with examples (e.g., 'PASS', 'FAIL') and matching syntax, adding clear meaning beyond the basic schema.
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?
The description clearly states the verb 'Read' and resource 'plugin test/debug logs', specifying they are 'filtered by a configurable prefix'. It distinguishes from sibling tools like 'read_server_log' by focusing on test/debug logs with a specific prefix mechanism, not general server logs.
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 description provides clear context for when to use this tool: for reading filtered test logs with incremental reading capability. It implies usage for monitoring test events but does not explicitly state when not to use it or name alternatives among siblings, such as 'read_server_log' for non-test logs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds valuable context about what gets checked (RCON connectivity, server log errors, database file status) and the recommended timing (before tests/debugging), which goes beyond annotations. No contradiction with annotations.
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?
Two sentences, zero waste. First sentence defines purpose with specific checks, second provides usage guideline. Front-loaded with core functionality, appropriately sized for a no-parameter diagnostic tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 0 parameters, rich annotations (readOnly, idempotent, etc.), and an output schema exists, the description is complete. It explains what the tool does, when to use it, and the scope of checks, without needing to detail return values or safety (covered by annotations/output schema).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are 0 parameters, and schema description coverage is 100% (though empty). The description doesn't need to explain parameters, but it implicitly confirms no inputs are required by focusing on overall health check. Baseline for 0 parameters is 4, and the description maintains this by not introducing unnecessary parameter discussion.
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?
The description clearly states the specific verb ('check') and resource ('overall plugin health') with three concrete aspects: RCON connectivity, recent errors in server log, and database file status. It distinguishes from sibling tools like 'read_server_log' or 'query_database' by covering multiple health indicators rather than focusing on a single component.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides when-to-use guidance: 'Recommended to call before running tests or debugging.' This gives clear context for usage and distinguishes it from siblings like 'run_command' or 'read_test_log' which are for execution or post-debugging analysis rather than pre-check health assessment.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable context beyond annotations: it specifies that only SELECT queries are allowed (write operations blocked) and that results are returned as a formatted ASCII table. Annotations cover readOnlyHint, idempotentHint, etc., but the description enhances this by detailing query restrictions and output format, though it doesn't mention rate limits or error handling.
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 front-loaded with the core purpose, followed by behavioral details and parameter explanation in a structured format. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (read-only database query), rich annotations (e.g., readOnlyHint, idempotentHint), and the presence of an output schema, the description is complete enough. It covers purpose, usage restrictions, and parameter semantics, aligning well with structured data to provide a holistic understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by explaining the 'sql' parameter as 'A SELECT SQL statement,' adding meaning beyond the bare schema. However, it doesn't provide syntax examples or constraints (e.g., SQLite-specific quirks), leaving some gaps in parameter understanding.
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?
The description clearly states the specific action ('Execute a read-only SELECT query') and resource ('against the plugin's SQLite database'), distinguishing it from sibling tools like check_plugin_status or run_command. It explicitly mentions the type of operation (SELECT) and the database system (SQLite), providing precise purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Execute a read-only SELECT query') and when not to use it ('Write operations are blocked'), with clear alternatives implied (e.g., use other tools for non-SELECT operations). It distinguishes this tool from siblings by focusing on database queries versus status checks or command execution.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable behavioral context beyond what annotations provide. While annotations indicate this is a non-readOnly, non-destructive, non-idempotent, open-world operation, the description explains that it waits for log output after command execution (with a default wait time) and specifically targets commands that output to logs rather than RCON responses. This provides practical implementation details that annotations don't cover.
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 perfectly structured and concise: a clear purpose statement, specific usage guidelines with example, and parameter explanations. Every sentence adds value with no redundancy. The information is front-loaded with the core functionality stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, open-world operation), the description provides complete context. It explains the purpose, when to use it, behavioral details about log capture timing, and parameter semantics. With an output schema present, the description doesn't need to explain return values, making this appropriately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining both parameters: 'command: The Minecraft command to execute' and 'wait_seconds: Seconds to wait for log output after execution (default 2).' This adds essential semantic meaning that the bare schema lacks, though it doesn't provide format details or constraints for the command parameter.
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?
The description clearly states the specific action ('Execute an RCON command and capture server log output') and distinguishes it from the sibling tool 'run_command' by specifying it's for commands whose feedback appears in server logs rather than RCON responses. It identifies the resource (RCON commands) and the unique output mechanism (log capture).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool versus alternatives: 'Useful for commands whose feedback appears in the server log rather than the RCON response (e.g. plugin commands that print results via logger).' This clearly differentiates it from the sibling 'run_command' tool and gives a concrete example of appropriate use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable context beyond annotations: it specifies that commands should be provided 'without leading slash', which is a critical behavioral detail not covered by annotations (which indicate non-readOnly, openWorld, non-idempotent, non-destructive). This clarifies execution format, though it doesn't detail potential side effects like server state changes or error handling.
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 front-loaded with the core purpose in the first sentence, followed by concise examples that illustrate usage without redundancy. Every sentence earns its place by clarifying execution format and providing practical guidance, with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (executing commands on a server), the description is complete: it covers purpose, usage, parameter semantics, and behavioral details like command formatting. With an output schema present, it appropriately omits return value explanations, and annotations provide safety context, making this well-rounded for agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for the single parameter 'command', the description fully compensates by providing clear semantics: it explains that the command is an RCON command for Minecraft, gives examples ('say Hello', 'gamemode creative Steve'), and specifies formatting ('without leading slash'), adding essential meaning beyond the bare schema.
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?
The description clearly states the specific action ('Execute an RCON command') and resource ('on the Minecraft server'), with explicit differentiation from sibling tools like 'run_command_with_log' by specifying 'without leading slash' and providing command examples that show direct execution versus logging variants.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to use this tool ('Execute an RCON command') and provides clear alternatives through examples and context, distinguishing it from siblings like 'run_command_with_log' by emphasizing direct command execution without logging, and implicitly from query/read tools by focusing on action-oriented commands.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![Minecraft-MCP-Server MCP server](https://glama.ai/mcp/servers/MinecraftCodeFoundary/Minecraft-MCP-Server/badges/card.svg)](https://glama.ai/mcp/servers/MinecraftCodeFoundary/Minecraft-MCP-Server)

Score Badge

Copy to your README.md:

[![Minecraft-MCP-Server MCP server](https://glama.ai/mcp/servers/MinecraftCodeFoundary/Minecraft-MCP-Server/badges/score.svg)](https://glama.ai/mcp/servers/MinecraftCodeFoundary/Minecraft-MCP-Server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/MinecraftCodeFoundary/Minecraft-MCP-Server'

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