Discover Awesome MCP Servers

Bailian Voice Clone MCP

Enables voice cloning and speech synthesis through Alibaba Cloud's Bailian and DashScope platforms. It provides tools to create, manage, and synthesize audio using custom cloned voice profiles.

Omni Server

Un servidor MCP para familiarizarse con el Protocolo de Contexto de Modelos.

myinstants-mcp

Enables AI agents to search, browse, and play millions of meme sounds and sound effects from myinstants.com directly through the user's speakers. It supports streaming audio for trending clips, categories, and viral soundboard buttons to enhance agent interactions with reactive audio.

Domain Check MCP Server

Okay, here's a translation of the English text "A Model Context Protocol (MCP) server for checking domain availability using IONOS endpoints" into Spanish, along with a few options depending on the nuance you want to convey: **Option 1 (Most Direct):** * Un servidor de Protocolo de Contexto de Modelo (MCP) para verificar la disponibilidad de dominios utilizando los endpoints de IONOS. **Option 2 (Slightly More Explanatory):** * Un servidor MCP (Protocolo de Contexto de Modelo) para la comprobación de la disponibilidad de dominios a través de los endpoints de IONOS. **Option 3 (Focus on Functionality):** * Un servidor basado en el Protocolo de Contexto de Modelo (MCP) para la verificación de la disponibilidad de dominios, utilizando los endpoints de IONOS. **Explanation of Choices:** * **"Servidor"** translates directly to "server." * **"Protocolo de Contexto de Modelo (MCP)"** is kept as is, assuming "MCP" is a well-known acronym in the target audience. If not, you might consider adding a brief explanation in parentheses the first time it's used. * **"Verificar la disponibilidad de dominios"** is the most common and direct translation of "checking domain availability." "Comprobación de la disponibilidad de dominios" is also correct and slightly more formal. * **"Utilizando los endpoints de IONOS"** is a direct and clear translation of "using IONOS endpoints." "A través de los endpoints de IONOS" is also a good alternative. * **"Basado en el Protocolo de Contexto de Modelo (MCP)"** emphasizes that the server's functionality is built upon the MCP protocol. **Which option is best depends on the context:** * If you're writing technical documentation, Option 1 or 2 are likely the best. * If you're trying to emphasize the server's purpose, Option 3 might be more suitable. I hope this helps!

MCP SQL Server Pro

Provides direct SQL query access to Microsoft SQL Server databases with full CRUD operations, enabling AI assistants to execute queries, modify data, and manage database objects through a simplified interface.

MCP TS Quickstart

