发现优秀的 MCP 服务器

jotae-mcp

Connects Claude to Jotae for creating events, configuring WhatsApp and email automations, and reading metrics through natural language.

AI Red Teaming MCP Server

AI red teaming toolkit exposed as a Model Context Protocol (MCP) server. Connect any MCP client and test AI systems for safety vulnerabilities.

My MCP Server

A Python template for building Model Context Protocol (MCP) servers that expose tools via JSON-RPC, enabling secure and scalable context and tool invocation for language models.

Aviation Model Context Protocol

Integration platform for aviation data sources including weather, NOTAMs, airport information, and flight planning APIs, enabling comprehensive pre-flight preparation and in-flight decision support.

MongoDB MCP Server

镜子 (jìng zi)

MCP keyword search

A Model Context Protocol server that enables keyword search within files, returning matching lines with line numbers.

unreal-engine-mcp

An MCP server that gives AI agents broad control over Unreal Engine 5.7, enabling actor/asset/level management, Blueprint and material creation, screenshots, automation, and arbitrary editor Python execution.

zhipu-vision-mcp

Provides vision capabilities to text-only models (like DeepSeek) via Zhipu free vision models, enabling image analysis, OCR, and image comparison through natural language.

YingDao RPA MCP Server

Enables AI to execute RPA applications and workflows through the Model Context Protocol, supporting both local and cloud modes.

dameng-mcp-server

MCP server for DaMeng database, enabling AI assistants to execute SQL queries, list tables, describe table structures, and retrieve schema information.

A2AL MCP Server

Enables AI agents to publish themselves, discover each other, and establish authenticated encrypted connections without central infrastructure, using a decentralized agent-to-agent networking protocol.

Remote MCP Server (Authless)

Deploys a remote MCP server on Cloudflare Workers without authentication, enabling connection to AI Playground and Claude Desktop via a proxy.

DETRAN BA: Licenciamento

Enables querying DETRAN BA vehicle licensing information from the official source via a read-only MCP server. It works with any MCP client over HTTP using pay-per-use credits.

Anki MCP Server

一个模型上下文协议服务器，它使大型语言模型（LLM）能够通过 AnkiConnect 与 Anki 抽认卡软件进行交互，从而实现抽认卡、牌组和笔记类型的创建和管理。

Pocketbase Mcp

MCP 兼容的 PocketBase 服务器实现

ADB MCP Server

A Model Context Protocol server that provides Android Debug Bridge functionality for automating Android devices, enabling remote device management, screen operations, app management, file operations, and shell command execution.

iA Document Management MCP Server

Provides tools to authenticate, search, and manage sessions within WingArc's iA Document Management System. It enables users to perform free word document searches and manage security tokens through the Model Context Protocol.

ghl-context-mcp

Enables AI agents to pull focused GoHighLevel context before talking to a contact, including contact lookup, timeline summaries, pipeline positions, and appointments, with optional guarded writes. It helps agents brief themselves on a person without exposing raw CRM API noise.

monarchmoney-node

MCP server providing 30 tools to access and manage Monarch Money financial data, including accounts, transactions, budgets, and more, enabling AI assistants to interact with personal finances.

Typescript Mcp Server Usage

