Discover Awesome MCP Servers

Anam MCP Server

Enables managing AI personas, avatars, voices, and sessions from any MCP client, for integration with Anam AI.

Agent QA

Evaluates MCP servers by running read-only checks and returning a graded report with an A-F letter grade.

Godalo

Affiliate product search for AI agents. Indexes structured merchant feeds — real prices, live stock, affiliate links built in. Works with any MCP client.

MCP GitHub Dashboard

A comprehensive GitHub project dashboard for MCP that monitors multiple repositories, pull requests, issues, deployments, and health status through AI assistants.

browser-smoke

Enables browser automation and smoke testing via Playwright, with tools for navigation, DOM interaction, screenshots, network capture, and more.

Cloudflare Email MCP Server

Manages Cloudflare KV namespaces and automates email processing from ProtonMail Bridge to structured KV storage with folder mapping.

roiq-os-mcp

Lightweight connector to operate ROIQ OS from Claude Code, enabling management of spaces, pages, boards, tables, cards, scripts, and more within token-based permissions.

mcp-data-delaware

Query and explore Delaware Open Data datasets via Socrata API, including search, filtering, and metadata retrieval.

API Wrapper MCP Server

Okay, I understand you want to create an MCP (Minecraft Protocol) server that acts as a proxy or intermediary for any API. This is a complex task, but I can outline the key concepts and steps involved. Keep in mind that this is a high-level overview, and you'll need significant programming experience (especially with networking, Java/Kotlin, and the Minecraft protocol) to implement it. **Core Idea:** The MCP server will: 1. **Listen for Minecraft client connections:** It will act like a standard Minecraft server, accepting connections from players. 2. **Authenticate the player (optional):** You can choose to require authentication against Mojang's servers or implement your own authentication system. 3. **Intercept and interpret Minecraft packets:** It will analyze the packets sent by the client to understand the player's actions (e.g., chat messages, commands, block interactions, movement). 4. **Translate player actions into API calls:** Based on the intercepted packets, it will construct and send requests to your target API. 5. **Receive responses from the API:** It will process the data returned by the API. 6. **Translate API responses into Minecraft packets:** It will convert the API data into packets that the Minecraft client can understand and display (e.g., chat messages, block changes, entity updates). 7. **Send the packets to the client:** It will transmit the modified or generated packets back to the player's Minecraft client. **Key Components and Steps:** 1. **Choose a Programming Language and Framework:** * **Java/Kotlin:** These are the most common languages for Minecraft server development. Kotlin is often preferred for its conciseness and modern features. * **Libraries/Frameworks:** * **Netty:** A powerful asynchronous event-driven network application framework. Essential for handling network connections and packet processing. * **Minecraft Protocol Libraries:** Libraries that handle the serialization and deserialization of Minecraft packets. Examples include: * **Glowstone:** A Minecraft server implementation (can be used as a library). * **ProtocolLib (for Bukkit/Spigot):** If you want to create a plugin for an existing server. Less suitable for a standalone MCP server. * **Custom Packet Handling:** You can implement your own packet handling logic, but this is significantly more complex. * **JSON/XML Libraries:** For parsing API responses (e.g., Gson, Jackson, JAXB). * **HTTP Client:** For making requests to your API (e.g., OkHttp, Apache HttpClient). 2. **Set up the Network Listener:** * Use Netty to create a server socket that listens for incoming connections on the standard Minecraft port (25565) or a custom port. * Handle new client connections: Create a `ChannelHandler` in Netty to manage each client connection. 3. **Implement the Minecraft Protocol Handshake and Login:** * Handle the initial handshake packets (protocol version, server address, port). * Implement authentication: * **Mojang Authentication:** Use Mojang's authentication API to verify the player's credentials. This requires handling UUIDs and access tokens. * **Custom Authentication:** Implement your own authentication system (e.g., username/password, API key). * Send the "Login Success" packet to the client. 4. **Packet Interception and Processing:** * **Packet Decoding:** Use your chosen Minecraft protocol library (or your own implementation) to decode incoming packets from the client. * **Packet Filtering:** Identify the packets that are relevant to your API integration. For example: * `ChatMessageC2SPacket` (chat messages) * `ClientCommandC2SPacket` (commands) * `PlayerActionC2SPacket` (block interactions) * `UseEntityC2SPacket` (entity interactions) * `PlayerMoveC2SPacket` (player movement) * **Data Extraction:** Extract the relevant data from the intercepted packets. For example, extract the chat message text, the command name and arguments, the block coordinates, or the entity ID. 5. **API Request Construction and Sending:** * Based on the extracted data, construct a request to your target API. This will involve: * Formatting the data into the API's expected format (e.g., JSON, XML). * Setting the appropriate HTTP method (e.g., GET, POST, PUT, DELETE). * Adding any required headers (e.g., API key, content type). * Use your HTTP client library to send the request to the API endpoint. 6. **API Response Handling:** * Receive the response from the API. * Parse the response data using your JSON/XML library. * Handle errors: Check the HTTP status code and any error messages in the response. 7. **Minecraft Packet Construction and Sending:** * Translate the API response data into Minecraft packets that the client can understand. For example: * `SystemChatS2CPacket` (chat messages) * `BlockChangeS2CPacket` (block changes) * `EntityPositionS2CPacket` (entity position updates) * `EntityMetadataS2CPacket` (entity data updates) * Encode the packets using your Minecraft protocol library (or your own implementation). * Send the packets to the client using Netty. 8. **Error Handling and Logging:** * Implement robust error handling to catch exceptions and prevent the server from crashing. * Use a logging framework (e.g., SLF4J, Log4j) to log important events and errors. 9. **Configuration:** * Create a configuration file (e.g., YAML, JSON) to store settings such as: * API endpoint URL * API key * Minecraft server port * Authentication settings **Example Scenario: Chat Message Integration** Let's say you want to integrate chat messages with an external service that performs sentiment analysis. 1. **Intercept `ChatMessageC2SPacket`:** Your server intercepts the packet containing the chat message. 2. **Extract the message:** You extract the text of the chat message. 3. **Send to API:** You send the message to your sentiment analysis API. For example: ```json { "message": "This is a great server!" } ``` 4. **Receive API response:** The API returns a sentiment score: ```json { "sentiment": "positive", "score": 0.85 } ``` 5. **Send to client:** You construct a `SystemChatS2CPacket` to display a message to the player: ``` [Server]: Your message was positive (score: 0.85) ``` **Challenges:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex and constantly evolving. You'll need to stay up-to-date with the latest changes. * **Performance:** Packet processing and API calls can be resource-intensive. You'll need to optimize your code to ensure good performance. * **Security:** Protect your server from attacks, such as packet injection and denial-of-service attacks. * **Scalability:** Design your server to handle a large number of concurrent connections. * **API Rate Limiting:** Be mindful of the API's rate limits and implement appropriate throttling mechanisms. **Code Snippets (Illustrative - Requires Adaptation):** ```java // Example using Netty (very simplified) import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.string.StringDecoder; import io.netty.handler.codec.string.StringEncoder; public class MCPProxyServer { public static void main(String[] args) throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline p = ch.pipeline(); // Add your Minecraft packet codecs here (replace StringDecoder/Encoder) p.addLast(new StringDecoder(), new StringEncoder(), new MCPHandler()); // Replace with actual packet handlers } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); ChannelFuture f = b.bind(25565).sync(); // Bind to Minecraft port f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } static class MCPHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { // Process incoming Minecraft packets here // Decode the packet, extract data, make API calls, // construct response packets, and send them back to the client. String receivedMessage = (String) msg; // Replace with actual packet decoding System.out.println("Received: " + receivedMessage); // Example: Send a response back to the client ctx.writeAndFlush("Server received: " + receivedMessage); // Replace with actual packet encoding } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } } } ``` **Important Considerations:** * **Legality:** Be sure to comply with Mojang's terms of service and API usage guidelines. * **Reverse Engineering:** You'll likely need to do some reverse engineering of the Minecraft protocol to understand the packet formats. * **Community Resources:** Look for existing Minecraft server implementations and libraries that can help you get started. This is a challenging project, but hopefully, this detailed outline gives you a good starting point. Good luck! Remember to break down the problem into smaller, manageable tasks.

