Discover Awesome MCP Servers

Novita MCP Server

An MCP server that enables seamless management of Novita AI platform resources, currently supporting GPU instance operations (list, create, start, stop, etc.) through compatible clients like Claude Desktop and Cursor.

PortHunter MCP

Analyzes PCAP/PCAPNG network capture files to detect port scanning techniques (SYN, FIN, Xmas), classify scan patterns, and enrich suspicious IP addresses with threat intelligence data. Provides comprehensive network security analysis through natural language interactions.

AI Makerspace: MCP Event

一个简短的演示，教你如何构建你自己的 MCP 服务器！

Terminal Control MCP

Enables AI agents to interact with terminal-based TUI applications by capturing visual terminal output as PNG screenshots and simulating keyboard input through a virtual X11 display.

agoda-review-mcp

寻找Agoda酒店评价的MCP服务器

Jokes MCP Server

Provides access to various joke APIs including Chuck Norris jokes, Dad jokes, and Yo Mama jokes. Integrates with Microsoft Copilot Studio to create humor-focused agents that can deliver jokes on demand.

ChatGPT Apps EdgeOne Pages Starter

A minimal MCP server template for deploying to Tencent Cloud EdgeOne Pages using Next.js and edge functions. Demonstrates tool registration and widget rendering with the hello_stat example tool.

PlayMCP Browser Automation Server

A comprehensive MCP server that provides powerful web automation tools using Playwright, enabling web scraping, testing, and browser interaction through natural language commands.

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.

Tavily Search

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

OpenAccess MCP

Enables secure remote access operations through SSH, SFTP, rsync, VPN, and tunneling with enterprise-grade policy enforcement and audit logging. Provides AI assistants with secure, policy-driven access to remote systems while maintaining comprehensive audit trails and zero-trust security.

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.

QMT-MCP-Server

一个服务器应用程序，使大型语言模型能够通过 QMT 交易系统执行股票交易操作，提供账户查询、持仓管理和订单下单等功能。

Sakura Cloud MCP Server

一个 MCP 服务器实现，使 AI 助手能够与 Sakura Cloud 基础设施进行交互和管理，包括服务器、磁盘、网络和容器化应用程序。

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.

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 命令的功能。

Container MCP Server

Enables weather lookups, mathematical calculations, and context-aware operations through a containerized MCP server with HTTP transport. Optimized for Docker/Kubernetes deployment with health checks and no external dependencies.

Remote MCP Server on Cloudflare

A Model Context Protocol server implementation that runs on Cloudflare Workers, allowing AI assistants like Claude to access external tools via MCP with OAuth login support.

Timesheet MCP Server

Enables automated timesheet management including creating entries, listing work activities, managing daily scrum updates, and viewing assigned projects with automatic authentication handling.

GitHub MCP Server by CData

GitHub MCP Server by CData

Video Convert MCP

A professional video format conversion tool based on MCP protocol that supports multiple formats, batch processing, and quality control for video files.

M/M/1 and M/M/c Queue Simulation Server

Enables simulation and analysis of M/M/1 and M/M/c queuing systems using SimPy, with tools for parameter validation, theoretical metric calculation, simulation execution, and comparison of separate vs pooled queue strategies.

Octagon VC Agents

An MCP server that runs AI-driven venture capitalist agents whose thinking is continuously enriched by Octagon Private Markets' real-time deals and intelligence for pitch feedback, diligence simulations, and term sheet negotiations.

OpenZeppelin Contracts MCP Server

A Model Context Protocol (MCP) server that allows AI agents to generate smart contracts using OpenZeppelin Contracts libraries.

MCP Infrastructure as Code Assistant

一个用于使用 Terraform 管理基础设施即代码的 MCP 服务器。