Discover Awesome MCP Servers

Lead Stampede MCP Server

Exposes SMB business data as tools for AI agents, enabling retrieval of business profiles, services, availability, and reviews.

Analook

Remote MCP server for AI-powered competitor intelligence, enabling real-time analysis of any product URL through tools like analyze_competitor and report retrieval.

mcp-openapi-demo

MCP server for the Petstore API enabling LLMs to find pets by status via function calling.

Telegram Gifts Analyst MCP Server

Enables AI agents to fetch real-time market data, analyze user inventories, and track deep analytics for the Telegram Gifts market via the GiftAsset API.

Chrome Bridge

MCP server + Chrome extension that drive the user's real, logged-in Chrome over a local WebSocket. 59 token-efficient web-dev tools: compact element refs instead of screenshots, server-side table filtering, visual regression, accessibility/SEO/security audits, network mocking. Also runs on ChromeOS/Crostini.

tech.engageable/analytics

Connects to GA4, Mixpanel, PostHog and other analytics platforms, providing 9 tools for trend analysis, anomaly detection, funnel analysis, and more via natural language queries.

SeaTable MCP

The official Model Context Protocol (MCP) server for SeaTable, built and maintained by SeaTable GmbH. It lets AI agents interact with data in your bases — reading, writing, searching, linking, and querying rows through a focused set of tools. The server intentionally focuses on data operations, not schema management (creating/deleting tables or columns), keeping the tool set lean and safe for auto

Context Engine

基于 tree-sitter 的代码索引与查询引擎，支持多语言符号查找、调用图分析和全文搜索，通过 MCP stdio 协议集成到 Claude Code 中。

mcp-arcgis-sarpycounty

Sarpy County GIS — Sarpy County, Nebraska open geospatial data (ArcGIS).

PDM MCP Server

AI-powered FPGA power estimation assistant that wraps Xilinx PDM API as MCP services for natural language power modeling and analysis.

🔍 mcp-find

