Discover Awesome MCP Servers

MCP Server Markup Language (MCPML)

MCP Server Markup Language (MCPML) - Một framework Python để xây dựng các MCP Server với sự hỗ trợ CLI và OpenAI Agent.

arxiv-mcp

Enables searching ArXiv papers, fetching paper details, daily category digests, and exploring author collaboration graphs.

mcp-gateway

AI gateway to unify authentication and expose internal APIs as MCP tools. Supports SSO, JWT, and basic auth with auto-refresh.

youtube-marketing-skills

MCP server that connects AI agents to real YouTube channel analytics and SEO management via OAuth, enabling content strategy, metadata updates, and companion WordPress posts without leaving the agent.

MCP server for LogSeq

Interacts with LogSeq via its API.

Memory MCP

A persistent, cross-provider memory server that stores user facts in Postgres and exposes search and upsert tools for any MCP-capable agent.

Marketo MCP Server

Python MCP server for the Marketo REST API, enabling leads management, campaigns, activities, and asset operations through natural language.

mcp-web-calc

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

meta-mcp-manager

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

API to MCP Gateway

Acts as a bridge between standard REST/OpenAPI web APIs and the Model Context Protocol, dynamically converting REST endpoints into MCP tools for LLM clients like Cursor, Claude Desktop, and n8n.

Echo MCP Server

Một máy chủ đơn giản triển khai Giao thức Ngữ cảnh Mô hình (Model Context Protocol - MCP) có chức năng lặp lại các tin nhắn, được thiết kế để kiểm tra các ứng dụng khách MCP.

MidPay MCP Server

