发现优秀的 MCP 服务器

GPT Windows Connector

Remote-first, model-independent Windows execution MCP for ChatGPT, Claude, Gemini, and other MCP-compatible AI clients.

MCP Access OAuth Server

Remote MCP server with built-in OAuth authentication via Cloudflare Access, enabling secure tool access and user identity-based restrictions.

URL Text Fetcher MCP Server

Enables fetching visible text content and extracting all links from web pages through URL requests. Designed specifically for LM Studio integration to provide web scraping capabilities.

stitch-mcp-stdio

Stable stdio MCP server for Google Stitch AI UI design tool, eliminating the proxy subprocess to prevent crashes. Provides tools to manage projects, screens, design systems, and generate UI designs.

claude-octopus

Wraps the Claude Agent SDK as MCP servers, letting you spawn multiple specialized Claude Code agents — each with its own model, tools, system prompt, and personality — from any MCP client.

yakit-mcp

Enables AI agents to drive the local Yakit engine for HTTP packet replay, GUI visualization, and screenshotting via CDP. Supports automatic protocol detection, batch replay, history management, and CDP-based GUI automation.

Simple PostgreSQL MCP Server

Enables executing SQL queries on PostgreSQL databases with configurable read-only or write access permissions through a minimal Model Context Protocol interface.

Google Docs + Gmail MCP Server

Enables appending content to Google Docs and creating Gmail drafts with human-in-the-loop approval, integrating structured AI tool interfaces via MCP-style endpoints.

servicenow-mcp

A read-only MCP server that enables AI assistants to query ServiceNow instances—incidents, changes, users, CMDB—with malformed query linting and injection protection.

Template for Bun MCP Server

