Discover Awesome MCP Servers

RF Tools

MCP server for rftools.io — 213 RF & electronics calculators + 13 server-side simulation tools for AI agents. Give Claude, Cursor, or any MCP-compatible AI assistant access to validated engineering calculators and heavy server-side simulations. Microstrip impedance, link budgets, filter design, converter sizing, antenna patterns, and 190+ more calculators — plus NEC2 antenna simulation, FDTD, Mon

SAP ADT MCP Server

An MCP server that enables AI assistants to interact with SAP systems via the ABAP Development Tools (ADT) REST API. It allows users to read ABAP source code, inspect DDIC objects, and execute SQL queries directly.

Claude Google Sheets MCP Server

A comprehensive MCP server for Google Sheets integration with Claude, enabling spreadsheet discovery, data manipulation, and formatting through natural language commands and slash commands.

google-sheet-mcp

A local MCP server for creating, reading, and updating Google Sheets.

GoCardless MCP Server

Enables AI assistants to interact with GoCardless payment data, providing tools to manage customers, payments, mandates, subscriptions, and payouts. Includes Xero integration support for automatic parsing of metadata.

simple-mcp-server

Okay, here's a basic outline and code snippets for a simple Minecraft Protocol (MCP) server implementation using Java Spring Boot. Keep in mind that a *full* MCP server is a complex undertaking, and this will be a very simplified example to get you started. It will focus on handling the initial handshake and a basic status response. **Important Considerations:** * **Complexity:** The Minecraft protocol is intricate. This example will only cover a tiny fraction of it. You'll need to consult the official Minecraft protocol documentation for a complete implementation. * **Libraries:** You'll likely need a library to help with handling the Minecraft protocol's binary data format. While you *could* write your own, using a library will save you a lot of time and effort. Popular options include: * **Netty:** A powerful, asynchronous event-driven network application framework. It's a common choice for game servers. (This example will use Netty directly, as Spring Boot integrates well with it.) * **Minecraft Server Libraries:** Some libraries are specifically designed for Minecraft server development, but they might be more heavyweight than needed for a simple MCP server. * **Security:** This example will *not* address security concerns. A real Minecraft server needs robust security measures. * **Error Handling:** The error handling in this example is minimal. A production server needs comprehensive error handling. **Project Setup (Spring Boot with Netty)** 1. **Create a Spring Boot Project:** Use Spring Initializr ([https://start.spring.io/](https://start.spring.io/)) to create a new Spring Boot project. Include the "Web" dependency (for basic Spring Boot functionality). You *don't* need to explicitly include Netty; we'll add it as a direct dependency. 2. **Add Netty Dependency:** Add the Netty dependency to your `pom.xml` (if using Maven) or `build.gradle` (if using Gradle): **Maven (`pom.xml`):** ```xml <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.94.Final</version> <!-- Use the latest stable version --> </dependency> ``` **Gradle (`build.gradle`):** ```gradle dependencies { implementation 'io.netty:netty-all:4.1.94.Final' // Use the latest stable version // ... other dependencies } ``` **Code Structure** We'll create the following classes: * `MinecraftServer`: The main class that starts the Netty server. * `MinecraftServerInitializer`: Configures the Netty pipeline. * `MinecraftServerHandler`: Handles the incoming Minecraft protocol packets. * `MCPPacket`: A base class for representing Minecraft packets. * `HandshakePacket`: Represents the handshake packet. * `StatusRequestPacket`: Represents the status request packet. * `StatusResponsePacket`: Represents the status response packet. * `PingPacket`: Represents the ping packet. * `PongPacket`: Represents the pong packet. **Code Implementation** ```java import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.stereotype.Component; @SpringBootApplication public class MinecraftServerApplication { public static void main(String[] args) { SpringApplication.run(MinecraftServerApplication.class, args); } @Component public static class MinecraftServerRunner implements CommandLineRunner { @Value("${minecraft.server.port:25565}") // Default port private int port; @Override public void run(String... args) throws Exception { new MinecraftServer(port).run(); } } } // MinecraftServer.java import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MinecraftServer { private static final Logger logger = LoggerFactory.getLogger(MinecraftServer.class); private final int port; public MinecraftServer(int port) { this.port = port; } public void run() throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(); // Accepts incoming connections EventLoopGroup workerGroup = new NioEventLoopGroup(); // Handles the traffic of the accepted connections try { ServerBootstrap b = new ServerBootstrap(); // Helper class to set up the server b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) // Use NIO for non-blocking .childHandler(new MinecraftServerInitializer()) // Handles new connections .option(ChannelOption.SO_BACKLOG, 128) // Maximum queue length for incoming connection indications .childOption(ChannelOption.SO_KEEPALIVE, true); // Keep connections alive // Bind and start to accept incoming connections. ChannelFuture f = b.bind(port).sync(); // Bind to the port and wait for the server to start logger.info("Minecraft server started on port {}", port); // Wait until the server socket is closed. // In this example, this does not happen, but you can do that to gracefully // shut down your server. f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } } // MinecraftServerInitializer.java import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.socket.SocketChannel; import io.netty.handler.codec.LengthFieldBasedFrameDecoder; import io.netty.handler.codec.LengthFieldPrepender; public class MinecraftServerInitializer extends ChannelInitializer<SocketChannel> { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); // Add a frame decoder to handle Minecraft's variable-length packets pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4)); // Add a frame encoder to prepend the length of the packet pipeline.addLast("framePrepender", new LengthFieldPrepender(4)); // Add the Minecraft protocol handler pipeline.addLast("handler", new MinecraftServerHandler()); } } // MinecraftServerHandler.java import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MinecraftServerHandler extends ChannelInboundHandlerAdapter { private static final Logger logger = LoggerFactory.getLogger(MinecraftServerHandler.class); @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf in = (ByteBuf) msg; try { // Read the packet ID int packetId = readVarInt(in); logger.debug("Received packet with ID: {}", packetId); switch (packetId) { case 0x00: // Handshake handleHandshake(ctx, in); break; case 0x00: // Status Request handleStatusRequest(ctx); break; case 0x01: // Ping handlePing(ctx, in); break; default: logger.warn("Unknown packet ID: {}", packetId); in.skipBytes(in.readableBytes()); // Discard remaining data break; } } finally { in.release(); // Important: Release the buffer } } private void handleHandshake(ChannelHandlerContext ctx, ByteBuf in) throws Exception { int protocolVersion = readVarInt(in); String serverAddress = readString(in); int serverPort = in.readUnsignedShort(); int nextState = readVarInt(in); logger.debug("Handshake - Protocol: {}, Address: {}:{}, Next State: {}", protocolVersion, serverAddress, serverPort, nextState); // Respond based on the 'nextState' if (nextState == 1) { // Status // Do nothing here, wait for the status request } else if (nextState == 2) { // Login logger.warn("Login is not implemented."); ctx.close(); // Close the connection } else { logger.warn("Unknown next state: {}", nextState); ctx.close(); } } private void handleStatusRequest(ChannelHandlerContext ctx) { logger.debug("Status request received"); // Create a sample status response String jsonResponse = "{\n" + " \"version\": {\n" + " \"name\": \"1.20.1\",\n" + " \"protocol\": 763\n" + " },\n" + " \"players\": {\n" + " \"max\": 100,\n" + " \"online\": 0,\n" + " \"sample\": []\n" + " },\n" + " \"description\": {\n" + " \"text\": \"A Spring Boot Minecraft Server\"\n" + " }\n" + "}"; // Write the status response ByteBuf buffer = ctx.alloc().buffer(); writeVarInt(buffer, 0x00); // Status Response packet ID writeString(buffer, jsonResponse); ctx.writeAndFlush(buffer).addListener(future -> { if (!future.isSuccess()) { logger.error("Error sending status response", future.cause()); } }); } private void handlePing(ChannelHandlerContext ctx, ByteBuf in) { long payload = in.readLong(); logger.debug("Ping received with payload: {}", payload); // Respond with a pong packet ByteBuf buffer = ctx.alloc().buffer(); writeVarInt(buffer, 0x01); // Pong packet ID buffer.writeLong(payload); ctx.writeAndFlush(buffer).addListener(future -> { if (!future.isSuccess()) { logger.error("Error sending pong response", future.cause()); } }); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { logger.error("Exception caught", cause); ctx.close(); } // Helper methods for reading and writing Minecraft's VarInt format private int readVarInt(ByteBuf in) { int numRead = 0; int result = 0; byte read; do { read = in.readByte(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt is too big"); } } while ((read & 0x80) != 0); return result; } private void writeVarInt(ByteBuf out, int value) { while (true) { if ((value & ~0x7F) == 0) { out.writeByte(value); return; } out.writeByte((value & 0x7F) | 0x80); value >>>= 7; } } private String readString(ByteBuf in) { int length = readVarInt(in); byte[] bytes = new byte[length]; in.readBytes(bytes); return new String(bytes); } private void writeString(ByteBuf out, String s) { byte[] bytes = s.getBytes(); writeVarInt(out, bytes.length); out.writeBytes(bytes); } } ``` **Explanation:** 1. **`MinecraftServerApplication`:** The main Spring Boot application class. It uses a `CommandLineRunner` to start the `MinecraftServer` after the application context is initialized. It also reads the server port from the `application.properties` file (or uses the default 25565). 2. **`MinecraftServer`:** * Sets up the Netty `ServerBootstrap`. * Configures the `bossGroup` (for accepting connections) and `workerGroup` (for handling I/O). * Specifies the `NioServerSocketChannel` for non-blocking I/O. * Sets the `childHandler` to `MinecraftServerInitializer`, which configures the pipeline for each new connection. * Binds to the specified port and starts listening for connections. 3. **`MinecraftServerInitializer`:** * This is crucial. It defines the *pipeline* of handlers that process incoming and outgoing data. * `LengthFieldBasedFrameDecoder`: Minecraft uses variable-length packets. This decoder reads the length of the packet from the beginning of the data and uses that to frame the packet correctly. It prevents issues where you read incomplete packets. * `LengthFieldPrepender`: This adds the length of the packet to the beginning of the data before sending it. * `MinecraftServerHandler`: The main handler that processes the Minecraft protocol. 4. **`MinecraftServerHandler`:** * `channelRead()`: This method is called whenever data is received from a client. * It reads the packet ID (a VarInt). * It uses a `switch` statement to handle different packet types: * **Handshake (0x00):** Reads the protocol version, server address, port, and "next state." The "next state" determines whether the client wants to get the server status (1) or log in (2). This example only handles the status request. * **Status Request (0x00):** Sends a simple JSON status response. The JSON includes the Minecraft version, player count, and a description. * **Ping (0x01):** Responds with a pong packet containing the same payload. * `exceptionCaught()`: Handles exceptions that occur during processing. * **Helper Methods:** `readVarInt()`, `writeVarInt()`, `readString()`, `writeString()`: These methods are essential for reading and writing Minecraft's variable-length integer (VarInt) and string formats. These are *not* standard Java types. **How to Run:** 1. **Build the Project:** Use Maven (`mvn clean install`) or Gradle (`gradle clean build`) to build your Spring Boot project. 2. **Run the Application:** Run the generated JAR file (usually in the `target` or `build/libs` directory) using `java -jar <your-jar-file.jar>`. 3. **Test with a Minecraft Client:** * Start a Minecraft client. * Add a new server with the address `localhost` and the port you configured (default: 25565). * If everything is working, you should see the server in your server list with the status information you provided in the `StatusResponsePacket`. **Important Notes and Improvements:** * **VarInt and Strings:** The `readVarInt`, `writeVarInt`, `readString`, and `writeString` methods are *critical*. Minecraft uses these custom formats for efficiency. * **Error Handling:** Add more robust error handling. Log errors properly and handle unexpected data gracefully. * **Asynchronous Operations:** Use Netty's asynchronous features (e.g., `ChannelFuture` listeners) to avoid blocking the event loop. * **Configuration:** Externalize the server configuration (port, MOTD, etc.) using Spring Boot's configuration properties. * **Logging:** Use a proper logging framework (like SLF4J) for debugging and monitoring. * **Security:** Implement proper authentication and authorization if you want to allow players to log in. This is a *major* undertaking. * **Packet Handling:** Create separate classes for each packet type to improve code organization. * **Protocol Documentation:** Refer to the official Minecraft protocol documentation for the most up-to-date information: [https://wiki.vg/Protocol](https://wiki.vg/Protocol) This example provides a starting point. Building a fully functional Minecraft server is a significant project. Good luck!

