Discover Awesome MCP Servers

SEO MCP Connector

Local management console and permission wrapper for integrating Google Search Console, GA4, Bing Webmaster Tools, PageSpeed, and SEO analysis through a controlled MCP endpoint.

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.

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.

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, implement an SSE (Server-Sent Events) MCP (Message Channel Protocol - assuming you mean a custom protocol for communication) server, and integrate it with a Node.js Express.js application. I'll provide code snippets and explanations to guide you. **Conceptual Overview** 1. **Playwright (Web Scraping):** Playwright will be used to navigate to the target webpage, extract the URLs you need, and potentially handle pagination or dynamic content loading. 2. **Node.js/Express.js (Server):** Express.js will create a web server that serves the initial HTML page (if needed) and, more importantly, handles the SSE endpoint. 3. **SSE (Server-Sent Events):** SSE is a one-way communication protocol where the server pushes updates to the client (browser). In this case, the server will push the extracted URLs to the client as they are found. 4. **MCP (Custom Protocol - Assumed):** Since you mentioned MCP, I'm assuming you have a specific format or structure for the messages you want to send over the SSE connection. I'll provide a placeholder for you to adapt to your actual MCP requirements. If you don't have a specific MCP, you can simply send the URLs as JSON or plain text. **Code Example (with Explanations)** **1. Project Setup** ```bash mkdir playwright-sse-example cd playwright-sse-example 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 cors = require('cors'); const app = express(); const port = 3000; app.use(cors()); // Enable CORS for cross-origin requests (important for browser access) app.get('/sse', async (req, res) => { res.setHeader('Content-Type', 'text/event-stream'); res.setHeader('Cache-Control', 'no-cache'); res.setHeader('Connection', 'keep-alive'); res.flushHeaders(); // Send headers immediately let urlCount = 0; try { const browser = await chromium.launch({ headless: true }); // Or false for debugging const page = await browser.newPage(); await page.goto('https://example.com'); // Replace with your target URL // Function to extract URLs (adjust selector as needed) async function extractUrls() { const links = await page.$$eval('a', (anchors) => { return anchors.map((anchor) => anchor.href).filter(href => href); // Filter out empty hrefs }); return links; } // Function to send data via SSE (MCP placeholder) function sendData(url) { const mcpMessage = { type: 'url', data: url, }; // Format the SSE event const eventData = `data: ${JSON.stringify(mcpMessage)}\n\n`; res.write(eventData); urlCount++; } // Initial URL extraction const initialUrls = await extractUrls(); initialUrls.forEach(url => sendData(url)); // Example: Handle pagination (if needed) // This is a simplified example. You'll need to adapt it to your specific website's pagination. // It assumes there's a "next" button. // let nextPageButton = await page.$('a[rel="next"]'); // Example selector // while (nextPageButton) { // await nextPageButton.click(); // await page.waitForLoadState('networkidle'); // Wait for page to load // const newUrls = await extractUrls(); // newUrls.forEach(url => sendData(url)); // nextPageButton = await page.$('a[rel="next"]'); // } await browser.close(); console.log(`Sent ${urlCount} URLs`); res.write(`data: done\n\n`); // Signal completion res.end(); } catch (error) { console.error('Error during scraping:', error); res.write(`data: error: ${error.message}\n\n`); res.end(); } }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **3. `index.html` (Client-Side HTML - Optional)** This is a simple HTML page to connect to the SSE endpoint and display the received URLs. You can serve this using Express.js (see below). ```html <!DOCTYPE html> <html> <head> <title>SSE URL Fetcher</title> </head> <body> <h1>Fetched URLs</h1> <ul id="urlList"></ul> <script> const urlList = document.getElementById('urlList'); const eventSource = new EventSource('http://localhost:3000/sse'); // Adjust URL if needed eventSource.onmessage = (event) => { try { const mcpMessage = JSON.parse(event.data); if (mcpMessage.type === 'url') { const url = mcpMessage.data; const listItem = document.createElement('li'); listItem.textContent = url; urlList.appendChild(listItem); } else if (event.data === 'done') { console.log('Finished receiving URLs.'); eventSource.close(); // Close the connection } else if (event.data.startsWith('error:')) { console.error('Error from server:', event.data.substring(7)); eventSource.close(); } } catch (error) { console.error('Error parsing SSE data:', error); eventSource.close(); } }; eventSource.onerror = (error) => { console.error('SSE error:', error); eventSource.close(); }; </script> </body> </html> ``` **4. Serving the HTML (Add to `server.js`)** ```javascript // ... (previous server.js code) ... app.use(express.static('public')); // Serve static files from the 'public' directory // Create a 'public' directory and put index.html inside it. ``` **Explanation:** * **`server.js`:** * Sets up an Express.js server. * Defines an SSE endpoint (`/sse`). * Sets the necessary headers for SSE (`Content-Type`, `Cache-Control`, `Connection`). * Launches a Playwright browser. * Navigates to the target URL. * `extractUrls()`: This function uses Playwright's `$$eval` to extract all `href` attributes from `<a>` tags on the page. **Important:** Adjust the CSS selector (`'a'`) to match the specific HTML structure of the website you're scraping. You might need something more specific like `'div.link-container a'` or similar. * `sendData()`: This function formats the URL into an MCP message (JSON in this example) and sends it as an SSE event. **Adapt this to your actual MCP format.** * Handles pagination (example code, needs adaptation). * Closes the browser and signals completion to the client. * Error handling. * **`index.html`:** * Creates an `EventSource` to connect to the SSE endpoint. * Listens for `message` events from the server. * Parses the MCP message (JSON in this example). * Adds the extracted URLs to a list on the page. * Handles the `done` signal to close the connection. * Handles errors. **How to Run:** 1. Save the code as `server.js` and `index.html`. 2. Create a directory named `public` and put `index.html` inside it. 3. Run `node server.js` in your terminal. 4. Open `http://localhost:3000` in your browser. **Important Considerations and Adaptations:** * **Website Structure:** The most important part to adapt is the CSS selector used in `extractUrls()`. Inspect the HTML of the target website carefully to find the correct selector to extract the URLs you need. * **Pagination:** The pagination example is very basic. Most websites have more complex pagination schemes. You'll need to analyze the website's pagination and write code to correctly navigate through the pages. This might involve clicking "next" buttons, following numbered page links, or handling infinite scrolling. * **Dynamic Content:** If the website loads content dynamically (e.g., using JavaScript), you might need to use Playwright's `waitForSelector` or `waitForFunction` to wait for the content to load before extracting the URLs. * **Error Handling:** Implement robust error handling to catch exceptions during scraping and SSE communication. * **Rate Limiting:** Be respectful of the website's resources. Implement rate limiting to avoid overloading the server. You can use `await page.waitForTimeout(delay)` to introduce delays between requests. * **Headless Mode:** `headless: true` runs the browser in the background. Use `headless: false` for debugging to see the browser window. * **MCP Implementation:** Replace the JSON serialization in `sendData()` with your actual MCP encoding logic. * **CORS:** The `cors()` middleware is essential to allow your client-side JavaScript (running in the browser) to make requests to your server running on a different origin (localhost:3000). **Example of a more complex selector:** Let's say the URLs you want to extract are within `div` elements with the class `product-item`, and the links are inside `a` tags within those divs: ```javascript async function extractUrls() { const links = await page.$$eval('div.product-item a', (anchors) => { return anchors.map((anchor) => anchor.href).filter(href => href); }); return links; } ``` **Example of waiting for dynamic content:** ```javascript await page.goto('https://example.com'); await page.waitForSelector('.loaded-content'); // Wait for an element with class 'loaded-content' to appear const urls = await extractUrls(); ``` This comprehensive example should give you a solid foundation for building your Playwright-based URL scraper with SSE and Node.js/Express.js. Remember to adapt the code to the specific requirements of the website you're targeting and your MCP protocol.

