Complete Guide to Using MCP for Minecraft Modding

1.1 What is MCP

MCP (Model Context Protocol) is an essential tool for Minecraft mod development, especially for version 1.12.2. This comprehensive guide will walk you through the entire process of setting up and using MCP for creating your own mods.

1.2 MCP History

The MCP protocol was first released by Anthropic on November 25, 2024, as an open standard aimed at addressing the complexity of interactions between AI models and the external world. Before MCP, developers needed to create custom interfaces for each AI application and data source, which was not only time-consuming but also difficult to maintain and scale.

As large language models (LLMs) grew more powerful, their need for real-time, diverse data increased. MCP emerged to meet this need by providing a standardized protocol that makes it easier for AI models to access and process various types of data.

1.3 Why MCP is Needed

Before MCP, enabling AI models to use external data typically required:

• Manually copying and pasting information into prompts
• Uploading and downloading files
• Creating custom implementations for each new data source

These methods were not only cumbersome but also difficult to scale, creating information silos. While some platforms (like OpenAI and Google) offered Function Calling capabilities, these implementations were often platform-dependent with significant differences between platforms. For example, OpenAI's function calling method is incompatible with Google's, requiring developers to rewrite code when switching models, increasing adaptation costs.

MCP solves these problems by providing a standardized protocol that makes it easier for developers to connect AI models with various data sources and tools.

1.4 MCP vs Function Calling

• MCP (Model Context Protocol): A standard protocol that enables seamless interaction between AI models and APIs.
• Function Calling: A mechanism for AI models to call functions.

Both technologies aim to enhance AI models' ability to interact with external data, but MCP can enhance not just AI models but also other application systems. MCP is a higher-level protocol that defines how applications and AI models exchange contextual information, while Function Calling is a specific mechanism within this protocol.

An AI Agent is an autonomous intelligent system that can use Function Calling and MCP to analyze and execute tasks to achieve specific goals.

1.5 Value of MCP

MCP brings multiple benefits to AI applications and developers:

• Standardization: MCP aims to define a standardized protocol that allows developers to quickly connect models with data sources without repetitive development, enhancing model universality and implementation efficiency while reducing the complexity of connecting models with diverse data sources.
• Flexibility: MCP ensures LLM switching flexibility by helping LLMs integrate directly with data and tools. It's not limited to specific AI models; any model supporting MCP can be flexibly switched.
• Openness: As an open protocol, MCP allows any developer to create MCP servers for their products. This helps rapidly expand the ecosystem, creating network effects similar to HTTP and REST APIs, and driving the integration of models with application scenarios.
• Security: The MCP protocol has built-in strict permission control mechanisms, with data source owners always maintaining access control. Models require explicit authorization when accessing data, preventing data leakage and misuse issues.
• Ecosystem: MCP provides rich plugins and tools, allowing developers to use ready-made MCP servers without reinventing the wheel.

2.1 Basic Components

MCP follows a client-server architecture, including these core components:

• MCP Hosts: LLM applications that initiate requests (e.g., Claude Desktop, IDEs, or AI tools).
• MCP Clients: Inside the host program, maintaining a 1:1 connection with the MCP server.
• MCP Servers: Providing context, tools, and prompt information to MCP clients.
• Local Resources: Resources in the local computer that MCP servers can safely access (e.g., files, databases).
• Remote Resources: Remote resources that MCP servers can connect to (e.g., via APIs).

MCP Client

The MCP client acts as a bridge between the LLM and MCP server, with the following workflow:

1. The MCP client first obtains a list of available tools from the MCP server.
2. It sends the user's query along with tool descriptions to the LLM via function calling.
3. The LLM decides whether to use tools and which ones to use.
4. If tools are needed, the MCP client executes the corresponding tool calls through the MCP server.
5. The results of the tool calls are sent back to the LLM.
6. The LLM generates a natural language response based on all information.
7. Finally, the response is displayed to the user.

Claude Desktop and Cursor both support MCP Server connection capabilities, acting as MCP clients to connect to MCP Servers for sensing and implementing calls.

MCP Server

The MCP server is a key component in the MCP architecture, providing three main types of functionality:

