发现优秀的 MCP 服务器

PhantomAPI

Compiles any software into an API by learning from user demonstrations, providing a deterministic, low-latency MCP server with zero token cost at runtime.

claude-openai-image-mcp

A security-first MCP server that generates images via OpenAI's image model (gpt-image-2) and returns them as MCP image content, usable from Claude Code, Claude Desktop, and other stdio MCP clients.

reactome-mcp

Enables AI assistants to search, browse, analyze, and export biological pathway data from Reactome through natural language.

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.

mcp-mastodon

Provides access to public Mastodon data including trending posts, account profiles, and public timeline via mastodon.social without authentication.

sheets-mcp

Enables Claude Desktop to read, write, and manage Google Sheets through natural language conversation using the Model Context Protocol.

xunfeiPpt MCP Server

Enables PPT generation using iFlytek Zhiwen API, supporting multiple transport protocols (HTTP, SSE, HTTP-Stream) and ReACT workflows for intelligent template selection, content generation, and document-to-PPT conversion.

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.

Data Documentation Checker

Extracts and validates data documentation to ensure consistent understanding of field meanings, types, and constraints. Exposes tools for extracting data dictionaries, checking documentation clarity, and comparing schema versions.

MCP Document Analysis Server

A Model Context Protocol server that provides document analysis capabilities to LLM applications, including extraction, chunking, summarization, and semantic search for PDF, DOCX, and plaintext documents.

unifi-network-mcp

MCP server providing typed, safety-gated access to UniFi Network consoles via the official API, enabling management of devices, clients, networks, WiFi, firewall policies, and more.

indian-stock-market-mcp

MCP server providing real-time Indian stock market data through 15 tools, including stock details, historical data, market overview, and news. Works with Claude Desktop, Claude Code, Cursor, Windsurf, and other MCP clients using an API key from IndianAPI.in.

Rapid URL Indexer MCP Server

Enables submitting URLs to the Rapid URL Indexer API, tracking submissions across projects, and auto-detecting new pages from sitemaps.

VaultForge

An MCP server for Obsidian that enables canvas creation with auto-layout, BM25-ranked search, vault theme mapping, and 27 tools for managing notes, files, and links.

Spotify MCP Server

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

Red Hat Security Data API MCP Server

Enables querying Red Hat security data including CSAF advisories, CVEs, and OVAL streams through natural language.

Recruitment AI MCP

This MCP server provides hiring automation tools for recruitment processes. It enables users to generate job descriptions, score CVs, create interview questions, benchmark salaries, and draft offer letters through natural language interactions.

custom-browser-mcp

MCP server that extracts accessibility tree, design tokens, screenshots, Claude DSL, and Figma JSON from any URL using a persistent Chromium browser with zero LLM cost.

MCPServerDemo

A demonstration server that implements JSON-RPC 2.0 methods for basic arithmetic using FastAPI. It provides integration examples for the Model Context Protocol (MCP) using FastMCP to connect with Claude Desktop.

figma-mcp

Enables Claude to create and edit Figma designs in real time through MCP tools, allowing natural language commands for generating slides, charts, and other elements.

Motion MCP Server

Bridges Motion's API with LLMs via the Model Context Protocol, enabling natural language task, project, and schedule management.

sdm-mcp

MCP server to remotely control Siglent SDM3000 series digital multimeters via TCP/IP SCPI protocol, enabling measurement, configuration, and data acquisition.

Figma Context MCP

A Model Context Protocol (MCP) server that enhances Figma design integration by adding element position information to API responses, enabling AI assistants to better understand spatial relationships and convert designs to code more accurately.

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.

mcp_query_table

A MCP server that queries financial website tables using Playwright, enabling automated data retrieval from sources like Tonghuashun and East Money, and exposing the results via MCP tools.

API Tester AI MCP

API Tester AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

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 服务器的聚合代理。