Discover Awesome MCP Servers

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.

Fibery MCP Server

Espejo de

contentstack-mcp

contentstack-mcp

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.

Kubecost MCP Server

An implementation that enables AI assistants to interact with Kubecost cost management platform through natural language, providing access to budget management and cost analysis features.

Neva

SDK del servidor MCP para Rust

mcp-bauplan

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

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.

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.

Web Browser

Habilita las capacidades de navegación web utilizando BeautifulSoup4.

MCP Workshop Starter

A starter kit for building Model Context Protocol servers that enables AI tools to access external data and functionalities like checking holidays, disk space, timezones, RSS feeds, code diffs, and web performance metrics.

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.

Remote MCP Server for Cloudflare

A deployable server that implements the Model Context Protocol (MCP) on Cloudflare Workers, enabling integration of custom tools with AI assistants like Claude without requiring authentication.

MySQL Server

Este servidor permite que los modelos de IA interactúen con bases de datos MySQL a través de una interfaz estandarizada.

All-in-One Dev

Protocolo de Contexto de Modelo Todo en Uno: qdrant, Google Suite (Gmail, Calendar, ...), Jira, GitLab, CLI, ...

Terminally MCP

An MCP server that gives AI assistants the ability to create, manage, and control terminal sessions through a safe, isolated tmux environment.

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.

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

MCP Vulnerability Checker Server

A Model Context Protocol server providing security vulnerability intelligence tools including CVE lookup, EPSS scoring, CVSS calculation, exploit detection, and Python package vulnerability checking.

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.

YouTube Analytics MCP Server by CData

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

Multichain MCP Server

Un conjunto de herramientas integral para construir agentes de IA con capacidades de blockchain, que permite interacciones con múltiples redes blockchain para tareas como la gestión de billeteras, transferencias de fondos, interacciones con contratos inteligentes y el puenteo de activos entre cadenas.

justdopeshop

