Discover Awesome MCP Servers

Trino MCP Server

Enables database schema analysis and management for Trino servers through dynamic connections. Supports DDL validation, dependency analysis, schema documentation generation, and safe SQL execution with multiple concurrent connections.

qenex-pathfinder

Provides security scanning tools for Claude Code, enabling real-time vulnerability detection, code analysis, and rule explanations for codebases.

72bpm-leadgen-mcp-server

An MCP server that turns discovery → enrichment → scoring → outreach into callable tools, scoped to 72BPM's four practice areas.

Cost Explorer MCP

Estimates Claude API costs with interactive sliders, live comparison across five models, and returns the selected model to the conversation.

adclip

Generates ad creative (copy and images) from a structured JSON brief across Meta, Google, LinkedIn, and X formats. Includes self-review loops for policy compliance and variant scoring, and can run without API keys using Claude CLI.

Verificação de Identidade (Argentina)

Verifies a person's identity in Argentina by cross-checking provided data (DNI, name, birth, and address). Read-only MCP server with one tool, works with any MCP client over HTTP.

pa-dmv

Query Pennsylvania DMV data for EV adoption and vehicle registrations by county and ZIP code.

wiki-helper

Enables querying a Git-stored Markdown wiki by syncing, indexing, and providing tools to list, search, and read documents via MCP.

FireScrape MCP Server

Enables AI models to search the web using DuckDuckGo, scrape webpage content in markdown format, and browse/read local files for code analysis and debugging.

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.

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.

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.

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.

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

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

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.

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.

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.

Stripe MCP Server

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

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.

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.

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.

Tenjin MCP Server

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

mcp-server-redmine

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

Fetch MCP Server