• Resources: File-like data that can be read by clients, such as API responses or file contents.
• Tools: Functions that can be called by LLMs (requiring user approval).
• Prompts: Pre-written templates that help users complete specific tasks.

These features enable MCP servers to provide rich contextual information and operational capabilities for AI applications, enhancing the utility and flexibility of LLMs.

2.2 How MCP Works

The MCP protocol employs a unique architectural design that divides communication between LLMs and resources into three main parts: clients, servers, and resources.

Clients are responsible for sending requests to MCP servers, which then forward these requests to the appropriate resources. This layered design allows the MCP protocol to better control access permissions, ensuring that only authorized users can access specific resources.

Here's the basic workflow of MCP:

1. Initialize Connection: The client sends a connection request to the server, establishing a communication channel.
2. Send Request: The client constructs a request message based on needs and sends it to the server.
3. Process Request: The server receives the request, parses its content, and performs the corresponding operation (such as querying a database, reading a file, etc.).
4. Return Result: The server packages the processing result into a response message and sends it back to the client.
5. Disconnect: After the task is completed, the client can actively close the connection or wait for the server to time out and close it.

The MCP tool calling process is as follows:

1. User sends a question -> LLM analyzes available tools
2. Client executes selected tools through the MCP server
3. Results are sent back to the LLM
4. LLM answers based on tool results and the user's question

This process is similar to Retrieval-Augmented Generation (RAG), but replaces the retrieval part with tool calling.

2.3 Communication Mechanisms

The MCP protocol supports two main communication mechanisms: local communication based on standard input/output and remote communication based on SSE (Server-Sent Events).

Both mechanisms use JSON-RPC 2.0 format for message transmission, ensuring standardization and extensibility of communication.

• Local Communication: Transmits data through stdio, suitable for communication between clients and servers running on the same machine.
• Remote Communication: Uses SSE combined with HTTP to achieve real-time data transmission across networks, suitable for scenarios requiring access to remote resources or distributed deployment.

2.4 Data Security

MCP greatly reduces the risk of data leakage through standardized data access interfaces by minimizing direct contact with sensitive data. MCP has built-in security mechanisms to ensure that only verified requests can access specific resources, adding an extra layer of protection for data security. Additionally, the MCP protocol supports various encryption algorithms to ensure data security during transmission.

For example, MCP servers control their own resources and don't need to provide sensitive information like API keys to LLM providers. This way, even if an LLM provider is attacked, attackers cannot obtain this sensitive information.

3.1 File System Access

MCP allows AI models to safely access local file systems, read and write files, enabling AI assistants to:

• Read local documents for analysis
• Create and edit files
• Manage folders and file structures
• Save generated content locally

3.2 Database Operations

Through MCP, AI models can connect to databases and execute query operations:

• Retrieve information from enterprise internal databases
• Analyze database records
• Execute SQL queries and explain results
• Update database content (when authorized)

3.3 API Integration

MCP enables AI models to interact with various API services:

• Get real-time information (such as weather, stock prices, news)
• Call third-party services
• Integrate with enterprise internal API systems
• Access cloud services and online tools

3.4 Development Tool Integration

MCP can connect AI models with development tools and environments:

• Access code repositories and version control systems
• Perform code analysis and debugging
• Integrate with IDEs (Integrated Development Environments)
• Automate development workflows

3.5 Browser Automation

Through MCP, AI models can control browsers to perform various operations:

• Access web pages and extract information
• Fill out forms and perform click operations
• Automate repetitive web tasks
• Conduct web page testing and validation

3.6 Productivity Tools

MCP can connect AI models with various productivity and communication tools:

• Manage calendars and schedule meetings
• Process emails and messages
• Create and edit documents, spreadsheets, and presentations
• Organize tasks and projects

4.1 Environment Setup

First, we need to prepare a Python environment and install the necessary dependencies:

# Create and enter project directory
mkdir my_first_mcp
cd my_first_mcp

# Create virtual environment
python -m venv venv

# Activate virtual environment
# Windows:
venv\Scripts\activate
# Linux/Mac:
# source venv/bin/activate

# Install dependencies
pip install "mcp[cli]" httpx

4.2 Creating an MCP Server

Create a file named search_server.py to implement a simple web search service:

