Discover Awesome MCP Servers

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.

Financial MCP Server

Provides mock financial data including bank transactions, credit reports, and EPF details for the Finarrator application through authenticated API endpoints.

trykittai-mcp-server

trykittai-mcp-server

nanobanana-mcp

A security-hardened MCP server for generating and editing images using Google Gemini models. It provides tools for text-to-image creation and iterative image editing with strict input validation and secure file handling.

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.

beeper-mcp

Một dịch vụ backend để thực hiện các giao dịch beeper trên Binance Smart Chain

Todoist AI MCP Server

Enables AI agents to access and modify Todoist accounts to manage tasks and projects on the user's behalf. It provides a suite of tools for task operations and supports interactive UI widgets for a rich visual experience in AI chat interfaces.

Jokes MCP Server

A Model Context Protocol server that delivers various types of jokes (Chuck Norris, Dad jokes, etc.) and can be integrated with Microsoft Copilot Studio and GitHub Copilot.

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.

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.

Flux

An AI-powered MCP server that enables natural language interaction with AO (Arweave Operating system) for creating, running, and testing code and handlers without manual coding.

Hands-on MCP (Message Control Protocols) Guide

MCP cơ bản

DevPlan MCP Server

Transforms ideas into detailed, executable development plans with built-in verification, lessons learned tracking, and GitHub issue remediation workflows. Guides Claude through structured interviews, plan generation, execution with Haiku agents, and verification with Sonnet agents to maintain context and code quality across sessions.

Ravelry MCP Server

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) tích hợp với API Ravelry, cho phép các trợ lý AI tìm kiếm và truy xuất các mẫu đan và móc.

MCP DEMO

Dự án này trình bày kiến trúc client-server sử dụng máy chủ MCP (Model Configuration Protocol - Giao thức Cấu hình Mô hình) tùy chỉnh được tích hợp với các công cụ MCP để tạo và trả về mã React + TypeScript một cách động.

Security Scanner MCP Server

Enables comprehensive vulnerability scanning using Nuclei scanner with support for single targets, network ranges, and cluster-wide security assessments with customizable severity levels and automated scheduling.

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.

huuh

huuh.me is AI-native Youtube - dead easy AI for people with stuff to do - collaborative AI projects for teams - public AI-native knowledge sharing - monetization of AI-native content streams

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.

MCP Manager Local

Máy chủ để quản lý các máy chủ MCP

simple-mcp-server