Okay, here's how you can search for Minecraft Protocol (MCP) servers from the command line. Keep in mind that there isn't a single, universally accepted command-line tool specifically designed for this. You'll likely need to use a combination of tools and techniques. Here are a few approaches, ranging from simpler to more complex: **1. Using `nmap` (Network Mapper) for Basic Port Scanning (Simplest, but Limited):** * **Concept:** Minecraft servers typically run on port 25565. `nmap` can scan a range of IP addresses to see if that port is open. This only tells you if *something* is listening on that port, not necessarily that it's a Minecraft server. * **Installation (if you don't have it):** * **Linux (Debian/Ubuntu):** `sudo apt-get install nmap` * **Linux (Fedora/CentOS/RHEL):** `sudo yum install nmap` * **macOS:** `brew install nmap` (if you have Homebrew) Otherwise, download from the Nmap website. * **Windows:** Download from the Nmap website ([https://nmap.org/download.html](https://nmap.org/download.html)). You'll likely need to add the Nmap directory to your system's `PATH` environment variable. * **Usage:** ```bash nmap -p 25565 <IP_ADDRESS_OR_RANGE> ``` * Replace `<IP_ADDRESS_OR_RANGE>` with: * A single IP address (e.g., `192.168.1.100`) * A range of IP addresses (e.g., `192.168.1.1-254` to scan the entire 192.168.1.x subnet) * A CIDR notation (e.g., `192.168.1.0/24` - same as the previous example) * **Example:** ```bash nmap -p 25565 192.168.1.0/24 ``` * **Interpretation:** `nmap` will output a list of IP addresses and their port status. If you see "25565/tcp open" for an IP address, it *might* be a Minecraft server. * **Limitations:** * Doesn't actually query the server to confirm it's Minecraft. * Can be slow if you scan a large range of IP addresses. * Scanning large ranges of public IP addresses without permission is generally unethical and potentially illegal. Only scan networks you own or have explicit permission to scan. **2. Using `mcstatus` (Python Library) for Server Status Queries (More Accurate, Requires Python):** * **Concept:** `mcstatus` is a Python library that can query a Minecraft server and retrieve its status (e.g., player count, MOTD, version). You can use it from the command line via a Python script. * **Installation (requires Python):** ```bash pip install mcstatus ``` * **Python Script (e.g., `mc_scanner.py`):** ```python import mcstatus import asyncio async def check_server(ip_address, port=25565): try: server = await mcstatus.JavaServer.lookup(f"{ip_address}:{port}") status = await server.status() print(f"Server: {ip_address}:{port}") print(f" Description: {status.description}") print(f" Players: {status.players.online}/{status.players.max}") print(f" Version: {status.version.name}") return True except Exception as e: #print(f" Error: {e}") #Uncomment for more verbose error messages return False async def main(): ip_addresses = ["127.0.0.1", "example.com"] # Replace with your list of IPs #ip_addresses = [f"192.168.1.{i}" for i in range(1, 255)] #Example of scanning a subnet tasks = [check_server(ip) for ip in ip_addresses] results = await asyncio.gather(*tasks) #Optional: Print summary of found servers found_servers = sum(results) print(f"\nFound {found_servers} Minecraft servers.") if __name__ == "__main__": asyncio.run(main()) ``` * **Explanation of the Script:** * It uses the `mcstatus` library to connect to Minecraft servers. * The `check_server` function attempts to connect to a server at the given IP address and port. If successful, it retrieves and prints the server's status information. If it fails, it prints an error message (commented out by default to reduce noise). * The `main` function defines a list of IP addresses to scan. **Important:** Replace the example IP addresses (`"127.0.0.1", "example.com"`) with the IP addresses or range of IP addresses you want to scan. The commented-out line shows how to scan a subnet. * It uses `asyncio` to perform the checks concurrently, making the scanning process much faster. * It prints a summary of the number of servers found. * **Usage:** 1. Save the script as `mc_scanner.py`. 2. **Edit the `ip_addresses` list in the script** to contain the IP addresses or range you want to scan. 3. Run the script from the command line: ```bash python mc_scanner.py ``` * **Advantages:** * More accurate than `nmap` because it actually queries the server. * Provides useful information about the server (player count, MOTD, version). * Can be relatively fast with asynchronous scanning. * **Disadvantages:** * Requires Python and the `mcstatus` library. * Still requires you to provide a list of IP addresses to scan. **3. Using Online Minecraft Server Lists and Web Scraping (Most Complex, Potentially Unreliable):** * **Concept:** There are websites that list Minecraft servers. You could potentially use a command-line tool like `curl` or `wget` to download the HTML of these websites and then use a tool like `grep`, `sed`, or `awk` to extract the server IP addresses and other information. * **Example (Conceptual - Requires Adaptation to Specific Website):** ```bash curl "https://example.com/minecraft-server-list" | grep -oE "([0-9]{1,3}\.){3}[0-9]{1,3}:[0-9]{1,5}" ``` * This is a very basic example and will likely not work without modification. You'll need to: * Replace `"https://example.com/minecraft-server-list"` with the actual URL of a Minecraft server list website. * Adjust the `grep` regular expression to match the specific format of IP addresses and ports on that website. The example regex `([0-9]{1,3}\.){3}[0-9]{1,3}:[0-9]{1,5}` tries to find IPv4 addresses followed by a colon and a port number. * You might need to use more sophisticated tools like `xmllint` or `pup` (if the website uses XML or HTML in a way that's difficult to parse with `grep`) to extract the data. * **Advantages:** * Potentially can find servers without knowing their IP addresses in advance. * **Disadvantages:** * Very fragile. The website's HTML structure can change at any time, breaking your script. * Web scraping can be against the terms of service of some websites. * Can be slow and resource-intensive. * Requires a good understanding of HTML, regular expressions, and command-line tools. **Important Considerations:** * **Ethical and Legal Issues:** Scanning networks without permission is generally unethical and potentially illegal. Only scan networks you own or have explicit permission to scan. * **Rate Limiting:** Many servers and websites have rate limiting in place to prevent abuse. If you send too many requests too quickly, you may be blocked. Implement delays in your scripts to avoid this. * **Firewalls:** Firewalls can block your scans. Make sure your firewall is configured to allow outgoing connections on port 25565 (or whatever port you're scanning). * **Server Discovery Protocols:** Minecraft uses a simple protocol for server discovery. The `mcstatus` library implements this protocol. You could potentially implement your own client to discover servers, but it's generally easier to use an existing library. **Which Method to Choose:** * If you just want to quickly check if a specific IP address is running a Minecraft server, use `mcstatus`. * If you need to scan a range of IP addresses and don't need detailed information, use `nmap` (but be aware of its limitations). * If you want to find servers without knowing their IP addresses in advance, you could try web scraping, but be prepared for a lot of work and potential unreliability. Consider using a dedicated Minecraft server list website's API if they offer one. I recommend starting with the `mcstatus` method, as it's the most accurate and provides the most useful information. Remember to replace the example IP addresses in the script with the IP addresses you want to scan. I hope this helps! Let me know if you have any other questions. ```spanish Claro, aquí te explico cómo buscar servidores de Minecraft Protocol (MCP) desde la línea de comandos. Ten en cuenta que no existe una herramienta de línea de comandos única y universalmente aceptada diseñada específicamente para esto. Es probable que necesites usar una combinación de herramientas y técnicas. Aquí tienes algunos enfoques, desde los más simples hasta los más complejos: **1. Usando `nmap` (Network Mapper) para un escaneo básico de puertos (Más simple, pero limitado):** * **Concepto:** Los servidores de Minecraft normalmente se ejecutan en el puerto 25565. `nmap` puede escanear un rango de direcciones IP para ver si ese puerto está abierto. Esto solo te dice si *algo* está escuchando en ese puerto, no necesariamente que sea un servidor de Minecraft. * **Instalación (si no lo tienes):** * **Linux (Debian/Ubuntu):** `sudo apt-get install nmap` * **Linux (Fedora/CentOS/RHEL):** `sudo yum install nmap` * **macOS:** `brew install nmap` (si tienes Homebrew). De lo contrario, descarga desde el sitio web de Nmap. * **Windows:** Descarga desde el sitio web de Nmap ([https://nmap.org/download.html](https://nmap.org/download.html)). Es probable que necesites agregar el directorio de Nmap a la variable de entorno `PATH` de tu sistema. * **Uso:** ```bash nmap -p 25565 <DIRECCIÓN_IP_O_RANGO> ``` * Reemplaza `<DIRECCIÓN_IP_O_RANGO>` con: * Una sola dirección IP (por ejemplo, `192.168.1.100`) * Un rango de direcciones IP (por ejemplo, `192.168.1.1-254` para escanear toda la subred 192.168.1.x) * Una notación CIDR (por ejemplo, `192.168.1.0/24` - igual que el ejemplo anterior) * **Ejemplo:** ```bash nmap -p 25565 192.168.1.0/24 ``` * **Interpretación:** `nmap` mostrará una lista de direcciones IP y su estado de puerto. Si ves "25565/tcp open" para una dirección IP, *podría* ser un servidor de Minecraft. * **Limitaciones:** * No consulta realmente al servidor para confirmar que es Minecraft. * Puede ser lento si escaneas un rango grande de direcciones IP. * Escanear grandes rangos de direcciones IP públicas sin permiso generalmente no es ético y potencialmente ilegal. Solo escanea redes que te pertenezcan o tengas permiso explícito para escanear. **2. Usando `mcstatus` (Biblioteca de Python) para consultas de estado del servidor (Más preciso, requiere Python):** * **Concepto:** `mcstatus` es una biblioteca de Python que puede consultar un servidor de Minecraft y recuperar su estado (por ejemplo, el número de jugadores, el MOTD, la versión). Puedes usarlo desde la línea de comandos a través de un script de Python. * **Instalación (requiere Python):** ```bash pip install mcstatus ``` * **Script de Python (por ejemplo, `mc_scanner.py`):** ```python import mcstatus import asyncio async def check_server(ip_address, port=25565): try: server = await mcstatus.JavaServer.lookup(f"{ip_address}:{port}") status = await server.status() print(f"Servidor: {ip_address}:{port}") print(f" Descripción: {status.description}") print(f" Jugadores: {status.players.online}/{status.players.max}") print(f" Versión: {status.version.name}") return True except Exception as e: #print(f" Error: {e}") #Descomenta para mensajes de error más detallados return False async def main(): ip_addresses = ["127.0.0.1", "example.com"] # Reemplaza con tu lista de IPs #ip_addresses = [f"192.168.1.{i}" for i in range(1, 255)] #Ejemplo de escanear una subred tasks = [check_server(ip) for ip in ip_addresses] results = await asyncio.gather(*tasks) #Opcional: Imprime un resumen de los servidores encontrados found_servers = sum(results) print(f"\nSe encontraron {found_servers} servidores de Minecraft.") if __name__ == "__main__": asyncio.run(main()) ``` * **Explicación del script:** * Utiliza la biblioteca `mcstatus` para conectarse a los servidores de Minecraft. * La función `check_server` intenta conectarse a un servidor en la dirección IP y el puerto dados. Si tiene éxito, recupera e imprime la información de estado del servidor. Si falla, imprime un mensaje de error (comentado por defecto para reducir el ruido). * La función `main` define una lista de direcciones IP para escanear. **Importante:** Reemplaza las direcciones IP de ejemplo (`"127.0.0.1", "example.com"`) con las direcciones IP o el rango de direcciones IP que deseas escanear. La línea comentada muestra cómo escanear una subred. * Utiliza `asyncio` para realizar las comprobaciones de forma concurrente, lo que hace que el proceso de escaneo sea mucho más rápido. * Imprime un resumen del número de servidores encontrados. * **Uso:** 1. Guarda el script como `mc_scanner.py`. 2. **Edita la lista `ip_addresses` en el script** para que contenga las direcciones IP o el rango que deseas escanear. 3. Ejecuta el script desde la línea de comandos: ```bash python mc_scanner.py ``` * **Ventajas:** * Más preciso que `nmap` porque realmente consulta al servidor. * Proporciona información útil sobre el servidor (número de jugadores, MOTD, versión). * Puede ser relativamente rápido con el escaneo asíncrono. * **Desventajas:** * Requiere Python y la biblioteca `mcstatus`. * Aún requiere que proporciones una lista de direcciones IP para escanear. **3. Usando listas de servidores de Minecraft en línea y web scraping (Más complejo, potencialmente poco confiable):** * **Concepto:** Hay sitios web que enumeran servidores de Minecraft. Podrías usar una herramienta de línea de comandos como `curl` o `wget` para descargar el HTML de estos sitios web y luego usar una herramienta como `grep`, `sed` o `awk` para extraer las direcciones IP del servidor y otra información. * **Ejemplo (Conceptual - Requiere adaptación al sitio web específico):** ```bash curl "https://example.com/lista-de-servidores-minecraft" | grep -oE "([0-9]{1,3}\.){3}[0-9]{1,3}:[0-9]{1,5}" ``` * Este es un ejemplo muy básico y probablemente no funcionará sin modificaciones. Necesitarás: * Reemplazar `"https://example.com/lista-de-servidores-minecraft"` con la URL real de un sitio web de lista de servidores de Minecraft. * Ajustar la expresión regular `grep` para que coincida con el formato específico de las direcciones IP y los puertos en ese sitio web. La expresión regular de ejemplo `([0-9]{1,3}\.){3}[0-9]{1,3}:[0-9]{1,5}` intenta encontrar direcciones IPv4 seguidas de dos puntos y un número de puerto. * Es posible que necesites usar herramientas más sofisticadas como `xmllint` o `pup` (si el sitio web usa XML o HTML de una manera que es difícil de analizar con `grep`) para extraer los datos. * **Ventajas:** * Potencialmente puede encontrar servidores sin conocer sus direcciones IP de antemano. * **Desventajas:** * Muy frágil. La estructura HTML del sitio web puede cambiar en cualquier momento, rompiendo tu script. * El web scraping puede estar en contra de los términos de servicio de algunos sitios web. * Puede ser lento y consumir muchos recursos. * Requiere una buena comprensión de HTML, expresiones regulares y herramientas de línea de comandos. **Consideraciones importantes:** * **Cuestiones éticas y legales:** Escanear redes sin permiso generalmente no es ético y potencialmente ilegal. Solo escanea redes que te pertenezcan o tengas permiso explícito para escanear. * **Limitación de velocidad:** Muchos servidores y sitios web tienen limitaciones de velocidad para evitar el abuso. Si envías demasiadas solicitudes demasiado rápido, es posible que te bloqueen. Implementa retrasos en tus scripts para evitar esto. * **Firewalls:** Los firewalls pueden bloquear tus escaneos. Asegúrate de que tu firewall esté configurado para permitir las conexiones salientes en el puerto 25565 (o cualquier puerto que estés escaneando). * **Protocolos de descubrimiento de servidores:** Minecraft utiliza un protocolo simple para el descubrimiento de servidores. La biblioteca `mcstatus` implementa este protocolo. Podrías implementar tu propio cliente para descubrir servidores, pero generalmente es más fácil usar una biblioteca existente. **Qué método elegir:** * Si solo quieres verificar rápidamente si una dirección IP específica está ejecutando un servidor de Minecraft, usa `mcstatus`. * Si necesitas escanear un rango de direcciones IP y no necesitas información detallada, usa `nmap` (pero ten en cuenta sus limitaciones). * Si quieres encontrar servidores sin conocer sus direcciones IP de antemano, podrías intentar el web scraping, pero prepárate para mucho trabajo y una posible falta de fiabilidad. Considera usar la API de un sitio web de lista de servidores de Minecraft dedicado si ofrecen una. Recomiendo comenzar con el método `mcstatus`, ya que es el más preciso y proporciona la información más útil. Recuerda reemplazar las direcciones IP de ejemplo en el script con las direcciones IP que deseas escanear. ¡Espero que esto ayude! Avísame si tienes alguna otra pregunta.

