Discover Awesome MCP Servers

Python MCP Toolkit Server

A Python-based MCP server for file operations, web search with fallback, and task management, designed for Termux and extensible via plugins.

Brand MCP Server

Enables Claude Desktop to query a PostgreSQL brand database through MCP. Supports local stdio and remote HTTP/SSE deployments with API key authentication for secure database access.

mcp-ssh-multi

MCP server for managing multiple SSH servers via AI assistants, offering tools for remote command execution, file operations, and system monitoring.

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.

Heygen Universal MCP Server

Provides a standardized interface for interacting with Heygen's AI video generation tools and services through a unified API.

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.

Weather Forecast MCP Server

Provides weather forecast data for any location using the Open-Meteo API, returning temperature, precipitation, cloud cover, humidity, and wind speed for specified date ranges.

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!

recall-mcp

Persistent memory MCP server for AI coding agents. Stores, searches, and retrieves context across sessions using SQLite and FTS5.

postiz-mcp

Enables interaction with Postiz for social media scheduling, content management, and analytics through MCP-compatible clients, with write and delete operations gated by environment variables.

JJ Planner MCP Server

Enables AI agents to manage projects, tasks, and schedules in JJ Planner through CRUD operations.

GitLab MCP Server

Enables AI assistants to interact with GitLab repositories, manage branches, create merge requests, and perform file operations through natural language.

depwire

Code dependency graph and AI context engine. 10 MCP tools that give Claude, Cursor, and any MCP client full codebase context — impact analysis, dependency tracing, architecture summaries, and interactive arc diagram visualization. Supports TypeScript, JavaScript, Python, and Go.

griptape-mcp

Provides AI assistants with direct access to official Griptape framework documentation and code examples through a pre-built SQLite database. It enables accurate code generation for Griptape agents, pipelines, and nodes by eliminating documentation hallucinations.

Orchestration MCP

A TypeScript MCP server for launching, tracking, and managing external coding-agent runs across local and remote backends like Codex and Claude Code. It allows top-level agents to orchestrate subagents through tools for spawning tasks, polling events, and handling interactive sessions.

MCP Finnhub Server

Provides comprehensive financial market data and news through the Finnhub API. Enables real-time stock quotes, company profiles, financial metrics, analyst recommendations, and market news access.

NearIQ MCP Server

Connects NearIQ competitive intelligence to AI tools like Claude Desktop, Claude Code, Cursor, and Windsurf, enabling queries about competitors, reviews, rank tracking, and more.

HubSpot Extended MCP Server

A standalone MCP server that extends HubSpot functionality for post-call processing and pre-call preparation workflows.

Document Convert MCP

Enables document format conversion between Word, Markdown, PDF, HTML, and plain text, supporting batch operations and format validation via the AI MCP protocol.

gsd-mcp-server

MCP server for the GSD (Get Shit Done) lifecycle framework. Exposes GSD project state, phases, milestones, and commands as MCP tools and resources.

MCP JSONDiff Kel

An efficient MCP server for performing accurate, deep comparisons between JSON objects or strings using the deepdiff engine. It provides AI agents with standardized difference reports, supporting nested structures and various input formats to ensure precise data analysis.

SpinAI App

Integración del agente SpinAi con el servidor Hubspot Mcp.

sakutto-mcp-server

A production-ready MCP server for AI agents, providing deep web research and RAG capabilities via Cloudflare Workers.

Markdown RAG Documentation

Enables semantic search over local Markdown documentation using hybrid retrieval combining embeddings, keyword search, and graph traversal with automatic file watching and zero-configuration setup.

Debug-MCP

Enables AI assistants to perform interactive Python debugging with breakpoints, step execution, and variable inspection using the Debug Adapter Protocol (DAP) through an MCP server interface.

commerce-mcp-server

Enables e-commerce operations such as product search, price updates, and order notes via MCP tools, with secure credential handling.

context7-mcp

Context7 MCP is a service that provides developers with the latest code documentation and examples. By integrating into the development environment, it ensures that the code generated by LLMS is based on the latest library documentation.

Swift Test MCP Server

Enables running Swift package tests through the swift test command in specified directories. Provides a secure way for MCP clients to execute Swift tests without requiring full shell access.

mcp-bitbucket

Access all major Bitbucket Cloud features—repositories, pull requests, issues, branches, pipelines, deployments, and more—using a modern Rust codebase. Expose Bitbucket as Model Context Protocol (MCP) tools, ideal for bots, CI/CD, and workflow automation.