发现优秀的 MCP 服务器

DeepSeek MCP Server

镜子 (jìng zi)

JBAssist - Microsoft Graph MCP Server

一个兼容 Windows 的 MCP 服务器，用于查询 Microsoft Graph API。

Azure DevOps MCP Server by Zubeid HendricksAzure DevOps MCP Server

用于 Azure DevOps API 的 MCP 服务器，支持项目管理、存储库操作等。

Deno Deploy MCP Template Repo

一个用于在 Deno Deploy 上托管 MCP 服务器的模板仓库。

CLI MCP Server

镜子 (jìng zi)

create-mcp-server

一个用于创建 MCP 服务器的 MCP 服务器

mcpDemo

MCP服务器演示

MCP TypeScript Template

一个对初学者友好的基础，用于使用 TypeScript 构建模型上下文协议 (MCP) 服务器（以及未来也包括客户端）。此模板提供了一个全面的起点，包含生产就绪的实用程序、结构良好的代码以及用于构建 MCP 服务器的工作示例。

CodeSynapse

一个 MCP（模型上下文协议）服务器，它与语言服务器协议（LSP）集成，以便将代码库中丰富的语义信息暴露给 LLM 代码代理。

mcd-demo

正在测试创建简单的 Minecraft (MCP) 服务器并与 LangChain 代理集成。

uv-mcp

用于内省 Python 环境的 MCP 服务器

teable-mcp-server

一个用于与 Teable 数据库交互的 MCP 服务器。

VNDB MCP Server

一个模型上下文协议（MCP）服务器，用于访问视觉小说数据库（VNDB）API。这使得Claude AI能够搜索和检索视觉小说信息。

MCPAgentAI 🚀

Python SDK，旨在简化与 MCP（模型上下文协议）服务器的交互。 它提供了一个易于使用的界面，用于连接到 MCP 服务器、读取资源和调用工具。

🚀 Memgraph MCP Server

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

mcp_server

LLM 集成用的 MCP 服务器

MCP Server Markup Language (MCPML)

MCP 服务器标记语言 (MCPML) - 一个 Python 框架，用于构建具有 CLI 和 OpenAI 代理支持的 MCP 服务器。

Linear MCP Server

一个处理所有线性资源类型的线性 MCP 实现。

UIThub MCP Server

简单的 GitHub MCP 服务器。

Fetch MCP Server

