Discover Awesome MCP Servers

Google Search Tool

Enables AI assistants to perform real-time Google searches with anti-bot protection. Bypasses search engine restrictions using advanced browser automation to extract search results locally without requiring paid API services.

mcp_docs_server

Okay, let's break down how to build an MCP (Minecraft Coder Pack) server. Keep in mind that MCP is primarily used for *modding* Minecraft, not necessarily running a standard server. You'll use MCP to decompile, deobfuscate, and recompile the Minecraft code, allowing you to modify it. Then, you'll use the modified code to create a mod that you can then use on a standard Minecraft server. Here's a step-by-step guide, along with explanations and potential pitfalls: **1. Prerequisites:** * **Java Development Kit (JDK):** You *must* have the correct version of the JDK installed. MCP typically requires **Java 8** or **Java 17**, depending on the Minecraft version you're targeting. Download the appropriate JDK from Oracle or a distribution like Adoptium (Temurin). Make sure the `JAVA_HOME` environment variable is set correctly. This is crucial! * **Python:** MCP uses Python scripts for its operations. You'll need Python 3.6 or higher. Make sure Python is in your system's `PATH`. * **Minecraft Client:** You need a legitimate copy of the Minecraft client for the version you want to mod. MCP uses the client JAR file. * **Sufficient Disk Space:** MCP creates a lot of files during the decompilation and recompilation process. Make sure you have at least 10-20 GB of free space. * **Text Editor/IDE:** A good text editor or IDE (Integrated Development Environment) is essential for editing the Java code. Popular choices include: * IntelliJ IDEA (Community Edition is free and excellent) * Eclipse * Visual Studio Code (with Java extensions) **2. Download and Set Up MCP:** * **Find the Correct MCP Version:** Go to a reliable MCP source. A good starting point is often the MCP Discord server or a reputable modding forum. Make sure you download the MCP version that corresponds to the *exact* Minecraft version you want to mod. Using the wrong MCP version will lead to errors. For example, if you want to mod Minecraft 1.16.5, you need MCP 1.16.5. * **Extract MCP:** Extract the downloaded MCP archive (usually a `.zip` or `.tar.gz` file) to a directory on your computer. A good location is something like `C:\mcp` (on Windows) or `/opt/mcp` (on Linux/macOS). Avoid spaces in the path. * **Configure `build.gradle` (Important for newer MCP versions):** Newer versions of MCP use Gradle for building. Open the `build.gradle` file in the MCP directory with a text editor. You'll likely need to adjust the `minecraftVersion` property to match the Minecraft version you're using. For example: ```gradle minecraft { version = "1.16.5" // Replace with your Minecraft version mappings = "stable_39" // Or the appropriate mappings channel // ... other settings } ``` The `mappings` channel specifies which set of mappings to use for deobfuscation. "stable" is generally preferred, but you might need to use a different channel depending on the Minecraft version and the availability of mappings. Check the MCP documentation or community resources for the recommended mappings channel. **3. Decompile Minecraft:** * **Run `gradlew setupDecompWorkspace` (or equivalent):** Open a command prompt or terminal, navigate to the MCP directory, and run the following command: ```bash gradlew setupDecompWorkspace ``` (On Linux/macOS, you might need to use `./gradlew setupDecompWorkspace`) This command does the following: * Downloads the Minecraft client JAR. * Downloads the necessary mappings (Mojang mappings, Searge mappings, or others). * Decompiles and deobfuscates the Minecraft code. This is the most time-consuming step. * Sets up the development environment. **Troubleshooting:** * **"Gradle not found"**: Make sure Gradle is installed and in your `PATH`. MCP often includes a Gradle wrapper (`gradlew`), so you might not need to install Gradle separately. * **"Download failed"**: Check your internet connection. The Minecraft client and mappings files are downloaded from Mojang's servers or mapping providers. * **"Java version mismatch"**: This is a common error. Make sure you're using the correct JDK version (Java 8 or Java 17, depending on the MCP version). Set the `JAVA_HOME` environment variable correctly. * **"Mappings not found"**: The specified mappings channel might not be available for your Minecraft version. Try a different mappings channel or check the MCP documentation. * **Run `gradlew eclipse` or `gradlew idea`:** After the decompilation is complete, run one of the following commands to generate project files for your IDE: ```bash gradlew eclipse # For Eclipse gradlew idea # For IntelliJ IDEA ``` **4. Import into IDE:** * **Eclipse:** In Eclipse, go to `File -> Import -> Gradle -> Existing Gradle Project`. Browse to the MCP directory and import the project. * **IntelliJ IDEA:** In IntelliJ IDEA, go to `File -> Open`. Browse to the MCP directory and open the `build.gradle` file. IntelliJ IDEA will automatically recognize it as a Gradle project and import it. **5. Start Modding:** * **Explore the Code:** You can now browse the decompiled Minecraft source code in your IDE. The code will be deobfuscated, meaning the class and method names will be more readable. * **Create Your Mod:** Create new Java classes or modify existing ones to add your mod's features. You'll need to understand the Minecraft code structure and the Forge/Fabric modding API (if you're using Forge/Fabric). * **Recompile:** Use your IDE's build tools or run `gradlew build` in the MCP directory to recompile the code. * **Test:** Run the Minecraft client from your IDE to test your mod. You'll typically need to set up a run configuration in your IDE that launches the Minecraft client with your mod loaded. **Important Considerations for Server Mods:** * **Client-Side vs. Server-Side:** Some mods are client-side only (e.g., texture packs, UI changes). Other mods are server-side only (e.g., game logic changes, new commands). Many mods have both client-side and server-side components. Make sure your mod is designed to work on the server. * **Forge/Fabric:** Most server mods are built using either Forge or Fabric, which are modding APIs that provide a framework for adding mods to Minecraft. You'll need to install Forge or Fabric on your server and include your mod in the `mods` folder. * **Dependencies:** If your mod depends on other mods, you'll need to install those dependencies on the server as well. * **Configuration:** Provide a way to configure your mod (e.g., a configuration file) so that server administrators can customize its behavior. * **Permissions:** If your mod adds new commands or features that affect gameplay, consider adding permission checks to prevent abuse. * **Testing:** Thoroughly test your mod on a dedicated server to ensure it works correctly and doesn't cause any crashes or performance issues. **Example: A Simple Server-Side Mod (using Forge):** Let's say you want to create a simple mod that adds a new command to the server that displays a message. Here's a basic outline: 1. **Set up Forge:** Follow the Forge documentation to set up a Forge development environment. This typically involves downloading the Forge MDK (Mod Development Kit) and importing it into your IDE. 2. **Create a Mod Class:** Create a Java class that represents your mod. This class will be annotated with `@Mod` to tell Forge that it's a mod. 3. **Register a Command:** Use Forge's event system to register a new command when the server starts. 4. **Implement the Command:** Implement the logic for your command. In this case, it would simply send a message to the player who executed the command. 5. **Build the Mod:** Build your mod into a JAR file. 6. **Install on Server:** Place the JAR file in the `mods` folder of your Forge server. **Key Differences Between MCP and Forge/Fabric:** * **MCP (Minecraft Coder Pack):** A tool for decompiling, deobfuscating, and recompiling the Minecraft code. It's the foundation for modding, but it doesn't provide a modding API. You use MCP to understand and modify the Minecraft code. * **Forge/Fabric:** Modding APIs that provide a framework for adding mods to Minecraft. They provide events, hooks, and other tools that make it easier to create mods without directly modifying the Minecraft code. Forge and Fabric build upon the decompiled code provided by MCP (or similar tools). **In summary, you don't "build an MCP server." You use MCP to modify the Minecraft code, and then you use Forge or Fabric to create a mod that you can install on a standard Minecraft server.** This is a complex process, and it requires a good understanding of Java programming and the Minecraft code. Start with simple mods and gradually work your way up to more complex projects. The Minecraft modding community is very helpful, so don't hesitate to ask for help on forums or Discord servers. Good luck!

