Discover Awesome MCP Servers

openaiTreasureHuntMCP

A minimal Next.js application demonstrating how to build an OpenAI Apps SDK compatible MCP server with widget rendering in ChatGPT.

Excalidraw MCP Server

Generates beautiful Excalidraw diagrams from natural language descriptions using a local llama.cpp LLM, entirely offline.

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.

Strava MCP

An MCP server that supplements the official Strava connector with write access, segments, routes, photos, derived analysis, and interactive visualizations.

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.

dejank

An MCP server that gives AI agents hands-on control of a live React Native app, enabling UI taps, screenshots, UI/component trees, native logs, and JS/React profiling to debug, verify fixes, and diagnose performance issues.

Connxio MCP Server

Provides tools for managing Connxio integrations, code components, environment variables, and security configs through the Connxio v2 management API.

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.

mcp-memory-graph

A personal memory MCP server for Obsidian/markdown vaults that provides hybrid retrieval (semantic, keyword, tag, time-aware co-occurrence) and is shared across multiple AI clients.

comfy-mcp

MCP server that enables AI agents to control a local ComfyUI instance for image generation, allowing workflow understanding, parameter modification, execution, and model discovery.

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.

sdm-mcp

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

@bounded-systems/bounded-tools-mcp

Local, read-only MCP server that provides verified access to bounded.tools' signed static API, including the Web-Build Conformance report and SPDX SBOM, with byte-for-byte verification against a Sigstore-signed manifest.

Vybog MCP Server

MCP server for the Fund Tracking System, enabling agents to manage lending business data such as entities, borrowers, investors, deals, and referrals with full CRUD and bulk operations.

lautfm-mcp

MCP server providing access to the laut.fm Radioadmin API for managing radio stations, playlists, tracks, users, and automation.

Social Search MCP

A Model Context Protocol (MCP) server that empowers LLMs to search across specific social media platforms using the industry's best search engines.

ChurnCue

Production-oriented customer-retention intelligence that uses deterministic machine learning to predict churn and generate prioritized rescue reports, governed through MCP tools.

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.

Motion MCP Server

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

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.

materials-project-mcp-from-scratch

An educational MCP server that wraps the Materials Project API, exposing tools to search chemical systems, get material summaries, find semiconductors by band gap, and retrieve crystal structure facts.

sheets-mcp

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

TOON MCP Server

Enables users to convert structured data into Token-Oriented Object Notation (TOON) to reduce LLM token usage and costs by up to 70%. It provides tools for encoding, decoding, and analyzing data formats like JSON, CSV, and XML to optimize prompt efficiency.

MCP Server Template

A generic template for building remote MCP servers based on Streamable HTTP, with a demo ping tool and infrastructure for authentication, logging, testing, Docker, and CI/CD.

Clara Carros MCP server

Enables AI assistants to search car inventory, estimate import taxes (ISV) and resale values, and request quotes from Clara Carros, a Portuguese used and imported cars marketplace.

macos-desktop-control

Provides native macOS desktop automation for AI agents, enabling screen capture, mouse/keyboard control, window management, and iOS/Android simulator control in both foreground and background modes without focus stealing.