## Playwright, SSE MCP Server, and Node.js Express.js: Fetching URLs from a Webpage Here's a breakdown of how you can fetch URLs from a webpage using Playwright, stream them to a client using Server-Sent Events (SSE) with an MCP (Message Channel Protocol) server, and manage the server with Node.js and Express.js. This example focuses on the core logic and assumes you have basic familiarity with these technologies. **1. Project Setup:** ```bash mkdir playwright-sse-example cd playwright-sse-example npm init -y npm install playwright express sse-channel ``` **2. `server.js` (Node.js Express Server with SSE and Playwright):** ```javascript const express = require('express'); const { chromium } = require('playwright'); const SSE = require('sse-channel'); const app = express(); const port = 3000; // SSE Channel const channel = new SSE({ pingInterval: 30000 // Optional: Send a ping every 30 seconds to keep the connection alive }); // Express Middleware to handle SSE requests app.get('/stream', channel.middleware); // Route to trigger Playwright and stream URLs app.get('/fetch-urls', async (req, res) => { const urlToScrape = req.query.url; // Get the URL from the query parameter if (!urlToScrape) { return res.status(400).send('Missing URL parameter. Please provide a URL like: /fetch-urls?url=https://example.com'); } try { // Launch Playwright const browser = await chromium.launch(); const page = await browser.newPage(); // Navigate to the URL await page.goto(urlToScrape); // Extract URLs (Adjust the selector as needed) const urls = await page.evaluate(() => { const links = Array.from(document.querySelectorAll('a')); // Select all <a> tags return links.map(link => link.href); }); // Stream URLs via SSE for (const url of urls) { channel.send({ data: url }); } // Close the browser await browser.close(); // Send a completion message channel.send({ data: 'DONE' }); console.log('Finished scraping and streaming URLs.'); } catch (error) { console.error('Error during scraping:', error); channel.send({ data: `ERROR: ${error.message}` }); res.status(500).send(`Error: ${error.message}`); // Also send an error to the initial request } }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **3. `client.html` (Simple HTML Client to Receive SSE):** ```html <!DOCTYPE html> <html> <head> <title>SSE Client</title> </head> <body> <h1>SSE URL Stream</h1> <ul id="urlList"></ul> <script> const urlList = document.getElementById('urlList'); const eventSource = new EventSource('http://localhost:3000/stream'); // Connect to the SSE endpoint eventSource.onmessage = (event) => { const data = event.data; if (data === 'DONE') { const listItem = document.createElement('li'); listItem.textContent = 'Scraping Complete!'; urlList.appendChild(listItem); eventSource.close(); // Close the connection when done } else if (data.startsWith('ERROR:')) { const listItem = document.createElement('li'); listItem.textContent = `Error: ${data.substring(7)}`; // Remove "ERROR: " prefix urlList.appendChild(listItem); eventSource.close(); // Close the connection on error } else { const listItem = document.createElement('li'); listItem.textContent = data; urlList.appendChild(listItem); } }; eventSource.onerror = (error) => { console.error('SSE error:', error); const listItem = document.createElement('li'); listItem.textContent = 'SSE Connection Error'; urlList.appendChild(listItem); eventSource.close(); }; // Function to start the scraping process function startScraping(url) { fetch(`http://localhost:3000/fetch-urls?url=${url}`) .then(response => { if (!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } console.log('Scraping started...'); }) .catch(error => { console.error('Error starting scraping:', error); const listItem = document.createElement('li'); listItem.textContent = `Error starting scraping: ${error.message}`; urlList.appendChild(listItem); eventSource.close(); }); } // Example usage: Start scraping when the page loads window.onload = () => { const urlToScrape = prompt("Enter the URL to scrape:"); if (urlToScrape) { startScraping(urlToScrape); } else { alert("No URL provided. Please refresh the page and enter a URL."); } }; </script> </body> </html> ``` **Explanation:** 1. **`server.js`:** - **Imports:** Imports `express`, `playwright`, and `sse-channel`. - **SSE Channel:** Creates an `SSE` channel to manage the streaming of data. The `pingInterval` is optional but recommended to prevent the connection from timing out. - **SSE Middleware:** Registers the `channel.middleware` to handle SSE requests on the `/stream` endpoint. This sets the correct headers for SSE. - **`/fetch-urls` Route:** - **URL Parameter:** Gets the URL to scrape from the `url` query parameter. Handles the case where the URL is missing. - **Playwright Launch:** Launches a Chromium browser instance using Playwright. - **Page Navigation:** Navigates the page to the specified URL. - **URL Extraction:** Uses `page.evaluate` to run JavaScript code within the browser context. This code selects all `<a>` tags and extracts their `href` attributes (the URLs). **Important:** Adjust the `document.querySelectorAll('a')` selector to match the specific HTML structure of the website you are scraping. You might need to use more specific CSS selectors to target the correct links. - **SSE Streaming:** Iterates through the extracted URLs and sends each one as a separate SSE event using `channel.send({ data: url })`. The `data` field is the content of the SSE event. - **Browser Closure:** Closes the Playwright browser instance to release resources. - **Completion Message:** Sends a `DONE` message via SSE to signal the end of the scraping process. - **Error Handling:** Includes a `try...catch` block to handle potential errors during scraping. Sends an `ERROR` message via SSE and also sends an HTTP error response to the initial request. - **Express Server:** Starts the Express server on port 3000. 2. **`client.html`:** - **SSE Connection:** Creates an `EventSource` object to connect to the `/stream` endpoint on the server. This establishes the SSE connection. - **`onmessage` Handler:** This function is called whenever the server sends a new SSE event. - **Data Handling:** It extracts the `data` from the event. - **URL Display:** It creates a new list item (`<li>`) and adds the URL to the `urlList` (the `<ul>` element in the HTML). - **Completion Handling:** If the data is `DONE`, it adds a "Scraping Complete!" message to the list and closes the `EventSource` connection. - **Error Handling:** If the data starts with `ERROR:`, it displays the error message and closes the `EventSource` connection. - **`onerror` Handler:** This function is called if there's an error with the SSE connection itself. It displays an error message and closes the connection. - **`startScraping` Function:** This function initiates the scraping process by making a `fetch` request to the `/fetch-urls` endpoint on the server, passing the URL to scrape as a query parameter. It handles potential errors during the initial request. - **`window.onload`:** This ensures that the scraping process starts when the page has fully loaded. It prompts the user to enter the URL to scrape. **How to Run:** 1. **Install Dependencies:** `npm install` in the project directory. 2. **Start the Server:** `node server.js` 3. **Open `client.html` in your browser.** The browser will prompt you for the URL to scrape. Enter a URL (e.g., `https://www.example.com`). 4. **Observe the Results:** The URLs extracted from the webpage will be displayed in the `urlList` in the browser. **Key Improvements and Considerations:** * **Error Handling:** The code includes more robust error handling, both on the server and the client. It sends error messages via SSE and also provides HTTP error responses. * **URL Parameter:** The server now expects the URL to scrape as a query parameter (e.g., `/fetch-urls?url=https://example.com`). This is a more standard way to pass data to a server. * **Client-Side Scraping Initiation:** The client now initiates the scraping process by making a `fetch` request to the server. This allows the server to handle the Playwright logic and stream the results back to the client. * **`DONE` Message:** The server sends a `DONE` message via SSE to signal the end of the scraping process. The client uses this message to close the SSE connection and display a completion message. * **`pingInterval`:** The `pingInterval` in the `SSE` constructor helps keep the SSE connection alive, especially for long-running scraping tasks. * **Selector Adjustment:** **Crucially, you'll need to adjust the CSS selector in the `page.evaluate` function to match the specific HTML structure of the website you are scraping.** The example uses `document.querySelectorAll('a')`, which selects all `<a>` tags. You might need to use more specific selectors to target the correct links. Use your browser's developer tools to inspect the HTML and determine the appropriate selector. * **Rate Limiting:** Be mindful of rate limiting when scraping websites. Implement delays between requests to avoid overloading the server. Playwright provides mechanisms for this. * **Asynchronous Operations:** The code uses `async/await` to handle asynchronous operations, making the code more readable and easier to manage. * **Resource Management:** The Playwright browser instance is closed after the scraping is complete to release resources. * **Security:** Be careful when scraping websites. Respect the website's `robots.txt` file and avoid scraping sensitive information. Sanitize the URLs before displaying them on the client to prevent XSS vulnerabilities. * **MCP (Message Channel Protocol):** The original request mentioned MCP. While SSE is a simpler solution for streaming data from the server to the client, MCP provides a more robust and bidirectional communication channel. If you need more complex communication patterns (e.g., the client sending commands to the server to control the scraping process), you might consider using a library like `socket.io` or `ws` (WebSockets) instead of SSE. However, for the basic task of streaming URLs, SSE is generally sufficient. Implementing a full MCP server is beyond the scope of this example. * **Scalability:** For high-volume scraping, consider using a message queue (e.g., RabbitMQ, Kafka) to distribute the scraping tasks across multiple workers. **Korean Translation of Key Concepts:** * **Playwright:** 플레이라이트 * **Server-Sent Events (SSE):** 서버 전송 이벤트 * **Message Channel Protocol (MCP):** 메시지 채널 프로토콜 * **Node.js:** 노드제이에스 * **Express.js:** 익스프레스제이에스 * **URL:** URL (유알엘) * **Scraping:** 스크래핑 (웹 스크래핑) * **Endpoint:** 엔드포인트 * **Query Parameter:** 쿼리 파라미터 * **CSS Selector:** CSS 선택자 * **Asynchronous:** 비동기 * **Rate Limiting:** 속도 제한 * **Error Handling:** 오류 처리 * **Resource Management:** 자원 관리 * **Security:** 보안 This comprehensive example provides a solid foundation for building a URL scraper using Playwright, SSE, and Node.js. Remember to adapt the code to your specific needs and always respect the terms of service of the websites you are scraping.

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.

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.

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.