Discover Awesome MCP Servers

Lightbrush Booking Agent MCP

A development framework for restaurant booking automation that is currently only ~5% functional with mock implementations. The actual booking functionality, MCP integration, and web automation features are not yet implemented.

mcp-http

Provides a generic HTTP client tool allowing AI agents to make arbitrary HTTP requests from their environment, with support for environment-variable placeholders for secrets.

Memex-Wiki MCP Server

Provides AI agents with a secure offline-first long-term memory system using Obsidian Markdown vault and 3D knowledge graph, with RLM-based querying to avoid context overload.

vision-mcp

Enables text-only LLMs to see images/videos via cloud vision models, offering vision chat, OCR, grounding, and media info tools with free GLM fallback.

DAV MCP Server

A Model Context Protocol server that allows users to interact with their CalDAV, CardDAV, and WebDAV services (calendars, contacts, and files) from Fastmail and Apple iCloud accounts.

CST MCP

An MCP server that integrates CST Studio Suite with the Model Context Protocol to enable automated electromagnetic simulation workflows. It provides specialized tools for material definition management and direct interaction with the CST Studio Suite environment.

mcp-watchmode

Provides streaming availability data across 200+ services, including title search, releases, and title catalog.

MonkeyMCP

This MCP server provides tools to retrieve monkey data and generate unique simulated journeys with species-specific activities and health statistics, enabling interaction with monkey-related information and simulations.

mcp-permid

Provides access to Refinitiv/LSEG Permanent Identifiers (PermID) through an MCP gateway, enabling AI agents to query financial instrument and entity data via natural language or direct tool calls.

mcp-pionex

Enables AI assistants to interact with the Pionex exchange through MCP, providing market data, account info, spot trading, grid bots, and Dual Investment tools with strict anti-hallucination guardrails including two-phase order confirmation and live symbol/price validation.

Stripe MCP Server

Enables natural language interaction with Stripe accounts to query customers, revenue, invoices, subscriptions, disputes, and issue refunds.

skillhub-mcp

Bridges Claude-style skills to MCP tools, enabling any MCP client to call the same skills for cross-client reuse and flexible packaging.

mcp-server-redmine

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

Tenjin MCP Server

Enables agents to discover, read, buy, and publish knowledge using USDC on Base, with search and free essays at no cost.

OpenAPI MCP