codesteer-atlas

Local MCP server for semantic code search using Tree-sitter AST parsing, local embeddings, and hybrid search; enables indexing and querying codebases entirely offline.

VulnerabilityMCPServer

MCP server for retrieving vulnerability data (CVE) via HTTP, testable with MCP Inspector and OpenCode.

AE-MCP

An MCP server that enables AI assistants to control Adobe After Effects with 70+ tools for compositing, animation, effects, and motion graphics.

jlcpcb-search-mcp

Enables AI assistants to search JLCPCB's 450K+ electronic component catalog with real-time stock levels and pricing, supporting keyword search, filtering, and detailed component information.

system-prompts-mcp-server

Model Context Protocol server exposing system prompt files and summaries.

ServiceNow Cowork Automation API

MCP-compatible backend that automates ServiceNow incident handling via Microsoft 365 Copilot, offering tools for incident analysis, automation, and job status retrieval.

QBO-MCP-TS

Enables QuickBooks Online integration for financial management with CRUD operations, reporting, real-time updates, and automation.

Progresso MCP

Enables MCP clients to interact with a live Progresso workspace for board, CRM, projects, and time tracking via Supabase.

mcp-locator

An MCP server that lets AI agents read and write locale JSON translation files directly from the conversation without loading the whole catalog into context.

