发现优秀的 MCP 服务器

mcp-server-redmine

Enables AI assistants to create, update, and query Redmine issues and projects directly from conversations.

openapi-spec-mcp

Turns any OpenAPI/Swagger spec into queryable tools for LLMs, enabling endpoint search, detail retrieval, and schema exploration.

PureContext MCP

Indexes codebases and lets AI agents retrieve precise code snippets (functions, classes, routes) instead of reading entire files, reducing token usage and improving accuracy.

dbridge-mcp

Read-only MCP server that lets AI agents safely query SQLite, PostgreSQL, and MySQL/MariaDB. Enforces read-only transactions with column masking, row caps, query timeouts, EXPLAIN-based cost rejection, and rate limiting.

ERPNext MCP Server

A production-ready server that enables AI assistants like Claude Desktop to seamlessly integrate with ERPNext for document operations, reporting, and custom workflows through natural language interaction.

Cypress Page Object Generator

An MCP server for automatically generating Cypress page objects from frontend components like Vue, React, or CoffeeScript.

Outlook MCP Server

Provides programmatic access to Microsoft Outlook mailboxes, enabling AI assistants to search, analyze, and extract insights from emails in personal and shared mailboxes.

mcp-web-calc

Provides web search, URL fetching, summarization, math evaluation, and Wikipedia tools for LM Studio without needing an API key.

kongen-mcp

Connects MCP clients to Kongen Labs' Pattern Intelligence API for reasoning regime detection, structural transfer scoring, and intelligent model routing.

Odoo MCP Server

Enables AI assistants to interact with Odoo ERP systems, allowing operations like searching employees, managing holidays, and executing custom methods on Odoo models via XML-RPC.

🚀 Go-Tapd-SDK

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

mcp-tw-company

An MCP server for querying Taiwan company registry open data, enabling search by name, number, directors, business items, and branch offices.

flask-mcp-server

Flask-based Model Context Protocol (MCP) server for Python. Drop it into any Flask app or run it standalone.

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!

apc-mcp

apc-mcp is a Model Context Protocol server that brings audio plugin development workflows into any MCP-compatible client by wrapping CMake, ctest, clang-format, pluginval, and clap-validator into a clean tool interface for building, testing, linting, validating, and scaffolding JUCE, CLAP, VST3, and ARA plugin projects.

youtube-context-mcp

A small MCP server that gives agents rich context about a YouTube video — its transcript, jump-to-the-moment deep links, metadata, and most-replayed moments — so they can answer questions, summarize, pull quotes, or surface highlights.

Echo MCP Server

一个简单的服务器，实现了模型上下文协议（MCP），会将消息回显，专为测试 MCP 客户端而设计。

nimble

A token-efficient MCP server that reduces context window bloat by lazy loading tool descriptions and proxying calls through three simple tools, with a dashboard for managing connections.

Weather MCP Server

Provides current weather data and hourly forecasts for any location worldwide using the Open-Meteo API, accessible through HTTP transport without requiring an API key.

YouTube Knowledge MCP

Transforms YouTube into a queryable knowledge source with search, video details, transcript analysis, and AI-powered tools for summaries, learning paths, and knowledge graphs. Features quota-aware API access with caching and optional OpenAI/Anthropic integration for advanced content analysis.

MCP Shared Services

Modular monolithic FastAPI shared AI service platform providing config center, prompt registry, LLM gateway, RAG service, secret manager, tool registry, and MCP server wrapper.

OpenAlex MCP Server

Enables AI agents to search and analyze OpenAlex scholarly database for OSINT research, including works, authors, institutions, funding, citations, and collaboration networks.

meta-mcp-manager

Federates multiple MCP servers into a single endpoint with search, call, and admin tools, plus inbound/outbound OAuth.

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 格式的邮件内容等。 记住要处理错误并注意安全性。 希望这个演示对你有所帮助！

mcp-image-optimizer

A Model Context Protocol server for image optimization with advanced transformations powered by Sharp, enabling resize, convert, batch process, crop, watermark, and favicon generation from URLs or local files.

Fiji MCP Server

Enables AI agents to control Fiji/ImageJ for microscopy image analysis through natural language commands, supporting operations like image opening, filtering, particle analysis, and automated workflows.

MCP-Kit Developer Task Assignment System

Enables intelligent task assignment to developers using hybrid AI algorithms that match tasks based on past experience, skill sets, workload balance, and project alignment. Features enterprise-grade security with AES-256 encryption and 75% performance optimization through smart caching.