发现优秀的 MCP 服务器

iFlytek SparkAgent MCP Server

Enables integration with iFlytek's SparkAgent Platform to invoke task chains and upload files. Provides tools for interacting with iFlytek's AI agent services through the Model Context Protocol.

Elasticsearch 7.x MCP Server

提供一个 MCP 协议接口，用于与 Elasticsearch 7.x 数据库交互，支持全面的搜索功能，包括聚合、高亮和排序。

JigsawStack MCP Server

允许 AI 模型与 JigsawStack 模型交互的模型上下文协议服务器！

MCP Server Demo

A WebSocket-based Model Control Protocol (MCP) server that processes model requests and provides responses. Supports chat and text completion actions with a standardized JSON protocol for AI model communication.

GoScry

GoScry 是一个用 Go 编写的服务器应用程序，它充当控制系统（例如 LLM 或脚本）和 Web 浏览器之间的桥梁。

mcp-zeroentropy

MCP Server for ZeroEntropy collections, top documents and rerankers

Manus MCP

提供类似 Manus 功能的 MCP 服务器

mcp-ppt

design ppt

CoderSwap MCP Server

Enables AI agents to autonomously create and manage topic-specific vector knowledge bases with end-to-end functionality including project creation, content ingestion from URLs, semantic search, and progress tracking. Provides a complete research workflow without exposing low-level APIs.

UAAR University MCP Server

Provides structured access to PMAS Arid Agriculture University Rawalpindi's academic resources, admissions, and student services through 53 specialized tools. AI agents can manage course information, library services, hostel details, and administrative functions using secure stdio or HTTP transports.

PostgreSQL MCP Server

Enables natural language interaction with PostgreSQL databases through Amazon Q for querying data, listing tables, and describing schemas. It provides secure, read-only access with automatic row limits to ensure efficient database exploration.

MCP Vault

Enables AI assistants to interact with Obsidian vaults through file operations like moving/renaming files and analyzing markdown heading structures. Bridges AI assistants with Obsidian using the Local REST API plugin for seamless vault management.

SeekChat

SeekChat 支持 MCP 工具执行，使 AI 能够直接控制您的电脑并执行各种任务。轻松实现文件管理、数据分析、代码开发等自动化，将 AI 变成真正智能的助手。

Web Analysis MCP

Enables intelligent web searching using SearXNG with content crawling via Creeper, then summarizes webpage content using LLM to avoid token limit issues. Supports smart filtering with domain blacklist/whitelist and optional LLM-based relevance filtering.

Futuur API MCP Integration

Futuur API MCP 集成是一个强大的基于 TypeScript 的服务器，它实现了模型上下文协议 (MCP)，可与 Futuur API 无缝集成。 该项目为处理市场数据、类别、用户信息和投注操作提供了一个强大的接口。

Minimax MCP Tools

一个 MCP 服务器实现，集成了 Minimax API，从而在 Windsurf 和 Cursor 等编辑器中提供 AI 驱动的图像生成和文本转语音功能。

MSSQL MCP Server

一个模型上下文协议服务器，它能够实现与 Microsoft SQL Server 数据库的安全且结构化的交互，允许 AI 助手在受控访问的情况下列出表、读取数据和执行 SQL 查询。

Starlette MCP SSE

