发现优秀的 MCP 服务器

Workout Maker MCP Server

This MCP server enables the generation of structured fitness content, including detailed exercise instructions with image prompts, balanced daily workout sessions, and personalized multi-day training plans. It facilitates the creation of comprehensive workout programs tailored to specific goals, age ranges, and movement patterns.

PHPocalypse-MCP

一个消息控制协议服务器，为开发者自动运行 PHP 测试和静态分析工具，并将结果直接提供给 Cursor 编辑器中的 AI 助手。 (Alternative, slightly more literal translation): 一个消息控制协议服务器，它为开发者自动运行 PHP 测试和静态分析工具，并将结果直接提供给 Cursor 编辑器内的 AI 助手。

GitHub Agentic Chat MCP Server

使用 Go 语言实现的 GitHub Agentic Chat 的 MCP 服务器

Spotify MCP Server

一个轻量级的模型上下文协议服务器，使像 Cursor 和 Claude 这样的 AI 助手能够控制 Spotify 播放和管理播放列表。

PDF Agent MCP

Enables AI agents to efficiently process large local and online PDFs through selective extraction of text, images, and metadata. It provides tools for content search and document outline navigation to optimize context window usage.

Ubuntu MCP Server

A secure protocol server that allows AI assistants to safely interact with Ubuntu systems through controlled file operations, command execution, package management, and system information retrieval.

Cursor Self-Meta.

一个基于 stdio 的 Perl MCP 服务器实现，它允许以光标逐字访问其自身的内部状态。

workflows-mcp

A Model Context Protocol implementation that enables LLMs to execute complex, multi-step workflows combining tool usage with cognitive reasoning, providing structured, reusable paths through tasks with advanced control flow.

Overseerr MCP Server

启用与 Overseerr API 的交互，以管理电影和电视节目的请求，允许用户检查服务器状态并按各种标准过滤媒体请求。

Gemini MCP Server

Enables Claude Code to use Google Gemini AI capabilities for analyzing PDFs and images, generating and translating text, and reviewing code. Supports both CLI and API backends with different quota limits.

cBioPortal MCP Server

A server that enables AI assistants to interact with cancer genomics data from cBioPortal, allowing users to explore cancer studies, access genomic data, and retrieve mutations and clinical information.

AWS Athena MCP Server

Enables execution of SQL queries against AWS Athena databases with schema discovery, query status management, and result retrieval through a standardized Model Context Protocol interface.

git-steer

An autonomous GitHub management engine that enables control over repositories, branches, security alerts, and Actions workflows through natural language. It utilizes a zero-local-footprint architecture by storing all configuration and audit logs within a private state repository on GitHub.

MCP Novel Assistant

A novel management tool that uses SQLite database to store and manage novel information including chapters, characters, and plot outlines. Provides database operations and SQL query capabilities for writers to organize their creative work through natural language.

marker-mcp

A

Slack Notification MCP Server

Enables Claude AI to send real-time notifications to Slack channels with support for rich formatting, multiple channels, and customizable message styling for workflow automation and task completion alerts.

Simple MCP Server

A self-contained, dependency-free MCP server that provides utility tools for time, date, mathematical calculations, and shell command execution. It supports remote connectivity through SSE and is designed for easy deployment via Docker.

API as MCP

Converts REST APIs into MCP tools using Gradio, demonstrated with a local IBM Granite model via Ollama. Enables LLM clients to interact with any REST API endpoint through the MCP protocol.

cortex-cloud-docs-mcp-server

MCP server for asking questions about Cortex Cloud documentation

Frontend Review MCP

An MCP server that reviews UI edit requests by comparing before and after screenshots, providing visual feedback on whether changes satisfy the user's requirements.

Mcp-server-v2ex