mcp-web-calc

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

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.

mcp-obsidian

Connects AI assistants to Obsidian vaults via the Local REST API to search notes, retrieve content, and perform semantic searches. It features self-healing multi-URL connectivity and supports both stdio and HTTP transports for flexible deployment.

IELTS MCP Server

Connects Claude Desktop to Google Drive to access and analyze IELTS study materials without downloading, supporting PDFs, DOCX, and Google Docs.

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.

mcp-tw-company

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

SuperMemory MCP

A tool that makes memories stored in ChatGPT accessible across various language models without requiring logins or paywalls.

Cursor Talk to Figma MCP

Enables Cursor AI to communicate with Figma for reading designs and modifying them programmatically, allowing users to automate design tasks through natural language.

Roblox Studio MCP Server

A free, open-source MCP server that lets Claude, Cursor, Codex, or Gemini operate Roblox Studio — debug live playtests, bulk-edit places, and scaffold whole games — with a built-in safety layer.

portainer-mcp-server

MCP server for Portainer REST API that enables AI assistants to manage Docker containers, stacks, images, networks, and volumes through natural language.

advanced-gmail-mcp

A Gmail MCP server for Claude Code that enables full email management across multiple Gmail accounts, including tools for listing, searching, reading, sending, and organizing emails with OAuth2 authentication.

YokTez MCP

Enables searching the YÖK National Thesis Center and retrieving thesis contents in Markdown format for LLM applications. It allows users to perform detailed searches based on criteria like author, university, and subject while providing programmatic access to thesis metadata and PDF content.

flask-mcp-server

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

openapi-spec-mcp

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

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.

Echo MCP Server

Un servidor sencillo que implementa el Protocolo de Contexto de Modelo (MCP) que devuelve los mensajes, diseñado para probar clientes MCP.

enhanced-filesystem-mcp

High-performance MCP server giving AI agents advanced filesystem and automation capabilities on Windows, with 26 tools across file I/O, search, Git, process management, and more.

XML Documents MCP Server by CData

XML Documents MCP Server by CData

Pabal MCP

Manages App Store Connect and Google Play Console metadata, releases, and ASO workflows locally through MCP tools, enabling store management directly from AI clients without manual console navigation.

kongen-mcp

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

🚀 Go-Tapd-SDK

El Go Tapd SDK es una biblioteca cliente de Go para acceder a la API de Tapd, y también es compatible con el servidor MCP más reciente.

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.

MCP REST API Server

A server implementation of the Model Context Protocol (MCP) that provides REST API endpoints for managing and interacting with MCP resources.

Umbrella Terminal MCP

Provides access to 67 tools for querying Colorado legislative intelligence, including bills, statutes, rules, and campaign finance. It enables AI agents to analyze legislative attribution chains, stakeholder data, and legislator voting records.