AI Sales MCP Server

Enables AI assistants to query ERP sales data, including employees, sales, customers, and top products, through MCP tools.

Forge Workspace MCP Server

A deliberately narrow, approval-gated workspace server that safely reads and writes files and runs allowlisted commands only inside one configured workspace, requiring visible approval for every write, process execution, and file read, with stale-overwrite protection and symlink-escape rejection.

Looping Agent MCP

Turns a manager's plain-English goal into a verified, looped, watchable build run driven by the IDE's agent, without SDK.

ProductPilot MCP

An MCP server that helps digital product creators go from idea to a zipped, listing-ready product — including market research, product generation, SEO, listing copy, pricing, and Gumroad/Etsy preparation.

appmetrica-mcp

MCP server for Yandex AppMetrica analytics, enabling Claude to access reports, raw event logs, crash data, and push notification campaigns.

Gadget MCP Server

A read-only MCP server that enables querying and introspection of any Gadget app via GraphQL. It allows users to list models, inspect fields, and fetch records directly within AI tools like Claude and Cursor.

Cherry Studio Task Board

Provides Kanban, Gantt, list views, multi-project management, and archiving for task management via MCP protocol, enabling Cherry Studio Agent to create, update, query, and organize tasks.

GitLab MCP Server

HTTP-based MCP server for GitLab API, enabling project management, issue tracking, merge requests, and file operations through natural language.