Captain Data MCP API

Una API de middleware que conecta asistentes de IA como ChatGPT con las herramientas de Captain Data para extraer información de páginas de empresas y perfiles de LinkedIn.

ReleaseGuard MCP Server

Provides MCP tools for scanning, redacting, and packaging dataset/model directories for public release, leveraging Presidio for PII detection and generating Hugging Face cards and EU AI Act training-data summaries.

qveris-agent-toolkit

Capability routing network for AI agents to discover, inspect, and call 10,000+ real-world financial capabilities through one unified MCP protocol.

vault-mcp

Markdown + SQLite knowledge store with bidirectional wikilinks, exposed as an MCP server for AI agents to maintain an interconnected knowledge base.

SQLite MCP Server

Un servidor de Protocolo de Contexto de Modelo (MCP) ligero que permite a los Modelos de Lenguaje Grandes (LLMs) interactuar de forma autónoma con bases de datos SQLite.

Purefeed MCP Server

Connects AI assistants to Purefeed for access to AI-curated Twitter/X feeds, signals, semantic search, and post creation.

Kontomanager MCP Server

Enables programmatic access to Austrian mobile carriers (yesss!, Georg, XOXO) account management. Allows users to check usage, download bills, manage SIM settings, and configure call forwarding through natural language interactions.

