发现优秀的 MCP 服务器

MQTTX SSE Server

一个实现了模型-上下文协议 (MCP) 的方案，该方案支持通过服务器发送事件 (SSE) 传输 MQTT 操作。

Mcp Server Mas Sequential Thinking

mcp-server-mas-sequential-thinking 是一个专注于改进多智能体系统中决策过程的项目。它实现了序贯推理技术，以增强智能体在各种场景中的协作和效率。

MCP Snowflake Reader

一个模型上下文协议（MCP）服务器，提供对 Snowflake 数据库的安全只读访问。允许大型语言模型（LLM）安全地查询表和描述模式，而无需写入权限。使用 Python 和官方 Snowflake SDK 构建。

MCP Server for Wolfram Alpha Integration

一个使用 Wolfram Alpha API 的，基于 Python 的模型上下文协议 (MCP) 服务器。

writers-muse-mcp

一个MCP服务器，用于分析作者的写作风格并生成一篇博文。 (Alternatively, more literally: 一个分析作者写作风格并生成博文的MCP服务器。)

Uncover MCP

发现 MCP 服务器 (Fāxiàn MCP fúwùqì)

🌟 Unsplash MCP Server Repository

🔎 用于 Unsplash 图片搜索的 MCP 服务器。

Trino MCP Server

镜子 (jìng zi)

gorse

Data On Tap Inc. 是一家在加拿大运营网络 302 100 的完整 MVNO（移动虚拟网络运营商）。这是 DOT 的代码仓库。它包括高级安全和身份验证、各种连接工具、智能功能（包括智能网络预留）、eSIM/iSIM、引导无线连接、D2C 卫星、构建框架和概念，以及 OpenAPI 3.1 和 MCP 服务器。

mcp-server-yahoo-finance MCP server

镜子 (jìng zi)

ArxivAutoJob

这个仓库仅收集带有 [arxiv_mcp_project] 标签的 arXiv 论文。

Mcp Servers Collection

已验证的 MCP 服务器和集成集合

MCP (Model Context Protocol)

一个用于人工智能的简单模型上下文服务器

Atlassian Jira MCP Server

用于 Atlassian Jira 的 Node.js/TypeScript MCP 服务器。为 AI 系统（LLM）配备工具，以列出/获取项目、搜索/获取问题（使用 JQL/ID）以及查看开发信息（提交、PR）。将 AI 功能直接连接到 Jira 项目管理和问题跟踪工作流程中。

Eka MCP Server

Eka MCP 服务器 (Eka MCP fúwùqì)

Finance MCP Server

一个用 Python 构建的最小化 MCP 服务器，它暴露了两个示例工具：一个用于将公司名称转换为股票代码，另一个用于从雅虎财经获取财务数据。该项目的重点是学习如何构建和运行 MCP 服务器——使用一个简单的财务场景纯粹作为演示用例。

RAG Application

一个集成了 MCP 服务器的检索增强生成 (RAG) 应用的演示。

ピティナニュースMCPサーバー

PTNA 新闻源的 MCP 服务器

Weather App

