Discover Awesome MCP Servers

mcp-scholar

"mcp\_scholar" es una herramienta basada en Python para buscar y analizar artículos de Google Scholar, que admite funciones como búsquedas basadas en palabras clave e integración con clientes MCP y Cherry Studio. Proporciona funcionalidades como obtener los artículos más citados de los perfiles de Scholar y resumir las principales investigaciones.

MCP Memory

A server that gives MCP clients (Cursor, Claude, Windsurf, etc.) the ability to remember user information across conversations using vector search technology.

MCP Airtable Server

Provides tools for AI assistants to interact with Airtable databases, enabling CRUD operations on Airtable bases and tables.

JavaSinkTracer MCP

Enables AI-powered Java source code vulnerability auditing through function-level taint analysis. Performs reverse tracking from dangerous functions to external entry points to automatically discover potential security vulnerability chains.

allabout-mcp

MCP servers and more

Playwright MCP

A Model Context Protocol server that provides browser automation capabilities using Playwright, enabling LLMs to interact with web pages through structured accessibility snapshots without requiring screenshots or visually-tuned models.

Date and Time MCP Server

A simple Model Context Protocol (MCP) server that provides date and time functionality in any timezone, along with user profiles and personalized greeting resources.

Nextflow Developer Tools MCP

Un servidor de Protocolo de Contexto de Modelo diseñado para facilitar el desarrollo y las pruebas de Nextflow, proporcionando herramientas para construir desde el código fuente, ejecutar pruebas y gestionar el entorno de desarrollo de Nextflow.

FRED Macroeconomic Data MCP Server

Proporciona acceso a los Datos Económicos de la Reserva Federal (FRED) a través de Claude y otros clientes LLM, permitiendo a los usuarios buscar, recuperar y visualizar indicadores económicos como el PIB, el empleo y los datos de inflación.

Hourei MCP Server

Enables searching and retrieving Japanese legal information from the e-Gov Law API, including law searches by keyword, detailed law data retrieval, and revision history tracking.

Lens Protocol MCP Server

Enables AI tools to interact with the Lens Protocol decentralized social network ecosystem. Supports fetching profiles, posts, followers, searching content, and accessing social graph data through standardized MCP interfaces.

Torrent Search MCP Server

A Python MCP server that allows programmatic interaction to find torrents programmatically on ThePirateBay, Nyaa and YggTorrent.

Shadcn UI MCP Server

A Model Control Protocol server that allows users to discover, install, and manage Shadcn UI components and blocks through natural language interactions in compatible AI tools.

CPR Training MCP Server

Provides structured CPR training resources including lessons, demonstration videos, and reflective questions through an MCP interface. Enables AI assistants to deliver trusted cardiopulmonary resuscitation training content on demand.

Azure Impact Reporting MCP Server

Enables large language models to automatically report customer-facing issues with Azure resources by parsing natural language requests and submitting impact reports through the Azure Management API.

weibo-mcp-server

Un servicio MCP para obtener los N temas más populares de Weibo, compatible con llamadas en modo stdio y SSE.

Deepseek R1

Una implementación en Node.js/TypeScript de un servidor de Protocolo de Contexto de Modelo para el modelo de lenguaje Deepseek R1, optimizada para tareas de razonamiento con una ventana de contexto grande y totalmente integrada con Claude Desktop.

mcp-luma-dream-machine

Create videos and images using Luma AI, this MCP server handles all API functionality for Luma Dream Machine from Claude Desktop.

MCP Documentation Server

Un servidor MCP personalizado que permite la integración entre aplicaciones LLM y fuentes de documentación, proporcionando acceso asistido por IA a la documentación de LangGraph y el Protocolo de Contexto de Modelos (MCP).

BCRP-MCP

Model Context Protocol server that provides access to economic and financial time series data from Peru's Central Reserve Bank, enabling AI agents to search, explore, and analyze Peru's economic indicators through a standardized interface.

Hyperfabric MCP Server

Enables LLMs to interact with Hyperfabric infrastructure management APIs, providing access to 79 endpoints for managing fabrics, devices, networks, VNIs, VRFs, and other network infrastructure components.

Superstore MCP Server

Enables interaction with Real Canadian Superstore to extract order history, browse products, and export purchase data. Supports authentication via bearer token and provides comprehensive order management and product discovery capabilities.

🔍 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.

Web Browser

Habilita las capacidades de navegación web utilizando BeautifulSoup4.

HAP MCP Server

A Model Context Protocol server that provides seamless integration with Mingdao platform APIs, enabling AI applications to perform operations like worksheet management, record manipulation, and role management through natural language.

Jama Connect MCP Server (Unofficial)

Servidor de Protocolo de Contexto del Modelo para el Software Jama Connect

MCP YNAB Server

Proporciona acceso a la funcionalidad de YNAB (You Need A Budget, Necesitas un Presupuesto) a través del Protocolo de Contexto del Modelo, permitiendo a los usuarios ver los saldos de las cuentas, acceder a los datos de las transacciones y crear nuevas transacciones.