chia-explorer

MCP server that answers questions about the Chia blockchain, including balances, blocks, transactions, offers, fees, and more, using the public coinset.org API and CoinGecko for pricing.

SSAS MCP Server

A read-only MCP server for querying SQL Server Analysis Services (multidimensional cubes via MDX and tabular models via DAX) using Windows Integrated Security.

mcp-google-oauth

A remote MCP server with Google OAuth authentication, deployable to Cloudflare Workers, that provides tools accessible after signing in with Google.

syplugin-anMCPServer

A Model Context Protocol server plugin for SiYuan note-taking application that enables searching documents, retrieving content, and writing to notes through an HTTP-based interface.

CMS Provider Data Catalog MCP

A remote MCP server that lets an LLM explore, query, aggregate, and benchmark the ~234 datasets in the CMS Provider Data Catalog — hospitals, dialysis facilities, nursing homes, home health, hospice, physicians, and more — in plain language.

MindPort MCP Server

Enables AI systems to store and search resources with fuzzy search, regex, and tag filtering, with domain isolation and prompt template management.

MCP Agent Bridge

An agent gateway that aggregates multiple local MCP servers into a single MCP endpoint with runtime control, hot-reloadable configuration, and meta tools like bridge__execute for calling any child server tool without restart.

Pyrus MCP