Enables AI models to manage escrow payments, account monitoring, and blockchain-verified transactions through the Model Context Protocol.

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:** This will be our web scraping tool. It allows us to launch a browser (Chromium, Firefox, or WebKit), navigate to a webpage, and extract the URLs we need. 2. **Node.js with Express.js:** This will be our backend server. It will: * Receive requests to start the scraping process. * Orchestrate Playwright to fetch the URLs. * Act as an SSE server, pushing updates (e.g., URLs found, progress status) to the client. * Potentially act as an MCP, managing the scraping process (start, stop, monitor). 3. **SSE (Server-Sent Events):** A one-way communication protocol where the server pushes updates to the client (typically a web browser). This is ideal for real-time updates on the scraping progress. 4. **MCP (Management Control Plane):** In this context, it's a conceptual layer for managing the scraping process. It could involve features like: * Starting and stopping the scraping. * Monitoring the scraping progress. * Configuring the scraping (e.g., target URL, selectors). * Error handling and reporting. **Code Example (Illustrative)** **1. Project Setup** ```bash mkdir playwright-sse-mcp cd playwright-sse-mcp npm init -y npm install playwright express sse ``` **2. `server.js` (Node.js/Express.js with SSE)** ```javascript const express = require('express'); const { chromium } = require('playwright'); const sse = require('sse'); const app = express(); const port = 3000; let sseStream = null; // Store the SSE stream // Function to send SSE events function sendSSEEvent(event, data) { if (sseStream) { sseStream.send({ event: event, data: JSON.stringify(data) }); } else { console.warn("SSE stream not initialized. Event:", event, "Data:", data); } } // SSE Endpoint app.get('/events', (req, res) => { res.setHeader('Content-Type', 'text/event-stream'); res.setHeader('Cache-Control', 'no-cache'); res.setHeader('Connection', 'keep-alive'); res.flushHeaders(); // send the headers immediately const sseHandler = new sse(req, res); sseStream = sseHandler.pipe(null, { end: false }); // Store the stream // Optional: Send a welcome event sendSSEEvent('connected', { message: 'SSE connection established' }); req.on('close', () => { console.log('Client disconnected from SSE'); sseStream = null; // Clear the stream }); }); // Playwright Scraping Function async function scrapeUrls(url) { try { const browser = await chromium.launch(); const page = await browser.newPage(); await page.goto(url); const links = await page.evaluate(() => { const anchors = Array.from(document.querySelectorAll('a')); return anchors.map(anchor => anchor.href); }); await browser.close(); return links; } catch (error) { console.error('Error during scraping:', error); sendSSEEvent('error', { message: 'Scraping failed', error: error.message }); return []; // Return an empty array in case of error } } // API Endpoint to Start Scraping app.get('/scrape', async (req, res) => { const targetUrl = req.query.url; if (!targetUrl) { return res.status(400).send('Missing URL parameter'); } sendSSEEvent('start', { message: 'Scraping started', url: targetUrl }); const urls = await scrapeUrls(targetUrl); if (urls.length > 0) { urls.forEach(url => { sendSSEEvent('url', { url: url }); }); sendSSEEvent('complete', { message: 'Scraping completed', urlCount: urls.length }); } else { sendSSEEvent('no-urls', { message: 'No URLs found' }); } res.status(200).send('Scraping initiated. Check /events for updates.'); // Acknowledge the request }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **3. `client.html` (Simple HTML/JavaScript Client)** ```html <!DOCTYPE html> <html> <head> <title>Playwright SSE Client</title> </head> <body> <h1>Playwright SSE Client</h1> <button id="startButton">Start Scraping</button> <ul id="urlList"></ul> <script> const urlList = document.getElementById('urlList'); const startButton = document.getElementById('startButton'); const eventSource = new EventSource('http://localhost:3000/events'); eventSource.onmessage = (event) => { console.log('Received event:', event); // Log the raw event }; eventSource.addEventListener('connected', (event) => { const data = JSON.parse(event.data); console.log('Connected:', data.message); }); eventSource.addEventListener('url', (event) => { const data = JSON.parse(event.data); const listItem = document.createElement('li'); listItem.textContent = data.url; urlList.appendChild(listItem); }); eventSource.addEventListener('start', (event) => { const data = JSON.parse(event.data); console.log('Scraping started:', data.url); urlList.innerHTML = ''; // Clear the list }); eventSource.addEventListener('complete', (event) => { const data = JSON.parse(event.data); console.log('Scraping completed. Found', data.urlCount, 'URLs'); }); eventSource.addEventListener('error', (event) => { const data = JSON.parse(event.data); console.error('Error:', data.message, data.error); }); startButton.addEventListener('click', () => { const targetUrl = prompt('Enter the URL to scrape:'); if (targetUrl) { fetch(`http://localhost:3000/scrape?url=${targetUrl}`) .then(response => { if (!response.ok) { console.error('Error starting scraping:', response.statusText); } }); } }); </script> </body> </html> ``` **How to Run** 1. **Save the files:** Save the code as `server.js` and `client.html` in your `playwright-sse-mcp` directory. 2. **Start the server:** Run `node server.js` in your terminal. 3. **Open the client:** Open `client.html` in your web browser. 4. **Click the "Start Scraping" button:** Enter the URL you want to scrape (e.g., `https://www.example.com`). 5. **Observe the results:** The URLs found on the page will be displayed in the list in your browser, and you'll see messages in the browser's console. The server console will also show activity. **Explanation** * **`server.js`:** * Sets up an Express.js server. * Defines an SSE endpoint (`/events`). When a client connects to this endpoint, the server keeps the connection open and sends events as they occur. * The `scrapeUrls` function uses Playwright to: * Launch a browser. * Navigate to the target URL. * Extract all `href` attributes from `<a>` tags. * Close the browser. * The `/scrape` endpoint: * Receives the target URL as a query parameter. * Calls `scrapeUrls` to perform the scraping. * Sends SSE events to the client: * `start`: Indicates that scraping has started. * `url`: Sends each URL found. * `complete`: Indicates that scraping is finished. * `error`: Indicates an error occurred. * The `sendSSEEvent` function encapsulates the logic for sending SSE messages. * **`client.html`:** * Creates an `EventSource` object to connect to the SSE endpoint. * Listens for the `url`, `start`, `complete`, and `error` events. * Updates the HTML page to display the URLs as they are received. * A button allows the user to enter the URL to scrape. **Key Improvements and Considerations** * **Error Handling:** The code includes basic error handling, but you should add more robust error handling, especially in the `scrapeUrls` function. Consider retries, logging, and more informative error messages. * **Scalability:** For high-volume scraping, consider using a message queue (e.g., RabbitMQ, Kafka) to decouple the scraping tasks from the web server. This allows you to scale the scraping workers independently. * **Rate Limiting:** Be respectful of the websites you are scraping. Implement rate limiting to avoid overloading their servers. You can use libraries like `bottleneck` to help with this. * **User-Agent:** Set a proper User-Agent header in your Playwright code to identify your scraper. * **Headless Mode:** Run Playwright in headless mode (`chromium.launch({ headless: true })`) for better performance on a server. * **Selectors:** Instead of just getting all `<a>` tags, use more specific CSS selectors to target the URLs you actually need. This will make your scraper more robust. * **Dynamic Content:** If the website uses JavaScript to load content dynamically, you might need to use `page.waitForSelector()` or `page.waitForTimeout()` to wait for the content to load before extracting the URLs. * **Anti-Scraping Measures:** Websites often have anti-scraping measures in place. You might need to use techniques like: * Rotating proxies. * Solving CAPTCHAs. * Using realistic browser behavior (e.g., moving the mouse, scrolling). * **MCP Features:** * **Start/Stop:** Add API endpoints to start and stop the scraping process. You'll need to manage the Playwright browser instance and potentially use a separate process for scraping. * **Configuration:** Allow users to configure the scraping parameters (e.g., target URL, selectors, rate limits) through an API or a web interface. * **Monitoring:** Track the scraping progress (e.g., URLs found, pages visited, errors) and provide a dashboard to monitor the process. * **Data Storage:** Instead of just displaying the URLs in the browser, you'll likely want to store them in a database (e.g., MongoDB, PostgreSQL). **Example of Rate Limiting (using `bottleneck`)** ```javascript const Bottleneck = require("bottleneck"); const limiter = new Bottleneck({ maxConcurrent: 1, // Only one request at a time minTime: 1000 // Wait 1 second between requests }); async function scrapeUrls(url) { try { const browser = await chromium.launch(); const page = await browser.newPage(); // Wrap the page.goto call with the rate limiter await limiter.schedule(() => page.goto(url)); const links = await page.evaluate(() => { const anchors = Array.from(document.querySelectorAll('a')); return anchors.map(anchor => anchor.href); }); await browser.close(); return links; } catch (error) { console.error('Error during scraping:', error); sendSSEEvent('error', { message: 'Scraping failed', error: error.message }); return []; // Return an empty array in case of error } } ``` **Vietnamese Translation of Key Concepts** * **Playwright:** Công cụ tự động hóa trình duyệt (crawling/scraping). * **SSE (Server-Sent Events):** Sự kiện được máy chủ gửi (một chiều). * **MCP (Management Control Plane):** Lớp điều khiển quản lý (quản lý quá trình cào dữ liệu). * **Node.js/Express.js:** Máy chủ backend. * **Web Scraping:** Cào dữ liệu web. * **URL:** Đường dẫn trang web. * **Endpoint:** Điểm cuối API. * **Rate Limiting:** Giới hạn tốc độ yêu cầu. * **Headless Mode:** Chế độ không đầu (chạy trình duyệt ẩn). * **CSS Selector:** Bộ chọn CSS (để chọn các phần tử HTML cụ thể). This comprehensive example should give you a solid foundation for building your Playwright-based web scraper with SSE and a basic MCP. Remember to adapt the code to your specific needs and website structure. Good luck!

