Discover Awesome MCP Servers

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.

JetsonMCP

Connects AI assistants to NVIDIA Jetson Nano systems for edge computing management, enabling natural language control of AI workloads, hardware optimization, and system administration tasks.

mcp-confluent

Una implementación de servidor MCP construida para interactuar con las API REST de Confluent Kafka y Confluent Cloud.

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.

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.

Enrichment MCP Server

A Model Context Protocol server that enables users to perform third-party enrichment lookups for security observables (IP addresses, domains, URLs, emails) through services like VirusTotal, Shodan, and others.

Union MCP

Un servidor MCP que permite a los modelos Claude usar tareas, flujos de trabajo y aplicaciones de Union como herramientas en las conversaciones.

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.

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.

Chuk Design System

Provides access to a universal design token system with 7 pre-built themes (colors, typography, spacing, motion) and multi-format export capabilities for Canva, Remotion, PPTX, CSS, and W3C JSON.

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

shortcuts-mcp-server

MCP Remote Server

Enables execution of SSH commands on remote servers and management of Google Cloud Platform (GCE) instances through Cursor IDE.

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.

chromium-arm64

MCP server that enables browser automation and web testing on ARM64 devices like Raspberry Pi, allowing users to navigate websites, take screenshots, execute JavaScript, and perform UI testing via Claude.

Weather MCP Server

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

A Simple MCP Server and Client

Okay, here's a simple example of an MCP (Minecraft Communications Protocol) client and server in Python. This is a very basic illustration and doesn't cover all the complexities of a real MCP implementation. It focuses on establishing a connection, sending a simple message, and receiving a response. **Important Considerations:** * **Security:** This example is *not* secure. It transmits data in plain text. For any real-world application, you'd need to implement proper encryption (e.g., TLS/SSL). * **Error Handling:** The error handling is minimal. A robust implementation would need more comprehensive error checking and recovery. * **MCP Complexity:** Real MCP involves much more complex data structures, authentication, and message types. This is a simplified demonstration. * **Dependencies:** This example uses the standard `socket` library, which is built into Python. **Server (server.py):** ```python import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 25565 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break decoded_data = data.decode('utf-8') print(f"Received: {decoded_data}") # Simple response response = f"Server received: {decoded_data}".encode('utf-8') conn.sendall(response) ``` **Client (client.py):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 25565 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) message = "Hello, MCP Server!".encode('utf-8') s.sendall(message) data = s.recv(1024) print(f"Received: {data.decode('utf-8')}") ``` **How to Run:** 1. **Save:** Save the code as `server.py` and `client.py`. 2. **Run the Server:** Open a terminal or command prompt and run `python server.py`. The server will start listening for connections. 3. **Run the Client:** Open *another* terminal or command prompt and run `python client.py`. The client will connect to the server, send a message, and receive a response. **Explanation:** * **`socket.socket(socket.AF_INET, socket.SOCK_STREAM)`:** Creates a socket object. * `AF_INET`: Specifies the IPv4 address family. * `SOCK_STREAM`: Specifies a TCP socket (reliable, connection-oriented). * **`s.bind((HOST, PORT))` (Server):** Binds the socket to a specific address and port. * **`s.listen()` (Server):** Starts listening for incoming connections. * **`s.accept()` (Server):** Accepts a connection. This blocks until a client connects. It returns a new socket object (`conn`) representing the connection and the client's address (`addr`). * **`s.connect((HOST, PORT))` (Client):** Connects to the server at the specified address and port. * **`conn.recv(1024)` (Server & Client):** Receives data from the socket. The `1024` specifies the maximum number of bytes to receive at once. * **`conn.sendall(message)` (Server & Client):** Sends data to the socket. `sendall` ensures that all data is sent. * **`data.decode('utf-8')`:** Decodes the received bytes into a string using UTF-8 encoding. * **`message.encode('utf-8')`:** Encodes the string into bytes using UTF-8 encoding before sending. **Spanish Translation of Explanation:** * **`socket.socket(socket.AF_INET, socket.SOCK_STREAM)`:** Crea un objeto socket. * `AF_INET`: Especifica la familia de direcciones IPv4. * `SOCK_STREAM`: Especifica un socket TCP (confiable, orientado a la conexión). * **`s.bind((HOST, PORT))` (Servidor):** Vincula el socket a una dirección y puerto específicos. * **`s.listen()` (Servidor):** Comienza a escuchar las conexiones entrantes. * **`s.accept()` (Servidor):** Acepta una conexión. Esto se bloquea hasta que un cliente se conecta. Devuelve un nuevo objeto socket (`conn`) que representa la conexión y la dirección del cliente (`addr`). * **`s.connect((HOST, PORT))` (Cliente):** Se conecta al servidor en la dirección y el puerto especificados. * **`conn.recv(1024)` (Servidor y Cliente):** Recibe datos del socket. El `1024` especifica el número máximo de bytes para recibir a la vez. * **`conn.sendall(message)` (Servidor y Cliente):** Envía datos al socket. `sendall` asegura que todos los datos se envíen. * **`data.decode('utf-8')`:** Decodifica los bytes recibidos en una cadena utilizando la codificación UTF-8. * **`message.encode('utf-8')`:** Codifica la cadena en bytes utilizando la codificación UTF-8 antes de enviar. **Spanish Translation of Important Considerations:** * **Seguridad:** Este ejemplo *no* es seguro. Transmite datos en texto plano. Para cualquier aplicación del mundo real, necesitaría implementar un cifrado adecuado (por ejemplo, TLS/SSL). * **Manejo de errores:** El manejo de errores es mínimo. Una implementación robusta necesitaría una verificación y recuperación de errores más completa. * **Complejidad de MCP:** El MCP real implica estructuras de datos, autenticación y tipos de mensajes mucho más complejos. Esta es una demostración simplificada. * **Dependencias:** Este ejemplo utiliza la biblioteca estándar `socket`, que está integrada en Python. This provides a basic foundation. To build a more realistic MCP implementation, you would need to define specific message formats, handle different message types, implement authentication, and add robust error handling. Remember to prioritize security in any real-world application.

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.

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

File System MCP Server

Espejo de

MCP Multi-Server System

A dual-server MCP system with PostgreSQL integration that provides financial tools (stock prices, portfolio calculation, financial news) on one server and utility tools (weather, time, data processing, text analysis) on another server.

PostgreSQL MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona acceso de solo lectura a bases de datos PostgreSQL, permitiendo a los LLM inspeccionar esquemas de bases de datos y ejecutar consultas de solo lectura.