Enables authorized employees and AI hosts to perform Pyrus operations over the Model Context Protocol (MCP) with production-grade security and observability.

EdgeOne Geo MCP Server

Enables AI models to access user geolocation information through EdgeOne Pages Functions, allowing location-aware AI interactions.

Typefully MCP Server

A Model Context Protocol server that enables AI assistants to create and manage Twitter drafts on Typefully, supporting features like thread creation, scheduling, and retrieving published content.

FileManager MCP Server

Read-only MCP server for AI clients to browse and search project files securely, with configurable permissions, virtual paths, and key-based access.

K-Beauty MCP Server

Provides comprehensive Korean Beauty information through real-time web search, AI-powered skin analysis from photos, and curated knowledge of 58+ K-Beauty brands, ingredients, and personalized skincare routines.

alexandria-mcp

Semantic search over 4.6 million text chunks from 20,000+ classical philosophy and humanities works (pre-1928). Covers Aristotle, Plato, Kant, Hegel, Nietzsche and hundreds more. Multilingual: English, German, Latin, French, Italian, Greek, Russian.

mcp-fastify-server

サンプルモデルコンテキストプロトコル (MCP) サーバー

NexBrowser MCP Server

Connects MCP clients to a local NexBrowser desktop app for browser automation, environment management, and session-isolated page inspection via the Model Context Protocol.

FlowDot MCP Server

Connect any MCP-compatible AI client to the entire FlowDot platform, enabling management of workflows, recipes, custom nodes, apps, knowledge bases, agent toolkits, and community features.

AMEVA MCP Toolkit

A Model Context Protocol server integrating developer tools including Git control, document conversion, remote SSH execution, database operations, and utilities for automation and development productivity.

Product MCP Server

Enables natural language product management (CRUD) with multiple classification methods, including LLM-based and fast ML classifiers, for product creation, listing, updating, and deletion via a chat interface.

Azure MCP Server

Integrates Azure cloud services with GenAI applications via the Model Context Protocol, enabling comprehensive Azure API coverage with enterprise-ready features.

codex-photoshop-psd-automation

Enables Codex to orchestrate Adobe Photoshop via MCP to reconstruct AI-generated artwork into editable, validated layered PSDs, with automated saving, reopening, and verification.

simple-parallels

MCP server for managing Parallels Desktop VMs, including lifecycle operations and snapshots.