Okay, here's a guide to creating a build-less TypeScript quickstart for an MCP (presumably Minecraft Protocol) server implementation. This approach prioritizes speed of setup and iteration, sacrificing some performance and type-checking rigor in the process. **Be aware that this is for quick prototyping and experimentation, not production.** **Important Considerations:** * **Performance:** Running TypeScript directly without compilation is significantly slower than running compiled JavaScript. This is fine for small-scale testing, but not for handling many concurrent players. * **Type Checking:** You'll lose some of the benefits of TypeScript's static type checking at runtime. You'll need to be extra careful with your code. * **Module Resolution:** This approach relies on browser-style module resolution, which might not be ideal for larger projects. * **Error Handling:** Runtime errors might be less informative than compile-time errors. **Steps:** 1. **Project Setup:** * Create a new directory for your project: ```bash mkdir mcp-server-quickstart cd mcp-server-quickstart ``` * Initialize a `package.json` file (you can accept the defaults): ```bash npm init -y ``` * Install `ts-node` and `typescript` as development dependencies: ```bash npm install --save-dev ts-node typescript ``` * Create a `tsconfig.json` file. This is important for configuring TypeScript's behavior, even if we're not explicitly compiling. A minimal configuration is sufficient: ```json { "compilerOptions": { "target": "esnext", "module": "esnext", "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "dist" // Important to prevent ts-node from writing files to source directory }, "include": ["src/**/*"] } ``` **Explanation of `tsconfig.json` options:** * `target`: Specifies the ECMAScript target version. `esnext` is generally a good choice for modern environments. * `module`: Specifies the module system. `esnext` allows for modern `import` and `export` syntax. * `moduleResolution`: `node` tells TypeScript to use Node.js-style module resolution. * `esModuleInterop`: Enables interoperability between CommonJS and ES modules. This is often necessary when working with Node.js packages. * `forceConsistentCasingInFileNames`: Helps prevent issues with case-sensitive file systems. * `strict`: Enables all strict type-checking options. This is highly recommended for catching errors early. * `skipLibCheck`: Skips type checking of declaration files (`.d.ts`). This can speed up compilation, but might hide some errors. * `outDir`: Specifies the output directory for compiled JavaScript files. This is important even though we're not explicitly compiling, as `ts-node` might still attempt to write files. Setting it to "dist" prevents it from writing to the source directory. * `include`: Specifies the files to include in the compilation. Here, we include all TypeScript files in the `src` directory. * Create a `src` directory: ```bash mkdir src ``` 2. **Basic Server Implementation (src/index.ts):** ```typescript import net from 'net'; const PORT = 25565; // Default Minecraft port const server = net.createServer((socket) => { console.log(`Client connected: ${socket.remoteAddress}:${socket.remotePort}`); socket.on('data', (data) => { console.log(`Received data: ${data.toString()}`); // TODO: Implement Minecraft protocol handling here socket.write('Hello from the server!\n'); // Example response }); socket.on('end', () => { console.log(`Client disconnected: ${socket.remoteAddress}:${socket.remotePort}`); }); socket.on('error', (err) => { console.error(`Socket error: ${err}`); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); server.on('error', (err) => { console.error(`Server error: ${err}`); }); ``` **Explanation:** * **`net` module:** This is Node.js's built-in networking module. * **`createServer`:** Creates a TCP server. The callback function is executed for each new client connection. * **`socket`:** Represents the connection to a client. * **`socket.on('data', ...)`:** Handles data received from the client. This is where you'll need to implement the Minecraft protocol parsing and handling. * **`socket.write(...)`:** Sends data back to the client. * **`socket.on('end', ...)`:** Handles client disconnection. * **`socket.on('error', ...)`:** Handles socket errors. * **`server.listen(PORT, ...)`:** Starts the server listening on the specified port. * **`server.on('error', ...)`:** Handles server errors. 3. **Running the Server:** * Add a `start` script to your `package.json`: ```json { "name": "mcp-server-quickstart", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "ts-node src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "ts-node": "^10.9.2", "typescript": "^5.3.3" } } ``` * Run the server: ```bash npm start ``` You should see the message "Server listening on port 25565" in your console. 4. **Testing (Optional):** * You can use `telnet` or a simple TCP client to connect to the server and send data. For example: ```bash telnet localhost 25565 ``` Type some text and press Enter. You should see the server log the received data and send back "Hello from the server!". 5. **Next Steps (Implementing the Minecraft Protocol):** * **Understand the Minecraft Protocol:** This is the most important part. Refer to the official Minecraft protocol documentation (search for "Minecraft Protocol" on the Minecraft Wiki or other resources). It's complex and involves packet structures, compression, encryption, and state management. * **Packet Parsing and Serialization:** You'll need to implement code to parse incoming data into Minecraft packets and serialize outgoing packets into binary data. Consider using a library for this, but for a quickstart, you might want to start with manual parsing. * **State Management:** Keep track of the client's state (e.g., handshake status, login status, game state). * **Authentication:** Implement authentication if you want to require players to log in with their Minecraft accounts. * **Game Logic:** Start implementing the core game logic (e.g., handling player movement, block updates, chat messages). **Example of Basic Packet Handling (Illustrative - Requires More Detail):** ```typescript // src/index.ts (modified) import net from 'net'; const PORT = 25565; const server = net.createServer((socket) => { console.log(`Client connected: ${socket.remoteAddress}:${socket.remotePort}`); socket.on('data', (data) => { console.log(`Received data: ${data.toString('hex')}`); // Log raw data as hex // **VERY BASIC EXAMPLE - REPLACE WITH PROPER PROTOCOL PARSING** if (data.length > 0) { const packetId = data[0]; // First byte is often the packet ID switch (packetId) { case 0x00: // Example: Handshake packet ID console.log("Received Handshake packet"); // TODO: Parse the handshake packet data socket.write(Buffer.from([0x00, 0x00])); // Example response break; default: console.log(`Unknown packet ID: ${packetId}`); break; } } }); socket.on('end', () => { console.log(`Client disconnected: ${socket.remoteAddress}:${socket.remotePort}`); }); socket.on('error', (err) => { console.error(`Socket error: ${err}`); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); server.on('error', (err) => { console.error(`Server error: ${err}`); }); ``` **Important Notes:** * **Error Handling:** Add robust error handling to your code. Catch exceptions and log errors appropriately. * **Security:** Be aware of security vulnerabilities, especially when handling network data. Sanitize inputs and protect against common attacks. * **Libraries:** Consider using libraries for tasks like: * **Protocol Parsing:** Libraries specifically designed for parsing the Minecraft protocol. * **Data Compression:** Libraries for handling zlib compression (used in the Minecraft protocol). * **Encryption:** Libraries for handling encryption (used for authentication). * **Refactoring:** As your project grows, refactor your code to improve readability, maintainability, and performance. Consider using classes, interfaces, and modules to organize your code. This quickstart provides a basic foundation for building an MCP server in TypeScript without a build step. Remember that this approach is best suited for rapid prototyping and experimentation. For production environments, you'll need to compile your TypeScript code to JavaScript and optimize your code for performance. Good luck!