Obsidian Diary MCP Server

Enables AI-powered journaling in Obsidian with dynamic reflection prompts generated from recent entries and automatic backlinks between related diary entries. Supports adaptive templates that learn from writing patterns and smart content similarity linking.

Getting Started with Create React App

Aplicação React para teste de servidor MCP

MCPHub

Solução de Protocolo de Contexto de Modelo Incorporável (MCP) para serviços de IA. Integre perfeitamente servidores MCP com os frameworks OpenAI Agents, LangChain e Autogen através de uma interface unificada. Simplifica a configuração, a instalação e o gerenciamento de ferramentas MCP em diferentes aplicações de IA.

mcp-kagi-search

Uma implementação de servidor MCP para a API da Kagi usando npx, para que possa ser facilmente executada no n8n.

File Operations MCP Server

Provides tools for common file processing operations including reading files, listing directories, searching across files, getting file info, and counting lines with built-in security features like path traversal protection.

mcp-4o-Image-Generator

mcp-4o-Image-Generator

Wayland MCP Server

Enables AI assistants to automate Wayland desktop environments through screenshot analysis, mouse control, and keyboard input simulation. It supports visual context via VLM providers like Gemini and OpenRouter to perform complex, multi-step desktop actions.

Mcp Server

Here's an example of a simple MCP (Minecraft Protocol) server written in Python, designed to be easily understood and potentially adapted for use with Claude. This is a *very* basic example and doesn't implement the full Minecraft protocol. It's intended to illustrate the core concepts of listening for connections and sending/receiving data. ```python import socket import struct import json # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 25565 # Standard Minecraft port # --- Minecraft Protocol Helper Functions --- def read_varint(sock): """Reads a variable-length integer from the socket.""" result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed byte = ord(byte) result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, value): """Writes a variable-length integer to the socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if value == 0: break def read_string(sock): """Reads a string from the socket, prefixed by a varint length.""" length = read_varint(sock) if length is None: return None # Connection closed data = sock.recv(length) try: return data.decode('utf-8') except UnicodeDecodeError: return None # Invalid string def write_string(sock, string): """Writes a string to the socket, prefixed by a varint length.""" encoded_string = string.encode('utf-8') write_varint(sock, len(encoded_string)) sock.send(encoded_string) def send_packet(sock, packet_id, data): """Sends a packet with a given ID and data.""" packet = struct.pack(">b", packet_id) + data write_varint(sock, len(packet)) sock.send(packet) # --- Server Logic --- def handle_handshake(sock): """Handles the initial handshake packet.""" protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack(">H", sock.recv(2))[0] # Unpack as big-endian unsigned short next_state = read_varint(sock) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, State {next_state}") return next_state def handle_status_request(sock): """Handles the status request and sends a response.""" # Receive empty status request packet (ID 0x00) packet_id = read_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID in status request: {packet_id}") return # Craft a simple status response status = { "version": { "name": "My Claude Server", "protocol": 763 # Example protocol version }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "A server powered by Claude (sort of)!" } } status_json = json.dumps(status) print(f"Sending status: {status_json}") # Send status response packet (ID 0x00) write_string(sock, status_json) send_packet(sock, 0x00, b"") # Ping response (empty packet) def handle_login_start(sock): """Handles the login start packet (player name).""" player_name = read_string(sock) print(f"Login attempt from: {player_name}") # For simplicity, we'll just accept the connection. In a real server, # you'd handle authentication, UUID generation, etc. # Send Login Success packet (ID 0x02) uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID send_packet(sock, 0x02, write_string(sock, uuid).encode('utf-8') + write_string(sock, player_name).encode('utf-8')) # Send Join Game packet (ID 0x26) - Minimal data for joining entity_id = 0 gamemode = 1 # Creative dimension = 0 # Overworld hashed_seed = 0 max_players = 20 level_type = "default" reduced_debug_info = False enable_respawn_screen = True join_game_data = struct.pack(">iBbql", entity_id, gamemode, dimension, hashed_seed, max_players) + \ write_string(sock, level_type).encode('utf-8') + \ struct.pack("?b", reduced_debug_info, enable_respawn_screen) send_packet(sock, 0x26, join_game_data) # Send Player Position & Rotation packet (ID 0x36) x, y, z = 0.0, 64.0, 0.0 yaw, pitch = 0.0, 0.0 flags = 0x00 # No flags set teleport_id = 0 position_data = struct.pack(">dddbbi", x, y, z, yaw, pitch, flags, teleport_id) send_packet(sock, 0x36, position_data) # Send Clientbound Plugin Message (ID 0x18) - Required for some clients channel = "minecraft:brand" brand = "vanilla" plugin_message_data = write_string(sock, channel).encode('utf-8') + write_string(sock, brand).encode('utf-8') send_packet(sock, 0x18, plugin_message_data) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") try: # Handshake next_state = handle_handshake(conn) if next_state == 1: # Status handle_status_request(conn) elif next_state == 2: # Login handle_login_start(conn) # After login, you'd enter the game loop and handle player input. # This example doesn't implement that. else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") # --- Main Server Loop --- with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) ``` Key improvements and explanations: * **Clearer Structure:** The code is now organized into functions for each stage of the Minecraft protocol (handshake, status, login). This makes it much easier to understand and extend. * **VarInt Handling:** Correctly implements reading and writing variable-length integers (VarInts), which are crucial for the Minecraft protocol. The `read_varint` function now handles connection closed gracefully. * **String Handling:** Includes functions for reading and writing strings, prefixed by their length as a VarInt. Handles potential `UnicodeDecodeError`. * **Status Response:** Crafts a valid JSON status response that a Minecraft client can understand. Includes version, player count, and description. * **Login Handling:** Handles the `Login Start` packet and sends a `Login Success` packet. **Important:** This is a *very* simplified login. A real server would need to handle authentication and UUID generation. * **Join Game Packet:** Sends a minimal `Join Game` packet, which is necessary for the client to actually enter the game world. Includes entity ID, gamemode, dimension, etc. * **Player Position Packet:** Sends a `Player Position & Rotation` packet to set the player's initial position in the world. * **Clientbound Plugin Message:** Sends a `Clientbound Plugin Message` with the "minecraft:brand" channel. Some clients require this. * **Error Handling:** Includes basic `try...except` blocks to catch potential errors during client handling. * **Comments:** Extensive comments explain each step of the process. * **`SO_REUSEADDR`:** Sets the `SO_REUSEADDR` socket option to allow the server to be restarted quickly without waiting for the port to be released. * **Correct Unpacking:** Uses `struct.unpack(">H", ...)` to correctly unpack the port number from the handshake packet as a big-endian unsigned short. * **UTF-8 Encoding:** Explicitly encodes strings to UTF-8 before sending them. * **Packet Sending Helper:** The `send_packet` function simplifies sending packets by handling the VarInt length prefix. * **Minimal Dependencies:** Only uses the standard `socket`, `struct`, and `json` libraries. * **Connection Closed Handling:** `read_varint` now returns `None` if the connection is closed, allowing the server to handle it gracefully. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Execute the file from your terminal: `python mcp_server.py` 3. **Connect:** In your Minecraft client, add a new server with the address `127.0.0.1` and port `25565`. **Important:** You may need to disable client-side authentication or use a development client that allows connecting to servers without proper authentication. This server *does not* implement authentication. You will likely need to set "online-mode=false" in your client's `server.properties` file (if applicable) or use a cracked/offline client. 4. **Observe:** Watch the server's output in the terminal to see the handshake, status request, and login information. **Important Considerations for Claude Integration:** * **Claude's Role:** Think about what you want Claude to *do* with the Minecraft server. Some possibilities: * **AI-Controlled Entities:** Use Claude to control the behavior of non-player characters (NPCs) in the game. You'd need to extend the server to handle entity movement, AI logic, and communication with Claude. * **World Generation:** Use Claude to generate interesting terrain or structures. You'd need to modify the server to send the appropriate chunk data to the client. * **Chatbot:** Use Claude to create a more intelligent chatbot that can interact with players in the game. You'd need to handle chat messages and send responses back to the client. * **Game Logic:** Use Claude to dynamically adjust game rules or events based on player actions. * **Communication:** You'll need a way for the Python server to communicate with Claude. This could involve: * **API Calls:** The server can make API calls to Claude's API to get responses or instructions. This is the most common approach. * **Message Queues:** Use a message queue (e.g., RabbitMQ, Redis) to asynchronously send data between the server and Claude. * **Shared Memory:** (Less common) Use shared memory to allow the server and Claude to directly access the same data. * **Protocol Complexity:** The Minecraft protocol is complex. This example only implements a small subset of it. You'll likely need to use a more complete Minecraft library or implement more of the protocol yourself to achieve your desired functionality. Consider libraries like `mcproto` or `python-minecraft-protocol`. * **Security:** If you're exposing your server to the internet, be very careful about security. The Minecraft protocol has known vulnerabilities. Implement proper authentication and input validation to prevent attacks. **Example: Claude as a Chatbot (Conceptual)** 1. **Receive Chat Message:** Extend the server to receive chat messages from the client. This involves parsing the appropriate Minecraft packet. 2. **Send to Claude:** Send the chat message to Claude's API. You might include additional context, such as the player's name, location, and current game state. 3. **Receive Response:** Receive a response from Claude. 4. **Send Chat Message:** Send a chat message back to the client (or to all clients) with Claude's response. **Portuguese Translation of Key Concepts:** * **MCP (Minecraft Protocol):** Protocolo Minecraft * **Server:** Servidor * **Client:** Cliente * **Handshake:** Handshake (aperto de mão inicial, negociação) * **Status:** Status (estado) * **Login:** Login (autenticação) * **Packet:** Pacote (dados enviados pela rede) * **VarInt (Variable-length Integer):** Inteiro de Comprimento Variável * **JSON:** JSON (formato de dados) * **API (Application Programming Interface):** API (Interface de Programação de Aplicações) * **Message Queue:** Fila de Mensagens * **Shared Memory:** Memória Compartilhada * **Entity:** Entidade (personagem, objeto no jogo) * **Chunk:** Chunk (pedaço do mundo do Minecraft) * **Authentication:** Autenticação * **UUID (Universally Unique Identifier):** UUID (Identificador Único Universal) This comprehensive example and explanation should give you a solid foundation for building a Minecraft server that integrates with Claude. Remember to start small, test frequently, and focus on one specific goal at a time. Good luck!