Okay, here's a breakdown of how you can fetch URLs from a webpage using Playwright, integrate it with an SSE (Server-Sent Events) MCP (Management Control Plane) server, and use Node.js with Express.js to orchestrate everything. I'll provide code snippets and explanations to guide you. **Conceptual Overview** 1. **Playwright (Web Scraping):** Playwright will be used to launch a browser, navigate to the target webpage, and extract the URLs you need. 2. **Node.js/Express.js (Server):** Express.js will create a web server that handles requests to start the scraping process and stream the results back to the client. 3. **SSE (Server-Sent Events):** SSE will be used to push the extracted URLs from the server to the client in real-time as they are found. This is more efficient than repeatedly polling the server. 4. **MCP (Management Control Plane):** The MCP part is a bit more abstract. It implies you have a system for managing and controlling the scraping process. This could involve: * Configuration: Specifying the target URL, selectors for extracting URLs, etc. * Monitoring: Tracking the progress of the scraping job. * Error Handling: Managing errors that occur during scraping. * Scaling: Distributing the scraping workload across multiple instances. **Code Example (Illustrative)** **1. Project Setup** ```bash mkdir playwright-sse-mcp cd playwright-sse-mcp npm init -y npm install playwright express eventsource ``` **2. `server.js` (Node.js/Express.js Server)** ```javascript const express = require('express'); const { chromium } = require('playwright'); const app = express(); const port = 3000; app.use(express.json()); // For parsing JSON request bodies // In-memory storage for SSE connections (replace with a more robust solution for production) const sseClients = []; app.get('/sse', (req, res) => { res.setHeader('Content-Type', 'text/event-stream'); res.setHeader('Cache-Control', 'no-cache'); res.setHeader('Connection', 'keep-alive'); res.flushHeaders(); const clientId = Date.now(); // Unique ID for the client const newClient = { id: clientId, res, }; sseClients.push(newClient); console.log(`${clientId} Connection open`); req.on('close', () => { console.log(`${clientId} Connection closed`); sseClients = sseClients.filter((client) => client.id !== clientId); }); }); function sendSSE(data) { sseClients.forEach((client) => { client.res.write(`data: ${JSON.stringify(data)}\n\n`); }); } app.post('/scrape', async (req, res) => { const { url, selector } = req.body; // Get URL and selector from request body if (!url || !selector) { return res.status(400).send('URL and selector are required.'); } console.log(`Starting scrape for ${url} with selector ${selector}`); try { const browser = await chromium.launch(); const page = await browser.newPage(); await page.goto(url); const links = await page.locator(selector).evaluateAll(links => links.map(link => link.href)); for (const link of links) { sendSSE({ url: link }); // Send each URL via SSE } await browser.close(); console.log(`Scrape complete for ${url}`); res.status(200).send('Scrape started and URLs are being streamed.'); } catch (error) { console.error('Scrape error:', error); sendSSE({ error: error.message }); // Send error via SSE res.status(500).send('Scrape failed.'); } }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **3. `client.html` (Simple Client to Receive SSE)** ```html <!DOCTYPE html> <html> <head> <title>SSE Client</title> </head> <body> <h1>SSE Stream</h1> <ul id="urlList"></ul> <script> const urlList = document.getElementById('urlList'); const eventSource = new EventSource('http://localhost:3000/sse'); eventSource.onmessage = (event) => { const data = JSON.parse(event.data); if (data.url) { const listItem = document.createElement('li'); listItem.textContent = data.url; urlList.appendChild(listItem); } else if (data.error) { const listItem = document.createElement('li'); listItem.textContent = `Error: ${data.error}`; urlList.appendChild(listItem); } }; eventSource.onerror = (error) => { console.error('SSE error:', error); }; </script> </body> </html> ``` **4. Running the Example** 1. **Start the Server:** `node server.js` 2. **Open `client.html`** in your browser. 3. **Send a POST request to `/scrape`:** You can use `curl`, `Postman`, or a similar tool. For example: ```bash curl -X POST -H "Content-Type: application/json" -d '{"url": "https://www.example.com", "selector": "a"}' http://localhost:3000/scrape ``` Replace `"https://www.example.com"` with the URL you want to scrape and `"a"` with the CSS selector for the links you want to extract. **Explanation** * **`server.js`:** * Sets up an Express.js server. * `/sse` endpoint: Handles SSE connections. It sets the correct headers for SSE and keeps track of connected clients. * `sendSSE(data)`: Sends data to all connected SSE clients. * `/scrape` endpoint: * Receives the target URL and CSS selector from the request body. * Launches a Playwright browser. * Navigates to the URL. * Uses `page.locator(selector).evaluateAll()` to extract the `href` attributes of all elements matching the selector. * Sends each URL back to the client via SSE. * Handles errors and sends error messages via SSE. * **`client.html`:** * Creates an `EventSource` object to connect to the `/sse` endpoint. * Listens for `message` events from the server. * Parses the JSON data and displays the URLs in a list. * Handles errors. **Important Considerations for Production (MCP)** * **Configuration Management:** Instead of hardcoding the URL and selector in the `curl` command, you'd typically store them in a database or configuration file. Your MCP would provide an interface for managing these configurations. * **Job Queuing:** Use a message queue (e.g., RabbitMQ, Kafka) to queue scraping jobs. This allows you to handle a large number of requests without overloading the server. * **Scaling:** Run multiple instances of the scraping server behind a load balancer. The message queue will distribute the jobs across the instances. * **Monitoring:** Use a monitoring system (e.g., Prometheus, Grafana) to track the performance of the scraping servers, the number of jobs in the queue, and any errors that occur. * **Error Handling:** Implement robust error handling and retry mechanisms. For example, if a scraping job fails, you might retry it a few times before giving up. * **Rate Limiting:** Be respectful of the websites you are scraping. Implement rate limiting to avoid overloading their servers. * **Data Storage:** Instead of just displaying the URLs in the browser, you'll likely want to store them in a database or other data store. * **Authentication/Authorization:** Secure your MCP endpoints with authentication and authorization to prevent unauthorized access. * **Headless Mode:** Run the Playwright browser in headless mode (which is the default) for better performance. **Example of MCP Integration (Conceptual)** Let's say you have an MCP API endpoint `/api/scrape-jobs` that allows you to create new scraping jobs. The request body might look like this: ```json { "url": "https://www.example.com", "selector": "a", "callbackUrl": "https://your-data-store.com/api/store-data" // Where to send the scraped data } ``` Your server would then: 1. Receive the request to `/api/scrape-jobs`. 2. Validate the request. 3. Create a job in the message queue (e.g., RabbitMQ). 4. A worker process (one of your scraping server instances) would pick up the job from the queue. 5. The worker would scrape the URL, extract the data, and send it to the `callbackUrl`. 6. The worker would update the job status in the MCP (e.g., "in progress", "completed", "failed"). This is a simplified example, but it illustrates the basic principles of integrating Playwright with an SSE server and an MCP. The specific implementation will depend on your requirements and the architecture of your MCP. **Chinese Translation of Key Concepts** * **Web Scraping:** 网络爬虫 (wǎngluò páchóng) * **Server-Sent Events (SSE):** 服务器发送事件 (fúwùqì fāsòng shìjiàn) * **Management Control Plane (MCP):** 管理控制平面 (guǎnlǐ kòngzhì píngmiàn) * **Playwright:** Playwright (no direct translation, use the English name) * **Node.js:** Node.js (no direct translation, use the English name) * **Express.js:** Express.js (no direct translation, use the English name) * **URL:** 网址 (wǎngzhǐ) * **CSS Selector:** CSS 选择器 (CSS xuǎnzéqì) * **Endpoint:** 端点 (duāndiǎn) * **Message Queue:** 消息队列 (xiāoxi duìliè) * **Load Balancer:** 负载均衡器 (fùzài jūnhéngqì) * **Monitoring:** 监控 (jiānkòng) * **Error Handling:** 错误处理 (cuòwù chǔlǐ) * **Rate Limiting:** 速率限制 (sùlǜ xiànzhì) This comprehensive explanation and code example should give you a solid foundation for building your Playwright-based web scraping solution with SSE and MCP integration. Remember to adapt the code and architecture to your specific needs and environment. Good luck!