Okay, here's a simplified explanation of how to build a basic Minecraft Protocol (MCP) server using TypeScript, focusing on the core concepts and a minimal example. Keep in mind that a full MCP server is a complex undertaking, and this is just a starting point. **Conceptual Overview** 1. **Minecraft Protocol (MCP):** Minecraft clients and servers communicate using a specific binary protocol. You need to understand the structure of packets (data messages) defined by this protocol. The protocol changes with each Minecraft version. [Wiki.vg](https://wiki.vg/Protocol) is *the* resource for protocol information. 2. **TCP Socket Server:** Your server will listen for incoming TCP connections from Minecraft clients. 3. **Packet Handling:** When a client connects, your server needs to: * Receive data from the socket. * Parse the data into MCP packets. * Process the packets (e.g., handle handshake, login, player movement). * Construct appropriate response packets. * Send the response packets back to the client. 4. **TypeScript:** TypeScript adds static typing to JavaScript, making your code more maintainable and easier to reason about. **Simplified Example (Conceptual - Requires Libraries)** This example outlines the basic structure. You'll need to install libraries for socket handling, data serialization/deserialization (for MCP packets), and potentially logging. ```typescript import * as net from 'net'; // You'll need to install a library for handling Minecraft packets. // Example: npm install prismarine-packet // import { createSerializer, createDeserializer } from 'prismarine-packet'; const serverPort = 25565; // Default Minecraft port // Basic server information (for the server list ping) const serverDescription = "My Simple TS Server"; const maxPlayers = 10; const onlinePlayers = 0; const protocolVersion = 763; // Example: Minecraft 1.17.1 protocol version const minecraftVersion = "1.17.1"; // Create the TCP server const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); // **Packet Handling (Simplified)** socket.on('data', (data) => { // In a real server, you'd: // 1. Deserialize the data into a Minecraft packet. // 2. Determine the packet type (e.g., Handshake, Login Start). // 3. Process the packet based on its type. // 4. Construct a response packet. // 5. Serialize the response packet. // 6. Send the serialized data back to the client. // **Extremely Simplified Example: Responding to a Handshake (Very Incomplete)** // This is just to illustrate the concept. It's not a complete handshake implementation. const packetId = data[0]; // Assuming the first byte is the packet ID if (packetId === 0x00) { // Handshake packet ID (This is version-dependent!) console.log("Received Handshake"); // **In reality, you'd parse the handshake data to get the protocol version, server address, and port.** // **Create a Status Response (Server List Ping)** const statusResponse = { version: { name: minecraftVersion, protocol: protocolVersion }, players: { max: maxPlayers, online: onlinePlayers, sample: [] // Player list (optional) }, description: { text: serverDescription } }; // **Serialize the status response to JSON** const statusResponseJson = JSON.stringify(statusResponse); // **Create the Status Response packet (0x00)** // **This is where you'd use a proper packet serialization library.** // **The following is a placeholder and WILL NOT WORK without proper serialization.** const responsePacket = Buffer.from([ 0x00, // Packet ID (Status Response) statusResponseJson.length, // Length of the JSON string (This needs to be properly encoded) ...Buffer.from(statusResponseJson, 'utf8') // The JSON string itself ]); // Send the response socket.write(responsePacket); // Request socket.once('data', (requestData) => { if (requestData[0] === 0x00) { console.log("Received Request"); const pongResponse = Buffer.from([ 0x01, // Pong packet ID 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Payload (timestamp) ]); socket.write(pongResponse); socket.end(); } }); } else { console.log("Received unknown packet ID:", packetId); } }); socket.on('close', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Socket error:', err); }); }); // Start the server server.listen(serverPort, () => { console.log(`Server listening on port ${serverPort}`); }); ``` **Important Considerations and Next Steps** * **Minecraft Protocol Library:** You *absolutely* need a library to handle the Minecraft protocol. `prismarine-packet` is a popular choice, but there are others. This library will handle the complex serialization and deserialization of packets. Install it with `npm install prismarine-packet`. You'll need to adapt the example code to use the library's functions. * **Protocol Version:** The Minecraft protocol changes with each version. Make sure you're using the correct protocol version for the Minecraft client you're testing with. [Wiki.vg](https://wiki.vg/Protocol_version_IDs) lists protocol version IDs. * **Error Handling:** The example has minimal error handling. You need to add robust error handling to catch exceptions and prevent your server from crashing. * **Asynchronous Operations:** Use `async/await` or Promises to handle asynchronous operations (like socket reads and writes) properly. * **State Management:** You'll need to manage the state of each connected client (e.g., their username, position, inventory). * **Security:** Implement security measures to prevent exploits and attacks. * **World Generation:** If you want a playable world, you'll need to implement world generation. * **Multiplayer:** Handling multiple players concurrently adds significant complexity. **How to Run** 1. **Install Node.js:** Make sure you have Node.js installed. 2. **Create a Project:** Create a directory for your project and run `npm init -y` to create a `package.json` file. 3. **Install Dependencies:** `npm install net prismarine-packet` (or your chosen packet library). You might need other dependencies as you develop. 4. **Save the Code:** Save the TypeScript code as a `.ts` file (e.g., `server.ts`). 5. **Compile:** Compile the TypeScript code to JavaScript: `tsc server.ts` (you might need to configure `tsconfig.json` first). 6. **Run:** Run the server: `node server.js` **In summary, this is a very basic outline. Building a real Minecraft server is a significant project. Start small, focus on understanding the protocol, and use libraries to help you.**

MCP Local Router

一个 MCP（模型上下文协议）本地路由器，用作 MCP 服务器的聚合代理。

Kali Linux MCP Server

一个工具，允许通过多会话协议服务器执行 Kali Linux 命令来进行渗透测试，支持诸如 SQL 注入和命令执行等安全测试操作。

MCP Server Boilerplate

A starter template for building custom MCP servers with example tools, TypeScript support, and multi-client installation scripts for Claude Desktop, Cursor, and other MCP-compatible AI assistants.

Remote MCP Server (Authless)

A template for deploying an authentication-free MCP server on Cloudflare Workers. Enables easy deployment and connection to MCP clients like Claude Desktop or Cloudflare AI Playground via Server-Sent Events.

Rosbridge MCP Server

A Model Context Protocol server that provides tools to publish messages to ROS topics via rosbridge WebSocket, enabling integration between language models and ROS-based robotics systems.

Deno MCP Template Repo

一个使用 Deno 编写和发布 MCP 服务器的模板仓库。

NEXIA Consciousness Engine

Provides Claude Desktop with persistent memory across sessions, storing up to 10,000 memories with semantic search and automatic context bridging. Features temporal versioning and anti-degradation protocols to maintain conversation continuity.