Okay, here's a template structure and some example code for a Bun + Minecraft Protocol (MCP) server project, along with explanations to get you started. This focuses on the core structure and handling basic connections. You'll need to adapt it based on the specific features you want to implement. **Project Structure:** ``` bun-mcp-server/ ├── src/ │ ├── index.ts # Main entry point │ ├── server.ts # Server logic (listening, connection handling) │ ├── protocol.ts # MCP packet handling (encoding/decoding) │ ├── player.ts # Player object/class │ ├── config.ts # Configuration loading │ └── utils.ts # Utility functions ├── package.json ├── bun.lockb ├── .gitignore └── README.md ``` **1. `package.json`:** ```json { "name": "bun-mcp-server", "version": "0.0.1", "description": "A Minecraft Protocol server written in Bun", "main": "src/index.ts", "scripts": { "start": "bun run src/index.ts", "dev": "bun run --watch src/index.ts" }, "dependencies": { // Add any dependencies here, e.g., for logging, configuration, etc. }, "devDependencies": { "@types/node": "^20.0.0" // Important for Node.js compatibility }, "type": "module" } ``` **Explanation:** * `name`, `version`, `description`: Standard package metadata. * `main`: Specifies the entry point of your application. * `scripts`: Defines commands for running and developing your server. `bun run src/index.ts` starts the server. `bun run --watch src/index.ts` starts the server in watch mode, automatically restarting when files change. * `dependencies`: List any external libraries your project uses. You'll likely need libraries for more advanced features (e.g., logging, configuration parsing). * `devDependencies`: Development-time dependencies, like TypeScript type definitions. `@types/node` is crucial for compatibility with Node.js APIs that Bun supports. * `type": "module"`: This is *essential* for using ES modules (import/export syntax) in Bun. **2. `src/index.ts` (Main Entry Point):** ```typescript import { startServer } from './server'; import { loadConfig } from './config'; async function main() { try { const config = await loadConfig(); // Load configuration console.log("Configuration loaded:", config); startServer(config); // Start the server } catch (error) { console.error("Error starting server:", error); } } main(); ``` **Explanation:** * This is the starting point of your application. * It imports the `startServer` function from `server.ts` and `loadConfig` from `config.ts`. * It calls `loadConfig` to load the server configuration. * It calls `startServer` to start the server, passing the configuration. * It includes error handling to catch any errors that occur during startup. **3. `src/server.ts` (Server Logic):** ```typescript import { listen } from 'bun'; import { handleConnection } from './protocol'; import { ServerConfig } from './config'; export function startServer(config: ServerConfig) { console.log(`Starting server on ${config.host}:${config.port}`); Bun.serve({ fetch(req, server) { if (server.upgrade(req)) { // handle WebSocket request return undefined; } return new Response("Upgrade failed :(", { status: 500 }); }, websocket: { open(ws) { console.log("Client connected"); handleConnection(ws); // Handle the new connection }, message(ws, message) { // Handle WebSocket message console.log(`Received message: ${message}`); }, close(ws, code, message) { console.log(`Client disconnected with code ${code} and message ${message}`); }, error(ws, error) { console.error("WebSocket error:", error); }, }, port: config.port, hostname: config.host, }); console.log("Server started"); } ``` **Explanation:** * This file contains the core server logic. * `startServer` function takes a `config` object (defined in `config.ts`). * It uses `Bun.serve` to create an HTTP server that listens for incoming connections. * The `fetch` function handles HTTP requests and upgrades them to WebSockets. * The `websocket` object defines the WebSocket event handlers: * `open`: Called when a new WebSocket connection is established. It calls `handleConnection` to process the connection. * `message`: Called when a WebSocket message is received. This is where you'll handle incoming MCP packets. * `close`: Called when a WebSocket connection is closed. * `error`: Called when a WebSocket error occurs. * The server listens on the port and hostname specified in the configuration. **4. `src/protocol.ts` (MCP Packet Handling):** ```typescript import { WebSocket } from 'bun'; import { Player } from './player'; export function handleConnection(ws: WebSocket) { console.log("Handling new connection..."); const player = new Player(ws); // Create a new player object ws.addEventListener("message", (event) => { const message = event.data; if (typeof message === "string") { console.log(`Received text message: ${message}`); } else if (message instanceof ArrayBuffer) { // Handle binary data (MCP packets) const buffer = new Uint8Array(message); console.log(`Received binary message: ${buffer}`); // TODO: Decode the MCP packet and process it // Example: // const packetId = buffer[0]; // switch (packetId) { // case 0x00: // Handshake // handleHandshake(buffer, player); // break; // // ... other packet types // default: // console.warn(`Unknown packet ID: ${packetId}`); // } } else { console.log(`Received unknown message type: ${typeof message}`); } }); ws.addEventListener("close", () => { console.log("Connection closed"); // Clean up player data }); ws.addEventListener("error", (error) => { console.error("WebSocket error:", error); }); } // Example Handshake handler (replace with actual MCP logic) function handleHandshake(buffer: Uint8Array, player: Player) { // TODO: Implement handshake logic based on the MCP protocol console.log("Handling handshake packet"); // Example: Read protocol version, server address, and next state from the buffer // const protocolVersion = buffer.readInt32BE(1); // Example: Read from offset 1 // ... } ``` **Explanation:** * This file handles the Minecraft Protocol (MCP) logic. * `handleConnection` is called when a new WebSocket connection is established. * It creates a `Player` object to represent the connected player. * It sets up event listeners for the WebSocket: * `message`: This is the most important part. It receives incoming messages from the client. You'll need to: * Check if the message is a string or an `ArrayBuffer`. MCP packets are binary data (ArrayBuffer). * Decode the MCP packet. This involves reading the packet ID and any data associated with the packet. * Process the packet based on its ID. This might involve updating the player's state, sending data to other players, etc. * `close`: Called when the connection is closed. You'll need to clean up any player data. * `error`: Called when an error occurs. * The `handleHandshake` function is a placeholder. You'll need to implement the actual handshake logic based on the MCP protocol. The handshake is the first packet sent by the client and is used to establish the connection. **5. `src/player.ts` (Player Class):** ```typescript import { WebSocket } from 'bun'; export class Player { socket: WebSocket; username: string | null = null; // Add other player properties here (e.g., position, health, inventory) constructor(socket: WebSocket) { this.socket = socket; } send(data: Uint8Array) { if (this.socket.readyState === WebSocket.OPEN) { this.socket.send(data); } else { console.warn("Socket is not open, cannot send data"); } } // Add methods for updating player state, sending packets, etc. } ``` **Explanation:** * This file defines the `Player` class, which represents a connected player. * It stores the player's WebSocket connection, username, and other properties. * The `send` method sends data to the player's client. * You'll need to add methods for updating the player's state, sending packets, and handling other player-related logic. **6. `src/config.ts` (Configuration):** ```typescript import { readFile } from 'node:fs/promises'; // Use Node.js fs/promises for file reading export interface ServerConfig { host: string; port: number; motd: string; // Message of the Day maxPlayers: number; } const defaultConfig: ServerConfig = { host: '0.0.0.0', port: 25565, motd: 'A Bun Minecraft Server', maxPlayers: 20, }; export async function loadConfig(): Promise<ServerConfig> { try { // Attempt to load from config.json const configFile = await readFile('config.json', 'utf-8'); const parsedConfig = JSON.parse(configFile) as Partial<ServerConfig>; // Merge with defaults, overriding with values from config.json return { ...defaultConfig, ...parsedConfig }; } catch (error) { console.warn("Failed to load config.json, using default configuration:", error); return defaultConfig; } } ``` **Explanation:** * This file handles loading the server configuration. * The `ServerConfig` interface defines the structure of the configuration object. * `defaultConfig` provides default values for the configuration. * `loadConfig` attempts to load the configuration from a `config.json` file. If the file doesn't exist or is invalid, it uses the default configuration. * It uses `node:fs/promises` to read the file asynchronously. This is important for performance. **7. `config.json` (Example Configuration File):** ```json { "port": 25566, "motd": "My Awesome Bun Server!" } ``` **8. `src/utils.ts` (Utility Functions):** ```typescript // Example utility function (add more as needed) export function hexEncode(data: Uint8Array): string { return Array.from(data) .map(byte => byte.toString(16).padStart(2, '0')) .join(''); } ``` **9. `.gitignore`:** ``` node_modules bun.lockb ``` **Key Concepts and Next Steps:** 1. **Minecraft Protocol (MCP):** This is the most important part. You *must* understand the MCP to build a functional server. Refer to the official Minecraft Protocol documentation (search for "Minecraft Protocol" or "wiki.vg/Protocol"). Pay close attention to: * **Packet IDs:** Each packet has a unique ID that identifies its type. * **Data Types:** The MCP uses specific data types (e.g., VarInt, VarLong, strings, integers, booleans). You'll need to read and write these data types correctly. * **Packet Structure:** Each packet has a specific structure, with fields in a defined order. * **State Machine:** The protocol operates in different states (Handshaking, Status, Login, Play). You need to handle packets differently depending on the current state. 2. **Binary Data Handling:** MCP packets are binary data. You'll need to use `Uint8Array` and `DataView` to read and write data to the buffers. 3. **VarInt and VarLong:** These are variable-length integers used in the MCP. You'll need to implement functions to read and write them. 4. **Asynchronous Operations:** Bun is designed for asynchronous operations. Use `async/await` and Promises to handle network I/O efficiently. 5. **Error Handling:** Implement robust error handling to catch and log errors. 6. **Logging:** Use a logging library to log important events and errors. 7. **Configuration:** Use a configuration file to store server settings (e.g., port, MOTD, max players). 8. **Player Management:** Keep track of connected players and their state. 9. **World Management:** Implement world loading, saving, and generation. 10. **Game Logic:** Implement the game logic (e.g., player movement, block placement, entity spawning). **Example: Reading a VarInt (Important for MCP):** ```typescript function readVarInt(buffer: Uint8Array, offset: number): { value: number, bytesRead: number } { let result = 0; let shift = 0; let bytesRead = 0; while (true) { const byte = buffer[offset + bytesRead]; bytesRead++; if (byte === undefined) { throw new Error("Incomplete VarInt"); } result |= (byte & 0x7F) << shift; shift += 7; if (!(byte & 0x80)) { return { value: result, bytesRead: bytesRead }; } if (shift > 35) { throw new Error("VarInt is too big"); } } } ``` **Example: Writing a VarInt:** ```typescript function writeVarInt(value: number): Uint8Array { const buffer: number[] = []; while (true) { const byte = value & 0x7F; value >>>= 7; if (value !== 0) { buffer.push(byte | 0x80); } else { buffer.push(byte); break; } } return new Uint8Array(buffer); } ``` **How to Run:** 1. **Install Bun:** Follow the instructions on the official Bun website ([https://bun.sh/](https://bun.sh/)). 2. **Create the Project:** Create the directory structure and files as described above. 3. **Install Dependencies:** Run `bun install` in the project directory. 4. **Start the Server:** Run `bun run start` or `bun run dev` in the project directory. **Important Considerations for Bun:** * **Node.js Compatibility:** Bun aims to be compatible with Node.js APIs, but there may be differences. Test your code thoroughly. * **WebSockets:** Bun has excellent WebSocket support. * **Performance:** Bun is designed for performance. Take advantage of its features to optimize your server. This template provides a solid foundation for building a Bun + MCP server. Remember to consult the Minecraft Protocol documentation and adapt the code to your specific needs. Good luck! **Chinese Translation of Key Terms:** * **Minecraft Protocol (MCP):** Minecraft 协议 (Minecraft Xiéyì) * **Packet:** 数据包 (Shùjùbāo) * **Server:** 服务器 (Fúwùqì) * **Client:** 客户端 (Kèhùduān) * **WebSocket:** WebSocket (pronounced the same in Chinese) * **Handshake:** 握手 (Wòshǒu) * **VarInt:** 变长整数 (Biàncháng Zhěngshù) * **Configuration:** 配置 (Pèizhì) * **Player:** 玩家 (Wánjiā) * **World:** 世界 (Shìjiè) * **MOTD (Message of the Day):** 每日消息 (Měirì Xiāoxī) or 服务器标语 (Fúwùqì Biāoyǔ) * **ArrayBuffer:** 数组缓冲区 (Shùzǔ Huǎnchōngqū) * **Uint8Array:** 8位无符号整数数组 (8 Wèi Wúfúhào Zhěngshù Shùzǔ) This should give you a good start. Let me know if you have any more questions!

SciMath MCP

Enables reliable engineering and scientific computation through tools for exact arithmetic, unit-aware formulas, calculus, linear algebra, statistics, uncertainty propagation, and physical constants, all executed safely in reproducible subprocesses.

MCP Google Analytics Server

Enables comprehensive integration with Google Analytics 4, allowing users to read analytics reports and send custom events through both the Data API and Measurement Protocol v2.

cuad-audit

An MCP server that audits a contract liability clause against a derived company standard, producing a verdict only when grounded in retrieved evidence and passing a faithfulness check. It abstains with 'insufficient-grounding' when evidence is too weak.

Excel MCP Server

Enables reading and writing of values, formulas, and formatting in Microsoft Excel files including .xlsx and .xlsm formats. It supports sheet management, table creation, and provides Windows-exclusive features like live editing and screen capture.

iotforge

Enables AI assistants to discover and control IoT devices on local networks and via Bluetooth LE.

SearXNG MCP Server

Enables web search through SearXNG instances, offering tools for general and category-specific queries, engine selection, time filtering, and engine discovery.

buyme-mcp-vercel

Remote MCP server for searching Israeli businesses that accept BuyMe gift cards, with tools for filtering businesses by category, region, and price.

mteam-mcp-server

Enables AI assistants to search, get details, and download torrents from the M-Team private tracker via its API.

Personal Capital MCP Connector

Enables natural language queries about financial accounts, net worth, transactions, and asset allocation via the Empower/Personal Capital API.

contactapi

Enables AI clients to manage contacts through CRUD operations (list, get, create/upsert by email, update, delete) with OAuth 2.1 authentication.

swarm-at

Enables agent settlement, trust verification, and ledger operations for multi-agent workflows, with tools for blueprint management, credit tracking, and provenance recording.

ElevenLabs MCP Server

Enables interaction with ElevenLabs Text-to-Speech and audio processing APIs. Supports speech generation, voice cloning, audio transcription, and sound effect creation through natural language.

timer-mcp

A minimal MCP server that gives AI agents the ability to pause execution by waiting a specified number of seconds, with support for local and AWS AgentCore deployment.

screen-buffer-mcp

An MCP server that enables high-speed Android screenshot capture with ~50ms latency using the scrcpy frame buffer. It maintains a circular buffer for instant access to recent frames and automatically falls back to ADB when scrcpy is unavailable.

Nordic Economics MCP

Semantic search over Nordic economic data — market announcements, quarterly reports (162 companies), macro data (NO/SE/DK/FI), commodity prices, and press releases. 180,000+ vectors.

x402 Payment Gateway MCP Server

Enables AI agents to make micropayments using USDC on Solana via the x402 protocol, supporting payment requests, on-chain verification, and revenue tracking.

MCP Simple AivisSpeech

A Model Context Protocol server that integrates with AivisSpeech to enable AI assistants to convert text to natural-sounding Japanese speech with customizable voice parameters.

vector-mirror

A deterministic SVG perception tool for LLM agents that renders SVGs in a real browser to measure geometry, colors, and spatial constraints, reporting results in grid grammar and W3C color names without guessing.

@fictjs/mcp

MCP server for retrieving Fict documentation, running compiler/ESLint/TypeScript diagnostics, and generating shareable Playground links.

mcp-tenant-isolation

Static analysis scanner for multi-tenant SaaS and MCP server code that catches cross-tenant data leakage with 57 deterministic rules, including an MCP server for Claude Desktop and Cursor integration.