Discover Awesome MCP Servers

roku-mcp

Enables AI agents to inspect and control Roku devices—query UI elements, send remote input, launch channels, and run tests—using the Model Context Protocol or a CLI.

health-feeds

Enables searching and reading curated health and medicine RSS/Atom feeds, with the ability to fetch any feed URL.

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.**

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.

reactome-mcp

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

3d-eyes

Enables coding agents to visually inspect and diagnose 3D files (meshes and Gaussian splats) for defects like flipped normals or floaters, without GPU dependencies.

resume-editor-mcp

MCP server for AI-native resume optimization, providing tools to load JD, analyze match, rewrite sections, and assemble customized resumes.

QIDI Studio MCP Server

Manages QIDI Studio 3D printing profiles locally, enabling AI assistants to read and write filament, process, and machine presets via the Model Context Protocol.

beds24-mcp

MCP server for the Beds24 API, providing semantic search over documentation and schema validation for API payloads.

mailchimp-mcp

An MCP server that interfaces with the Mailchimp Marketing API to manage audiences, email campaigns, and subscribers. It enables users to create and schedule campaigns, handle member lists, and send test or live emails through natural language commands.

ProofGate

Evidence-first delivery audit MCP server that evaluates task requirements against delivery evidence and returns a reproducible pass/needs_review/fail decision with a deterministic receipt.

Poke MCP + Gemini Frontend Tools

Provides AI-powered tools for UX/UI review, web component generation, and code refactoring using Google Gemini.

MetaTrader5 MCP Server

Enables access to MetaTrader5 market data and trading functionality, including real-time quotes, historical OHLCV data, tick data, symbol information, and technical indicators for forex and other trading instruments.

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.

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.

MCPGTCG

An MCP server for the Genius Invokation TCG simulator that allows AI models to interact with the game through a structured interface. It provides comprehensive tools for querying game states, accessing indexed card data, and executing gameplay actions like elemental tuning and character selection.

real-estate-analyzer

Analyzes real estate locations using Kakao Local API, providing insights on education, transportation, convenience, nature, and future value.

GPTImage

Image generation for Claude Code via ChatGPT subscription token. No API key needed.

argus

An agentic QA framework that authors, generates, triages, and self-heals Playwright tests for any web app, usable from Claude Code/Desktop as an MCP server or from CI as a CLI.

MCP Database Filesystem

Enables SQL Server database operations (queries, table management) and file system access (read, write, directory listing) with security controls. Supports comprehensive database interactions and file management through a unified MCP interface.

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.

Umami MCP

A read-only Model Context Protocol server for self-hosted Umami analytics. Enables querying website analytics data such as pageviews, visitors, and metrics through natural language.

DefectDojo Intelligence MCP Server

Enables permission-preserving access to DefectDojo OSS via MCP, using the caller's own API token, with read tools, deterministic analytics and reporting, plus optional gated write and history tools.

Kali Linux MCP Server

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

woffu-manager

An MCP server to manage time tracking and time off on Woffu, allowing users to clock in days, view balances, request leave, and check team availability.

Garoon MCP Server

A Model Context Protocol (MCP) server that integrates Cybozu's Garoon groupware, enabling schedule management, meeting scheduling, and user search through natural language.

mcp-nrel

Wraps the US National Renewable Energy Laboratory developer API, enabling access to renewable energy data through an MCP interface.

jira-analysis-mcp

A powerful Model Context Protocol (MCP) server for seamless Jira integration with AI assistants like Claude. Features advanced search capabilities, intelligent pod aliases, comprehensive ticket analysis, and full API support.

Windows Calculator MCP Server

Connects Claude Desktop to Windows Calculator, enabling accurate mathematical calculations using Windows' native PowerShell calculation engine.

MCP Enterprise Architecture Project

Provides a set of MCP tools (file, database, GitHub, Slack, browser, calendar, email, vector search, Python execution) with safety constraints and OpenAI integration for enterprise architecture automation.