MCP Server with OpenAI Integration

Production-ready MCP server that integrates OpenAI API with extensible tool support, enabling dynamic plugin loading and knowledge search capabilities through multiple interfaces including CLI and browser UI.

User Info MCP Server

An MCP server providing tools for user information management with capabilities for retrieving, searching, and adding user data stored in a JSON file.

KubeBlocks Cloud MCP Server

MCP server for KubeBlocks Cloud

TalkToAnki

An MCP server that enables AI assistants to seamlessly manage Anki flashcards, decks, and templates through the AnkiConnect API. It supports intelligent querying, batch note creation, and detailed study progress analysis using natural language.

Xiaohongshu (RedBook) MCP Server

Enables automated interaction with Xiaohongshu (Little Red Book) platform including searching posts, retrieving content and comments, and posting AI-generated comments with persistent login support.

Twilio MCP Server by CData

This read-only MCP Server allows you to connect to Twilio data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Stimulus Docs MCP Server

An MCP server that provides access to up-to-date Stimulus JS documentation directly within Claude conversations and VS Code.

Actor-Critic Thinking MCP Server

Provides dual-perspective analysis through alternating actor (creator/performer) and critic (analyzer/evaluator) viewpoints, generating comprehensive performance evaluations with balanced, actionable feedback.