Okay, here's a working example of a Starlette server with Server-Sent Events (SSE) based MCP (Message Channel Protocol) support. This example demonstrates a basic setup, including: * **Starlette Application:** The core web application. * **SSE Endpoint:** An endpoint that streams events to connected clients. * **MCP-like Structure:** A simplified structure for sending messages with a type and data. * **Basic Message Handling:** A simple example of how to handle different message types on the server. ```python import asyncio import json import time from typing import AsyncGenerator from starlette.applications import Starlette from starlette.responses import StreamingResponse from starlette.routing import Route # Define MCP Message Structure (Simplified) class MCPMessage: def __init__(self, type: str, data: dict): self.type = type self.data = data def to_json(self): return json.dumps({"type": self.type, "data": self.data}) # Global Queue for Messages (In-memory, for demonstration) message_queue = asyncio.Queue() async def event_stream(request): async def generate_events() -> AsyncGenerator[str, None]: try: while True: message: MCPMessage = await message_queue.get() # Get message from queue message_json = message.to_json() yield f"data: {message_json}\n\n" await asyncio.sleep(0.1) # Simulate some processing time except asyncio.CancelledError: print("Client disconnected, stopping event stream.") finally: print("Event stream generator finished.") return StreamingResponse(generate_events(), media_type="text/event-stream") async def send_test_messages(): """ Simulates sending messages to the queue. In a real application, these messages would come from other parts of your system. """ await asyncio.sleep(1) # Wait a bit before sending messages for i in range(5): message = MCPMessage(type="test_event", data={"message": f"Test message {i}"}) await message_queue.put(message) print(f"Sent message: {message.to_json()}") await asyncio.sleep(2) message = MCPMessage(type="status_update", data={"status": "Completed!"}) await message_queue.put(message) print(f"Sent message: {message.to_json()}") async def startup(): """ Startup function to start background tasks. """ asyncio.create_task(send_test_messages()) routes = [ Route("/events", endpoint=event_stream), ] app = Starlette(debug=True, routes=routes, on_startup=[startup]) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` Key improvements and explanations: * **MCPMessage Class:** Defines a simple class to represent MCP messages with `type` and `data` fields. This makes it easier to structure and serialize messages. The `to_json()` method converts the message to a JSON string for sending over SSE. * **`message_queue`:** An `asyncio.Queue` is used to hold messages that need to be sent to the SSE clients. This is crucial for decoupling the message producers from the SSE endpoint. The queue allows messages to be added from anywhere in your application. * **`event_stream` Function:** This is the SSE endpoint. It uses an `async generator` to continuously yield events to the client. Crucially, it retrieves messages from the `message_queue`. * **Error Handling (Client Disconnect):** The `try...except asyncio.CancelledError` block in the `generate_events` function is *essential*. It catches the `asyncio.CancelledError` that is raised when the client disconnects. Without this, your server will likely crash or throw errors when a client closes the connection. The `finally` block ensures cleanup. * **`send_test_messages` Function:** This function simulates sending messages to the queue. In a real application, these messages would come from other parts of your system (e.g., background tasks, API endpoints). It demonstrates how to put messages onto the queue. It uses `asyncio.sleep` to simulate delays. * **`startup` Function:** The `startup` function is registered with the Starlette application. It's used to start background tasks when the application starts. In this case, it starts the `send_test_messages` task. * **JSON Serialization:** The `json.dumps()` function is used to serialize the message data to JSON before sending it over SSE. This is the standard way to format data for SSE. * **SSE Format:** The `yield f"data: {message_json}\n\n"` line is *critical*. It formats the data correctly for SSE. Each event must be prefixed with `data: ` and followed by two newline characters (`\n\n`). * **Media Type:** The `StreamingResponse` is created with `media_type="text/event-stream"`. This tells the client that the server is sending SSE events. * **Uvicorn:** The example uses Uvicorn as the ASGI server. Make sure you have it installed (`pip install uvicorn`). * **Clearer Comments:** The code is heavily commented to explain each part. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `sse_mcp_server.py`). 2. **Install Dependencies:** ```bash pip install starlette uvicorn ``` 3. **Run:** ```bash python sse_mcp_server.py ``` 4. **Test with a Client:** Use a browser or a tool like `curl` to connect to the SSE endpoint. Here's an example using `curl`: ```bash curl -N http://localhost:8000/events ``` The `-N` option tells `curl` not to buffer the output, so you'll see the events as they arrive. **Example Client (JavaScript/HTML):** ```html <!DOCTYPE html> <html> <head> <title>SSE MCP Client</title> </head> <body> <h1>SSE MCP Client</h1> <div id="events"></div> <script> const eventSource = new EventSource('http://localhost:8000/events'); eventSource.onmessage = (event) => { const eventsDiv = document.getElementById('events'); const message = JSON.parse(event.data); // Parse the JSON eventsDiv.innerHTML += `<p>Type: ${message.type}, Data: ${JSON.stringify(message.data)}</p>`; }; eventSource.onerror = (error) => { console.error("SSE error:", error); const eventsDiv = document.getElementById('events'); eventsDiv.innerHTML += "<p>Error connecting to SSE server.</p>"; eventSource.close(); // Close the connection on error }; </script> </body> </html> ``` Save this as an HTML file (e.g., `sse_mcp_client.html`) and open it in your browser. Make sure the server is running. **Important Considerations for Production:** * **Error Handling:** Implement robust error handling on both the server and client. Handle connection errors, message parsing errors, and other potential issues. * **Scalability:** For production, consider using a more scalable message queue (e.g., Redis, RabbitMQ) instead of the in-memory `asyncio.Queue`. * **Authentication/Authorization:** Implement authentication and authorization to protect your SSE endpoint. * **Connection Management:** Keep track of connected clients and handle disconnections gracefully. * **Message Format:** Define a clear and consistent message format for your MCP protocol. Consider using a schema validation library to ensure that messages are valid. * **Heartbeats:** Implement heartbeats to detect dead connections. The server can periodically send a "ping" message, and the client can respond with a "pong" message. If the server doesn't receive a "pong" within a certain time, it can close the connection. * **Reconnection:** The client should automatically attempt to reconnect if the connection is lost. The `EventSource` API has built-in reconnection logic, but you may need to customize it. * **Buffering:** Be aware of potential buffering issues. The server and client may buffer messages, which can lead to delays. You may need to adjust the buffer sizes to optimize performance. **Chinese Translation of Key Concepts:** * **Server-Sent Events (SSE):** 服务器发送事件 (Fúwùqì fāsòng shìjiàn) * **Message Channel Protocol (MCP):** 消息通道协议 (Xiāoxī tōngdào xiéyì) * **Starlette:** (No direct translation, usually referred to by its English name) * **Endpoint:** 端点 (Duāndiǎn) * **Asynchronous:** 异步 (Yìbù) * **Queue:** 队列 (Duìliè) * **Message:** 消息 (Xiāoxī) * **Client:** 客户端 (Kèhùduān) * **Server:** 服务器 (Fúwùqì) * **JSON:** JSON (Usually referred to by its English name, but can be translated as JavaScript 对象表示法 - JavaScript duìxiàng biǎoshì fǎ) * **Streaming:** 流式传输 (Liúshì chuánshū) This comprehensive example provides a solid foundation for building a Starlette server with SSE-based MCP support. Remember to adapt it to your specific needs and consider the production considerations mentioned above.

