Discover Awesome MCP Servers

etfedge-mcp

Read-only MCP server for Taiwan active ETF research database, providing tools to list ETFs, track buy/sell deltas, view stock history and PnL, and find consensus buys across ETFs.

arcgis-glasgow

Enables querying Glasgow City Council GIS open geospatial datasets (parcels, zoning, public works) via natural language or direct tools: search datasets, query layers with SQL-like filters, and retrieve layer schemas.

mcp-examples

Enables retrieving user and post data through MCP tools, with Zod-based request validation and OpenAPI/Swagger UI support.

MCP Node Server

Here's a basic Node.js server example that could be used as a starting point for an MCP (presumably, you mean Minecraft Protocol) server. Keep in mind that building a full Minecraft server from scratch is a *very* complex undertaking. This example focuses on the initial connection and handshake. You'll need to install the `node-minecraft-protocol` library to make this work. ```bash npm install minecraft-protocol ``` ```javascript const mc = require('minecraft-protocol'); const server = mc.createServer({ 'online-mode': false, // Set to true for authentication with Mojang servers host: '0.0.0.0', // Listen on all interfaces port: 25565, // Default Minecraft port version: '1.19.4', // Specify the Minecraft version (adjust as needed) maxPlayers: 10, // Maximum number of players motd: "My Awesome MCP Server" // Message of the day }); server.on('login', (client) => { console.log(`${client.username} connected`); // Send a join game packet (required) client.write('login', { entityId: client.id, isHardcore: false, gameMode: 0, // 0: Survival, 1: Creative, 2: Adventure, 3: Spectator previousGameMode: -1, worldNames: [ 'minecraft:overworld' ], dimensionCodec: { dimension: { type: 'compound', name: 'dimension', value: { ambient_light: { type: 'float', value: 0.0 }, bed_works: { type: 'byte', value: 1 }, coordinate_scale: { type: 'double', value: 1.0 }, effects: { type: 'string', value: 'minecraft:overworld' }, fixed_time: { type: 'long', value: 6000 }, has_ceiling: { type: 'byte', value: 0 }, has_raids: { type: 'byte', value: 0 }, has_skylight: { type: 'byte', value: 1 }, height: { type: 'int', value: 384 }, infiniburn: { type: 'string', value: 'minecraft:infiniburn_overworld' }, logical_height: { type: 'int', value: 384 }, min_y: { type: 'int', value: -64 }, monster_spawn_block_light_limit: { type: 'int', value: 0 }, monster_spawn_light_level: { type: 'int', value: 7 }, natural: { type: 'byte', value: 1 }, piglin_safe: { type: 'byte', value: 0 }, respawn_anchor_works: { type: 'byte', value: 0 }, require_skylight: { type: 'byte', value: 1 }, ultrawarm: { type: 'byte', value: 0 } } } }, dimension: 'minecraft:overworld', seed: [0, 0], maxPlayers: server.maxPlayers, isFlat: false, isDebug: false, hasLimitedFeature: false }); // Send position and look (required) client.write('position', { x: 0, y: 64, z: 0, yaw: 0, pitch: 0, flags: 0, teleportId: 0 }); // Send a chat message to the player client.write('chat', { message: JSON.stringify({ translate: 'chat.type.announcement', with: [ 'Server', 'Welcome to the server!' ] }), position: 0, // 0: chat, 1: system message, 2: game_info sender: '0' }); client.on('end', () => { console.log(`${client.username} disconnected`); }); client.on('error', (err) => { console.log(`Client ${client.username} error: ${err}`); }); }); server.on('listening', () => { console.log(`Server listening on port ${server.socketServer.address().port}`); }); server.on('error', (err) => { console.log(`Server error: ${err}`); }); ``` Key improvements and explanations: * **`npm install minecraft-protocol`**: This is *essential*. You need to install the `minecraft-protocol` library. * **`require('minecraft-protocol')`**: Imports the necessary library. * **`createServer` options:** * `'online-mode': false` : Disables authentication with Mojang's servers. **Use with caution!** This makes your server vulnerable to impersonation. Set to `true` for a production server. If set to `true`, players *must* have a valid Minecraft account to join. * `host: '0.0.0.0'` : Listens on all network interfaces. This is usually what you want. * `port: 25565` : The default Minecraft port. * `version: '1.19.4'` : **CRITICAL:** Specifies the Minecraft version the server is compatible with. This *must* match the version the client is using. Check the `minecraft-protocol` documentation for supported versions. Using the wrong version will cause connection errors. * `maxPlayers: 10` : Sets the maximum number of players allowed on the server. * `motd: "My Awesome MCP Server"` : Sets the message of the day that is displayed in the Minecraft client's server list. * **`server.on('login', (client) => { ... });`**: This is the most important part. This event handler is called when a client successfully connects to the server and completes the initial handshake. * **`client.username`**: The username of the connecting player. * **`client.write('login', { ... });`**: This sends the "login" packet to the client. This packet is *required* for the client to properly join the game. The contents of this packet are very important and depend on the Minecraft version. The example provides a basic configuration. The `dimensionCodec` and `dimension` data structures are complex and version-dependent. You'll likely need to adjust these based on the specific Minecraft version you're targeting. The example includes a basic `dimensionCodec` for the overworld. * **`client.write('position', { ... });`**: Sends the player's initial position and rotation. This is also *required*. * **`client.write('chat', { ... });`**: Sends a chat message to the player. This is just an example of how to send data to the client. The `message` field is a JSON string representing the chat message. The `translate` field is used for localization. * **`client.on('end', () => { ... });`**: Handles client disconnections. * **`client.on('error', (err) => { ... });`**: Handles client errors. Important for debugging. * **`server.on('listening', () => { ... });`**: Called when the server starts listening for connections. * **`server.on('error', (err) => { ... });`**: Handles server-level errors. **How to run it:** 1. Save the code as a `.js` file (e.g., `mcp_server.js`). 2. Open a terminal or command prompt. 3. Navigate to the directory where you saved the file. 4. Run the server using `node mcp_server.js`. **Important Considerations and Next Steps:** * **Minecraft Protocol Complexity:** The Minecraft protocol is *extremely* complex. This example only handles the initial connection. To build a functional server, you'll need to implement handling for many other packets, including: * Chunk data (sending the world to the client) * Player movement * Entity management * Block updates * Chat messages * Inventory management * And much, much more. * **World Generation:** You'll need to generate or load a Minecraft world. The example doesn't include any world generation. You'll need to use a library or implement your own world generation algorithm. * **Entity Management:** You'll need to manage entities (players, mobs, items) in the world. * **Security:** If you enable `online-mode`, you'll need to handle authentication with Mojang's servers securely. If you disable `online-mode`, you'll need to implement your own authentication system to prevent impersonation. * **Performance:** Building a high-performance Minecraft server is challenging. You'll need to optimize your code to handle a large number of players and entities. * **Libraries:** Consider using existing Minecraft server libraries or frameworks to simplify the development process. While `minecraft-protocol` handles the protocol itself, you'll likely want higher-level abstractions for world management, entity management, and game logic. * **Version Compatibility:** The Minecraft protocol changes frequently. Make sure your server is compatible with the Minecraft version you're targeting. The `minecraft-protocol` library provides support for multiple versions, but you'll need to update your code when a new version is released. This example provides a basic foundation. Building a full Minecraft server is a significant undertaking. Be prepared to invest a lot of time and effort. Start with small, manageable steps, and gradually add more features. Good luck! ```spanish Aquí tienes un ejemplo básico de un servidor Node.js que podría usarse como punto de partida para un servidor MCP (presumiblemente, te refieres al Protocolo de Minecraft). Ten en cuenta que construir un servidor de Minecraft completo desde cero es una tarea *muy* compleja. Este ejemplo se centra en la conexión inicial y el handshake. Necesitarás instalar la librería `node-minecraft-protocol` para que esto funcione. ```bash npm install minecraft-protocol ``` ```javascript const mc = require('minecraft-protocol'); const server = mc.createServer({ 'online-mode': false, // Establecer a true para la autenticación con los servidores de Mojang host: '0.0.0.0', // Escuchar en todas las interfaces port: 25565, // Puerto predeterminado de Minecraft version: '1.19.4', // Especifica la versión de Minecraft (ajusta según sea necesario) maxPlayers: 10, // Número máximo de jugadores motd: "Mi Increíble Servidor MCP" // Mensaje del día }); server.on('login', (client) => { console.log(`${client.username} conectado`); // Envía un paquete de unión al juego (requerido) client.write('login', { entityId: client.id, isHardcore: false, gameMode: 0, // 0: Supervivencia, 1: Creativo, 2: Aventura, 3: Espectador previousGameMode: -1, worldNames: [ 'minecraft:overworld' ], dimensionCodec: { dimension: { type: 'compound', name: 'dimension', value: { ambient_light: { type: 'float', value: 0.0 }, bed_works: { type: 'byte', value: 1 }, coordinate_scale: { type: 'double', value: 1.0 }, effects: { type: 'string', value: 'minecraft:overworld' }, fixed_time: { type: 'long', value: 6000 }, has_ceiling: { type: 'byte', value: 0 }, has_raids: { type: 'byte', value: 0 }, has_skylight: { type: 'byte', value: 1 }, height: { type: 'int', value: 384 }, infiniburn: { type: 'string', value: 'minecraft:infiniburn_overworld' }, logical_height: { type: 'int', value: 384 }, min_y: { type: 'int', value: -64 }, monster_spawn_block_light_limit: { type: 'int', value: 0 }, monster_spawn_light_level: { type: 'int', value: 7 }, natural: { type: 'byte', value: 1 }, piglin_safe: { type: 'byte', value: 0 }, respawn_anchor_works: { type: 'byte', value: 0 }, require_skylight: { type: 'byte', value: 1 }, ultrawarm: { type: 'byte', value: 0 } } } }, dimension: 'minecraft:overworld', seed: [0, 0], maxPlayers: server.maxPlayers, isFlat: false, isDebug: false, hasLimitedFeature: false }); // Envía la posición y la mirada (requerido) client.write('position', { x: 0, y: 64, z: 0, yaw: 0, pitch: 0, flags: 0, teleportId: 0 }); // Envía un mensaje de chat al jugador client.write('chat', { message: JSON.stringify({ translate: 'chat.type.announcement', with: [ 'Server', '¡Bienvenido al servidor!' ] }), position: 0, // 0: chat, 1: mensaje del sistema, 2: game_info sender: '0' }); client.on('end', () => { console.log(`${client.username} desconectado`); }); client.on('error', (err) => { console.log(`Error del cliente ${client.username}: ${err}`); }); }); server.on('listening', () => { console.log(`Servidor escuchando en el puerto ${server.socketServer.address().port}`); }); server.on('error', (err) => { console.log(`Error del servidor: ${err}`); }); ``` Mejoras clave y explicaciones: * **`npm install minecraft-protocol`**: Esto es *esencial*. Necesitas instalar la librería `minecraft-protocol`. * **`require('minecraft-protocol')`**: Importa la librería necesaria. * **Opciones de `createServer`:** * `'online-mode': false` : Desactiva la autenticación con los servidores de Mojang. **¡Úsalo con precaución!** Esto hace que tu servidor sea vulnerable a la suplantación de identidad. Establecer a `true` para un servidor de producción. Si se establece en `true`, los jugadores *deben* tener una cuenta de Minecraft válida para unirse. * `host: '0.0.0.0'` : Escucha en todas las interfaces de red. Esto es generalmente lo que quieres. * `port: 25565` : El puerto predeterminado de Minecraft. * `version: '1.19.4'` : **CRÍTICO:** Especifica la versión de Minecraft con la que el servidor es compatible. Esto *debe* coincidir con la versión que está utilizando el cliente. Consulta la documentación de `minecraft-protocol` para ver las versiones compatibles. Usar la versión incorrecta causará errores de conexión. * `maxPlayers: 10` : Establece el número máximo de jugadores permitidos en el servidor. * `motd: "Mi Increíble Servidor MCP"` : Establece el mensaje del día que se muestra en la lista de servidores del cliente de Minecraft. * **`server.on('login', (client) => { ... });`**: Esta es la parte más importante. Este controlador de eventos se llama cuando un cliente se conecta correctamente al servidor y completa el handshake inicial. * **`client.username`**: El nombre de usuario del jugador que se conecta. * **`client.write('login', { ... });`**: Esto envía el paquete "login" al cliente. Este paquete es *requerido* para que el cliente se una correctamente al juego. El contenido de este paquete es muy importante y depende de la versión de Minecraft. El ejemplo proporciona una configuración básica. Las estructuras de datos `dimensionCodec` y `dimension` son complejas y dependen de la versión. Es probable que necesites ajustar esto en función de la versión específica de Minecraft a la que te diriges. El ejemplo incluye un `dimensionCodec` básico para el supramundo. * **`client.write('position', { ... });`**: Envía la posición y rotación inicial del jugador. Esto también es *requerido*. * **`client.write('chat', { ... });`**: Envía un mensaje de chat al jugador. Esto es solo un ejemplo de cómo enviar datos al cliente. El campo `message` es una cadena JSON que representa el mensaje de chat. El campo `translate` se utiliza para la localización. * **`client.on('end', () => { ... });`**: Maneja las desconexiones del cliente. * **`client.on('error', (err) => { ... });`**: Maneja los errores del cliente. Importante para la depuración. * **`server.on('listening', () => { ... });`**: Se llama cuando el servidor comienza a escuchar las conexiones. * **`server.on('error', (err) => { ... });`**: Maneja los errores a nivel del servidor. **Cómo ejecutarlo:** 1. Guarda el código como un archivo `.js` (por ejemplo, `mcp_server.js`). 2. Abre una terminal o símbolo del sistema. 3. Navega al directorio donde guardaste el archivo. 4. Ejecuta el servidor usando `node mcp_server.js`. **Consideraciones importantes y próximos pasos:** * **Complejidad del protocolo de Minecraft:** El protocolo de Minecraft es *extremadamente* complejo. Este ejemplo solo maneja la conexión inicial. Para construir un servidor funcional, necesitarás implementar el manejo de muchos otros paquetes, incluyendo: * Datos del chunk (enviar el mundo al cliente) * Movimiento del jugador * Gestión de entidades * Actualizaciones de bloques * Mensajes de chat * Gestión de inventario * Y mucho, mucho más. * **Generación del mundo:** Necesitarás generar o cargar un mundo de Minecraft. El ejemplo no incluye ninguna generación de mundo. Necesitarás usar una librería o implementar tu propio algoritmo de generación de mundo. * **Gestión de entidades:** Necesitarás gestionar las entidades (jugadores, mobs, objetos) en el mundo. * **Seguridad:** Si habilitas `online-mode`, necesitarás manejar la autenticación con los servidores de Mojang de forma segura. Si deshabilitas `online-mode`, necesitarás implementar tu propio sistema de autenticación para evitar la suplantación de identidad. * **Rendimiento:** Construir un servidor de Minecraft de alto rendimiento es un desafío. Necesitarás optimizar tu código para manejar un gran número de jugadores y entidades. * **Librerías:** Considera usar librerías o frameworks de servidores de Minecraft existentes para simplificar el proceso de desarrollo. Si bien `minecraft-protocol` maneja el protocolo en sí, es probable que desees abstracciones de nivel superior para la gestión del mundo, la gestión de entidades y la lógica del juego. * **Compatibilidad de versiones:** El protocolo de Minecraft cambia con frecuencia. Asegúrate de que tu servidor sea compatible con la versión de Minecraft a la que te diriges. La librería `minecraft-protocol` proporciona soporte para múltiples versiones, pero necesitarás actualizar tu código cuando se lance una nueva versión. Este ejemplo proporciona una base básica. Construir un servidor de Minecraft completo es una tarea importante. Prepárate para invertir mucho tiempo y esfuerzo. Comienza con pasos pequeños y manejables, y agrega gradualmente más funciones. ¡Buena suerte!