import httpx
from mcp.server import FastMCP

# Initialize FastMCP server
app = FastMCP('web-search')

@app.tool()
async def web_search(query: str) -> str:
    """
    Search the internet for content
    Args:
        query: Content to search for
    Returns:
        Search result summary
    """
    # Using a simple search API, can be replaced with other search services in actual applications
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.duckduckgo.com/?q={query}&format=json"
        )
        data = response.json()
        
        # Extract search results
        results = []
        if "AbstractText" in data and data["AbstractText"]:
            results.append(f"Summary: {data['AbstractText']}")
        
        if "RelatedTopics" in data:
            for topic in data["RelatedTopics"][:5]:  # Limit to first 5 related topics
                if "Text" in topic:
                    results.append(f"- {topic['Text']}")
        
        if not results:
            return "No relevant results found"
        
        return "\n\n".join(results)

if __name__ == "__main__":
    app.run(transport='stdio')

4.3 Testing the MCP Server

We can use the Inspector tool provided by MCP to test our server:

# Install Inspector tool (requires Node.js environment)
npm install -g @modelcontextprotocol/inspector

# Run Inspector
mcp dev search_server.py

After running, a local URL will be provided (usually http://localhost:5173). Open this URL in a browser, click the "Connect" button to connect to the server, then switch to the "Tools" tab, click the "List Tools" button to view available tools, and finally test our search tool.

4.4 Creating an MCP Client

Now, let's create a simple client to call our search service. Create a file named search_client.py:

import asyncio
from mcp.client.stdio import stdio_client
from mcp import ClientSession, StdioServerParameters

# Configure server parameters
server_params = StdioServerParameters(
    command='python',
    args=['search_server.py']
)

async def main():
    # Create stdio client
    async with stdio_client(server_params) as (stdio, write):
        # Create ClientSession object
        async with ClientSession(stdio, write) as session:
            # Initialize ClientSession
            await session.initialize()
            
            # List available tools
            tools = await session.list_tools()
            print("Available tools:")
            for tool in tools:
                print(f"- {tool['name']}: {tool['description']}")
            print()
            
            # User input search query
            query = input("Enter search content: ")
            
            # Call search tool
            print("Searching...")
            result = await session.call_tool('web_search', {'query': query})
            
            # Display results
            print("\nSearch results:")
            print(result)

if __name__ == "__main__":
    asyncio.run(main())

Run the client:

python search_client.py

5.1 Basic Example: Web Search Server

Here's a basic implementation example of an MCP server that provides web search functionality.

Initialize Project

First, use the uv tool to initialize the project and install necessary dependencies:

# Initialize project
uv init mcp_getting_started
cd mcp_getting_started

# Create virtual environment and enter it
uv venv
.venv\Scripts\activate.bat  # Windows system
# source .venv/bin/activate  # Linux/Mac system

# Install dependencies
uv add "mcp[cli]" httpx openai

Implement Web Search Server

Create a file named web_search.py to implement a simple web search MCP server:

import httpx
from mcp.server import FastMCP

# Initialize FastMCP server
app = FastMCP('web-search')

@app.tool()
async def web_search(query: str) -> str:
    """
    Search the internet for content
    Args:
        query: Content to search for
    Returns:
        Summary of search results
    """

    async with httpx.AsyncClient() as client:
        response = await client.post(
            'https://open.bigmodel.cn/api/paas/v4/tools',
            headers={'Authorization': 'YOUR_API_KEY'},
            json={
                'tool': 'web-search-pro',
                'messages': [
                    {'role': 'user', 'content': query}
                ],
                'stream': False
            }
        )

        res_data = []
        for choice in response.json()['choices']:
            for message in choice['message']['tool_calls']:
                search_results = message.get('search_result')
                if not search_results:
                    continue
                for result in search_results:
                    res_data.append(result['content'])

        return '\n\n\n'.join(res_data)

if __name__ == "__main__":
    app.run(transport='stdio')

Test MCP Server

You can use the official Inspector tool to test the MCP server:

# Run Inspector via npx
npx -y @modelcontextprotocol/inspector uv run web_search.py

# Or run via mcp dev command
mcp dev web_search.py

5.2 LLM Integration

Here's an example of integrating an MCP server with a large language model:

import os
import asyncio
from dotenv import load_dotenv
from openai import AsyncOpenAI
from mcp.client.stdio import stdio_client
from mcp import ClientSession, StdioServerParameters

# Load environment variables
load_dotenv()

# Configure OpenAI client
client = AsyncOpenAI(
    api_key=os.getenv("OPENAI_API_KEY")
)

# Configure MCP server parameters
server_params = StdioServerParameters(
    command='python',
    args=['search_server.py']
)

async def main():
    # Connect to MCP server
    async with stdio_client(server_params) as (stdio, write):
        async with ClientSession(stdio, write) as session:
            await session.initialize()
            
            # Get tool list
            tools = await session.list_tools()
            
            # Build tool descriptions
            tool_descriptions = []
            for tool in tools:
                tool_descriptions.append({
                    "type": "function",
                    "function": {
                        "name": tool["name"],
                        "description": tool["description"],
                        "parameters": tool["inputSchema"]
                    }
                })
            
            print("AI Assistant is ready! Enter 'exit' to end the conversation.")
            
            while True:
                # Get user input
                user_input = input("\nYou: ")
                if user_input.lower() in ['exit', 'quit']:
                    break
                
                print("AI Assistant is thinking...")
                
                # Call OpenAI model
                response = await client.chat.completions.create(
                    model="gpt-3.5-turbo",
                    messages=[{"role": "user", "content": user_input}],
                    tools=tool_descriptions,
                    tool_choice="auto"
                )
                
                # Process model response
                message = response.choices[0].message
                
                # If model chooses to use tools
                if message.tool_calls:
                    tool_outputs = []
                    
                    for tool_call in message.tool_calls:
                        function_name = tool_call.function.name
                        function_args = eval(tool_call.function.arguments)
                        
                        print(f"AI Assistant is using tool: {function_name}")
                        
                        # Call MCP tool
                        tool_response = await session.call_tool(function_name, function_args)
                        
                        tool_outputs.append({
                            "tool_call_id": tool_call.id,
                            "role": "tool",
                            "name": function_name,
                            "content": tool_response
                        })
                    
                    # Send tool responses back to model
                    messages = [
                        {"role": "user", "content": user_input},
                        message.model_dump()
                    ]
                    messages.extend(tool_outputs)
                    
                    final_response = await client.chat.completions.create(
                        model="gpt-3.5-turbo",
                        messages=messages
                    )
                    
                    # Output final response
                    print("\nAI Assistant:", final_response.choices[0].message.content)
                else:
                    # If model answers directly
                    print("\nAI Assistant:", message.content)

if __name__ == "__main__":
    asyncio.run(main())

5.3 Practical Use Cases

Case 1: File System Access

Here's an example of an MCP server that allows AI models to access the local file system:

from mcp.server import FastMCP
import os

app = FastMCP('filesystem')

@app.tool()
async def list_files(directory: str = ".") -> str:
    """
    List files and folders in the specified directory
    Args:
        directory: Directory path to list contents, defaults to current directory
    Returns:
        List of directory contents
    """
    try:
        items = os.listdir(directory)
        result = []
        for item in items:
            full_path = os.path.join(directory, item)
            item_type = "Folder" if os.path.isdir(full_path) else "File"
            result.append(f"{item} ({item_type})")
        return "\n".join(result)
    except Exception as e:
        return f"Error: {str(e)}"

@app.tool()
async def read_file(file_path: str) -> str:
    """
    Read file content
    Args:
        file_path: Path of the file to read
    Returns:
        File content
    """
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            return f.read()
    except Exception as e:
        return f"Error: {str(e)}"

@app.tool()
async def write_file(file_path: str, content: str) -> str:
    """
    Write content to file
    Args:
        file_path: Path of the file to write to
        content: Content to write
    Returns:
        Operation result
    """
    try:
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(content)
        return f"Successfully wrote to file: {file_path}"
    except Exception as e:
        return f"Error: {str(e)}"

if __name__ == "__main__":
    app.run(transport='stdio')

Case 2: Database Queries

Here's an example of an MCP server that allows AI models to execute SQL queries:

from mcp.server import FastMCP
import sqlite3
import pandas as pd

app = FastMCP('database')

@app.tool()
async def execute_query(query: str, database_path: str = "example.db") -> str:
    """
    Execute SQL query
    Args:
        query: SQL query statement
        database_path: Database file path
    Returns:
        Query result
    """
    try:
        conn = sqlite3.connect(database_path)
        
        # Check if it's a SELECT query
        if query.strip().upper().startswith("SELECT"):
            df = pd.read_sql_query(query, conn)
            result = df.to_string()
        else:
            cursor = conn.cursor()
            cursor.execute(query)
            conn.commit()
            result = f"Query executed successfully, affected {cursor.rowcount} rows"
            
        conn.close()
        return result
    except Exception as e:
        return f"Error: {str(e)}"

if __name__ == "__main__":
    app.run(transport='stdio')

Case 3: Browser Automation

Here's an example of an MCP server using Playwright for browser automation:

from mcp.server import FastMCP
from playwright.async_api import async_playwright

app = FastMCP('browser-automation')

@app.tool()
async def browse_website(url: str) -> str:
    """
    Visit website and get content
    Args:
        url: Website URL to visit
    Returns:
        Web page content summary
    """
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        
        try:
            await page.goto(url)
            title = await page.title()
            content = await page.content()
            
            # Extract page text content
            text = await page.evaluate('''() => {
                return document.body.innerText.substring(0, 1000) + "...";
            }''')
            
            await browser.close()
            return f"Title: {title}\n\nContent Summary:\n{text}"
        except Exception as e:
            await browser.close()
            return f"Error: {str(e)}"

if __name__ == "__main__":
    app.run(transport='stdio')

6.1 Security Considerations

• Permission Control: Always verify user permissions, especially when involving file system and database operations.
• Principle of Least Privilege: Limit the access scope of tools, providing only the minimum permissions needed to complete tasks.
• Sensitive Information Protection: Don't hardcode sensitive information (like API keys) in tools; use environment variables or secure key management systems.
• Input Validation: Validate and sanitize all user inputs to prevent injection attacks.
• Audit Logging: Implement detailed logging to track all tool calls and resource accesses.

6.2 Performance Optimization

• Asynchronous Processing: For time-consuming operations, consider implementing asynchronous processing to avoid blocking the main thread.
• Data Caching: Cache frequently requested data to reduce repeated calculations and network requests.
• Pagination: When handling large amounts of data, implement pagination mechanisms to avoid returning too much data at once.
• Timeout Control: Set reasonable timeout periods for all external calls to prevent long waiting times.
• Resource Limits: Limit the size of returned data to avoid exceeding the model's context window.

6.3 User Experience

• Clear Error Messages: Provide specific, easy-to-understand error messages to help users quickly locate problems.
• Progress Feedback: Implement progress feedback mechanisms, especially for long-running operations, to let users know the current status.
• Intuitive Tool Design: Design intuitive tool names and descriptions to help models correctly choose tools.
• Graceful Degradation: Provide alternative options when preferred methods fail to ensure functionality.
• User Confirmation: Implement user confirmation mechanisms for potentially risky operations to avoid accidental operations.

6.4 Debugging Tips

• Use Inspector: Utilize the MCP Inspector tool for interactive debugging to visually inspect requests and responses.
• Detailed Logging: Implement different levels of logging to easily adjust log detail levels in development and production environments.
• Unit Testing: Write unit tests for complex tools to ensure functionality correctness.
• Mock Data: Create mock data and environments for testing without affecting production systems.
• Breakpoint Debugging: Set breakpoints at key code locations and use debuggers to step through code execution.

7.1 Official Resources

• MCP Official Website
• MCP GitHub Repository
• MCP Server List
• MCP Documentation

7.2 Community Resources

• Awesome MCP Servers - Community-maintained list of MCP servers
• MCP Discord Community
• MCP Chinese Getting Started Guide

7.3 Tools & Libraries

• MCP Inspector - Tool for debugging MCP servers
• MCP Python Library - Python implementation of MCP
• MCP TypeScript Library - TypeScript implementation of MCP
• MCP CLI - MCP command-line tool