Discover Awesome MCP Servers

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol (MCP) servers using TypeScript SDK, with example implementations of tools (calculator, greeting) and resources (server info).

Cloudflare Remote MCP Server Template

Enables the deployment of remote Model Context Protocol servers on Cloudflare Workers without authentication. It allows users to host custom tools and connect them to AI clients using Server-Sent Events (SSE).

Figma MCP Server

一个 TypeScript 服务器，实现了模型上下文协议 (Model Context Protocol)，从而可以使用自然语言提示，通过 Cursor Agent 在 Figma 中实现 AI 驱动的设计创作。

Composer Trade MCP

Enables AI assistants to create, backtest, and manage automated investment strategies (symphonies) on Composer, including searching through 1000+ existing strategies, monitoring portfolio performance, and executing trades with live market data.

OpenAPI Korea MCP Server

Enables access to Korean public data services through OpenAPI integration. Supports querying government datasets like parking information in Sejong City through natural language interactions.

SmartMoneyOracle

Whale & Institutional Flow MCP Server — 8 tools for protocol TVL flows, alpha signals, stablecoin supply tracking. Part of ToolOracle (tooloracle.io).

Crypto Portfolio MCP

一个用于追踪和管理加密货币投资组合配置的 MCP 服务器。

DVID MCP Server

MCP server for mostly read-only access to DVID

API Status Check MCP Server

Monitor the real-time status of 200+ popular APIs and services. Check if services like GitHub, Stripe, AWS, and Slack are experiencing outages or degraded performance directly from your AI assistant.

MCP Tools: Command-Line Interface for Model Context Protocol Servers

A command-line interface for interacting with MCP (Model Context Protocol) servers using both stdio and HTTP transport.

Snapchat Ads MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Snapchat Ads (beta): https://www.cdata.com/download/download.aspx?sku=JPZK-V&type=beta

MCP Server Setup Prompt

帮助人工智能构建 Minecraft 服务器的提示。 (Bāngzhù réngōng zhìnéng gòujiàn Minecraft fúwùqì de tíshì.) This translates to: "A prompt to help AI build Minecraft servers."

MCP Server for Danmarks Statistik

将丹麦统计局的 API 作为可编程资源公开，使其易于与语言模型和现代 AI 应用集成，从而能够使用自然语言查询统计数据。

mcp-remote-macos-use

第一个开源的MCP服务器，使AI能够完全控制远程macOS系统。

MCP Apps POC

A proof-of-concept demonstrating interactive UI capabilities for MCP servers through a task management example. Shows how MCP servers can deliver HTML/CSS/JS interfaces that render inside AI chat clients with bidirectional communication.

Marlo MCP

Enables interaction with Marlo's maritime finance and operations platform, providing access to vessel management, voyage tracking, financial data, banking transactions, loans, compliance reporting, and operational analytics for shipping businesses.

AutoCAD MCP Server

Enables users to control AutoCAD, GstarCAD, or ZWCAD through natural language via Claude Desktop. It provides tools for drawing geometric shapes, adding text and dimensions, and managing CAD files using the Windows COM interface.

Tavily Search

一个集成了 Tavily 搜索 API 的 MCP 服务器实现，为 LLM 提供优化的搜索能力。

Simple MCP Server with upstream auth via local rest endpoint

MCP服务器原型设计的沙盒

k8s-pilot

A lightweight, centralized control plane server that enables management of multiple Kubernetes clusters simultaneously, supporting context switching and CRUD operations on common Kubernetes resources.

mcp-remote-py

A minimal Python-based proxy that bridges local MCP STDIO clients with remote MCP SSE servers. It enables bidirectional JSON-RPC message passing between standard command-line tools and web-based remote endpoints.

astro-airflow-mcp

An MCP server that enables AI assistants to interact with Apache Airflow's REST API for DAG management, task monitoring, and system diagnostics. It provides comprehensive tools for triggering workflows, retrieving logs, and inspecting system health across Airflow 2.x and 3.x versions.

Twilio MCP

Enables sending SMS text messages through Twilio's messaging service with a simple send_text tool that supports configurable recipients and messaging service integration.