mcp-metricool

MCP server for Metricool — schedule social media posts, get analytics, and find optimal posting times.

shortcuts-mcp-server

shortcuts-mcp-server

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.

Package README Core MCP Server

Intelligently detects package managers and provides unified access to documentation and information across 15+ package ecosystems including npm, PyPI, and others. Automatically routes requests to appropriate package-specific MCP servers for README retrieval, package information, and cross-ecosystem package search.

mcp-tw-company

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

waterloo-learn-mcp

An MCP server that gives desktop AI apps access to your Waterloo LEARN courses, enabling listing courses, getting announcements, content, grades, and upcoming events through natural language.

websearch-mcp

A self-hosted MCP server that gives AI agents deep internet research capabilities — no API keys required, powered by SearxNG, Playwright, and Docker.

taskmaster-mcp

MCP server providing Jira tools to fetch, create, update tickets, manage attachments, and generate AI-powered ticket content.

you-need-an-advisor-mcp

An MCP server that connects AI assistants to YNAB budgets, enabling natural language queries about finances backed by full API coverage and built-in YNAB methodology knowledge.

SQLx MCP Server

Provides comprehensive database management tools for PostgreSQL, MySQL, and SQLite databases. Enables querying table structures, executing read-only and write queries, exporting DDL statements, and managing database metadata through natural language.

ts-mcp-durable-browser-automation

MCP server for robust browser automation of legacy web portals, featuring exactly-once execution via an SQLite-backed idempotency lock and resilient Playwright locators.

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.

Thrive MCP API Server

A remote MCP server that can be deployed on Cloudflare Workers, using OAuth authentication and SSE transport for tool invocation.

ModelSim MCP Server

Exposes ModelSim/QuestaSim command-line tools as 57 MCP tools for FPGA simulation automation, covering library management, compilation, simulation, waveform analysis, and coverage collection.

Google Search Console MCP Server

Enables AI agents to query Google Search Console data including search analytics, URL inspection, sitemap management, and site performance monitoring, with per-user OAuth authentication.

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.

Librarian

Provides AI agents with persistent knowledge storage, enabling them to store, search, and retrieve text, documents, and files using semantic and keyword search via MCP tools.