Discover Awesome MCP Servers

KuzuMem-MCP

A distributed memory bank MCP server that stores AI agent memories in a KùzuDB graph database with repository/branch isolation. Features AI-powered memory optimization, dependency tracking, and comprehensive graph analysis capabilities.

MCP Script Runner

一个 MCP 服务器，它将指定文件夹中的 shell 脚本作为工具来执行。

CodeBadger Toolkit

Provides static code analysis using Joern's Code Property Graph technology for 12+ programming languages. Enables security analysis, code browsing, taint flow detection, and CPGQL queries through natural language.

Powerdrill

一个 MCP 服务器，提供与 Powerdrill (https://powerdrill.ai/) 数据集交互的工具，从而实现智能 AI 数据分析和洞察。

habitat

这是一个协作组件的集合，它们共同作用，可以方便地在本地和网络上管理、开发、使用和迁移 MCP 服务器。

Video Metadata MCP

Enables comprehensive video file metadata management including reading, editing, and batch processing of video properties like title, description, tags, and technical specifications. Supports multiple video formats with intelligent caching and search capabilities.

MCP Gastos

Enables personal expense management through CSV storage, allowing AI agents to add, query, and analyze expenses with automatic categorization and payment method validation.

MCP Server Manager

一个桌面应用程序，用于管理 MCP (机器完成协议) 服务器，并与 Claude 和 Cursor 等 AI 工具集成。

mediawiki-mcp-server

一个 MCP 服务器，它允许你使用 LLM 🤖 在任何使用 MediaWiki 的 wiki 站点上搜索和检索内容。支持 wikipedia.org、fandom.com、wiki.gg 以及更多使用 MediaWiki 的站点！

LLV Helix Framework

Implements the Lines-Loops-Vibes creativity operating system with tools for building strategic flows, creating iterative loops, and managing energy states. Provides pre-built templates for innovation, strategic design, narrative strategy, and creative intelligence workflows.

mcp-servers-latest

最新可用的 Minecraft 服务器。

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 服务器！

Sakura Cloud MCP Server

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

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!

MCP Time Server

Provides current time information with support for multiple IANA timezones, defaulting to Asia/Shanghai timezone.

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.

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.

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.

Symbol Blockchain MCP Server (REST API tools)

Symbol 区块链 MCP 服务器。（REST API 工具）