MCP Servers

Discover Awesome MCP Servers

Extend your agent with 28,691 capabilities via MCP servers.

All28,691

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.

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.

Spotify MCP Node Server

Enables AI assistants to control Spotify playback, manage playlists, search music, and access listening history. Requires Spotify Premium and uses secure OAuth 2.0 with PKCE authentication.

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.

mcp_server

Here are a few ways to translate "MCP server for LLM integration" into Spanish, depending on the specific context: **General Options:** * **Servidor MCP para la integración de LLM:** This is a direct translation and is generally understood. "LLM" is often used as is, even in Spanish-speaking contexts, especially in technical discussions. * **Servidor MCP para integrar LLM:** This is a slightly more concise version, using the infinitive "integrar" (to integrate). **More Specific Options (depending on what "MCP" and "LLM" refer to):** * If "MCP" refers to a specific platform or technology, replace "MCP" with its Spanish equivalent or the original acronym if it's commonly used. For example, if MCP is "Media Control Platform," you might say: "Servidor de la Plataforma de Control de Medios para la integración de LLM." * If "LLM" refers to a specific Large Language Model, you might replace it with its Spanish name (if it has one) or a more descriptive term. For example, if you want to be more explicit: "Servidor MCP para la integración de modelos de lenguaje grandes." **Therefore, the best option depends on the context. However, the most common and generally understandable translation is:** * **Servidor MCP para la integración de LLM** If you can provide more context about what "MCP" and "LLM" refer to, I can give you a more precise translation.

shortcuts-mcp-server

Gmail Notes Server

A TypeScript-based MCP server built on the Gmail API that implements a simple notes system. It enables users to create, manage, and summarize text-based notes through specialized resources and tools.

Precision astronomical ephemeris and planetary positions via the Swiss Ephemeris.

A self-contained MCP server that gives AI agents the ability to calculate high-precision astronomical data. It provides tropical zodiac coordinates, planetary speeds, retrograde detection, and house cusps using the trusted Swiss Ephemeris engine. 100%

Meeting Scheduler

Automates meeting logistics with tools for scheduling, availability checking, slot finding, timezone conversion, and recurring date generation. Eliminates the need for custom calendar logic by providing validated time operations and formatted invitations for applications and AI assistants.

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.

Weather MCP Server

A Model Context Protocol server that provides weather information and forecasts based on user location or address input.

Firebase Live MCP Server

Enables querying and management of live Firebase projects, providing access to Firestore collections and documents. It also allows users to retrieve and filter Cloud Function logs directly through the Model Context Protocol.

Shortlist MCP Server

Enables users to search for jobs, prefill applications using AI, and automate submissions across major platforms like Lever and Ashby directly from Claude or Cursor. It provides a full suite of tools for managing job queues, profile data, and resumes within a chat interface.

MCP Synth Controller

Enables LLMs to control synthesizer parameters in real-time by translating natural language commands into OSC messages sent to a JUCE synthesizer application.

Mcp Server Code Analyzer

stackzero-labs/mcp

A model context protocol server that enables applications to use stackzero-labs/ui components through the MCP protocol, supporting both standalone operation and integration with Claude Desktop and Cursor.

ynab-mcp-server

Espejo de

MCP API Server Template

MCP Meeting Summary System

An AI-powered meeting assistant that combines FastAPI backend with React frontend to generate high-quality meeting summaries and provide Q&A functionality using OpenAI and Selenium.

TG_MCP

A lightweight Python interface that exposes TigerGraph database operations as structured tools and URI-based resources for Claude and other MCP agents.

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.

smaregi-mcp

Enables interaction with the Smaregi POS API to manage products, sales, inventory, and member information directly through Claude Code. It provides a suite of CRUD tools and comprehensive API documentation to streamline retail management via natural language.

MCPGex

Enables LLMs to systematically develop and validate regex patterns by defining test cases with expected matches, testing patterns against them, and iteratively refining until all requirements are satisfied.

Valkey MCP Task Management Server

Enables AI agents to create, manage, and track tasks within plans using Valkey as the persistence layer. Supports plan and task management with Markdown notes, status tracking, and prioritization through multiple transport protocols (SSE, Streamable HTTP, STDIO).

Pagos Data MCP Server

Enables Claude to retrieve BIN (Bank Identification Number) data for payment cards, with options for basic or enhanced insights through the Pagos API.

Persistent Shell MCP

Enables AI assistants to execute shell commands and manage long-running processes within persistent tmux sessions across isolated workspaces. It features a dual-window architecture to separate raw command execution from interactive terminal output.

ZBD MCP Server

A server that adds Bitcoin payment capabilities to LLMs, enabling sending/receiving payments, creating charges, managing wallets, and performing other Bitcoin Lightning Network operations.

Stellar MCP

Enables interaction with Stellar Classic and Soroban smart contracts, allowing users to manage accounts, process payments, and handle asset operations. It provides comprehensive tools for building, deploying, and retrieving the interfaces of smart contracts on the Stellar network.

Decodo MCP Server

Enables web scraping and data extraction from websites with geographic flexibility, privacy features, and anti-detection capabilities. Supports scraping general websites, Google Search, Amazon Search, and Reddit with customizable parameters for rendering, geolocation, and locale.

MCP Server Markup Language (MCPML)

MCP Server Markup Language (MCPML) - Un marco de Python para construir servidores MCP con soporte para CLI y Agente OpenAI.