서울시 교통 데이터 MCP 서버

서울시 교통 데이터 MCP 서버 - 실시간 교통 정보, 대중교통, 따릉이 등의 데이터를 제공하는 MCP 서버

Spec-driven Development MCP Server

Enables AI-guided spec-driven development workflow that transforms ideas into implementation through structured stages: goal collection, requirements gathering in EARS format, technical design documentation, task planning, and systematic code execution.

MCP Pokemon Server

An MCP server implementation that enables users to interact with the PokeAPI to fetch Pokemon information through natural language queries.

GitLab MCP Server

Enables AI assistants to interact with GitLab for managing projects, branches, issues, and merge requests. It provides tools for searching code and performing file operations like reading and writing directly within repositories.

Weather Union MCP Server

Provides real-time weather data and air quality information for geographic coordinates or major Indian cities using the Weather Union API.

ClickUp MCP Server

Provides integration with ClickUp's API, allowing you to retrieve task information and manage ClickUp data through MCP-compatible clients.

Make.com MCP Server

Enables Claude Desktop to trigger and interact with Make.com automation scenarios through webhooks. Allows users to execute complex workflows and integrations with third-party services like Google Sheets, Notion, and Slack using natural language commands.

konquest-meta-ads-mcp

Supervised Meta Ads operating system for Claude Code. 57 tools for campaign management, multi-asset ads, targeting, pixel diagnostics, catalogs, and safety gates. All ads created PAUSED - operator approves every action.

Perplexity API Platform MCP Server

Provides AI assistants with real-time web search, reasoning, and research capabilities through Perplexity's Sonar models and Search API. Supports quick searches, deep research, advanced reasoning, and direct web search with ranked results.

mcptut1

