Discover Awesome MCP Servers

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.

OurFamilyWizard MCP

Connects Claude to OurFamilyWizard for natural-language access to co-parenting messages, calendar, expenses, and journal.

Excalidraw MCP App Server

Enables AI assistants to generate interactive Excalidraw diagrams with viewport camera control and fullscreen editing directly in the chat.

enhx-memory

A persistent, project-scoped memory layer for AI coding agents, providing 39 tools for capturing, searching, deduplicating, relating, and maintaining memory records across long-running coding sessions.

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.

EdgeOne Geo MCP Server

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

owui-bash-mcp

Enables Open WebUI to execute bash commands for coding tasks in a persistent projects workspace, with configurable timeouts and output limits.

Agent QA

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

MCP GitHub Dashboard

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

Kali MCP Server

Production-grade MCP server that exposes Kali Linux penetration testing tools to AI agents, enabling automated reconnaissance, web application testing, vulnerability assessment, and more.

mcp-weather-plus

Provides real-time weather forecasts, air quality data, and timezone information via Open-Meteo API, with no API key required.

etsy-mcp-server

MCPサーバーをEtsyと連携させる

crypto-data-mcp

Free MCP server for real-time cryptocurrency data. Get token prices, market overview, top movers, historical charts, and detailed token info directly in Claude Code, Cursor, or any MCP-compatible AI tool. Powered by CoinGecko with 70+ token mappings and built-in caching.

mcp-iso8859-writer

Enables writing and editing files in ISO-8859-1 encoding, automatically converting UTF-8 content to ISO-8859-1 for legacy codebases.

Cryptair MCP Server

Enables AI agents to certify documents, prove agreements, and verify counterparty claims with on-chain receipts on Hedera Hashgraph. Provides tools for document certification, two-party attestation, and agent registration with zero-config setup.

dy-mcp-demo (dy-mcp)

A public demo of a personal-context MCP server that exposes six typed contexts (project, idea, preference, writing_style, skill, general) and twelve tools for managing personal data, with an hourly data reset.

Agent Lab

Run and test agentic systems in isolated Docker sandboxes, varying system prompts, models, and task prompts while capturing full behavior traces via MCP tools.

metatrader5-mcp-server

Enables AI applications to interact with MetaTrader 5 terminals via WebSocket MCP protocol for trading operations and account management.

MCP Calculator

An MCP server that enables AI models to perform mathematical calculations and other tasks like email operations and knowledge search through a bidirectional communication protocol.

Korea Stats MCP

Enables natural language querying of Korean statistical data from KOSIS, including population, employment, GDP, housing prices, and more, with support for regional and trend analysis.

AbletonMCP

Connects Claude AI to Ableton Live through the Model Context Protocol, enabling prompt-assisted music production with track creation, instrument loading, clip editing, and session control. Allows users to create complete musical arrangements by describing what they want in natural language.

DME MCP Server

Exposes DME storage O&M actions as MCP V1 tools, enabling management of storage modules such as SAN, NAS, and storage via natural language. It provides per-module MCP endpoints and a root server to enumerate available tools.

clockify-mcp

MCP server for Clockify time tracking, enabling CRUD operations on workspaces, projects, tasks, clients, tags, users, and time entries.

adaptive-agent-mcp

A self-evolving RAG system that enables AI agents to autonomously read and write memory, continuously learning and adapting user preferences, daily logs, and knowledge graphs across applications.

Prizmad

Generate AI UGC video ads from any product URL in 5 minutes. Realistic AI avatars, natural voiceover, proven ad templates. No actors, no editing, no experience required.

Behringer WING MCP

Enables controlling Behringer WING digital mixers via OSC, supporting fader, mute, pan, and name operations on strips, with raw OSC access for unsupported parameters.

j5ed-knowledge-graph

A knowledge graph MCP server providing persistent, structured memory for AI assistants with multi-agent isolation, tiered search, and index navigation.

MCP Docs Provider

Enables AI models to seamlessly access and query local markdown technical documentation files, providing automatic documentation context without explicit prompting.

brreg-mcp-server

Enables AI agents to search and retrieve Norwegian company data from the Brønnøysund Register Centre's open API, including company details, roles, and subunits.

kernel-build-mcp

An MCP server designed for remote Linux kernel cross-compilation over Tailscale SSH. It enables users to manage configurations, execute kernel builds, and retrieve build artifacts directly through an MCP-compatible interface.