Mcp Cassandra Server

Here are a few possible translations, depending on the specific context you're referring to. I'll provide the most likely and then some alternatives: **Most Likely (Referring to how a model interacts with Cassandra):** * **模型上下文协议 (mó xíng shàng xià wén xié yì)** - This is a direct and generally accurate translation. It emphasizes the "context" in which the model operates and the "protocol" it uses to interact with Cassandra. **Alternatives (Depending on the nuance you want to convey):** * **模型与 Cassandra 数据库的交互协议 (mó xíng yǔ Cassandra shù jù kù de jiāo hù xié yì)** - "Model interaction protocol with Cassandra database." This is more explicit and detailed. It's good if you want to be very clear about what you're talking about. * **模型访问 Cassandra 数据库的协议 (mó xíng fǎng wèn Cassandra shù jù kù de xié yì)** - "Model access protocol for Cassandra database." This focuses on the "access" aspect, implying how the model reads and writes data. * **Cassandra 数据库的模型上下文 (Cassandra shù jù kù de mó xíng shàng xià wén)** - "Model context for Cassandra database." This is less about a specific protocol and more about the overall environment and information the model needs to work with Cassandra. It might be appropriate if you're discussing the data structures, configurations, or other elements the model relies on. **Which one to use?** * If you're talking about a specific set of rules or API calls the model uses to communicate with Cassandra, use **模型上下文协议 (mó xíng shàng xià wén xié yì)** or **模型与 Cassandra 数据库的交互协议 (mó xíng yǔ Cassandra shù jù kù de jiāo hù xié yì)**. * If you're talking about how the model reads and writes data, use **模型访问 Cassandra 数据库的协议 (mó xíng fǎng wèn Cassandra shù jù kù de xié yì)**. * If you're talking about the overall environment and data the model needs to function with Cassandra, use **Cassandra 数据库的模型上下文 (Cassandra shù jù kù de mó xíng shàng xià wén)**. **Key Vocabulary:** * **模型 (mó xíng):** Model * **上下文 (shàng xià wén):** Context * **协议 (xié yì):** Protocol * **Cassandra 数据库 (Cassandra shù jù kù):** Cassandra database * **交互 (jiāo hù):** Interaction * **访问 (fǎng wèn):** Access To give you the *best* translation, please provide more context about what you mean by "Model Context Protocol." For example: * Are you talking about a specific API? * Are you talking about how a machine learning model interacts with Cassandra? * Are you talking about data structures used for communication? The more information you provide, the more accurate and helpful my translation can be.

NervusDB MCP Server

Enables building and querying code knowledge graphs for project analysis, with tools for exploring code relationships, managing workflows, and automating development tasks. Integrates with Git and GitHub for branch management and pull request creation.

MCP Server Boilerplate

A starter template for building Model Context Protocol servers that can integrate with AI assistants like Claude or Cursor, providing custom tools, resource providers, and prompt templates.

sheet-music-mcp

用于乐谱渲染的 MCP 服务器

MCP 만들면서 원리 파헤쳐보기