Okay, I will provide you with a basic example of how to create an MCP (Minecraft Protocol) server using TypeScript. Keep in mind that building a full-fledged Minecraft server from scratch is a complex undertaking. This example will focus on the core networking and handshake aspects. You'll need to install some dependencies first. **1. Project Setup and Dependencies:** First, create a new TypeScript project: ```bash mkdir mcp-server cd mcp-server npm init -y npm install typescript ts-node ws --save npm install @types/node @types/ws --save-dev ``` * `ws`: A popular WebSocket library for Node.js. Minecraft uses a custom protocol over TCP, but WebSocket provides a convenient way to handle the underlying socket communication for this example. In a real Minecraft server, you'd implement the protocol directly over TCP. * `typescript`: The TypeScript compiler. * `ts-node`: Allows you to execute TypeScript files directly. * `@types/node`, `@types/ws`: TypeScript type definitions for Node.js and WebSocket, respectively. Create a `tsconfig.json` file: ```json { "compilerOptions": { "target": "es2017", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` **2. `src/index.ts` (Main Server Code):** ```typescript import * as WebSocket from 'ws'; const PORT = 25565; // Or any port you prefer const wss = new WebSocket.Server({ port: PORT }, () => { console.log(`Server started on port ${PORT}`); }); wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { // In a real Minecraft server, you'd parse the Minecraft protocol packets here. // This is a simplified example, so we're just echoing the message. console.log(`Received: ${message}`); // Example: Echo the message back to the client ws.send(`Server received: ${message}`); }); ws.on('close', () => { console.log('Client disconnected'); }); ws.on('error', error => { console.error('WebSocket error:', error); }); }); wss.on('error', error => { console.error('Server error:', error); }); console.log('MCP Server is starting...'); ``` **Explanation:** * **Import `ws`:** Imports the WebSocket library. * **`PORT`:** Defines the port the server will listen on. Minecraft's default port is 25565. * **`WebSocket.Server`:** Creates a new WebSocket server instance. * **`wss.on('connection', ...)`:** This is the core of the server. It's called whenever a new client connects. * `ws`: Represents the WebSocket connection to the client. * `ws.on('message', ...)`: Handles incoming messages from the client. **This is where you would implement the Minecraft protocol parsing and handling.** In this example, it simply logs the message and echoes it back. * `ws.on('close', ...)`: Handles client disconnections. * `ws.on('error', ...)`: Handles errors on the WebSocket connection. * **`wss.on('error', ...)`:** Handles errors on the server itself. **3. Building and Running:** 1. **Compile:** Run `npm run tsc` (or just `tsc` if you have it globally installed) to compile the TypeScript code into JavaScript. This will create a `dist` directory with the compiled `index.js` file. You might need to add `"build": "tsc"` to your `package.json` scripts section. 2. **Run:** Execute the server using `node dist/index.js` or `ts-node src/index.ts`. **Important Considerations and Next Steps (for a *real* Minecraft server):** * **Minecraft Protocol:** The code above uses WebSockets for simplicity. A *real* Minecraft server communicates using a custom binary protocol over TCP. You'll need to: * **Understand the Protocol:** Study the Minecraft protocol documentation (see links below). It involves packets with specific IDs, data types, and structures. * **Implement Packet Parsing/Serialization:** Write code to read incoming TCP data, parse it into Minecraft packets, and serialize packets to send back to the client. Libraries exist that can help with this, but you'll still need to understand the protocol. * **Handshake:** The initial connection involves a handshake where the client and server exchange protocol versions. You need to implement this handshake correctly. * **Authentication:** Minecraft servers typically require authentication. You'll need to handle login requests and verify user credentials. * **Game Logic:** This example has *no* game logic. You'll need to implement the core game mechanics: world generation, player movement, entity management, block updates, etc. * **Threading/Asynchronous Operations:** Minecraft servers are highly concurrent. You'll need to use threading or asynchronous programming (e.g., `async/await` in TypeScript) to handle multiple clients efficiently. * **World Storage:** You'll need a way to store the game world data (blocks, entities, etc.). This could involve files, databases, or other storage mechanisms. **Example of a very basic handshake (to illustrate the concept):** ```typescript // Inside the 'connection' handler: ws.on('message', message => { const buffer = Buffer.from(message); // Convert to Buffer for binary data // Example: Very basic handshake (replace with actual protocol parsing) if (buffer[0] === 0x00) { // Assuming 0x00 is a handshake packet ID const protocolVersion = buffer.readInt32BE(1); // Read protocol version const serverAddressLength = buffer.readInt8(5); const serverAddress = buffer.toString('utf8', 6, 6 + serverAddressLength); const serverPort = buffer.readUInt32BE(6 + serverAddressLength); const nextState = buffer.readInt8(10 + serverAddressLength); console.log(`Handshake: Protocol ${protocolVersion}, Address ${serverAddress}:${serverPort}, Next State ${nextState}`); // Send a response (e.g., a status response) const response = JSON.stringify({ version: { name: "My TypeScript Server", protocol: protocolVersion }, players: { max: 10, online: 0, sample: [] }, description: { text: "A simple TypeScript Minecraft server" } }); const responseBuffer = Buffer.from(response); const length = responseBuffer.length; const lengthBuffer = Buffer.alloc(1); lengthBuffer.writeInt8(length); ws.send(Buffer.concat([lengthBuffer, responseBuffer])); } else { console.log(`Received other message: ${message}`); } }); ``` **Important Resources:** * **Minecraft Protocol Documentation:** This is essential. Search for "Minecraft Protocol" or "wiki.vg Minecraft Protocol". `wiki.vg` is a good starting point. * **Existing Minecraft Server Implementations:** Look at open-source Minecraft server projects (e.g., in Java or other languages) to see how they handle the protocol and game logic. This can be a great learning resource. However, be aware that the protocol changes over time, so make sure the implementation you're looking at is relatively up-to-date. **Chinese Translation of Key Terms:** * **Minecraft Protocol:** 我的世界协议 (Wǒ de shìjiè xiéyì) * **Server:** 服务器 (Fúwùqì) * **Client:** 客户端 (Kèhùduān) * **Packet:** 数据包 (Shùjù bāo) * **Handshake:** 握手 (Wòshǒu) * **Authentication:** 身份验证 (Shēnfèn yànzhèng) * **WebSocket:** WebSocket (Websocket, no direct translation is commonly used) * **TCP:** TCP (TCP, no direct translation is commonly used) * **Port:** 端口 (Duānkǒu) * **Connection:** 连接 (Liánjiē) * **Message:** 消息 (Xiāoxī) * **Error:** 错误 (Cuòwù) * **Protocol Version:** 协议版本 (Xiéyì bǎnběn) This is a very basic starting point. Building a real Minecraft server is a significant project. Good luck!