A generic MCP server that builds its tools at runtime from any OpenAPI specification, enabling interaction with any REST API through natural language.

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 Protocol) 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 from clients (e.g., a web browser or another application). This server will: * Receive requests to start the URL fetching process. * Orchestrate the Playwright scraping. * Send progress updates and results back to the client using Server-Sent Events (SSE). 3. **SSE (Server-Sent Events):** SSE is a one-way communication protocol where the server pushes updates to the client in real-time. This is ideal for providing progress updates as the scraping happens. 4. **MCP (Management Control Protocol):** The term "MCP" is a bit vague in this context. I'm assuming it refers to a system or protocol for managing and controlling the scraping process. In this example, I'll treat it as a way to send commands to the server (e.g., "start scraping," "stop scraping," "set target URL"). You might need to adapt this part based on the specifics of your MCP implementation. **Code Example (Illustrative)** **1. Project Setup** ```bash mkdir playwright-sse-scraper cd playwright-sse-scraper npm init -y npm install express playwright eventsource ``` **2. `server.js` (Node.js/Express.js Server)** ```javascript const express = require('express'); const { chromium } = require('playwright'); const EventEmitter = require('events'); const app = express(); const port = 3000; app.use(express.json()); // For parsing JSON request bodies // Event emitter for SSE updates const sseEmitter = new EventEmitter(); let browser = null; // Playwright browser instance let page = null; // Playwright page instance let isScraping = false; let targetUrl = ''; let scrapedUrls = []; // Function to start Playwright and navigate to the target URL async function initializePlaywright(url) { try { browser = await chromium.launch({ headless: true }); // Or false for debugging page = await browser.newPage(); await page.goto(url); return true; } catch (error) { console.error("Error initializing Playwright:", error); sseEmitter.emit('update', { type: 'error', message: `Playwright initialization failed: ${error.message}` }); return false; } } // Function to extract URLs from the page async function extractUrls() { try { const urls = await page.evaluate(() => { const links = Array.from(document.querySelectorAll('a')); return links.map(link => link.href); }); return urls; } catch (error) { console.error("Error extracting URLs:", error); sseEmitter.emit('update', { type: 'error', message: `URL extraction failed: ${error.message}` }); return []; } } // Function to scrape URLs async function scrape(url) { if (!isScraping) { sseEmitter.emit('update', { type: 'status', message: 'Scraping stopped.' }); return; } if (!browser || !page) { const initialized = await initializePlaywright(url); if (!initialized) { isScraping = false; return; } } sseEmitter.emit('update', { type: 'status', message: 'Scraping in progress...' }); try { const newUrls = await extractUrls(); scrapedUrls = [...new Set([...scrapedUrls, ...newUrls])]; // Deduplicate sseEmitter.emit('update', { type: 'urls', urls: newUrls }); sseEmitter.emit('update', { type: 'status', message: `Found ${newUrls.length} new URLs. Total: ${scrapedUrls.length}` }); // Example: Scroll down to load more content (adjust as needed) await page.evaluate(() => { window.scrollBy(0, window.innerHeight); }); await page.waitForTimeout(2000); // Wait for content to load if (isScraping) { scrape(url); // Recursive call to continue scraping } else { sseEmitter.emit('update', { type: 'status', message: 'Scraping completed.' }); await browser.close(); browser = null; page = null; } } catch (error) { console.error("Scraping error:", error); sseEmitter.emit('update', { type: 'error', message: `Scraping failed: ${error.message}` }); isScraping = false; if (browser) { await browser.close(); browser = null; page = null; } } } // 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(); const listener = (data) => { res.write(`data: ${JSON.stringify(data)}\n\n`); }; sseEmitter.on('update', listener); req.on('close', () => { sseEmitter.removeListener('update', listener); console.log('Client disconnected'); }); }); // MCP-like endpoints (adjust to your MCP) app.post('/mcp/start', (req, res) => { targetUrl = req.body.url; if (!targetUrl) { return res.status(400).send({ error: 'URL is required' }); } if (isScraping) { return res.status(400).send({ error: 'Scraping already in progress' }); } isScraping = true; scrapedUrls = []; // Reset scraped URLs scrape(targetUrl); res.send({ message: 'Scraping started' }); }); app.post('/mcp/stop', (req, res) => { isScraping = false; res.send({ message: 'Scraping stopped' }); }); app.get('/mcp/status', (req, res) => { res.send({ isScraping: isScraping, targetUrl: targetUrl, scrapedUrls: scrapedUrls.length }); }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **3. `index.html` (Client-side Example)** ```html <!DOCTYPE html> <html> <head> <title>Playwright SSE Scraper</title> </head> <body> <h1>Playwright SSE Scraper</h1> <label for="url">URL:</label> <input type="text" id="url" value="https://example.com"><br><br> <button id="startButton">Start Scraping</button> <button id="stopButton">Stop Scraping</button> <h2>Status:</h2> <div id="status"></div> <h2>URLs:</h2> <ul id="urls"></ul> <script> const urlInput = document.getElementById('url'); const startButton = document.getElementById('startButton'); const stopButton = document.getElementById('stopButton'); const statusDiv = document.getElementById('status'); const urlsList = document.getElementById('urls'); let eventSource = null; startButton.addEventListener('click', () => { const url = urlInput.value; startScraping(url); }); stopButton.addEventListener('click', () => { stopScraping(); }); function startScraping(url) { fetch('/mcp/start', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ url: url }) }) .then(response => response.json()) .then(data => { console.log(data); connectToSSE(); }) .catch(error => { console.error('Error starting scraping:', error); statusDiv.textContent = `Error starting scraping: ${error}`; }); } function stopScraping() { fetch('/mcp/stop', { method: 'POST' }) .then(response => response.json()) .then(data => { console.log(data); if (eventSource) { eventSource.close(); eventSource = null; } }) .catch(error => { console.error('Error stopping scraping:', error); statusDiv.textContent = `Error stopping scraping: ${error}`; }); } function connectToSSE() { if (eventSource) { eventSource.close(); } eventSource = new EventSource('/events'); eventSource.onmessage = (event) => { const data = JSON.parse(event.data); console.log('Received SSE event:', data); switch (data.type) { case 'status': statusDiv.textContent = data.message; break; case 'urls': data.urls.forEach(url => { const li = document.createElement('li'); li.textContent = url; urlsList.appendChild(li); }); break; case 'error': statusDiv.textContent = `Error: ${data.message}`; break; } }; eventSource.onerror = (error) => { console.error('SSE error:', error); statusDiv.textContent = `SSE error: ${error}`; eventSource.close(); eventSource = null; }; } </script> </body> </html> ``` **Explanation** * **`server.js`:** * Sets up an Express.js server. * Uses `playwright` to launch a Chromium browser and navigate to the target URL. * `extractUrls()` uses `page.evaluate()` to run JavaScript code within the browser context to extract all `href` attributes from `<a>` tags. * The `/events` endpoint sets up the SSE connection. It sends updates as `data: JSON.stringify(data)\n\n`. * The `/mcp/start` endpoint receives the target URL, starts the Playwright scraping process, and resets the `scrapedUrls` array. * The `/mcp/stop` endpoint sets `isScraping` to `false`, which will stop the scraping loop. * The `/mcp/status` endpoint provides the current status of the scraper. * The `scrape()` function is recursive. It extracts URLs, scrolls down (to load more content), waits, and then calls itself again if `isScraping` is still true. This creates a continuous scraping loop. * Error handling is included to catch Playwright errors and send error messages via SSE. * The `EventEmitter` is used to manage SSE updates. * **`index.html`:** * Provides a simple user interface with a URL input, start/stop buttons, a status display, and a list to show the extracted URLs. * Uses JavaScript to: * Send POST requests to `/mcp/start` and `/mcp/stop` to control the scraping process. * Connect to the `/events` SSE endpoint using `EventSource`. * Update the UI based on the SSE messages received from the server. **How to Run** 1. Save the code as `server.js` and `index.html` in your `playwright-sse-scraper` directory. 2. Run `node server.js` in your terminal. 3. Open `index.html` in your web browser (usually `http://localhost:3000`). 4. Enter a URL in the input field and click "Start Scraping." 5. Click "Stop Scraping" to halt the process. **Important Considerations and Improvements** * **Error Handling:** The error handling in the example is basic. You should add more robust error handling, logging, and retry mechanisms. * **Rate Limiting:** Be very careful not to overload the target website. Implement delays and respect `robots.txt`. Consider using a proxy server to avoid getting your IP address blocked. * **`robots.txt`:** Always check the `robots.txt` file of the target website to see which pages are allowed to be scraped. Respect the rules. * **Dynamic Content:** If the website uses a lot of JavaScript to load content dynamically, you might need to use `page.waitForSelector()` or `page.waitForTimeout()` to wait for elements to appear before extracting URLs. * **Selectors:** The `document.querySelectorAll('a')` selector is very basic. You might need to use more specific CSS selectors to target the URLs you want to extract. * **Headless Mode:** `headless: true` runs the browser in the background. Set it to `false` for debugging. * **Scalability:** For large-scale scraping, consider using a more robust queueing system (e.g., Redis, RabbitMQ) and running multiple Playwright instances in parallel. * **MCP Integration:** Adapt the `/mcp/*` endpoints to match the specific commands and data format of your MCP system. * **Data Storage:** Instead of just displaying the URLs in the browser, you'll likely want to store them in a database or file. * **Authentication:** If the target website requires authentication, you'll need to handle login using Playwright. * **Legal and Ethical Considerations:** Make sure you have the right to scrape the website. Be transparent about your scraping activities. Don't scrape personal information without consent. This comprehensive example should give you a solid foundation for building your Playwright-based URL scraper with SSE and Node.js. Remember to adapt the code to your specific needs and always be ethical and responsible when scraping websites.

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.

iris

Enables AI agents to create, list, update, and delete Microsoft 365 email drafts, with a hard guarantee that no message can be sent automatically, ensuring human review before any email goes out.

mcp-web-calc

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

mcp-week-day

A minimal MCP server that exposes a single tool, day_in_week, to return the current weekday name.

Marketo MCP Server

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

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.

taskmaster-mcp

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

feedly-mcp

Enables Claude to read your Feedly subscriptions via a local stdio server, listing folders and feeds, fetching recent articles, checking unread counts, searching for new feeds, and optionally marking items as read while keeping your API token on your machine.

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-metricool

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

MCP server for LogSeq

Interacts with LogSeq via its API.

machine-maintenance-agent

Enables agents to inspect machine status and sensor anomalies, search maintenance guidance, and create maintenance tickets through controlled MCP tools.

Inkeep MCP Server for Vercel

Enables asking questions and performing semantic searches against an Inkeep knowledge base. Deployable to Vercel with Next.js.