Okay, I understand you want information about using Cursor with a GitHub MCP (Mod Configuration Pack) server. Here's a breakdown of what that likely means and how to approach it, along with some considerations: **Understanding the Components** * **Cursor:** This refers to the CurseForge launcher, a popular platform for managing Minecraft mods and modpacks. It's now owned by Overwolf. * **GitHub:** A web-based platform for version control and collaboration using Git. It's where many mod developers host their source code and sometimes even distribute modpacks. * **MCP (Mod Configuration Pack) Server:** This is a Minecraft server that is designed to run with a specific set of mods (a modpack). The "MCP" part usually implies that the server is configured to work with a particular modpack available on CurseForge or another platform. **How to Use Cursor with a GitHub MCP Server (Likely Scenarios)** The most common scenarios are: 1. **Downloading a Modpack from GitHub and Importing into Cursor:** * **Scenario:** A modpack developer hosts their modpack files (manifest, mods, configs) on GitHub. You want to use Cursor to manage and launch the modpack. * **Steps:** 1. **Find the GitHub Repository:** Locate the GitHub repository for the modpack. Look for a `manifest.json` file or similar file that describes the modpack. 2. **Download the Repository (or Specific Files):** You have a few options: * **Clone the Repository:** If you're familiar with Git, clone the entire repository to your local machine using `git clone <repository_url>`. * **Download as ZIP:** GitHub usually provides a "Code" button with an option to "Download ZIP". This downloads a compressed archive of the repository. * **Download Specific Files:** If the repository is large, you might only need the `manifest.json` and the `overrides` folder (if it exists). Download these individually. 3. **Import into Cursor (CurseForge Launcher):** * Open the CurseForge launcher. * Click the "+" button to create a new custom profile. * Choose "Import a previously created profile". * Select the `manifest.json` file you downloaded (or extracted from the ZIP). * Cursor will then download and install the mods specified in the manifest. 4. **Copy Server Files (if needed):** The GitHub repository *might* also contain server files (e.g., `server.properties`, start scripts, world files). If so, copy these to your server directory. *Important:* Be very careful about overwriting existing server files unless you know what you're doing. 5. **Launch the Server:** Start your Minecraft server using the appropriate start script (e.g., `start.bat`, `start.sh`). 6. **Launch the Client:** Launch the modpack profile you created in Cursor. 7. **Connect:** Connect to your server using the server's IP address and port. 2. **Using Cursor to Manage Mods for a Server You Manually Set Up:** * **Scenario:** You've already set up a Minecraft server and want to use Cursor to easily manage the mods on both the client and server. * **Steps:** 1. **Create a Custom Profile in Cursor:** Create a new custom profile in the CurseForge launcher. 2. **Add Mods:** Use the CurseForge launcher's interface to add the mods you want to use on your server. Make sure you add the *exact same versions* of the mods to your client profile as you will put on the server. 3. **Copy Mods to Server:** Navigate to the `mods` folder within your CurseForge profile directory (usually something like `CurseForge\Instances\<profile_name>\mods`). Copy all the `.jar` files from this folder to the `mods` folder of your Minecraft server. 4. **Configure Server (if needed):** Some mods require server-side configuration. Copy any necessary configuration files from your CurseForge profile's `config` folder to the `config` folder of your Minecraft server. 5. **Launch the Server:** Start your Minecraft server. 6. **Launch the Client:** Launch the modpack profile you created in Cursor. 7. **Connect:** Connect to your server. 3. **Contributing to a Modpack on GitHub (Advanced):** * **Scenario:** You're a developer or contributor to a modpack hosted on GitHub and want to use Cursor to test changes. * **Steps:** 1. **Fork the Repository:** Fork the modpack's GitHub repository to your own account. 2. **Clone the Fork:** Clone your forked repository to your local machine. 3. **Set Up a Development Environment:** This usually involves setting up a Minecraft development environment with the Minecraft Development Kit (MDK) or similar tools. This is beyond the scope of this basic explanation. 4. **Make Changes:** Modify the modpack files (e.g., `manifest.json`, config files, scripts). 5. **Test with Cursor:** Import the `manifest.json` into Cursor to create a test profile. Launch the profile and test your changes. 6. **Commit and Push:** Commit your changes to your local Git repository and push them to your forked repository on GitHub. 7. **Create a Pull Request:** Create a pull request from your forked repository to the original modpack repository. The modpack maintainers can then review and merge your changes. **Important Considerations** * **Mod Versions:** *Crucially*, the mod versions on your client (managed by Cursor) *must* match the mod versions on your server. Mismatched versions are a very common cause of connection problems and crashes. * **Server Configuration:** Some mods require specific server-side configuration. Read the mod documentation carefully to understand any server-side setup requirements. * **Dependencies:** Make sure you have all the necessary dependencies for the mods you're using. Cursor should handle most dependencies automatically, but it's good to be aware of them. * **Resource Packs:** If the modpack includes resource packs, make sure they are installed correctly on both the client and server (if the server supports them). * **Firewall:** Ensure that your firewall is not blocking connections to your Minecraft server. * **Port Forwarding:** If you're hosting the server on your home network and want others to connect from outside your network, you'll need to configure port forwarding on your router. * **Server Start Script:** The server start script (e.g., `start.bat`, `start.sh`) is crucial. Make sure it's configured correctly to allocate enough memory to the server. A common issue is not allocating enough RAM, leading to crashes. Look for the `-Xmx` parameter in the script (e.g., `-Xmx4G` for 4 GB of RAM). * **EULA:** You must agree to the Minecraft End User License Agreement (EULA) to run a Minecraft server. This usually involves setting `eula=true` in the `eula.txt` file. * **GitHub Repository Structure:** The structure of the GitHub repository can vary. Look for a `README.md` file that provides instructions on how to use the modpack. **Troubleshooting** * **Connection Refused:** This usually means the server isn't running or your client is trying to connect to the wrong IP address or port. * **Incompatible Mod Versions:** Double-check that the mod versions on the client and server match exactly. * **Crashing:** Check the server logs and client logs for error messages. These logs can provide clues about the cause of the crash. Common causes include insufficient RAM, incompatible mods, or configuration errors. * **Missing Mods:** Make sure all the required mods are present in the `mods` folder on both the client and server. **Example `manifest.json` (Simplified)** ```json { "manifestType": "minecraftModpack", "manifestVersion": 1, "name": "My Awesome Modpack", "version": "1.0.0", "author": "Your Name", "minecraft": { "version": "1.19.2", "modLoaders": [ { "id": "forge-43.2.0", "primary": true } ] }, "files": [ { "projectID": 238222, "fileID": 4087234, "required": true }, { "projectID": 283797, "fileID": 4123456, "required": true } ], "overrides": "overrides" } ``` * `projectID` and `fileID` refer to the mod's ID and file ID on CurseForge. * `overrides` specifies a folder containing configuration files and other assets that should be copied to the Minecraft instance. **In summary:** Using Cursor with a GitHub MCP server involves downloading the modpack files from GitHub, importing them into Cursor, and then copying the necessary files to your Minecraft server. Pay close attention to mod versions and server configuration. If you provide more specific details about the GitHub repository you're working with, I can give you more tailored instructions.

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.