Discover Awesome MCP Servers

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.

MCP Reminder Service

Enables sending messages and scheduling reminders through multiple platforms including Telegram and Feishu. Supports real-time messaging and cron-based scheduled notifications with comprehensive logging and error handling.

Lemonade MCP Server

Enables AI assistants to interact with Lemonade's insurance services for renters, homeowners, pet, and car insurance using Playwright browser automation. Users can retrieve quotes, manage existing policies, file claims, and access policy documents through natural language.

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.

Firestore MCP Server

Enables AI assistants to interact with Firebase Firestore databases through full CRUD operations, collection management, and advanced query support. It features automatic type conversion for Firestore-specific data and tools for counting or filtering documents.

MCP Help Scout

A comprehensive MCP server that provides full access to Help Scout's Docs and Inbox APIs. It enables users to manage knowledge base articles, collections, and sites while also handling customer conversations, threads, and mailbox operations.

solon-ai-mcp-embedded-examples

Solon AI MCP 嵌入式示例

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.

YApi MCP Server

Enables interaction with YApi API management platform through natural language, allowing automated interface management including creating/updating APIs, managing categories, importing data, and retrieving project information.

FastMCP Todo Server

A server that receives todo requests via FastMCP and stores them in MongoDB for processing by the Swarmonomicon todo worker.

Maccy Clipboard MCP

An MCP server that gives Claude and other AI assistants access to your Maccy clipboard history, allowing search, retrieval, and management of copied content through natural conversation.

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.

Olostep MCP Server

镜子 (jìng zi)

Gemini MCP Server

Enables Claude Code to use Google Gemini AI capabilities for analyzing PDFs and images, generating and translating text, and reviewing code. Supports both CLI and API backends with different quota limits.

Deno MCP Template Repo

一个使用 Deno 编写和发布 MCP 服务器的模板仓库。

Knowledge Graph Memory Server

通过持久记忆系统增强用户互动，该系统可以记住跨聊天的信息，并通过利用本地知识图谱和课程管理从过去的错误中学习。

Remote MCP Server (Authless)

A template for deploying an authentication-free MCP server on Cloudflare Workers. Enables easy deployment and connection to MCP clients like Claude Desktop or Cloudflare AI Playground via Server-Sent Events.

Frida MCP

一个符合 MCP 协议的服务器，它使 AI 系统能够通过 Frida 的动态插桩功能与移动和桌面应用程序进行交互，从而实现进程管理、设备控制、JavaScript 执行和脚本注入。

react-analyzer-mcp

A Docker-managed MCP server for analyzing React codebases and generating component documentation from mounted workspaces. It enables users to scan projects, analyze JSX/TSX strings directly, and generate Markdown docs while ensuring safe path handling.

ACI MCP Server

Enables management and configuration of Cisco ACI (Application Centric Infrastructure) fabrics through the APIC REST API, providing 35+ tools for tenant management, network policies, EPGs, bridge domains, VRFs, contracts, and health monitoring.

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.

UAB Research Computing Documentation MCP Server

Provides AI assistants with access to University of Alabama at Birmingham's Research Computing documentation, enabling users to search and retrieve information about the Cheaha HPC cluster, SLURM job scheduling, storage systems, and available software tools.

Firebase Realtime Database API MCP Server

An MCP Server that provides natural language access to Google's Firebase Realtime Database API, enabling database operations and management through conversation.

TrustMRR MCP Server

Connects AI assistants to the TrustMRR API to browse, filter, and analyze startup listings by revenue, MRR, and growth metrics. It enables detailed retrieval of startup financials and pricing for comprehensive deal analysis.

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

MemLayer

Agent learning infrastructure that captures experience, surfaces what works, and builds reusable capabilities. MCP-native with 94.4% LongMemEval accuracy.

Maximum Sats MCP

Provides tools for AI agents to access Bitcoin, Lightning Network, and Nostr knowledge, including real-time network statistics and Web of Trust reputation data. It features an integrated Lightning Network payment system for micro-transactions and query-based interactions.

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.

AWS Athena MCP Server

Enables execution of SQL queries against AWS Athena databases with schema discovery, query status management, and result retrieval through a standardized Model Context Protocol interface.