Remotion Video Production MCP Server

Enables AI agents to programmatically scaffold Remotion projects, analyze audio for beat-synced scenes, synthesize voiceovers with word-level timecodes, preview frames, and render finished videos.

auditreach

BYOK Reddit/YouTube research CLI with a tamper-evident, hash-chained audit log. Includes an MCP server for agent-native use.

Mobbin Agent

MCP server that gives AI agents browser-based access to Mobbin for design research, screen discovery, and screenshot collection through automated browser control.

Plaud

Enables read-only, natural-language access to Plaud recordings, including listing recordings, retrieving speaker-attributed transcripts, AI-generated summaries, action items, and user data through MCP tools.

pidp10-mcp

An MCP server for driving an ITS session on a PiDP-10 emulator over raw TCP, supporting persistent connections, raw control-byte transmission, and escape syntax for DDT commands. It enables interaction with ITS systems through natural language via MCP tools like open, send, read, and status.

Java Map Component Platform (Java MCP)

Servidor Java MCP

Amadeus-QQ-MCP

An MCP server that enables AI clients to send and receive QQ messages through NapCatQQ (OneBot v11) for both private and group chats. It supports message context management, real-time WebSocket listening, and human-like typing simulation.

RhinoMCP

Connects Rhino and Grasshopper to Claude AI via the Model Context Protocol, enabling prompt-assisted 3D modeling, scene manipulation, and control through tools like object creation, layer management, and code execution.

