Discover Awesome MCP Servers

adobe-cja-mcp

MCP server for Adobe Customer Journey Analytics, enabling AI-powered analytics queries including reports, breakdowns, trends, and dimension searches through Claude and other MCP clients.

Trademark Big Data MCP Server

Provides comprehensive trademark information services, including fuzzy company search, detailed trademark status tracking, and statistical analysis. Users can analyze trademark portfolios by tracking application trends, registration data, and category distributions for specific companies.

Bookmark MCP Server

Enables Claude Code to save, find, and list bookmarks stored in a JSON file.

tubemind-secure-mcp

YouTube intelligence MCP server providing 18 tools for research, analytics, benchmarking, and content strategy, with OAuth2 and encrypted token storage.

BattleGrid MCP Server

Enables AI agents to play crypto prediction games on BattleGrid by managing accounts, submitting entries, and accessing market data through MCP tools and prompts.

mcp-screenshot

MCP server for taking Linux / Wayland screenshots via grim and slurp.

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.

MCP Java SDK for Java 8

SDK del Protocolo de Contexto del Modelo adaptado para Java 8

nia-link

Automate web browsing and data extraction by converting live pages into clean Markdown. Execute multi-step workflows and interact with websites using human-like movements.

mcp-apps-office-kit

Enables LLM Desktop clients to generate rich media content like PPT, HTML, and flowcharts via Canvas Core and MCP Apps extension mechanism.

Telegram MCP Server

A Telegram integration for Claude, Cursor, and other MCP-compatible clients. It exposes Telegram account, chat, message, contact, media, folder, and admin operations through the Model Context Protocol using Telethon.

Freqtrade-MCP

Integrates with the Freqtrade cryptocurrency trading bot via its REST API to enable AI-driven automated trading and bot management. It allows users to fetch market data, monitor performance, manage whitelists, and execute trades through natural language.

Compass

MCP Compass es un servicio de descubrimiento y recomendación que ayuda a los asistentes de IA a encontrar y comprender servidores del Protocolo de Contexto de Modelos a través de consultas en lenguaje natural.

Hands-on MCP (Message Control Protocols) Guide

"MCP básico"

MCP Code Mode

Universal Python code execution MCP server that lets LLMs write and run Python for any task, with auto-install packages, streaming output, and automatic file display.

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.

Google Search Console MCP Server

Provides programmatic access to Google Search Console API data through Claude Code and Cursor, enabling search analytics, sitemap info, URL inspection, and indexing submission.

HLedger MCP Server

Provides AI assistants with direct access to HLedger accounting data and functionality, enabling natural language queries for balances, reports, journal entries, and financial analysis.

QBO-MCP-TS

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

Dev MCP Prompt Server

A lightweight server that provides curated, high-quality prompts for common development tasks like UI/UX design, project setup, and debugging to enhance AI-powered development workflows.

Roblox MCP Server

Bridges AI assistants with Roblox game environments in real-time via a Lua client and WebSocket connection. Enables AI tools like Claude to navigate instances, execute scripts, monitor remote events, and interact with the Roblox API through natural language.

MCP MySQL Server

Enables secure read-only access to MySQL databases through SELECT queries via HTTP SSE interface. Provides safe database exploration and data retrieval with configurable timeout settings.

Iceland News MCP Server

Fetches latest news from 6 Icelandic sources via 60+ RSS feeds across categories in Icelandic, English, and Polish, with configurable article limits and feed discovery.

VSCode Internal Command MCP Server

Converts VSCode into an MCP server that enables external clients to remotely execute VSCode internal commands, query workspace information, and interact with the editor through HTTP streaming. Built on the FastMCP framework with security controls and real-time monitoring.

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.

corpuskit

Enables AI coding agents to search documentation and query constraints via MCP tools kr_search and kr_constraints.

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!

Hardware Monitor MCP Server

Enables AI assistants to query real-time system metrics like CPU, RAM, disk, and battery usage, and check performance thresholds.

Professional Penetration Testing MCP Server

Provides access to over 40 industry-standard penetration testing tools, including Nmap, SQLMap, and Metasploit, within an isolated Kali Linux Docker container. It enables security professionals to perform comprehensive network reconnaissance, web application testing, and vulnerability research through natural language commands.

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.