GPT Image 2 Polza MCP Server

Enables generating and editing images using OpenAI's GPT Image 2 model via the Polza API, with support for multiple modes, reference images, and local file storage.

Brave Real Browser MCP Server

Enables advanced browser automation using real Brave Browser with 49 tools for web scraping, content extraction, video downloads, CAPTCHA solving, and anti-detection features. Includes automatic Brave installation, built-in ad-blocking with uBlock Origin, and support for complex scenarios like bypassing Cloudflare protection.

rosclaw-ur-rtde-mcp

MCP server for controlling Universal Robots arms and Robotiq grippers via RTDE protocol, enabling motion, force, I/O, and gripper operations.

TOONer

MCP proxy that wraps any MCP server and transparently converts JSON responses in tools/call to TOON format — a token-efficient alternative to JSON optimized for LLMs (~40% fewer tokens).

Blue Archive MCP Server

Provides comprehensive access to Blue Archive game data including students, equipment, stages, and multimedia content via the SchaleDB API. It enables AI assistants to perform advanced searches and retrieve detailed game information in English, Japanese, and Chinese.

roc-cwa-mcp

Enables to access Taiwan Central Weather Administration data, including 3-day and 1-week weather forecasts for counties/cities and historical rainfall data.

notes-mcp-server-l16

A Model Context Protocol (MCP) server that gives Claude a persistent personal notebook. Notes are stored on disk as JSON, so they survive restarts and are shared across every tool and resource.

solidworks-mcp

Enables LLMs to automate SolidWorks (open/save parts, modify dimensions, export STEP) via COM, and optionally generate geometry using build123d code-CAD with PNG previews.

mcp-data-orlando

Enables searching and querying Orlando Open Data datasets via Socrata SoQL, providing access to metadata and data rows through natural language or direct tool calls.

Playwright MCP Server for Security

Enables LLMs to perform browser automation tasks including web scraping, taking screenshots, and executing JavaScript using Playwright. It facilitates real-time interaction with web pages and the generation of automated test code.