Discover Awesome MCP Servers

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.

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.

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-stm-montevideo

MCP server exposing Montevideo public transportation data (STM) as tools for AI assistants, enabling natural language queries about routes, stops, arrivals, and trip planning.

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.

SitePulsar MCP Server

Measures and improves how findable, readable, and usable a website is to AI answer engines and autonomous AI agents through hosted AEO audit tools.

WhisperGraph MCP Server

Self-hostable MCP server for WhisperGraph — a graph of 7.39B nodes / 39B edges mapping DNS, BGP, GeoIP, WHOIS, and threat intelligence. Six read-only tools (Cypher query + schema introspection + threat assessment), six resources, eight investigation prompts. stdio and Streamable HTTP transports.

Anam MCP Server

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

Name.com MCP Server

Enables management of domains and DNS records through the Name.com REST API. Users can search for available domains, check bulk availability, and configure DNS records or nameservers using natural language.

MCP Twitter/X Server

Provides integration with Twitter/X, enabling reading posts from users and creating new posts.

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.

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.

mcp-sketch

Local MCP server for parsing Sketch exported HTML zip archives and extracting design structure information.

mcp-google-oauth

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

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.

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.

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.

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.

metatrader5-mcp-server

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

GetAppNiche MCP

Enables AI agents to query live App Store and Google Play data, including app search, revenue/download metrics, keyword difficulty, and reviews, via a hosted MCP server with API-key authentication.

Travel MCP Server

Enables travel package management, booking, and itinerary planning through MCP-compliant endpoints with 26 tools for searching, comparing, and booking travel packages.

mcp-outlook-desktop

Enables AI assistants to securely read, search, draft, and send Outlook emails, manage calendar events, and access mailbox folders through a local MAPI connection to Windows Outlook, with human-in-the-loop safeguards.

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.

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.