Thingiverse MCP Server

一个模型上下文协议服务器，允许 AI 助手从 Thingiverse 搜索、探索和检索 3D 打印模型。

MCP Log Reader

一个专门的 MCP 服务器，通过为 Claude 提供直接访问多个平台上的日志文件的权限，来帮助分析和调试模型上下文协议 (Model Context Protocol) 日志。

Kibela MCP Server

A Model Context Protocol server that allows AI applications to interact with Kibela knowledge bases, enabling users to search, create, update, and organize content through natural language.

Lunar Calendar MCP Server

Provides Chinese traditional calendar functions including BaZi calculation, solar-lunar calendar conversion, Huangli almanac queries, daily fortune readings, 24 solar terms, and Wu Xing (Five Elements) analysis.

AWS MCP Server

Enables AI assistants to execute AWS CLI commands and retrieve service documentation through the Model Context Protocol. It supports Unix pipes for output filtering and provides pre-defined prompt templates for common cloud management tasks.

Outlook MCP Server

Enables AI-powered email management for Microsoft Outlook, allowing users to search, compose, organize, and batch forward emails using natural language commands with 100% local processing.

Reservation System MCP Server

An MCP server that allows AI models to securely access and manage WeChat Cloud-based reservation data. It provides tools for querying records, updating appointment statuses, and deleting entries through the WeChat Cloud Development API.

mcp-sqlalchemy

通过 pyodbc 提供 SQLAlchemy 连接到任何可以通过 SQLAlchemy 访问的数据库管理系统 (DBMS)。

MCP Servers

这个仓库包含了我关于如何创建 MCP 服务器的学习笔记。

Sponge MCP Server

Provides a Model Context Protocol interface to the Sponge wallet API for managing digital assets and transaction histories. It enables users to securely check balances, retrieve addresses, and perform transfers using DAuth-style credential exchange.

KMB Bus MCP Server

一个模型上下文协议服务器，提供对香港九巴和龙运巴士路线信息和预计到达时间的实时访问，使语言模型能够回答用户关于巴士路线、站点和预计到达时间的问题。