eyeshot-mcp

Provides screenshot capture and vision analysis tools that enable AI to see and analyze screen content on Windows, forming an automated capture-analyze pipeline.

canvas-mcp

Connects Canvas LMS to Claude Desktop, enabling natural-language queries about courses, assignments, grades, and more.

ditto

An MCP server that loads your Ditto profile, mined from your local Claude Code, Codex, and OpenCode session logs, so your agent works like you. Exposes the load_ditto_profile tool over the Model Context Protocol.

data-centrevaldeloire

Enables AI agents to search, query, and explore datasets from the Centre-Val de Loire Open Data portal, covering regional services, transport, education, and environment.

kitty-mcp-server

MCP server for controlling the kitty terminal emulator. Exposes 40 tools for managing windows, tabs, layouts, text, appearance, and more.

powerplan

An MCP server that gives agents a human-language API over PLAN.md, enabling project plan management, task tracking, and iteration lifecycle without direct file editing.

Shopify MCP Server

Provides AI assistants with real-time access to Shopify store analytics, sales data, and inventory through ShopifyQL and the Admin GraphQL API. It enables users to query store performance, customer metrics, and marketing insights using natural language.

gmail-mcp

A Cloudflare Workers-based MCP server that connects Gmail to AI assistants, enabling search, read, send, reply-all, forward, and management of messages, drafts, labels, and threads across multiple Google accounts simultaneously.