mcmodding-mcp
MCModding-MCP is an AI-powered Model Context Protocol server providing real-time access to comprehensive Minecraft modding documentation, code examples, and API mappings for Fabric and NeoForge.
Core Capabilities:
• Search Documentation (search_fabric_docs) - Query 1,000+ pages of official Fabric/NeoForge documentation with filtering by category (items, blocks, entities, rendering, networking, data-generation, commands, sounds, etc.), loader, and Minecraft version
• Get Code Examples (get_example) - Retrieve working code snippets with full context and explanations, filterable by topic, mod loader, category, language, and Minecraft version
• Explain Concepts (explain_fabric_concept) - Get detailed explanations of fundamental modding concepts like mixins, registries, sided logic, events, and architectural patterns
• Version Information (get_minecraft_version) - Retrieve the latest or all indexed Minecraft versions
Key Features:
• Hybrid Search - Combines semantic embeddings, full-text, section, and code search strategies for optimal results
• Always Current - Weekly-indexed documentation (185K+ chunks) with automatic database updates, hash verification, and backups
• Version-Aware - Supports filtering by specific Minecraft versions and mod loaders for accurate information
Optional Extended Capabilities (installed via npx mcmodding-mcp manage):
• Parchment Mappings Database - Search 831K+ methods and 166K+ fields with parameter names and Javadocs using tools like search_mappings, get_class_details, lookup_obfuscated, get_method_signature, and get_package_classes
• Mod Examples Database - Search 1,000+ battle-tested code patterns from popular mods like Create, Botania, and Applied Energistics 2 using search_mod_examples, get_mod_example, list_indexed_mods, and get_mod_categories
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcmodding-mcphow do I register a custom sword in Fabric for Minecraft 1.21?"
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.
MCModding-MCP
🤖 AI-Powered Minecraft Modding Documentation Server
Give your AI assistant real-time access to Fabric & NeoForge documentation
📖 Documentation • 🚀 Quick Start • 💡 Features • 🤝 Contributing
✨ What is this?
MCModding-MCP is a Model Context Protocol (MCP) server that supercharges AI assistants like Claude with real, up-to-date Minecraft modding knowledge. No more hallucinations or outdated API references!
🎯 Key Benefits
Feature | Description |
📅 Always Current | Weekly-indexed from official sources |
✅ Accurate Answers | Real documentation, not hallucinations |
💻 Code Examples | Searchable code blocks with context |
🧠 Semantic Search | Understands meaning, not just keywords |
⚡ Zero Config | Works immediately after installation |
📊 Live Statistics
Database | Content |
📚 Docs | 1,000+ pages, 185K+ chunks |
🗺️ Mappings | 831K+ methods, 166K+ fields |
🧩 Examples | 1,000+ battle-tested patterns |
🔍 Embeddings | 185K+ semantic vectors |
📖 Javadocs | 2.3M+ documented parameters |
Related MCP server: devdocs-mcp
Quick Start
Installation
# Install globally
npm install -g mcmodding-mcpConfigure Your AI Client
Add to your MCP client configuration (e.g., Claude Desktop):
{
"mcpServers": {
"mcmodding": {
"command": "mcmodding-mcp"
}
}
}🧠 Optimized System Prompt
To get the best results, we recommend adding this to your AI's system prompt or custom instructions:
You are an expert Minecraft Modding Assistant connected to
mcmodding-mcp. DO NOT rely on your internal knowledge for modding APIs (Fabric/NeoForge) as they change frequently. ALWAYS use the available tools:
search_fabric_docsandget_examplefor documentation and code patterns
search_mappingsandget_class_detailsfor Minecraft internals and method signatures
search_mod_examplesfor battle-tested implementations from popular modsPrioritize working code examples over theoretical explanations. When dealing with Minecraft internals, use the mappings tools to get accurate parameter names and Javadocs. If the user specifies a Minecraft version, ensure all retrieved information matches that version.
That's it! Your AI assistant now has access to comprehensive Minecraft modding resources.
Database Management
Manage your documentation databases with the built-in CLI:
# Run the database manager
npx mcmodding-mcp manageThe interactive manager allows you to:
Install - Download databases you don't have yet
Update - Check for and apply database updates
Re-download - Restore deleted or corrupted databases
Available Databases
Database | Description | Size |
Documentation Database | Core Fabric & NeoForge documentation (installed by default) | ~520 MB |
Parchment Mappings ✨ NEW | Minecraft class/method/field mappings with Javadocs | ~180 MB |
Mod Examples Database | 1000+ high-quality modding examples | ~30 MB |
The manager shows version information and highlights available updates:
◉ 📚 Documentation Database [core]
✔ Installed: v0.2.1 → ↻ Update: v0.2.2 [520.3 MB]
Core Fabric & NeoForge documentation - installed by default
○ 🗺️ Parchment Mappings Database ✨ NEW
⚠ Not installed → Available: v0.1.0 [178.5 MB]
Minecraft class/method/field names with parameter names and Javadocs
○ 🧩 Mod Examples Database
⚠ Not installed → Available: v0.1.0 [28.1 MB]
1000+ high-quality modding examples for Fabric & NeoForgeAvailable Tools
The MCP server provides powerful tools across three categories:
📖 Documentation Tools
search_fabric_docs
Search documentation with smart filtering.
// Example: Find information about item registration
{
query: "how to register custom items",
category: "items", // Optional filter
loader: "fabric", // fabric | neoforge
minecraft_version: "1.21.10" // Optional version filter
}get_example
Get working code examples for any topic.
// Example: Get block registration code
{
topic: "custom block with block entity",
language: "java",
loader: "fabric"
}explain_fabric_concept
Get detailed explanations of modding concepts with related resources.
// Example: Understand mixins
{
concept: 'mixins';
}get_minecraft_version
Get current Minecraft version information.
// Get latest version
{
type: 'latest';
}
// Get all indexed versions
{
type: 'all';
}🗺️ Parchment Mappings Tools ✨ NEW
Requires Parchment Mappings database - install via npx mcmodding-mcp manage
search_mappings
Search Minecraft class, method, and field mappings with parameter names and Javadocs.
// Example: Find block-related classes and methods
{
query: "BlockEntity",
type: "class", // class | method | field | all
minecraft_version: "1.21.10",
include_javadoc: true
}get_class_details
Get comprehensive information about a Minecraft class including all methods and fields.
// Example: Explore the Block class
{
class_name: "net.minecraft.world.level.block.Block",
include_methods: true,
include_fields: true
}lookup_obfuscated
Look up deobfuscated names from obfuscated identifiers (useful for crash logs).
// Example: Decode an obfuscated method name
{
obfuscated_name: 'm_46859_';
}get_method_signature
Get the full signature of a method including all parameter names and types.
// Example: Get method details
{
class_name: "Block",
method_name: "onPlace"
}browse_package
Discover classes in a Minecraft package.
// Example: Browse block package
{
package_name: 'net.minecraft.world.level.block';
}🧩 Mod Examples Tools
Requires Mod Examples database - install via npx mcmodding-mcp manage
search_mod_examples
Search battle-tested code from popular mods like Create, Botania, and Applied Energistics 2.
// Example: Find block entity implementations
{
query: "block entity tick",
mod: "Create", // Optional: filter by mod
category: "tile-entities",
complexity: "intermediate"
}get_mod_example
Get detailed information about a specific example with full code and explanations.
// Example: Get full details for an example
{
id: 42,
include_related: true
}list_canonical_mods
Discover all indexed mods and their available examples.
list_mod_categories
Browse available example categories (blocks, entities, rendering, etc.).
Features
Hybrid Search Engine
Combines multiple search strategies for best results:
Strategy | Purpose |
FTS5 Full-Text | Fast keyword matching with ranking |
Semantic Embeddings | Understanding meaning and context |
Section Search | Finding relevant documentation sections |
Code Search | Locating specific code patterns |
Auto-Updates
The database automatically checks for updates on startup:
Compares local version with GitHub releases
Downloads new versions with hash verification
Creates backups before updating
Non-blocking - server starts immediately
Documentation Sources
Currently indexes:
wiki.fabricmc.net - Fabric Wiki (226+ pages)
docs.fabricmc.net - Official Fabric Docs (266+ pages)
docs.neoforged.net - NeoForge Docs (512+ pages)
For Developers
Development Setup
# Clone repository
git clone https://github.com/OGMatrix/mcmodding-mcp.git
cd mcmodding-mcp
# Install dependencies
npm install
# Run in development mode
npm run devBuild Commands
# Development
npm run dev # Watch mode with hot reload
npm run typecheck # TypeScript type checking
npm run lint # ESLint
npm run test # Run tests
npm run format # Prettier formatting
# Production
npm run build # Build TypeScript
npm run build:prod # Build with fresh documentation index
npm run index-docs # Index documentation with embeddings
# Database Management
npx mcmodding-mcp manage # Interactive database installer/updaterProject Structure
mcmodding-mcp/
├── src/
│ ├── index.ts # MCP server entry point
│ ├── db-versioning.ts # Auto-update system
│ ├── indexer/
│ │ ├── crawler.ts # Documentation crawler
│ │ ├── chunker.ts # Text chunking
│ │ ├── embeddings.ts # Semantic embeddings
│ │ ├── store.ts # SQLite database
│ │ └── sitemap.ts # Sitemap parsing
│ ├── services/
│ │ ├── search-service.ts # Search logic
│ │ └── concept-service.ts # Concept explanations
│ └── tools/
│ ├── searchDocs.ts # search_fabric_docs handler
│ ├── getExample.ts # get_example handler
│ └── explainConcept.ts # explain_fabric_concept handler
├── scripts/
│ └── index-docs.ts # Documentation indexing script
├── data/
│ ├── mcmodding-docs.db # SQLite database
│ └── db-manifest.json # Version manifest
└── dist/ # Compiled JavaScriptDatabase Schema
-- Documents: Full documentation pages
CREATE TABLE documents (
id INTEGER PRIMARY KEY,
url TEXT UNIQUE NOT NULL,
title TEXT NOT NULL,
content TEXT NOT NULL,
category TEXT NOT NULL,
loader TEXT NOT NULL, -- fabric | neoforge | shared
minecraft_version TEXT,
hash TEXT NOT NULL -- For change detection
);
-- Chunks: Searchable content units
CREATE TABLE chunks (
id TEXT PRIMARY KEY,
document_id INTEGER NOT NULL,
chunk_type TEXT NOT NULL, -- title | section | code | full
content TEXT NOT NULL,
section_heading TEXT,
code_language TEXT,
word_count INTEGER,
has_code BOOLEAN
);
-- Embeddings: Semantic search vectors
CREATE TABLE embeddings (
chunk_id TEXT PRIMARY KEY,
embedding BLOB NOT NULL, -- 384-dim Float32Array
dimension INTEGER NOT NULL,
model TEXT NOT NULL -- Xenova/all-MiniLM-L6-v2
);
-- FTS5 indexes for fast text search
CREATE VIRTUAL TABLE documents_fts USING fts5(...);
CREATE VIRTUAL TABLE chunks_fts USING fts5(...);Release Workflow
This project uses release-please for automated releases.
Branch Strategy
Branch | Purpose |
| Active development |
| Production releases |
How It Works
Push commits to
devusing conventional commitsRelease-please maintains a Release PR (
dev→prod)When merged, automatic release: npm publish + GitHub release + database upload
Changes sync back to
dev
See RELEASE_WORKFLOW.md for complete details.
Configuration
Environment Variables
Variable | Description | Default |
| Custom database path |
|
| Custom repo for updates | Auto-detected |
| Enable debug logging |
|
Disabling Auto-Updates
Set DB_PATH to a custom location to manage updates manually:
DB_PATH=/path/to/my/database.db mcmodding-mcp💡 Share Your Ideas!
We're actively developing mcmodding-mcp and want to hear from you!
Have an Idea?
Feature requests - What tools would make your modding easier?
New documentation sources - Know a great modding resource we should index?
Workflow improvements - How could the tools work better for your use case?
Found a Bug?
Incorrect search results?
Missing or outdated documentation?
Tool not working as expected?
Share Your Experience
Using mcmodding-mcp for a cool project? We'd love to hear about it! Share your story in Discussions.
Contributing
We welcome contributions! See CONTRIBUTING.md for guidelines.
Quick Contribution Guide
Fork the repository
Create a feature branch from
devMake changes with conventional commits
Submit a PR to
dev
License
MIT License - see LICENSE for details.
Changelog
See CHANGELOG.md for a detailed history of changes and releases.
Acknowledgments
Fabric Documentation - Official Fabric documentation
Fabric Wiki - Community wiki
NeoForge Documentation - Official NeoForge documentation
ParchmentMC - Parameter names and Javadoc mappings
Model Context Protocol - MCP specification
Transformers.js - Local ML embeddings
better-sqlite3 - Fast SQLite bindings
🎮 Built with ❤️ for the Minecraft modding community
If you find this project useful, please consider giving it a ⭐!
Available Tools
4 toolsexplain_fabric_conceptB
Get detailed explanation of a Fabric or Minecraft modding concept. Use this to understand fundamental concepts, terminology, or architectural patterns.
| Name | Required | Description | Default |
|---|---|---|---|
| concept | Yes | Concept to explain (e.g., 'mixins', 'registries', 'sided logic', 'fabric.mod.json', 'events') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool provides 'detailed explanation,' which implies a read-only, informational operation, but doesn't specify aspects like response format, potential errors, rate limits, or authentication needs. For a tool with zero annotation coverage, this is a significant gap in behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, consisting of two concise sentences that directly state the tool's purpose and usage without any wasted words. Every sentence earns its place by providing essential information efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and high schema coverage, the description is adequate but has clear gaps. It lacks output schema, so it doesn't explain return values, and with no annotations, it misses behavioral details. For a simple informational tool, it's minimally viable but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'concept' parameter well-documented in the schema. The description adds minimal value beyond the schema by implying the types of concepts (e.g., 'fundamental concepts, terminology, or architectural patterns'), but doesn't provide additional syntax or format details. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get detailed explanation') and resource ('Fabric or Minecraft modding concept'). It distinguishes itself from potential siblings by focusing on concept explanations rather than examples, versions, or documentation searches. However, it doesn't explicitly contrast with the sibling tools listed, which keeps it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance by stating 'Use this to understand fundamental concepts, terminology, or architectural patterns,' which suggests when to use it. However, it doesn't explicitly mention when not to use it or name alternatives among the sibling tools (e.g., use search_fabric_docs for broader searches). This lack of explicit exclusions or named alternatives limits the score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_exampleA
Get code examples for Minecraft modding topics. Returns complete, working code snippets with full context including explanations, source documentation, and metadata. Use this when you need concrete code examples for implementing features.
| Name | Required | Description | Default |
|---|---|---|---|
| topic | Yes | Topic or pattern to get examples for (e.g., 'register item', 'block entity', 'mixin', 'networking', 'custom armor'). Can be free-form text. | |
| language | No | Programming language (e.g., 'java', 'json', 'groovy') | java |
| loader | No | Mod loader to filter by | |
| minecraft_version | No | Target Minecraft version (e.g., '1.21.4', '1.21.10'). Latest: use 'latest' | |
| category | No | Documentation category to filter by | |
| limit | No | Maximum number of examples to return (1-10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the output format ('complete, working code snippets with full context including explanations, source documentation, and metadata'), which is helpful. However, it lacks details on error handling, rate limits, or authentication needs, leaving gaps for a tool with 6 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured with two sentences: the first defines the tool's purpose and output, the second provides usage guidelines. Every sentence adds value without redundancy, making it easy to scan and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (6 parameters, no output schema, no annotations), the description is reasonably complete. It covers purpose, output format, and usage context. However, it lacks details on behavioral aspects like error handling or performance, which would be beneficial for a tool returning code examples.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds no parameter-specific information beyond what's in the schema, such as examples for 'topic' or details on 'limit' behavior. Baseline 3 is appropriate when the schema does all the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Get code examples') and resources ('Minecraft modding topics'), distinguishing it from siblings like 'explain_fabric_concept' (conceptual explanations) and 'search_fabric_docs' (documentation search). It explicitly mentions the output format ('complete, working code snippets with full context').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance with 'Use this when you need concrete code examples for implementing features,' clearly indicating when to choose this tool over alternatives. It differentiates from siblings by focusing on practical code rather than conceptual explanations or general documentation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_minecraft_versionB
Get Minecraft version information from the indexed documentation. Returns either the latest version or all available versions.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Type of version info: 'latest' for newest version, 'all' for complete list | latest |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'Returns either the latest version or all available versions,' which implies a read-only operation, but lacks details on data sources, freshness, error handling, or rate limits. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and return options without redundancy. Every word contributes to understanding the tool's function, making it appropriately sized and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and return types but lacks details on behavioral traits and usage guidelines. Without annotations or output schema, it should provide more context on data handling and sibling differentiation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, fully documenting the single parameter 'type' with its enum values and default. The description adds minimal value by mentioning 'latest version or all available versions,' which aligns with the schema but does not provide additional syntax or format details. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Get Minecraft version information') and resource ('from the indexed documentation'), and distinguishes it from siblings by focusing on version retrieval rather than explanation, examples, or search. It explicitly mentions what is returned ('latest version or all available versions'), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus its siblings (e.g., explain_fabric_concept, get_example, search_fabric_docs). It mentions the return options ('latest' or 'all') but does not specify contexts or prerequisites for choosing between them, leaving usage decisions unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_fabric_docsA
Search Fabric modding documentation for guides and API information. Use this when you need to find documentation about Fabric modding features, APIs, or tutorials.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (e.g., 'how to register items', 'mixin tutorial', 'networking'). Be specific for best results. Especially useful for finding guides and API references. | |
| category | No | Documentation category to search within (default: all) | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the tool searches for 'guides and API information' but lacks details on behavioral traits like response format, pagination, error handling, or performance characteristics. It adds some context about what type of content is searched but doesn't fully compensate for the absence of annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded and concise with two sentences that directly state the purpose and usage guidelines, with no redundant or unnecessary information, making it highly efficient and easy to understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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, no annotations, no output schema), the description is adequate but incomplete. It covers purpose and usage well but lacks details on behavioral aspects and output, which could hinder an agent's ability to use it effectively without trial and error.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, such as examples or usage tips, but it implies the tool is for searching documentation, which aligns with the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('search') and resources ('Fabric modding documentation for guides and API information'), and distinguishes it from siblings by focusing on documentation search rather than concept explanation, examples, or version retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance on when to use this tool ('when you need to find documentation about Fabric modding features, APIs, or tutorials'), though it doesn't explicitly mention when not to use it or name alternatives, the context is clear enough for effective decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose with no overlap: explain_fabric_concept covers conceptual understanding, get_example provides code snippets, get_minecraft_version handles version data, and search_fabric_docs focuses on documentation retrieval. The descriptions reinforce these boundaries, making misselection unlikely.
All tool names follow a consistent verb_noun pattern (explain_fabric_concept, get_example, get_minecraft_version, search_fabric_docs), using snake_case throughout. This predictability aids agent comprehension and tool selection without confusion.
With 4 tools, the count is reasonable for a modding documentation server, covering key areas like concepts, examples, versions, and search. However, it feels slightly thin—adding tools for specific API queries or troubleshooting could enhance coverage, but the current set is well-scoped.
The tool surface covers core modding documentation needs: conceptual explanations, code examples, version info, and documentation search. Minor gaps exist, such as lack of tools for direct API calls or mod configuration, but agents can work around these using the provided tools effectively.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
An MCP server that gives your AI access to the source code and docs of all public github repos
MCP server for developer documentation, generated by doc2mcp.
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enables AI assistants to access up-to-date documentation for Python libraries like LangChain, LlamaIndex, and OpenAI through dynamic fetching from official sources.1MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that provides version-pinned, deterministic documentation sourced from DevDocs.io to AI assistants (Claude, RooCode, Cline, Copilot etc.) and also via offline mode. Not via Scraping! But using the supported downloading option from devdocs.15713MIT
- AlicenseNot gradedqualityAmaintenanceA Model Context Protocol server that gives AI assistants native access to Minecraft mod development tools — decompile, remap, search, and analyze Minecraft source code directly from your AI workflow.8535MIT
- AlicenseNot gradedqualityCmaintenanceMCP server that provides RAG-based access to Neoforge Mod API documentation, enabling LLMs to query the latest Neoforge modding knowledge.2MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/OGMatrix/mcmodding-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server