Okay, here's a breakdown of the server and client implementation for a system conceptually similar to the MCP (Master Control Program) from the movie Tron, along with considerations for a modern implementation. Keep in mind that a real-world MCP would be incredibly complex, so this is a simplified, illustrative example. **Conceptual Overview** The MCP, in essence, is a central control system. In a modern context, we can think of it as a distributed system with the following key components: * **Server (MCP Core):** The central authority. It manages resources, schedules tasks, enforces security policies, and monitors the overall system health. * **Clients (Programs/Processes):** These are the individual applications or processes that interact with the MCP to request resources, execute tasks, and report their status. * **Communication Protocol:** A well-defined protocol for clients and the server to exchange information. **Implementation Considerations** * **Language Choice:** Python is a good choice for prototyping and scripting due to its readability and extensive libraries. For performance-critical components, consider languages like Go, Rust, or C++. * **Communication:** gRPC, ZeroMQ, or even a simple TCP socket-based protocol can be used for communication between the server and clients. gRPC is a modern, high-performance RPC framework that's well-suited for this kind of system. * **Security:** Authentication and authorization are crucial. Use strong authentication mechanisms (e.g., TLS certificates, API keys) and implement role-based access control (RBAC) to restrict access to sensitive resources. * **Resource Management:** The MCP needs to track available resources (CPU, memory, disk space, network bandwidth) and allocate them to clients based on their needs and priorities. * **Task Scheduling:** A scheduler determines the order in which tasks are executed. Prioritization, deadlines, and dependencies should be considered. * **Monitoring and Logging:** Comprehensive monitoring and logging are essential for detecting errors, performance bottlenecks, and security breaches. * **Fault Tolerance:** The MCP should be designed to be fault-tolerant. Consider using techniques like redundancy, replication, and failover to ensure that the system remains operational even if some components fail. **Simplified Python Example (Illustrative)** This is a very basic example to demonstrate the core concepts. It's not production-ready. ```python # server.py (MCP Core) import socket import threading import json import time HOST = '127.0.0.1' PORT = 65432 # Resource Management (very basic) available_cpu = 100 resource_lock = threading.Lock() def handle_client(conn, addr): print(f"Connected by {addr}") while True: try: data = conn.recv(1024).decode() if not data: break try: request = json.loads(data) print(f"Received request: {request}") if request['action'] == 'request_cpu': cpu_units = request['cpu_units'] with resource_lock: global available_cpu if available_cpu >= cpu_units: available_cpu -= cpu_units response = {'status': 'granted', 'cpu_units': cpu_units} print(f"Granted {cpu_units} CPU units. Remaining: {available_cpu}") else: response = {'status': 'denied', 'reason': 'Insufficient CPU'} conn.sendall(json.dumps(response).encode()) elif request['action'] == 'report_status': status = request['status'] print(f"Client reported status: {status}") conn.sendall(json.dumps({'status': 'received'}).encode()) elif request['action'] == 'release_cpu': cpu_units = request['cpu_units'] with resource_lock: available_cpu += cpu_units response = {'status': 'released', 'cpu_units': cpu_units} print(f"Released {cpu_units} CPU units. Remaining: {available_cpu}") conn.sendall(json.dumps(response).encode()) else: response = {'status': 'error', 'message': 'Invalid action'} conn.sendall(json.dumps(response).encode()) except json.JSONDecodeError: response = {'status': 'error', 'message': 'Invalid JSON'} conn.sendall(json.dumps(response).encode()) except ConnectionResetError: print(f"Connection reset by {addr}") break except Exception as e: print(f"Error handling client: {e}") break print(f"Closing connection with {addr}") conn.close() def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"MCP Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() if __name__ == "__main__": main() ``` ```python # client.py (Program/Process) import socket import json import time HOST = '127.0.0.1' PORT = 65432 def request_cpu(conn, cpu_units): request = {'action': 'request_cpu', 'cpu_units': cpu_units} conn.sendall(json.dumps(request).encode()) response = json.loads(conn.recv(1024).decode()) return response def report_status(conn, status): request = {'action': 'report_status', 'status': status} conn.sendall(json.dumps(request).encode()) response = json.loads(conn.recv(1024).decode()) return response def release_cpu(conn, cpu_units): request = {'action': 'release_cpu', 'cpu_units': cpu_units} conn.sendall(json.dumps(request).encode()) response = json.loads(conn.recv(1024).decode()) return response def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) # Request CPU cpu_request_response = request_cpu(s, 20) print(f"CPU Request Response: {cpu_request_response}") if cpu_request_response['status'] == 'granted': # Report status status_response = report_status(s, 'Running task...') print(f"Status Response: {status_response}") time.sleep(5) # Simulate work # Release CPU cpu_release_response = release_cpu(s, 20) print(f"CPU Release Response: {cpu_release_response}") else: print("CPU request denied.") report_status(s, "Exiting") if __name__ == "__main__": main() ``` **How to Run:** 1. Save the code as `server.py` and `client.py`. 2. Run the server: `python server.py` 3. Run the client: `python client.py` (You can run multiple clients in separate terminals). **Explanation:** * **Server (server.py):** * Listens for incoming connections on a specified port. * Handles each client connection in a separate thread. * Receives JSON-encoded requests from clients. * Implements basic CPU resource management (request, release). * Responds to clients with JSON-encoded responses. * **Client (client.py):** * Connects to the server. * Sends JSON-encoded requests to the server (request CPU, report status, release CPU). * Receives JSON-encoded responses from the server. * Simulates a simple task that requests CPU, reports its status, and releases the CPU. **Improvements and Next Steps:** * **Error Handling:** Add more robust error handling to both the server and client. * **Authentication/Authorization:** Implement a proper authentication and authorization system. * **Resource Management:** Expand the resource management to include memory, disk space, and other resources. Implement a more sophisticated resource allocation algorithm. * **Task Scheduling:** Implement a task scheduler that can prioritize tasks, handle dependencies, and enforce deadlines. * **Monitoring:** Integrate monitoring tools to track system health and performance. * **Logging:** Use a logging library (e.g., `logging` in Python) to record events and errors. * **Concurrency:** Use asynchronous programming (e.g., `asyncio` in Python) for better concurrency and scalability. * **gRPC:** Migrate to gRPC for a more efficient and robust communication protocol. Define a gRPC service definition (a `.proto` file) that specifies the available RPC calls. * **Database:** Use a database to store information about users, resources, tasks, and system state. * **Distributed System:** Design the MCP as a distributed system with multiple server nodes for fault tolerance and scalability. Consider using a distributed consensus algorithm (e.g., Raft or Paxos) to ensure consistency across the nodes. **Translation to Chinese** Here's a translation of the conceptual overview and the improvements/next steps into Chinese: **概念概述 (Gài niàn ǒugài - Conceptual Overview)** MCP 本质上是一个中央控制系统。 在现代背景下，我们可以将其视为一个分布式系统，具有以下关键组件： * **服务器 (MCP 核心):** 中央权威。 它管理资源、调度任务、执行安全策略并监控整个系统健康状况。 * **客户端 (程序/进程):** 这些是与 MCP 交互以请求资源、执行任务和报告其状态的各个应用程序或进程。 * **通信协议:** 客户端和服务器交换信息的明确定义的协议。 **改进和下一步 (Gǎi jìn hé xià yī bù - Improvements and Next Steps)** * **错误处理 (Cuòwù chǔlǐ):** 向服务器和客户端添加更强大的错误处理。 * **身份验证/授权 (Shēnfèn yànzhèng/shòuquán):** 实施适当的身份验证和授权系统。 * **资源管理 (Zīyuán guǎnlǐ):** 扩展资源管理以包括内存、磁盘空间和其他资源。 实施更复杂的资源分配算法。 * **任务调度 (Rènwù diàodù):** 实施一个任务调度程序，可以优先处理任务、处理依赖关系并强制执行截止日期。 * **监控 (Jiānkòng):** 集成监控工具以跟踪系统健康状况和性能。 * **日志记录 (Rìzhì jìlù):** 使用日志记录库（例如 Python 中的 `logging`）来记录事件和错误。 * **并发 (Bìngfā):** 使用异步编程（例如 Python 中的 `asyncio`）以获得更好的并发性和可伸缩性。 * **gRPC:** 迁移到 gRPC 以获得更高效和强大的通信协议。 定义一个 gRPC 服务定义（一个 `.proto` 文件），指定可用的 RPC 调用。 * **数据库 (Shùjùkù):** 使用数据库来存储有关用户、资源、任务和系统状态的信息。 * **分布式系统 (Fēn bù shì xìtǒng):** 将 MCP 设计为具有多个服务器节点的分布式系统，以实现容错和可伸缩性。 考虑使用分布式共识算法（例如 Raft 或 Paxos）来确保节点之间的一致性。 This provides a starting point for building a system inspired by the MCP. Remember to prioritize security, scalability, and fault tolerance as you develop your implementation. Good luck!

NS Lookup MCP Server

一个简单的 MCP 服务器，它公开 nslookup 命令的功能。