Aquí tienes un tutorial sobre servidores y clientes MCP (Minecraft Coder Pack): **Título: Tutorial de Servidor y Cliente MCP (Minecraft Coder Pack)** **Introducción:** Este tutorial te guiará a través de los conceptos básicos para configurar un entorno de desarrollo con MCP (Minecraft Coder Pack) para modificar tanto el lado del servidor como el del cliente de Minecraft. MCP te permite descompilar, desensamblar y recompilar el código de Minecraft, facilitando la creación de mods. **Requisitos Previos:** * **Java Development Kit (JDK):** Asegúrate de tener instalado el JDK (Java Development Kit) más reciente. Puedes descargarlo desde el sitio web de Oracle o Adoptium. * **Minecraft:** Necesitas una copia legítima de Minecraft. * **MCP (Minecraft Coder Pack):** Descarga la versión de MCP que corresponda a la versión de Minecraft que deseas modificar. Puedes encontrarlo en foros de modding o sitios web dedicados. * **IDE (Entorno de Desarrollo Integrado):** Se recomienda usar un IDE como Eclipse o IntelliJ IDEA. Este tutorial asume que usas Eclipse. **Pasos:** **1. Configuración de MCP:** * **Extraer MCP:** Extrae el archivo ZIP de MCP en una carpeta de tu elección. Por ejemplo, `C:\MCP`. * **Configurar `conf/mcp.cfg`:** Abre el archivo `conf/mcp.cfg` con un editor de texto. Asegúrate de que las siguientes variables estén configuradas correctamente: * `ClientVersion = [Versión de Minecraft]` (Ejemplo: `ClientVersion = 1.19.2`) * `ServerVersion = [Versión de Minecraft]` (Ejemplo: `ServerVersion = 1.19.2`) * `MCPDeobfuscated = True` (Esto es importante para usar nombres legibles en el código) * **Ejecutar `decompile.bat` (Windows) o `decompile.sh` (Linux/macOS):** Abre una ventana de comandos (cmd en Windows, terminal en Linux/macOS) y navega hasta la carpeta de MCP. Ejecuta el script `decompile.bat` o `decompile.sh`. Este proceso descargará Minecraft, descompilará el código y aplicará los nombres deobfuscados. **Este proceso puede tardar bastante tiempo.** **2. Configuración del IDE (Eclipse):** * **Crear un nuevo espacio de trabajo:** Abre Eclipse y crea un nuevo espacio de trabajo en una ubicación diferente a la carpeta de MCP. Por ejemplo, `C:\Workspace`. * **Importar los proyectos MCP:** * Ve a `File -> Import -> General -> Existing Projects into Workspace`. * Haz clic en "Browse" y selecciona la carpeta de MCP. * Deberías ver dos proyectos: `Client` y `Server`. Selecciona ambos y haz clic en "Finish". **3. Entendiendo la Estructura del Proyecto:** * **`Client`:** Contiene el código del cliente de Minecraft. La mayoría de los archivos importantes se encuentran en `Client/src/main/java`. * **`Server`:** Contiene el código del servidor de Minecraft. La mayoría de los archivos importantes se encuentran en `Server/src/main/java`. * **`jars`:** Contiene los archivos JAR originales de Minecraft y los archivos JAR modificados después de la recompilación. * **`lib`:** Contiene las bibliotecas necesarias para compilar el código. **4. Modificando el Código del Cliente:** * **Ejemplo: Imprimir un mensaje en la consola al iniciar Minecraft:** * Navega a `Client/src/main/java` y busca la clase principal de Minecraft. En versiones más antiguas, suele ser `net.minecraft.client.Minecraft`. En versiones más recientes, puede estar en un paquete diferente. Usa la función de búsqueda de Eclipse (Ctrl+H) para encontrar la clase que contiene el método `main`. * Abre la clase y busca el método `main`. * Añade la siguiente línea de código dentro del método `main`: ```java System.out.println("¡Hola desde el cliente modificado!"); ``` * **Recompilar el Cliente:** * Haz clic derecho en el proyecto `Client` en el Explorador de Proyectos. * Selecciona `Build Project`. **5. Modificando el Código del Servidor:** * **Ejemplo: Imprimir un mensaje en la consola al iniciar el servidor:** * Navega a `Server/src/main/java` y busca la clase principal del servidor. En versiones más antiguas, suele ser `net.minecraft.server.MinecraftServer`. En versiones más recientes, puede estar en un paquete diferente. Usa la función de búsqueda de Eclipse (Ctrl+H) para encontrar la clase que contiene el método `main`. * Abre la clase y busca el método `main`. * Añade la siguiente línea de código dentro del método `main`: ```java System.out.println("¡Hola desde el servidor modificado!"); ``` * **Recompilar el Servidor:** * Haz clic derecho en el proyecto `Server` en el Explorador de Proyectos. * Selecciona `Build Project`. **6. Reobfuscación y Copia de Archivos:** * **Reobfuscación:** Después de realizar cambios, necesitas reobfuscar el código para que sea compatible con Minecraft. En la ventana de comandos, ejecuta el script `reobfuscate.bat` (Windows) o `reobfuscate.sh` (Linux/macOS). * **Copiar los archivos modificados:** * **Cliente:** El archivo JAR modificado del cliente se encuentra en `jars/versions/[Versión de Minecraft]/[Versión de Minecraft]_client.jar`. Copia este archivo y reemplaza el archivo original en la carpeta de versiones de Minecraft (ubicada en `.minecraft/versions/[Versión de Minecraft]/`). **¡Haz una copia de seguridad del archivo original antes de reemplazarlo!** * **Servidor:** El archivo JAR modificado del servidor se encuentra en `jars/versions/[Versión de Minecraft]/[Versión de Minecraft]_server.jar`. Copia este archivo y úsalo para iniciar tu servidor modificado. **7. Ejecutar Minecraft Modificado:** * **Cliente:** Inicia el lanzador de Minecraft y selecciona el perfil de la versión que modificaste. Deberías ver el mensaje "¡Hola desde el cliente modificado!" en la consola del lanzador. * **Servidor:** Ejecuta el archivo JAR del servidor modificado. Deberías ver el mensaje "¡Hola desde el servidor modificado!" en la consola del servidor. **Consejos y Trucos:** * **Usa un descompilador:** Si necesitas entender el código original de Minecraft, usa un descompilador como CFR o Fernflower. Eclipse tiene plugins que te permiten descompilar clases directamente. * **Documentación de Minecraft:** La documentación oficial de Minecraft es limitada, pero puedes encontrar información útil en la wiki de Minecraft y en foros de modding. * **Depuración:** Usa las herramientas de depuración de Eclipse para encontrar y corregir errores en tu código. * **Control de versiones:** Usa un sistema de control de versiones como Git para realizar un seguimiento de tus cambios y colaborar con otros modders. **Conclusión:** Este tutorial te proporciona los pasos básicos para configurar un entorno de desarrollo con MCP y modificar el código del cliente y del servidor de Minecraft. A partir de aquí, puedes explorar el código de Minecraft, aprender sobre las diferentes clases y métodos, y crear tus propios mods. ¡Buena suerte! **Advertencia:** Modificar el código de Minecraft puede ser complicado y puede causar problemas de estabilidad. Siempre haz una copia de seguridad de tus archivos antes de realizar cambios. Además, ten en cuenta que las actualizaciones de Minecraft pueden romper tus mods, por lo que es importante mantener tu MCP actualizado.