Okay, this is a complex request, but I'll provide a conceptual outline and code snippets to illustrate how you might implement a minimal MCP (Microservice Communication Protocol) server for weather data in Python, along with testing and pre-commit setup. I'll focus on clarity and structure rather than production-readiness. **Conceptual Overview** 1. **MCP Definition (Protocol Buffer):** Define the data structures and service interface using Protocol Buffers. This is the core of MCP. 2. **Server Implementation (Python):** Implement a gRPC server in Python that serves weather data based on the MCP definition. 3. **Client (Example):** A simple client to demonstrate how to request data from the server. 4. **Testing (pytest):** Write unit tests to verify the server's functionality. 5. **Pre-commit Hooks:** Configure pre-commit to run linters (e.g., `flake8`, `black`) and tests before committing code. **1. MCP Definition (weather.proto)** Create a file named `weather.proto`: ```protobuf syntax = "proto3"; package weather; service WeatherService { rpc GetWeather(WeatherRequest) returns (WeatherResponse) {} } message WeatherRequest { string city = 1; } message WeatherResponse { string city = 1; float temperature = 2; string condition = 3; } ``` **Explanation:** * `syntax = "proto3";`: Specifies the Protocol Buffer version. * `package weather;`: Defines the package name for the generated code. * `service WeatherService`: Defines the service with a single RPC method `GetWeather`. * `WeatherRequest`: The request message, containing the city name. * `WeatherResponse`: The response message, containing weather information. **2. Generate gRPC Code (Python)** You'll need the `grpcio-tools` package: ```bash pip install grpcio-tools ``` Then, compile the `.proto` file: ```bash python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. weather.proto ``` This will generate two Python files: `weather_pb2.py` (the data structures) and `weather_pb2_grpc.py` (the gRPC service definitions). **3. Server Implementation (server.py)** ```python import grpc from concurrent import futures import weather_pb2 import weather_pb2_grpc class WeatherServicer(weather_pb2_grpc.WeatherServiceServicer): def GetWeather(self, request, context): city = request.city # Simulate weather data (replace with actual data source) if city == "London": temperature = 15.0 condition = "Cloudy" elif city == "New York": temperature = 25.0 condition = "Sunny" else: temperature = 10.0 condition = "Unknown" return weather_pb2.WeatherResponse(city=city, temperature=temperature, condition=condition) def serve(): server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) weather_pb2_grpc.add_WeatherServiceServicer_to_server(WeatherServicer(), server) server.add_insecure_port('[::]:50051') # Listen on all interfaces, port 50051 server.start() server.wait_for_termination() if __name__ == '__main__': print("Starting gRPC server...") serve() ``` **Explanation:** * `WeatherServicer`: Implements the `WeatherServiceServicer` interface defined in `weather_pb2_grpc.py`. * `GetWeather`: The actual implementation of the RPC method. It receives a `WeatherRequest` and returns a `WeatherResponse`. This example uses hardcoded data for simplicity. In a real application, you'd fetch weather data from an external API or database. * `serve`: Creates a gRPC server, registers the `WeatherServicer`, and starts the server. **4. Client (client.py)** ```python import grpc import weather_pb2 import weather_pb2_grpc def run(): with grpc.insecure_channel('localhost:50051') as channel: stub = weather_pb2_grpc.WeatherServiceStub(channel) city = "London" request = weather_pb2.WeatherRequest(city=city) response = stub.GetWeather(request) print(f"Weather in {response.city}:") print(f" Temperature: {response.temperature}°C") print(f" Condition: {response.condition}") if __name__ == '__main__': run() ``` **Explanation:** * Creates a gRPC channel to connect to the server. * Creates a `WeatherServiceStub` to make RPC calls. * Sends a `WeatherRequest` for the city "London". * Prints the received `WeatherResponse`. **5. Testing (test_server.py)** Install `pytest` and `grpcio-testing`: ```bash pip install pytest grpcio-testing ``` ```python import pytest import grpc from grpc import aio from concurrent import futures import weather_pb2 import weather_pb2_grpc from server import WeatherServicer # Import your server implementation @pytest.fixture def grpc_server(): server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) weather_pb2_grpc.add_WeatherServiceServicer_to_server(WeatherServicer(), server) port = server.add_insecure_port('[::]:0') # Let the OS choose a port server.start() yield server, port # Provide the server and port to the tests server.stop(0) def test_get_weather(grpc_server): server, port = grpc_server with grpc.insecure_channel(f'localhost:{port}') as channel: stub = weather_pb2_grpc.WeatherServiceStub(channel) request = weather_pb2.WeatherRequest(city="London") response = stub.GetWeather(request) assert response.city == "London" assert response.temperature == 15.0 assert response.condition == "Cloudy" def test_get_weather_new_york(grpc_server): server, port = grpc_server with grpc.insecure_channel(f'localhost:{port}') as channel: stub = weather_pb2_grpc.WeatherServiceStub(channel) request = weather_pb2.WeatherRequest(city="New York") response = stub.GetWeather(request) assert response.city == "New York" assert response.temperature == 25.0 assert response.condition == "Sunny" def test_get_weather_unknown(grpc_server): server, port = grpc_server with grpc.insecure_channel(f'localhost:{port}') as channel: stub = weather_pb2_grpc.WeatherServiceStub(channel) request = weather_pb2.WeatherRequest(city="SomeRandomCity") response = stub.GetWeather(request) assert response.city == "SomeRandomCity" assert response.temperature == 10.0 assert response.condition == "Unknown" ``` **Explanation:** * `grpc_server` fixture: Creates and starts a gRPC server before each test and stops it afterward. It uses a dynamically assigned port to avoid conflicts. * `test_get_weather`: Tests the `GetWeather` method for a specific city ("London"). * `test_get_weather_new_york`: Tests the `GetWeather` method for a specific city ("New York"). * `test_get_weather_unknown`: Tests the `GetWeather` method for an unknown city. Run the tests: ```bash pytest ``` **6. Pre-commit Setup** Install `pre-commit`: ```bash pip install pre-commit ``` Create a `.pre-commit-config.yaml` file in the root of your project: ```yaml repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.5.0 # Use the latest stable version hooks: - id: trailing-whitespace - id: end-of-file-fixer - id: check-yaml - id: check-added-large-files - repo: https://github.com/psf/black rev: 24.2.0 # Use the latest stable version hooks: - id: black - repo: https://github.com/pycqa/flake8 rev: 7.0.0 # Use the latest stable version hooks: - id: flake8 additional_dependencies: ["flake8-protobuf"] # Add protobuf support - repo: local hooks: - id: pytest name: pytest entry: pytest language: system types: [python] pass_filenames: false ``` **Explanation:** * This configuration uses several popular pre-commit hooks: * `trailing-whitespace`, `end-of-file-fixer`, `check-yaml`, `check-added-large-files`: Basic cleanup and checks. * `black`: Code formatter. * `flake8`: Linter. The `additional_dependencies` line adds support for linting Protocol Buffer-related code. * `pytest`: Runs your tests. Install the pre-commit hooks: ```bash pre-commit install ``` Now, every time you commit, pre-commit will run these checks and formatters. If any of them fail, the commit will be aborted. **Running the Example** 1. **Generate gRPC code:** `python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. weather.proto` 2. **Start the server:** `python server.py` (in a separate terminal) 3. **Run the client:** `python client.py` 4. **Run the tests:** `pytest` 5. **Commit your changes:** `git commit -m "Your commit message"` (pre-commit will run) **Important Considerations and Improvements** * **Error Handling:** The server implementation lacks proper error handling. You should handle exceptions and return appropriate gRPC status codes. * **Data Source:** The server uses hardcoded weather data. Replace this with a real data source (e.g., an API or database). * **Authentication/Authorization:** For production systems, you'll need to add authentication and authorization to secure your gRPC service. * **Logging:** Implement logging for debugging and monitoring. * **Configuration:** Use environment variables or configuration files to manage server settings (e.g., port number, data source connection details). * **Asynchronous gRPC:** Consider using `grpc.aio` for asynchronous gRPC, which can improve performance, especially for I/O-bound operations. * **Health Checks:** Implement a health check endpoint to allow monitoring systems to verify the server's availability. * **Code Generation:** Consider using a build system (e.g., `make`, `nox`) to automate the code generation process. * **Dependency Management:** Use a tool like `poetry` or `pipenv` to manage your project's dependencies. * **CI/CD:** Integrate your tests and pre-commit hooks into a CI/CD pipeline to automate the build, test, and deployment process. This comprehensive example provides a solid foundation for building a gRPC-based microservice with testing and pre-commit setup. Remember to adapt and extend it to meet the specific requirements of your application.

📸 Smart Photo Journal MCP Server

镜子 (jìng zi)

IACR Cryptology ePrint Archive MCP Server

镜子 (jìng zi)

Grasshopper MCP サーバー

用于 Rhinoceros/Grasshopper 集成的模型上下文协议 (MCP) 服务器实现，使 AI 模型能够与参数化设计工具交互。

서울시 교통 데이터 MCP 서버

首尔市交通数据 MCP 服务器 - 提供实时交通信息、公共交通、Ttareungi（首尔市公共自行车）等数据的 MCP 服务器