Swagger MCP Server

A lightweight server that enables interaction with the Swagger Petstore API using the Model Context Protocol, allowing operations on pets, stores, and users through dynamically loaded OpenAPI specifications.

Peekaboo MCP

A macOS utility that captures screenshots and analyzes them with AI vision, enabling AI assistants to see and interpret what's on your screen.

Keyword Research Tool MCP Server

Provides comprehensive SEO analysis by crawling websites and generating AI-powered keyword insights, search volume data, and competitor strategies. It delivers detailed reports on keyword clusters and commercial intent to help optimize digital marketing workflows.

Datadog Logs MCP Server

Enables searching and retrieving Datadog logs through the Model Context Protocol with customizable queries, time ranges, and result limits.

ChainGPT AI News MCP Server

Provides access to AI-related crypto and Web3 news through the ChainGPT AI News API. Supports filtering by categories, blockchains, tokens, keywords, and date ranges across 40+ blockchains and 20+ categories.

Spring AI MCP Batch Job Server

Um servidor Spring Boot Model Context Protocol (MCP) que fornece ferramentas de processamento em lote para transações financeiras.

🎯 Kubernetes AI Management System

Sistema de Gerenciamento Kubernetes Alimentado por IA: Uma plataforma que combina processamento de linguagem natural com gerenciamento Kubernetes. Usuários podem realizar diagnósticos em tempo real, monitoramento de recursos e análise inteligente de logs. Simplifica o gerenciamento Kubernetes através de IA conversacional, fornecendo uma alternativa moderna.

arduino-mcp-server

Um servidor Arduino MCP escrito em Go.

SSH Read-Only MCP Server

Enables secure remote SSH command execution with strict read-only enforcement, allowing safe delegation of SSH access to Claude while preventing write operations. Supports connection pooling, command validation, and comprehensive logging for audit trails.

Scenario.com MCP Server

Provides access to Scenario.com's generative AI API for text-to-image and image-to-image generation, model training, upscaling, background removal, and 70+ other AI image tools.

Apple Reminders MCP Server

Enables management of Apple Reminders on macOS, including creating, updating, and querying reminders with due dates, priorities, and completion status across different reminder lists.

Vercel MCP Python Server

A serverless MCP server deployed on Vercel that provides basic utility tools including echo, time retrieval, arithmetic operations, and mock weather information. Includes an interactive client application for testing and demonstration purposes.