MCP Installer

A "MCP server that searches MCP servers" is a bit ambiguous. To translate it accurately, I need to understand what "MCP" refers to. Here are a few possibilities and their translations: **Possibility 1: MCP refers to Minecraft Protocol (most likely)** * **English:** Minecraft Protocol server that searches Minecraft Protocol servers. * **Spanish:** Servidor de Protocolo de Minecraft que busca servidores de Protocolo de Minecraft. **Possibility 2: MCP refers to a specific Minecraft modpack or server software (less likely, but possible)** * **English:** MCP server that searches MCP servers (assuming MCP is the name of the modpack/software). * **Spanish:** Servidor MCP que busca servidores MCP. **Possibility 3: MCP refers to something completely different (unlikely without more context)** If "MCP" has a different meaning, please provide more context so I can give you an accurate translation. **Therefore, the most likely and generally applicable translation is:** **Servidor de Protocolo de Minecraft que busca servidores de Protocolo de Minecraft.**

Moltjiji

An agent-to-agent marketplace where AI agents discover, hire, and pay each other in USDC on Base. Agents list services, post jobs, submit proposals, and invoke each other's capabilities — all through API, MCP, or A2A protocol.

Stealthee MCP

Enables detection and analysis of pre-public product launches through web search, content extraction, AI-powered scoring, and automated alerting. Provides comprehensive tools for surfacing stealth startup signals before they trend publicly.

MCP Weather Server

Provides real-time weather data and 5-day forecasts using OpenWeatherMap API. Supports querying by city name, country code, or geographic coordinates with detailed climate information including temperature, humidity, wind, and UV index.

Google Drive HPC Log Analyzer

Enables Claude to directly access Google Drive files and analyze High Performance Computing (HPC) log files. Automatically detects common HPC issues like memory errors, job timeouts, and resource allocation problems.

Filesystem MCP Server (@shtse8/filesystem-mcp)

Servidor Node.js del Protocolo de Contexto de Modelo (MCP) que proporciona acceso seguro y relativo al sistema de archivos para agentes de IA como Cline/Claude.

MCP English Tutor

A professional 1-on-1 English tutoring server that enables AI assistants to provide oral practice, grammar correction, and vocabulary recommendations. It features specialized tools for generating conversation topics, tracking progress, and creating immersive role-play scenarios.

Pokemon MCP Server

Simulates a Pokemon battle system by providing tools for managing Pokemon, executing turn-based combat, and analyzing type effectiveness. It enables AI models to facilitate interactive battles, generate random creatures, and implement complex battle strategies.

Browse Together MCP

Co-navega con tu IA mientras editas código. Un navegador controlado por Playwright con interfaz gráfica y un servidor MCP adjunto.

Aseprite MCP Tools

Servidor MCP para interactuar con la API de Aseprite

NocoDB MCP Server

Enables direct integration with NocoDB databases from Cursor IDE, providing complete CRUD operations, search capabilities, and specialized tools for Discord workflow automation. Features production-ready deployment with Docker support and comprehensive monitoring.

Finance MCP Server

Un servidor MCP mínimo construido con Python que expone dos herramientas de ejemplo: una para convertir el nombre de una empresa en un símbolo bursátil y otra para obtener datos financieros de Yahoo Finance. El proyecto se centra en aprender a construir y ejecutar un servidor MCP, utilizando un escenario financiero simple puramente como caso de uso de demostración.

hokan MCP Server

An unofficial MCP server that integrates with the hokan Insurance CRM API v2 to manage customer data, schedules, and tasks. It also features specialized tools for Japanese insurance law compliance, including intent confirmation and regulatory check generation.