Discover Awesome MCP Servers

BookStack MCP Server

Provides comprehensive tools for managing BookStack instances, including full CRUD operations for books, chapters, and pages. It features advanced image gallery management with URL upload support and full-text search capabilities across all content entities.

NoesisAPI

Solana on-chain intelligence API — token scans, wallet PnL, bundle detection, fresh wallets, dev profiling. MCP server for Claude, Cursor & AI agents. Live PumpFun/Raydium streams

Mnemosyne MCP

An active, stateful software knowledge graph engine that serves as an 'all-knowing development partner' for AI agents and human developers by modeling software projects into queryable knowledge graphs.

webmin-mcp-server

MCP server for Webmin system administration. 61 tools across 12 modules covering system monitoring, services, users, cron, packages, files, storage (SMART + LVM), security (Fail2ban), MySQL databases, Webmin ACL, and disk quotas. Four-tier safety framework with safe mode on by default. Python, MIT license, Docker and local deployment supported.

CucumberStudio MCP Server

Implementa un servidor del Protocolo de Contexto del Modelo que proporciona contexto desde CucumberStudio a asistentes de IA, permitiéndoles obtener datos y generar o modificar escenarios de prueba, features y otros recursos de CucumberStudio.

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!

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.

🤖 MCP Server Examples with AutoGen

Este repositorio demuestra cómo usar AutoGen para integrar servidores MCP (Protocolo de Contexto del Modelo) locales y remotos. Muestra una herramienta matemática local (math_server.py) que utiliza Stdio y una herramienta remota de Apify (Actor de Navegador Web RAG) a través de SSE para tareas como aritmética y navegación web.

MCP Chess Server

Provides Chess.com player data integration, enabling AI assistants to fetch real-time chess player profiles and comprehensive statistics including ratings, game counts, and performance metrics from Chess.com's public API.

Enterprise Operation Insight MCP Server

Provides comprehensive data insights into enterprise operations, including company trends, financing history, market rankings, and sentiment analysis. It enables users to perform keyword-based searches and evaluate business scale, tax qualifications, and competitive project profiles.

system-prompts-mcp-server

Model Context Protocol server exposing system prompt files and summaries.

Jules MCP Server

Connects AI coding assistants to the Jules API for autonomous coding sessions. Enables creating and managing coding sessions, GitHub integration, plan approval workflows, and real-time activity tracking directly from your IDE.

Postgres MCP Pro

An open source Model Context Protocol server for PostgreSQL that provides database health analysis, index tuning, query plan exploration, and safe SQL execution for AI agents throughout the development process.

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-weather

An MCP server that aggregates data from six weather sources to provide current conditions, forecasts, air quality, and aviation METAR information, specifically optimized for European and Nordic locations. It supports multi-source data merging and functions without API keys for several integrated providers.

Gmail MCP Server

Enables sending emails through Gmail using Google's Gmail API. Requires OAuth authentication setup through Google Cloud Console.

trykittai-mcp-server

trykittai-mcp-server

editor-mcp

Un servidor de edición de texto basado en Python, construido con FastMCP, que proporciona herramientas para operaciones de archivos. Este servidor permite leer, editar y gestionar archivos de texto a través de una API estandarizada siguiendo un proceso de varios pasos.

VLLM MCP Server

Enables text-only models to process images and other media formats by providing access to multimodal models from OpenAI and Dashscope (Alibaba Cloud). Supports flexible deployment options and comprehensive tooling for multimodal AI interactions.

QQ Channel Data Collector

Enables automated collection and AI-powered filtering of public QQ channel posts, comments, and images. Supports natural language criteria for content filtering and provides structured data storage in JSON/CSV formats.

Playwright MCP

Wrapper de Playwright para MCP que permite a clientes impulsados por LLM controlar un navegador para tareas de automatización.

Figma MCP Proxy Server

Provides secure access to Figma designs through Cursor IDE using a personal access token, enabling developers to list files, export assets, extract design tokens, and search designs without requiring individual Figma accounts.

Sage 300 MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Sage 300 (beta): https://www.cdata.com/download/download.aspx?sku=GTZK-V&type=beta

Coin Railz MCP Server

Provides access to 41 micropayment-based services for blockchain analytics, trading signals, prediction markets, and financial sentiment analysis. It enables users to perform crypto-native tasks like auditing smart contracts, tracking whale alerts, and analyzing DeFi liquidity through natural language.

OffensiveSET

An offensive security dataset generator that creates high-quality, multi-turn penetration testing conversation datasets for fine-tuning security-focused LLMs. It enables users to generate realistic pentesting workflows featuring chain-of-thought reasoning, tool outputs, and over 45 diverse attack scenarios.

Processing MCP Server

An MCP server that enables AI assistants to create and run Processing sketches directly through natural language commands.

LinkedIn MCP Server

A Model Context Protocol implementation that bridges language models with LinkedIn's API, enabling profile access, posting content, searching people, and retrieving company information through standardized tools.