发现优秀的 MCP 服务器

MCP Gmail Server

一个模型上下文协议（MCP）服务器，它为LLM提供Gmail访问，并由MCP Python SDK驱动。

MCP Development Server

镜子 (jìng zi)

Gridly MCP Server

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

MultiversX MCP Server

MultiversX 的 MCP 服务器

peer-mcp

MCP 代理，用于暴露本地 MCP 服务器

Simple MCP Client

一个测试模型上下文协议 (MCP) 服务器和客户端交互的示例项目。

mcp

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

The code samples here are not for production use

安全的可执行代理工具仓库环境

Spotify MCP Server

MCP 服务器，用于与 Splunk 交互

Jupiter MCP Server

为 Claude AI 提供访问 Solana 上 Jupiter 交换 API 的模型上下文协议服务器

Advanced PocketBase MCP Server

镜子 (jìng zi)

Todo Assistant with AI and Google Calendar Integration

基于人工智能的待办事项助手，集成了 Google 日历，并使用 OpenAI 的 API 和模型上下文协议 (MCP) 来支持自然语言任务管理。

Unity AI MCP Server

一个 MCP 服务器，为 Unity 游戏开发提供 AI 驱动的工具和助手，并与 Cursor IDE 集成。 (Alternatively, a slightly more literal translation could be:) 一个提供 AI 驱动的工具和助手给 Unity 游戏开发的 MCP 服务器，它与 Cursor IDE 集成。

🌐 Starknet MCP Server

Starknet MCP 服务器。

MCPServer

一个简单的 MCP 服务器，用于启用代理工作流。 (Yī gè jiǎndān de MCP fúwùqì, yòng yú qǐyòng dàilǐ gōngzuò liú.) Alternatively, depending on the context, you might also use: 一个简单的 MCP 服务器，以实现基于代理的工作流程。(Yī gè jiǎndān de MCP fúwùqì, yǐ shíxiàn jīyú dàilǐ de gōngzuò liúchéng.) The first translation is more literal, while the second emphasizes the "agent-based" nature of the workflow. Choose the one that best fits the specific context.

aiohttp-mcp

构建在 aiohttp 之上的模型上下文协议 (MCP) 服务器的工具： Here are some tools and libraries that can help you build Model Context Protocol (MCP) servers on top of aiohttp: * **aiohttp:** This is the fundamental asynchronous HTTP server and client library for Python. You'll use it to handle incoming MCP requests and send responses. You'll need to understand how to define routes, handle requests, and serialize/deserialize data. * **asyncio:** Since aiohttp is built on asyncio, you'll need a good understanding of asynchronous programming concepts like event loops, coroutines, and tasks. This is crucial for handling concurrent requests efficiently. * **Marshmallow (or similar serialization library):** MCP often involves structured data. Marshmallow is a popular library for serializing and deserializing Python objects to and from formats like JSON. This helps you validate incoming requests and format outgoing responses according to the MCP specification. Alternatives include `attrs` with `cattrs`, or `pydantic`. * **JSON Schema (and a validator):** MCP implementations often use JSON Schema to define the structure and validation rules for the request and response payloads. Libraries like `jsonschema` can be used to validate incoming requests against a schema, ensuring that they conform to the MCP specification. * **gRPC (optional, but relevant for comparison):** While you're building on aiohttp, it's worth understanding gRPC. gRPC is a high-performance RPC framework that's often used for similar purposes as MCP. Understanding gRPC can help you make informed design decisions about your MCP implementation. If performance is critical, consider whether gRPC might be a better fit than a custom aiohttp-based solution. * **Logging:** Use Python's built-in `logging` module to log requests, errors, and other relevant information. This is essential for debugging and monitoring your MCP server. * **Testing Framework (pytest, unittest):** Write unit tests and integration tests to ensure that your MCP server is working correctly. `pytest` is a popular and flexible testing framework. * **OpenAPI/Swagger (optional):** If you want to document your MCP API, you can use OpenAPI (formerly Swagger). Tools like `aiohttp-apispec` can help you generate OpenAPI specifications from your aiohttp routes. This makes it easier for clients to understand and use your MCP server. **Example (Conceptual):** ```python import asyncio import json from aiohttp import web import marshmallow import jsonschema # Define your data models using Marshmallow class MyRequestSchema(marshmallow.Schema): input_data = marshmallow.fields.String(required=True) class MyResponseSchema(marshmallow.Schema): output_data = marshmallow.fields.String(required=True) # Define your JSON Schema (alternative to Marshmallow for validation) request_schema = { "type": "object", "properties": { "input_data": {"type": "string"} }, "required": ["input_data"] } async def handle_mcp_request(request): try: data = await request.json() # Option 1: Validate with JSON Schema try: jsonschema.validate(instance=data, schema=request_schema) except jsonschema.exceptions.ValidationError as e: return web.json_response({"error": str(e)}, status=400) # Option 2: Validate and deserialize with Marshmallow # try: # validated_data = MyRequestSchema().load(data) # except marshmallow.exceptions.ValidationError as err: # return web.json_response({"errors": err.messages}, status=400) # Process the request (replace with your actual logic) input_data = data['input_data'] # or validated_data['input_data'] output_data = f"Processed: {input_data}" # Serialize the response with Marshmallow response_data = MyResponseSchema().dump({"output_data": output_data}) return web.json_response(response_data) except Exception as e: print(f"Error: {e}") return web.json_response({"error": "Internal Server Error"}, status=500) async def main(): app = web.Application() app.add_routes([web.post('/mcp', handle_mcp_request)]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, 'localhost', 8080) await site.start() print("Server started on http://localhost:8080") await asyncio.Future() # Run forever if __name__ == '__main__': asyncio.run(main()) ``` **Key Considerations for MCP:** * **Specification Adherence:** Carefully review the MCP specification you're implementing. Pay close attention to the required data formats, error codes, and communication protocols. * **Error Handling:** Implement robust error handling to gracefully handle invalid requests, unexpected errors, and other issues. Return informative error messages to the client. * **Security:** Consider security implications, especially if your MCP server is exposed to the internet. Implement authentication, authorization, and input validation to protect against malicious attacks. * **Performance:** Optimize your code for performance, especially if you expect a high volume of requests. Use asynchronous programming effectively, and consider caching frequently accessed data. * **Scalability:** Design your MCP server to be scalable, so that it can handle increasing traffic. Consider using a load balancer and multiple instances of your server. * **Monitoring:** Implement monitoring to track the performance and health of your MCP server. Use metrics like request latency, error rates, and resource utilization to identify and resolve issues. This comprehensive list should give you a good starting point for building your MCP server on top of aiohttp. Remember to adapt the tools and techniques to the specific requirements of your MCP implementation.

MCP Servers - OpenAI and Flux Integration

镜子 (jìng zi)

goose-with-mcp-servers

代号“鹅”的包含 MCP 服务器的 Docker 镜像

supOS MCP Server

镜子 (jìng zi)

Pocketbase Mcp

MCP 兼容的 PocketBase 服务器实现