Apollo.io MCP Server

A Model Context Protocol (MCP) server for the Apollo.io API, giving AI coding assistants direct access to Apollo.io's sales intelligence platform for prospecting, enrichment, CRM operations, and outreach.

Stock Snapshot MCP

A minimal MCP server that provides stock snapshots including company metadata, latest quote, fundamentals, and daily price history via the Alpha Vantage API.

Browser MCP Server

A universal browser automation server featuring 63 tools for programmatic Chrome control, multi-tab management, and media interaction using Playwright. It enables advanced actions like session recording, performance profiling, and pixel-based interaction through a safe, isolated browser profile.

Telegram Notify MCP Server

Connects VS Code Copilot to Telegram for mobile notifications, interactive approval workflows, and remote command input. Enables users to monitor AI agents, approve sensitive operations, and provide follow-up instructions from their smartphone.

Instagram Ads MCP Server

Wraps the Meta Marketing API to enable creating, modifying, viewing, and deleting Instagram ads via natural language.

UserFlow MCP

Simulates real users navigating your app and delivers qualitative UX feedback, including persona-driven testing, auto-friction detection, and WCAG accessibility audits.

Fider MCP Server

Enables interaction with Fider customer feedback platforms, supporting post management, commenting, tagging, and status updates through natural language commands.