EDB Debugger MCP

Exposes Evan's Debugger (EDB) features as MCP tools, enabling AI-driven debugging, reverse engineering, and exploit development with 147 tools including program control, breakpoints, memory analysis, ROP gadgets, and pwntools integration.

workatastartup-mcp

Enables AI assistants to query Y Combinator startup jobs and companies via the Work at a Startup platform, including advanced filters for skills, salary, equity, and visa sponsorship, plus tools to fetch detailed company and job information.

engram

Local, private memory layer for notes and files with temporal reasoning and citation. Enables agents to query and persist memories via the Model Context Protocol.

japan-rail-mcp

Provides read-only access to structured Japanese railway data, enabling station searches without an API key and live Shinkansen timetable, fare, seat class, and stop queries with an Ekispert API key.

claude-foundry-image

MCP server for Claude Code that enables image generation and editing via Azure AI Foundry's MAI Image API, writing files to disk and returning only the path.

MCP Adapter Implementation Example

Enables WordPress content management (posts, metadata, taxonomies, Gutenberg blocks) via the Model Context Protocol, demonstrating MCP Adapter integration patterns.

ui-component-judgment-mcp

Enables AI agents to receive a structured verdict on whether a UI component need can be satisfied by existing shadcn/ui or 21st.dev components or requires a custom build, with coverage scoring against real component evidence and a Mobbin reference when needed.

iris-eval/mcp-server

MCP-native agent evaluation and observability server. Log traces, evaluate output quality with 12 built-in rules (PII detection, prompt injection, cost thresholds), and track agent costs. Real-time dashboard, OTel-compatible spans. Self-hosted, MIT licensed.

Python MSSQL MCP Server

Enables Language Models to interact with Microsoft SQL Server databases by inspecting table schemas, executing SQL queries, and reading table data through a standardized Model Context Protocol interface.

ai-text-engine

MCP server that enables AI agents to create, edit, validate, and export single-file HTML text adventure games using JSON story data and MCP tools.