Discover Awesome MCP Servers

ElevenLabs MCP Server

Un servidor oficial del Protocolo de Contexto del Modelo (MCP) que permite a los clientes de IA interactuar con las APIs de Texto a Voz y procesamiento de audio de ElevenLabs, permitiendo la generación de voz, la clonación de voz, la transcripción de audio y otras tareas relacionadas con el audio.

MCP-Codex: Model Context Protocol Tool Orchestration

Un servidor MCP para invocar herramientas MCP de forma remota sin necesidad de instalación.

Freesound MCP Server

An MCP server that enables AI assistants to search, analyze, and retrieve information about audio samples from Freesound.org through their API.

Digital Asset Links API MCP Server

An MCP server that enables querying and managing relationships between websites and mobile apps through Google's Digital Asset Links API, auto-generated using AG2's MCP builder.

Playwright

Un servidor de Protocolo de Contexto de Modelo que proporciona capacidades de automatización del navegador utilizando Playwright. Este servidor permite a los LLM interactuar con páginas web, tomar capturas de pantalla y ejecutar JavaScript en un entorno de navegador real.

Agentic Commerce MCP Demo

Enables interactive restaurant discovery and ordering through a synthetic commerce flow with rich HTML UI. Demonstrates agentic commerce UX with tools to find restaurants, view menus, place mock orders, and generate receipts.

Neva

SDK del servidor MCP para Rust

mcp-bauplan

Un servidor MCP para interactuar con datos y ejecutar pipelines usando Bauplan.

MCP-LinkedIn

Dynamic tools to automate tasks on LinkedIn website.

Graphiti Knowledge Graph MCP Server

Enables AI assistants to build and query temporally-aware knowledge graphs from conversations and data. Supports adding episodes, searching entities and facts, and maintaining persistent memory across interactions.

Grasp

An open-source self-hosted browser agent that provides a dockerized browser environment for AI automation, allowing other AI apps and agents to perform human-like web browsing tasks through natural language instructions.

MCP OpenAPI Proxy

A tool that accelerates MCP protocol adoption by automatically generating MCP-compatible server components from OpenAPI specifications, enabling seamless integration with existing services as a sidecar.

PhonePi MCP

PhonePi MCP permite una integración perfecta entre las herramientas de IA de escritorio y tu teléfono inteligente, proporcionando más de 23 acciones directas que incluyen mensajería SMS, llamadas telefónicas, gestión de contactos, creación y búsqueda de fragmentos, uso compartido del portapapeles, notificaciones, comprobaciones del estado de la batería y controles remotos del dispositivo.

Model Context Protocol Python Server

A Python implementation of the Model Context Protocol (MCP) server that enables searching and extracting information from arXiv papers, designed to be extensible with additional MCP tools.

Random Number MCP

Production-ready MCP server that provides LLMs with essential random generation abilities, including random integers, floats, choices, shuffling, and cryptographically secure tokens.

OpenAlex MCP Server

Un servidor MCP (Protocolo de Contexto de Modelo) que se conecta a la API de OpenAlex.

Hello Golang MCP

