Discover Awesome MCP Servers

OpenViking MCP

Provides AI assistants with access to the OpenViking knowledge base for semantic search, document reading, and full-text retrieval. It enables vector-based intelligence, L0/L1 summaries, and glob-based pattern matching for local documentation.

shortcuts-mcp-server

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.

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 Weather Notes Server

Provides real-time weather data from Open-Meteo API and enables creating and retrieving notes stored locally in JSON format.

Acumatica MCP Server by CData

This read-only MCP Server allows you to connect to Acumatica data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

API MCP Server

A TypeScript-based MCP server that implements a simple notes system, providing resources for accessing notes via URIs, tools for creating notes, and prompts for generating summaries.

SuperMemory MCP

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

DDG MCP2

A basic MCP server template built with FastMCP framework that provides example tools for echoing messages and retrieving server information. Serves as a starting point for developing custom MCP servers with Docker support and CI/CD integration.

Azure DevOps MCP Proxy

Enables interaction with Azure DevOps through Personal Access Token authentication. Supports work item management, wiki operations, project/repository listing, and build pipeline access through natural language.

Neo4j MCP Clients & Servers

Model Context Protocol with Neo4j

XML Documents MCP Server by CData

XML Documents MCP Server by CData

MCP server for LogSeq

Interacts with LogSeq via its API.

Claude Kali MCP Commander

An MCP server that provides secure access to Kali Linux cybersecurity tools through Claude's interface, enabling users to run Kali Linux commands directly from Claude Desktop.

CockroachDB MCP Server

The CockroachDB MCP Server is a natural language interface designed for agentic applications and LLMs to manage, monitor and query data in CockroachDB.

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.

Axivion MISRA C:2012 Compliance Agent

An MCP server that integrates with GitHub Copilot to analyze Axivion static-analysis reports and provide MISRA C:2012 compliance assistance. It offers deep rule explanations, rationale, and confidence-scored fix suggestions for identified code violations.

Engineering Standards MCP Server

Provides AI assistants with structured access to an organization's engineering standards, practices, and processes through searchable knowledge base with CRUD operations and multi-dimensional organization.

sl-test

sl-test

AI BBS

An MCP server that enables direct AI-to-AI communication through a bulletin board system featuring semantic search, thread management, and cryptographic identity verification. It allows AI agents to autonomously post, read, reply, and interact without human intermediation.

Letter Counter MCP Server

Un servidor MCP que permite a los LLM contar las ocurrencias de letras específicas dentro de las palabras, creado como un ejemplo de aprendizaje para el Protocolo de Contexto del Modelo.

Rongcloud Native

Native MCP Overview RongCloud Native MCP is a lightweight RongCloud IM service wrapper based on the MCP (Model Control Protocol) protocol. By directly wrapping the high-performance Rust IM SDK, it provides a simple and efficient instant messaging solution for client-side or local applications

MCP-Kit Developer Task Assignment System

Enables intelligent task assignment to developers using hybrid AI algorithms that match tasks based on past experience, skill sets, workload balance, and project alignment. Features enterprise-grade security with AES-256 encryption and 75% performance optimization through smart caching.

Meme MCP Server

A Model Context Protocol server for managing, searching, and retrieving local meme images. It automatically hosts memes via a built-in HTTP server to ensure images can be displayed within chat applications.

membase mcp server

Un servidor de Protocolo de Contexto de Modelo (MCP) que permite la interacción segura con Membase.

Zentao MCP Server

Enables AI assistants to manage Zentao bugs, requirements, and test cases through natural language interactions. It supports querying, creating, and updating various Zentao data entities including products, projects, and executions.