Okay, here's a basic outline and code snippets for a simple MCP (Minecraft Protocol) server implementation using Java Spring Boot. Keep in mind that a *full* MCP server is a complex undertaking, and this will only cover the very fundamental aspects of handling a connection and sending a basic response. This is more of a starting point than a complete solution. **Conceptual Overview** 1. **Networking:** We'll use Spring's `@Component` and `@Service` annotations to manage the server socket and client connections. We'll use `ServerSocket` to listen for incoming connections and `Socket` to handle individual client connections. 2. **Protocol Handling:** The Minecraft protocol is binary and complex. For this simplified example, we'll assume a very basic "ping" request and a "pong" response. In a real server, you'd need to implement proper packet parsing and serialization/deserialization. Libraries like `netty` are often used for this. 3. **Threading:** Each client connection will be handled in its own thread to prevent blocking the main server thread. **Code Snippets** ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class McpServerApplication { public static void main(String[] args) { SpringApplication.run(McpServerApplication.class, args); } } ``` ```java import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @Component public class McpServer { private ServerSocket serverSocket; private ExecutorService executorService; private final int port = 25565; // Default Minecraft port private boolean running = true; @PostConstruct public void startServer() { executorService = Executors.newFixedThreadPool(10); // Limit to 10 concurrent connections try { serverSocket = new ServerSocket(port); System.out.println("MCP Server started on port " + port); // Main server loop executorService.submit(() -> { while (running) { try { Socket clientSocket = serverSocket.accept(); System.out.println("Client connected: " + clientSocket.getInetAddress().getHostAddress()); executorService.submit(new ClientHandler(clientSocket)); // Handle in separate thread } catch (IOException e) { if (running) { System.err.println("Error accepting connection: " + e.getMessage()); } } } }); } catch (IOException e) { System.err.println("Could not start server: " + e.getMessage()); } } @PreDestroy public void stopServer() { running = false; try { if (serverSocket != null) { serverSocket.close(); } if (executorService != null) { executorService.shutdownNow(); } System.out.println("MCP Server stopped."); } catch (IOException e) { System.err.println("Error stopping server: " + e.getMessage()); } } } ``` ```java import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket; public class ClientHandler implements Runnable { private final Socket clientSocket; public ClientHandler(Socket socket) { this.clientSocket = socket; } @Override public void run() { try ( PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())) ) { String inputLine; while ((inputLine = in.readLine()) != null) { System.out.println("Received: " + inputLine); if ("ping".equalsIgnoreCase(inputLine)) { out.println("pong"); // Simple response } else { out.println("Unknown command"); } } System.out.println("Client disconnected: " + clientSocket.getInetAddress().getHostAddress()); } catch (IOException e) { System.err.println("Error handling client: " + e.getMessage()); } finally { try { clientSocket.close(); } catch (IOException e) { System.err.println("Error closing socket: " + e.getMessage()); } } } } ``` **Explanation:** * **`McpServerApplication`:** The main Spring Boot application class. * **`McpServer`:** * `@Component`: Marks this class as a Spring-managed component. * `@PostConstruct`: The `startServer()` method is executed after the bean is created. It initializes the `ServerSocket` and starts listening for connections. It uses an `ExecutorService` to manage threads for each client. * `@PreDestroy`: The `stopServer()` method is executed when the application shuts down. It closes the `ServerSocket` and shuts down the `ExecutorService`. * The `while (running)` loop continuously accepts incoming connections. * Each accepted connection is passed to a `ClientHandler` in a separate thread. * **`ClientHandler`:** * `Runnable`: This class implements the `Runnable` interface, so it can be executed in a thread. * The `run()` method handles communication with the client. In this example, it reads lines from the input stream and responds with "pong" if it receives "ping". It uses `BufferedReader` and `PrintWriter` for simple text-based communication. **Important:** This is *not* how the real Minecraft protocol works. * The `try-with-resources` statement ensures that the `PrintWriter` and `BufferedReader` are closed properly. * The `finally` block ensures that the `Socket` is closed, even if an exception occurs. **How to Run:** 1. Create a new Spring Boot project in your IDE (IntelliJ IDEA, Eclipse, etc.). 2. Add the Spring Web dependency (for `@SpringBootApplication`). 3. Copy the code snippets into your project. 4. Run the `McpServerApplication` class. **Important Considerations and Next Steps:** * **Minecraft Protocol:** This example uses a very simplified text-based protocol. The real Minecraft protocol is binary and much more complex. You'll need to use a library like `netty` to handle the protocol correctly. Look into the Minecraft protocol documentation (wiki.vg is a good resource). * **Packet Handling:** You'll need to implement packet parsing and serialization/deserialization. This involves reading and writing data in specific formats (e.g., VarInts, strings, booleans). * **State Management:** You'll need to manage the state of each client connection (e.g., player position, inventory). * **Security:** Implement proper authentication and encryption to protect your server. * **Error Handling:** Add more robust error handling to handle unexpected events. * **Concurrency:** Be very careful with concurrency. Use appropriate synchronization mechanisms to prevent race conditions and other threading issues. * **World Generation:** You'll need to implement world generation to create the game world. * **Game Logic:** Implement the game logic (e.g., player movement, block breaking, item crafting). **Example using Netty (More Realistic)** This is a very basic example using Netty to handle the network communication. It still doesn't implement the full Minecraft protocol, but it's a step in the right direction. ```java 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; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; @Component public class NettyMcpServer { private final int port = 25565; private EventLoopGroup bossGroup; private EventLoopGroup workerGroup; @PostConstruct public void startServer() throws Exception { bossGroup = new NioEventLoopGroup(); 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(); p.addLast(new StringDecoder(), new StringEncoder(), new SimpleChannelInboundHandler<String>() { @Override protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception { System.out.println("Received: " + msg); if ("ping".equalsIgnoreCase(msg)) { ctx.writeAndFlush("pong\n"); // Netty requires explicit flush } else { ctx.writeAndFlush("Unknown command\n"); } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } }); } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); ChannelFuture f = b.bind(port).sync(); System.out.println("Netty MCP Server started on port " + port); f.channel().closeFuture().sync(); // Wait until the server socket is closed. } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); System.out.println("Netty MCP Server stopped."); } } @PreDestroy public void stopServer() { if (workerGroup != null) { workerGroup.shutdownGracefully(); } if (bossGroup != null) { bossGroup.shutdownGracefully(); } } } ``` **Key improvements with Netty:** * **Asynchronous, Event-Driven:** Netty is designed for high-performance networking. * **Channel Pipeline:** The `ChannelPipeline` allows you to easily add handlers for decoding, encoding, and processing data. * **Simplified Threading:** Netty handles the threading for you. **To use the Netty example:** 1. Add the Netty dependency to your `pom.xml` or `build.gradle`. 2. Replace the `McpServer` class with the `NettyMcpServer` class. **Important Notes about the Netty Example:** * **String Codec:** This example uses `StringDecoder` and `StringEncoder` for simplicity. You'll need to replace these with custom codecs that handle the Minecraft protocol's binary format. * **Line-Based:** The `\n` is added to the response because the `StringEncoder` and `StringDecoder` often work with line-based data. This is *not* part of the Minecraft protocol. * **Error Handling:** The `exceptionCaught` method is important for handling errors in the pipeline. **Translation to Vietnamese:** Dưới đây là một bản phác thảo cơ bản và các đoạn mã cho một triển khai máy chủ MCP (Minecraft Protocol) đơn giản bằng Java Spring Boot. Hãy nhớ rằng một máy chủ MCP *hoàn chỉnh* là một công việc phức tạp, và điều này sẽ chỉ bao gồm các khía cạnh rất cơ bản của việc xử lý một kết nối và gửi một phản hồi cơ bản. Đây giống như một điểm khởi đầu hơn là một giải pháp hoàn chỉnh. **Tổng quan về khái niệm** 1. **Mạng:** Chúng ta sẽ sử dụng các chú thích `@Component` và `@Service` của Spring để quản lý socket máy chủ và các kết nối máy khách. Chúng ta sẽ sử dụng `ServerSocket` để lắng nghe các kết nối đến và `Socket` để xử lý các kết nối máy khách riêng lẻ. 2. **Xử lý giao thức:** Giao thức Minecraft là nhị phân và phức tạp. Đối với ví dụ đơn giản này, chúng ta sẽ giả định một yêu cầu "ping" rất cơ bản và một phản hồi "pong". Trong một máy chủ thực tế, bạn cần triển khai phân tích cú pháp và tuần tự hóa/giải tuần tự hóa gói tin thích hợp. Các thư viện như `netty` thường được sử dụng cho việc này. 3. **Đa luồng:** Mỗi kết nối máy khách sẽ được xử lý trong luồng riêng của nó để ngăn chặn việc chặn luồng máy chủ chính. **Đoạn mã** (Các đoạn mã Java đã được cung cấp ở trên, không cần dịch lại) **Giải thích:** * `McpServerApplication`: Lớp ứng dụng Spring Boot chính. * `McpServer`: * `@Component`: Đánh dấu lớp này là một thành phần được quản lý bởi Spring. * `@PostConstruct`: Phương thức `startServer()` được thực thi sau khi bean được tạo. Nó khởi tạo `ServerSocket` và bắt đầu lắng nghe các kết nối. Nó sử dụng `ExecutorService` để quản lý các luồng cho mỗi máy khách. * `@PreDestroy`: Phương thức `stopServer()` được thực thi khi ứng dụng tắt. Nó đóng `ServerSocket` và tắt `ExecutorService`. * Vòng lặp `while (running)` liên tục chấp nhận các kết nối đến. * Mỗi kết nối được chấp nhận được chuyển đến `ClientHandler` trong một luồng riêng. * `ClientHandler`: * `Runnable`: Lớp này triển khai giao diện `Runnable`, vì vậy nó có thể được thực thi trong một luồng. * Phương thức `run()` xử lý giao tiếp với máy khách. Trong ví dụ này, nó đọc các dòng từ luồng đầu vào và trả lời bằng "pong" nếu nó nhận được "ping". Nó sử dụng `BufferedReader` và `PrintWriter` để giao tiếp dựa trên văn bản đơn giản. **Quan trọng:** Đây *không phải* là cách giao thức Minecraft thực hoạt động. * Câu lệnh `try-with-resources` đảm bảo rằng `PrintWriter` và `BufferedReader` được đóng đúng cách. * Khối `finally` đảm bảo rằng `Socket` được đóng, ngay cả khi xảy ra ngoại lệ. **Cách chạy:** 1. Tạo một dự án Spring Boot mới trong IDE của bạn (IntelliJ IDEA, Eclipse, v.v.). 2. Thêm dependency Spring Web (cho `@SpringBootApplication`). 3. Sao chép các đoạn mã vào dự án của bạn. 4. Chạy lớp `McpServerApplication`. **Các cân nhắc quan trọng và các bước tiếp theo:** * **Giao thức Minecraft:** Ví dụ này sử dụng một giao thức dựa trên văn bản rất đơn giản. Giao thức Minecraft thực tế là nhị phân và phức tạp hơn nhiều. Bạn cần sử dụng một thư viện như `netty` để xử lý giao thức một cách chính xác. Hãy xem tài liệu về giao thức Minecraft (wiki.vg là một nguồn tài nguyên tốt). * **Xử lý gói tin:** Bạn cần triển khai phân tích cú pháp và tuần tự hóa/giải tuần tự hóa gói tin. Điều này bao gồm việc đọc và ghi dữ liệu ở các định dạng cụ thể (ví dụ: VarInts, chuỗi, boolean). * **Quản lý trạng thái:** Bạn cần quản lý trạng thái của mỗi kết nối máy khách (ví dụ: vị trí người chơi, kho đồ). * **Bảo mật:** Triển khai xác thực và mã hóa thích hợp để bảo vệ máy chủ của bạn. * **Xử lý lỗi:** Thêm xử lý lỗi mạnh mẽ hơn để xử lý các sự kiện bất ngờ. * **Đồng thời:** Hãy rất cẩn thận với đồng thời. Sử dụng các cơ chế đồng bộ hóa thích hợp để ngăn chặn các điều kiện chạy đua và các vấn đề về luồng khác. * **Tạo thế giới:** Bạn cần triển khai tạo thế giới để tạo ra thế giới trò chơi. * **Logic trò chơi:** Triển khai logic trò chơi (ví dụ: di chuyển người chơi, phá khối, chế tạo vật phẩm). **Ví dụ sử dụng Netty (Thực tế hơn)** Đây là một ví dụ rất cơ bản sử dụng Netty để xử lý giao tiếp mạng. Nó vẫn chưa triển khai đầy đủ giao thức Minecraft, nhưng đó là một bước đi đúng hướng. (Đoạn mã Netty đã được cung cấp ở trên, không cần dịch lại) **Các cải tiến chính với Netty:** * **Không đồng bộ, hướng sự kiện:** Netty được thiết kế cho mạng hiệu suất cao. * **Channel Pipeline:** `ChannelPipeline` cho phép bạn dễ dàng thêm các trình xử lý để giải mã, mã hóa và xử lý dữ liệu. * **Đơn giản hóa đa luồng:** Netty xử lý đa luồng cho bạn. **Để sử dụng ví dụ Netty:** 1. Thêm dependency Netty vào `pom.xml` hoặc `build.gradle` của bạn. 2. Thay thế lớp `McpServer` bằng lớp `NettyMcpServer`. **Lưu ý quan trọng về ví dụ Netty:** * **String Codec:** Ví dụ này sử dụng `StringDecoder` và `StringEncoder` để đơn giản. Bạn cần thay thế chúng bằng các codec tùy chỉnh xử lý định dạng nhị phân của giao thức Minecraft. * **Dựa trên dòng:** `\n` được thêm vào phản hồi vì `StringEncoder` và `StringDecoder` thường hoạt động với dữ liệu dựa trên dòng. Đây *không phải* là một phần của giao thức Minecraft. * **Xử lý lỗi:** Phương thức `exceptionCaught` rất quan trọng để xử lý lỗi trong pipeline. This translation aims to be accurate and helpful. Remember that building a real Minecraft server is a significant project. Good luck!

.NET Types Explorer MCP Server

A Model Context Protocol (MCP) server that provides detailed type information from .NET projects for AI coding agents. The .NET Types Explorer MCP Server is a powerful tool designed to help AI coding agents understand and work with .NET codebases. It provides a structured way to explore assemblies,

Zulip MCP Server

Enables AI agents to interact with Zulip by reading, sending, and searching messages across streams and direct messages. It provides tools for stream management, topic organization, and handling emoji reactions via the Model Context Protocol.

MCP Server Boilerplate

A starter template for building MCP (Model Context Protocol) servers that integrate with Claude, Cursor, or other MCP-compatible AI assistants. Provides a clean foundation with TypeScript support, example tool implementation, and installation scripts for quick customization.

Model Context Protocol (MCP) - UOR Implementation

A GitHub-based implementation of the Model Context Protocol that enables LLMs to access and manipulate data in a Universal Object Reference (UOR) framework, providing standardized interfaces for object management with decentralized storage.

SQLite MCP Server

Một máy chủ Giao thức Ngữ cảnh Mô hình (MCP) gọn nhẹ, cho phép các Mô hình Ngôn ngữ Lớn (LLM) tương tác tự động với cơ sở dữ liệu SQLite.

MCP Cypress Page Object & Test Generator

An MCP server that automatically generates TypeScript Page Object classes and comprehensive Cypress test suites for any web page, supporting element interactions, workflow tests, and both positive and negative testing scenarios.