github-mcp-cursor-project-rules

Okay, here's a translation of "Cursor project rules and MCP server" into Chinese, along with some context to make sure it's the most accurate translation: **Possible Translations:** * **精确翻译 (Literal):** 光标项目规则和 MCP 服务器 (Guāngbiāo xiàngmù guīzé hé MCP fúwùqì) * **更自然的翻译 (More Natural):** 光标项目的规则与 MCP 服务器 (Guāngbiāo xiàngmù de guīzé yǔ MCP fúwùqì) **Explanation of the Translation Choices:** * **光标 (Guāngbiāo):** Cursor (as in the mouse cursor or a text cursor) * **项目 (Xiàngmù):** Project * **规则 (Guīzé):** Rules * **和 (Hé) / 与 (Yǔ):** And (both are acceptable, 与 is slightly more formal) * **MCP 服务器 (MCP Fúwùqì):** MCP Server (MCP is usually kept as is, as it's an acronym. 服务器 means "server.") * **的 (De):** A possessive particle, used to connect "光标项目" (Cursor project) and "规则" (rules) to make it "Cursor project's rules". **Which Translation to Use:** The more natural translation, **光标项目的规则与 MCP 服务器 (Guāngbiāo xiàngmù de guīzé yǔ MCP fúwùqì)**, is generally preferred because it flows better in Chinese. **Important Considerations (Context is Key):** To give you the *best* translation, I need a little more context. Here are some questions to consider: * **What kind of "Cursor project" is this?** Is it a software project involving cursors? Is it a project *named* "Cursor"? Knowing this will help me choose the most appropriate wording. * **What is the MCP server used for?** Knowing the purpose of the server will help ensure the translation is accurate. **Example with More Context:** Let's say the "Cursor project" is a software development project focused on improving cursor behavior, and the MCP server is used for managing the project's resources. Then, a possible translation could be: * **针对光标行为改进的软件项目规则与 MCP 服务器** (Zhēnduì guāngbiāo xíngwéi gǎijìn de ruǎnjiàn xiàngmù guīzé yǔ MCP fúwùqì) * This translates to: "Rules for the software project aimed at improving cursor behavior and the MCP server." Therefore, please provide more context if you want a more precise and accurate translation.

🚀 Go-Tapd-SDK

Go Tapd SDK 是一个用于访问 Tapd API 的 Go 客户端库，并且它也支持最新的 MCP 服务器。

mcp-server-email

好的，这是关于使用 Golang 发送电子邮件的 mcp-server 演示： **标题：使用 Golang 在 mcp-server 中发送电子邮件** **简介：** 本演示展示了如何在 mcp-server 环境中使用 Golang 发送电子邮件。我们将使用 `net/smtp` 包来连接 SMTP 服务器并发送邮件。 **先决条件：** * 安装 Golang (1.16 或更高版本) * 安装 mcp-server * 一个可用的 SMTP 服务器 (例如：Gmail, Outlook, 或本地 SMTP 服务器) * SMTP 服务器的凭据 (用户名和密码) **代码示例：** ```go package main import ( "fmt" "net/smtp" "log" ) // 配置信息 const ( smtpServer = "smtp.gmail.com" // 你的 SMTP 服务器地址 smtpPort = 587 // 你的 SMTP 服务器端口 senderEmail = "your_email@gmail.com" // 你的邮箱地址 senderPassword = "your_password" // 你的邮箱密码 (或应用专用密码) receiverEmail = "recipient_email@example.com" // 收件人邮箱地址 ) func main() { // 邮件内容 subject := "Golang Email Demo" body := "This is a test email sent from a Golang application in mcp-server." // 构建邮件消息 message := []byte( "To: " + receiverEmail + "\r\n" + "Subject: " + subject + "\r\n" + "\r\n" + body + "\r\n", ) // 认证信息 auth := smtp.PlainAuth("", senderEmail, senderPassword, smtpServer) // 连接到 SMTP 服务器并发送邮件 err := smtp.SendMail(smtpServer+":"+fmt.Sprintf("%d", smtpPort), auth, senderEmail, []string{receiverEmail}, message) if err != nil { log.Fatal(err) return } fmt.Println("Email sent successfully!") } ``` **代码解释：** 1. **导入必要的包：** `net/smtp` 用于 SMTP 连接和邮件发送，`fmt` 用于格式化字符串，`log` 用于错误处理。 2. **配置信息：** 定义了 SMTP 服务器地址、端口、发件人邮箱、发件人密码和收件人邮箱。 **请务必替换这些值为你自己的信息。** 对于 Gmail，你可能需要启用“允许安全性较低的应用访问”或使用应用专用密码。 3. **邮件内容：** 定义了邮件的主题和正文。 4. **构建邮件消息：** 使用字符串拼接构建邮件消息。 `\r\n` 用于换行。 5. **认证信息：** 使用 `smtp.PlainAuth` 创建一个认证对象，用于向 SMTP 服务器验证身份。 6. **连接到 SMTP 服务器并发送邮件：** 使用 `smtp.SendMail` 函数连接到 SMTP 服务器并发送邮件。 该函数接受 SMTP 服务器地址、认证对象、发件人邮箱、收件人邮箱列表和邮件消息作为参数。 7. **错误处理：** 检查 `smtp.SendMail` 函数是否返回错误，如果返回错误，则打印错误信息并退出程序。 8. **成功提示：** 如果邮件发送成功，则打印一条成功消息。 **运行步骤：** 1. 将代码保存为 `main.go` 文件。 2. 在 mcp-server 环境中，使用 `go run main.go` 命令运行程序。 3. 检查收件人邮箱，确认是否收到邮件。 **注意事项：** * **安全性：** 请勿将密码硬编码到代码中。 建议使用环境变量或配置文件来存储密码。 * **Gmail：** 如果使用 Gmail，你可能需要启用“允许安全性较低的应用访问”或使用应用专用密码。 启用“允许安全性较低的应用访问”可能会降低你的账户安全性，因此建议使用应用专用密码。 * **错误处理：** 在实际应用中，应该进行更完善的错误处理，例如重试发送邮件或记录错误日志。 * **速率限制：** 某些 SMTP 服务器可能会对发送邮件的速率进行限制。 如果遇到速率限制，可以尝试降低发送邮件的频率或使用其他 SMTP 服务器。 * **mcp-server 集成：** 本示例是一个独立的程序。 要将其集成到 mcp-server 中，你需要将其作为 mcp-server 的一个模块或服务来运行。 具体集成方式取决于 mcp-server 的架构和配置。 **中文翻译：** **标题：使用 Golang 在 mcp-server 中发送电子邮件** **简介：** 本演示展示了如何在 mcp-server 环境中使用 Golang 发送电子邮件。我们将使用 `net/smtp` 包来连接 SMTP 服务器并发送邮件。 **先决条件：** * 安装 Golang (1.16 或更高版本) * 安装 mcp-server * 一个可用的 SMTP 服务器 (例如：Gmail, Outlook, 或本地 SMTP 服务器) * SMTP 服务器的凭据 (用户名和密码) **代码示例：** ```go package main import ( "fmt" "net/smtp" "log" ) // 配置信息 const ( smtpServer = "smtp.gmail.com" // 你的 SMTP 服务器地址 smtpPort = 587 // 你的 SMTP 服务器端口 senderEmail = "your_email@gmail.com" // 你的邮箱地址 senderPassword = "your_password" // 你的邮箱密码 (或应用专用密码) receiverEmail = "recipient_email@example.com" // 收件人邮箱地址 ) func main() { // 邮件内容 subject := "Golang 邮件演示" body := "这是一封来自 mcp-server 中 Golang 应用程序的测试邮件。" // 构建邮件消息 message := []byte( "To: " + receiverEmail + "\r\n" + "Subject: " + subject + "\r\n" + "\r\n" + body + "\r\n", ) // 认证信息 auth := smtp.PlainAuth("", senderEmail, senderPassword, smtpServer) // 连接到 SMTP 服务器并发送邮件 err := smtp.SendMail(smtpServer+":"+fmt.Sprintf("%d", smtpPort), auth, senderEmail, []string{receiverEmail}, message) if err != nil { log.Fatal(err) return } fmt.Println("邮件发送成功!") } ``` **代码解释：** 1. **导入必要的包：** `net/smtp` 用于 SMTP 连接和邮件发送，`fmt` 用于格式化字符串，`log` 用于错误处理。 2. **配置信息：** 定义了 SMTP 服务器地址、端口、发件人邮箱、发件人密码和收件人邮箱。 **请务必替换这些值为你自己的信息。** 对于 Gmail，你可能需要启用“允许安全性较低的应用访问”或使用应用专用密码。 3. **邮件内容：** 定义了邮件的主题和正文。 4. **构建邮件消息：** 使用字符串拼接构建邮件消息。 `\r\n` 用于换行。 5. **认证信息：** 使用 `smtp.PlainAuth` 创建一个认证对象，用于向 SMTP 服务器验证身份。 6. **连接到 SMTP 服务器并发送邮件：** 使用 `smtp.SendMail` 函数连接到 SMTP 服务器并发送邮件。 该函数接受 SMTP 服务器地址、认证对象、发件人邮箱、收件人邮箱列表和邮件消息作为参数。 7. **错误处理：** 检查 `smtp.SendMail` 函数是否返回错误，如果返回错误，则打印错误信息并退出程序。 8. **成功提示：** 如果邮件发送成功，则打印一条成功消息。 **运行步骤：** 1. 将代码保存为 `main.go` 文件。 2. 在 mcp-server 环境中，使用 `go run main.go` 命令运行程序。 3. 检查收件人邮箱，确认是否收到邮件。 **注意事项：** * **安全性：** 请勿将密码硬编码到代码中。 建议使用环境变量或配置文件来存储密码。 * **Gmail：** 如果使用 Gmail，你可能需要启用“允许安全性较低的应用访问”或使用应用专用密码。 启用“允许安全性较低的应用访问”可能会降低你的账户安全性，因此建议使用应用专用密码。 * **错误处理：** 在实际应用中，应该进行更完善的错误处理，例如重试发送邮件或记录错误日志。 * **速率限制：** 某些 SMTP 服务器可能会对发送邮件的速率进行限制。 如果遇到速率限制，可以尝试降低发送邮件的频率或使用其他 SMTP 服务器。 * **mcp-server 集成：** 本示例是一个独立的程序。 要将其集成到 mcp-server 中，你需要将其作为 mcp-server 的一个模块或服务来运行。 具体集成方式取决于 mcp-server 的架构和配置。 **总结：** 这个演示提供了一个使用 Golang 在 mcp-server 环境中发送电子邮件的基本示例。 你可以根据自己的需求修改代码，例如添加附件、使用 HTML 格式的邮件内容等。 记住要处理错误并注意安全性。 希望这个演示对你有所帮助！