UnityAutonomousMCP

A comprehensive autonomous agent framework for Unity 2022.3.22f1 combining Model Context Protocol with AI decision-making, enabling intelligent task planning, editor automation, and multi-agent coordination.

AI Gateway MCP Server

Provides unified access to multiple AI providers through Vercel AI Gateway, enabling question answering, web search, multi-model research, and model listing.

mnema

Provides a file-first personal memory layer for AI agents, enabling them to store and retrieve memories as markdown files with an SQLite index. The MCP server offers read-only search by default, with optional write tools for manual memory addition and conflict resolution.

flashback-memory

Enables conversation memory for LLMs by storing chat history and retrieving relevant memories via embedding-based semantic search, supporting tools like store_turn and flashback_memory.

Sales MCP Server

Enables users to query enterprise sales data from a local SQLite database and investigate anomalies through an inline dashboard with human-in-the-loop review buttons.

Kleap

Enables AI agents to build, edit, and publish live websites with hosting, database, auth, and domains via the Model Context Protocol.

memory-mcp

Provides persistent memory for AI assistants via MCP, enabling them to store and recall facts, preferences, and tasks across conversations using either local file storage or a cloud backend with semantic search.

mcp-stratz

Enables querying Dota 2 data (hero stats, player matches, player heroes) via the STRATZ API, with support for arbitrary GraphQL queries.

Brex MCP Server

Enables AI agents to interact with the Brex financial platform, allowing access to account information, transactions, expenses, receipts, budgets, and spend limits through the Brex API.

BYU Learning Suite MCP Server

Enables Claude Desktop to interact with BYU Learning Suite data including assignments, grades, schedule, announcements, exams, and course content, currently using mock data.

ChunkHound

A local-first codebase intelligence tool that enables AI assistants to research codebases using semantic search, multi-hop relationship discovery, and structural parsing. It allows users to extract architectural patterns and institutional knowledge across 30+ programming languages through an MCP-compatible interface.