Aquí tienes una implementación mínima de un servidor MCP en Golang usando mcp-go: ```go package main import ( "context" "flag" "fmt" "log" "net" "net/http" "os" "os/signal" "syscall" "github.com/envoyproxy/go-control-plane/pkg/cache/v3" "github.com/envoyproxy/go-control-plane/pkg/server/v3" "google.golang.org/grpc" ) var ( grpcPort = flag.Int("grpc-port", 18000, "grpc port") httpPort = flag.Int("http-port", 18001, "http port") ) // SimpleCallbacks is a simple implementation of the Callbacks interface. type SimpleCallbacks struct{} func (cb *SimpleCallbacks) OnStreamOpen(ctx context.Context, streamID int64, typ string) error { log.Printf("Stream opened with ID: %d, Type: %s\n", streamID, typ) return nil } func (cb *SimpleCallbacks) OnStreamClosed(streamID int64, typ string) { log.Printf("Stream closed with ID: %d, Type: %s\n", streamID, typ) } func (cb *SimpleCallbacks) OnStreamRequest(streamID int64, req *envoy.DiscoveryRequest) error { log.Printf("Request received on stream ID: %d, Type: %s, Resource Names: %v\n", streamID, req.GetTypeUrl(), req.GetResourceNames()) return nil } func (cb *SimpleCallbacks) OnStreamResponse(streamID int64, req *envoy.DiscoveryRequest, resp *envoy.DiscoveryResponse) { log.Printf("Response sent on stream ID: %d, Type: %s, Version: %s\n", streamID, req.GetTypeUrl(), resp.GetVersionInfo()) } func (cb *SimpleCallbacks) OnFetchRequest(ctx context.Context, req *envoy.DiscoveryRequest) error { log.Printf("Fetch request received, Type: %s, Resource Names: %v\n", req.GetTypeUrl(), req.GetResourceNames()) return nil } func (cb *SimpleCallbacks) OnFetchResponse(req *envoy.DiscoveryRequest, resp *envoy.DiscoveryResponse) { log.Printf("Fetch response sent, Type: %s, Version: %s\n", req.GetTypeUrl(), resp.GetVersionInfo()) } func main() { flag.Parse() // Create a cache snapshotCache := cache.NewSnapshotCache(true, cache.IDHash{}, nil) // Create a new MCP server srv := server.NewServer(context.Background(), snapshotCache, &SimpleCallbacks{}) // Create a gRPC server grpcServer := grpc.NewServer() envoy.RegisterAggregatedDiscoveryServiceServer(grpcServer, srv) // Start the gRPC server grpcListener, err := net.Listen("tcp", fmt.Sprintf(":%d", *grpcPort)) if err != nil { log.Fatalf("failed to listen: %v", err) } log.Printf("gRPC server listening on port %d\n", *grpcPort) go func() { if err := grpcServer.Serve(grpcListener); err != nil { log.Fatalf("failed to serve: %v", err) } }() // Create an HTTP server for health checks (optional) http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) w.Write([]byte("OK")) }) httpServer := &http.Server{Addr: fmt.Sprintf(":%d", *httpPort)} log.Printf("HTTP server listening on port %d\n", *httpPort) go func() { if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { log.Fatalf("HTTP server failed: %v", err) } }() // Handle shutdown signals signalChan := make(chan os.Signal, 1) signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM) <-signalChan log.Println("Shutting down...") // Gracefully stop the gRPC server grpcServer.GracefulStop() // Gracefully stop the HTTP server if err := httpServer.Shutdown(context.Background()); err != nil { log.Printf("HTTP server shutdown error: %v", err) } log.Println("Server stopped") } ``` **Explanation:** 1. **Imports:** Imports necessary packages, including `mcp-go` (specifically `github.com/envoyproxy/go-control-plane/pkg/cache/v3` and `github.com/envoyproxy/go-control-plane/pkg/server/v3`) and the Envoy protobuf definitions (`envoy`). Also includes standard Go packages for networking, logging, and signal handling. 2. **Flags:** Defines command-line flags for the gRPC and HTTP ports. 3. **`SimpleCallbacks`:** This struct implements the `server.Callbacks` interface. It's crucial for logging and potentially for more complex logic like authorization or request modification. The provided implementation simply logs events. You'll likely need to customize this for your specific needs. 4. **`main` function:** - **Parse Flags:** Parses the command-line flags. - **Create Cache:** Creates a `cache.SnapshotCache`. This cache holds the configuration data that the MCP server will serve to clients. The `cache.IDHash{}` is a simple ID hashing function. The `nil` is for a logger (you can provide a custom logger here). - **Create Server:** Creates a new MCP server using `server.NewServer`. It takes the context, the cache, and the callbacks as arguments. - **Create gRPC Server:** Creates a gRPC server and registers the MCP service with it. - **Start gRPC Server:** Starts the gRPC server in a goroutine. - **Create HTTP Server (Optional):** Creates a simple HTTP server for health checks. This is useful for monitoring and deployment. - **Start HTTP Server:** Starts the HTTP server in a goroutine. - **Signal Handling:** Sets up signal handling to gracefully shut down the server when it receives a SIGINT or SIGTERM signal. - **Graceful Shutdown:** Gracefully stops the gRPC and HTTP servers. **How to use it:** 1. **Install dependencies:** ```bash go get github.com/envoyproxy/go-control-plane@latest go get google.golang.org/grpc ``` 2. **Save the code:** Save the code as `main.go`. 3. **Run the server:** ```bash go run main.go ``` You can also specify the ports: ```bash go run main.go --grpc-port=9000 --http-port=9001 ``` **Important Considerations:** * **Configuration:** This is a *minimal* implementation. It doesn't actually *serve* any configuration. You'll need to add code to populate the `snapshotCache` with the configuration data you want to serve. This typically involves: * Defining the Envoy resources (e.g., listeners, routes, clusters) as protobuf messages. * Creating a `cache.Snapshot` containing these resources. * Calling `snapshotCache.SetSnapshot(context.Background(), nodeID, snapshot)` to update the cache. You'll need to determine the `nodeID` based on the client's identity. * **Node ID:** The `nodeID` is how the MCP server identifies the client. You'll need to implement a mechanism to determine the `nodeID` from the incoming requests. This might involve inspecting the `DiscoveryRequest` or using authentication. * **Error Handling:** The example has basic error handling, but you should add more robust error handling for production use. * **Security:** This example doesn't include any security measures (e.g., authentication, authorization, TLS). You'll need to add these for a production environment. * **Callbacks:** The `SimpleCallbacks` implementation is very basic. You'll likely need to customize it to handle events like request validation, authorization, and logging. * **mcp-go vs. xDS:** MCP is a superset of xDS. While this example uses the `envoy.RegisterAggregatedDiscoveryServiceServer` which is technically an xDS endpoint, you can extend it to support MCP-specific features like resource groups and selectors. **Example of setting a snapshot (Illustrative - requires defining Envoy resources):** ```go // ... inside the main function, after creating the snapshotCache import ( cluster "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3" core "github.com/envoyproxy/go-control-plane/envoy/config/core/v3" endpoint "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3" listener "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3" route "github.com/envoyproxy/go-control-plane/envoy/config/route/v3" hcm "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/network/http_connection_manager/v3" "github.com/envoyproxy/go-control-plane/pkg/cache/types" "github.com/envoyproxy/go-control-plane/pkg/cache/v3" "github.com/envoyproxy/go-control-plane/pkg/resource/v3" "github.com/envoyproxy/go-control-plane/pkg/wellknown" "google.golang.org/protobuf/types/known/anypb" ) // Helper function to create an Any protobuf func toAny(pb proto.Message) (*anypb.Any, error) { a := &anypb.Any{} err := a.MarshalFrom(pb) if err != nil { return nil, err } return a, nil } // Example resource definitions (replace with your actual configuration) clusterName := "my-cluster" listenerName := "my-listener" routeName := "my-route" // Create a cluster myCluster := &cluster.Cluster{ Name: clusterName, ConnectTimeout: ptypes.DurationProto(5 * time.Second), ClusterDiscoveryType: &cluster.Cluster_Type{Type: cluster.Cluster_STATIC}, LbPolicy: cluster.Cluster_ROUND_ROBIN, LoadAssignment: &endpoint.ClusterLoadAssignment{ ClusterName: clusterName, Endpoints: []*endpoint.LocalityLbEndpoints{{ LbEndpoints: []*endpoint.LbEndpoint{{ Endpoint: &endpoint.Endpoint{ Address: &core.Address{ Address: &core.Address_SocketAddress{ SocketAddress: &core.SocketAddress{ Protocol: core.SocketAddress_TCP, Address: "127.0.0.1", // Replace with your backend address PortSpecifier: &core.SocketAddress_PortValue{ PortValue: 8080, // Replace with your backend port }, }, }, }, }, }}, }}, }, } // Create a route myRoute := &route.RouteConfiguration{ Name: routeName, VirtualHosts: []*route.VirtualHost{{ Name: "my-virtual-host", Domains: []string{"*"}, Routes: []*route.Route{{ Match: &route.RouteMatch{ PathSpecifier: &route.RouteMatch_Prefix{ Prefix: "/", }, }, Action: &route.Route_Route{ Route: &route.RouteAction{ ClusterSpecifier: &route.RouteAction_Cluster{ Cluster: clusterName, }, }, }, }}, }}, } // Create an HTTP connection manager httpConnectionManager := &hcm.HttpConnectionManager{ CodecType: hcm.HttpConnectionManager_AUTO, StatPrefix: "ingress_http", RouteSpecifier: &hcm.HttpConnectionManager_RouteConfig{ RouteConfig: myRoute, }, HttpFilters: []*hcm.HttpFilter{{ Name: wellknown.Router, }}, } // Convert the HTTP connection manager to an Any protobuf httpConnectionManagerAny, err := toAny(httpConnectionManager) if err != nil { log.Fatalf("Error converting HTTP connection manager to Any: %v", err) } // Create a listener myListener := &listener.Listener{ Name: listenerName, Address: &core.Address{ Address: &core.Address_SocketAddress{ SocketAddress: &core.SocketAddress{ Protocol: core.SocketAddress_TCP, Address: "0.0.0.0", PortSpecifier: &core.SocketAddress_PortValue{ PortValue: 8081, // Replace with your desired listener port }, }, }, }, FilterChains: []*listener.FilterChain{{ Filters: []*listener.Filter{{ Name: wellknown.HTTPConnectionManager, ConfigType: &listener.Filter_TypedConfig{ TypedConfig: httpConnectionManagerAny, }, }}, }}, } nodeID := "my-node-id" // Replace with the actual node ID // Create a snapshot snapshot, err := cache.NewSnapshot( nodeID, map[resource.Type][]types.Resource{ resource.ClusterType: {myCluster}, resource.RouteType: {myRoute}, resource.ListenerType: {myListener}, }, ) if err != nil { log.Fatalf("Error creating snapshot: %v", err) } // Set the snapshot in the cache if err := snapshotCache.SetSnapshot(context.Background(), nodeID, snapshot); err != nil { log.Fatalf("Error setting snapshot: %v", err) } log.Printf("Snapshot set for node ID: %s\n", nodeID) ``` This example creates a simple cluster, route, and listener and sets them in the cache. **You'll need to adapt this to your specific configuration needs.** Remember to install the `google.golang.org/protobuf` and `github.com/golang/protobuf/ptypes` packages. This more complete example provides a starting point for building a functional MCP server. Remember to thoroughly understand the Envoy configuration model and the `mcp-go` library to create a robust and secure solution.

LINE Bot MCP Server

Servidor MCP que integra la API de mensajería de LINE para conectar un Agente de IA a la Cuenta Oficial de LINE.

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

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.

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

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

MCP PostgreSQL Operations

Enables comprehensive PostgreSQL database monitoring, analysis, and management through natural language queries. Provides performance insights, bloat analysis, vacuum monitoring, and intelligent maintenance recommendations across PostgreSQL versions 12-17.

pure.md MCP server

Un servidor MCP que permite a clientes de IA como Cursor, Windsurf y Claude Desktop acceder a contenido web en formato Markdown, proporcionando capacidades de desbloqueo web y búsqueda.

Weather MCP Server

Enables real-time weather queries for cities worldwide using Open-Meteo API. Provides 7-day forecasts with detailed information including temperature, wind, humidity, precipitation, and comfort level assessments in both Chinese and English.

Claude Debugs for You

Habilitar a Claude (o cualquier otro LLM) para depurar tu código de forma interactiva (establecer puntos de interrupción y evaluar expresiones en el marco de la pila). Es independiente del lenguaje, asumiendo soporte de consola de depurador y un archivo launch.json válido para la depuración en VSCode.