Discover Awesome MCP Servers

ResembleMCP

Desafío de Implementación del Servidor MCP de Resemble AI

Chroma MCP Server

Here are a few ways to translate that, depending on the nuance you want to convey: **Option 1 (Most Direct):** > Servidor MCP para la integración de ChromaDB en Cursor con modelos de IA compatibles con MCP. **Option 2 (Slightly more descriptive, emphasizing the purpose):** > Servidor MCP para integrar ChromaDB en Cursor, utilizando modelos de IA que sean compatibles con MCP. **Option 3 (Focus on the compatibility aspect):** > Servidor MCP para la integración de ChromaDB en Cursor, diseñado para funcionar con modelos de IA compatibles con MCP. **Explanation of Choices:** * **MCP:** It's likely best to leave "MCP" as is, assuming it's an acronym or proper noun. If you know what it stands for, you *could* translate it, but without context, it's safer to keep it in English. * **ChromaDB:** Also best left as is, as it's a proper noun (likely a database name). * **Cursor:** Same as above. * **Integración:** The standard translation for "integration." * **Modelos de IA:** "AI models" translates directly to "modelos de IA" (modelos de inteligencia artificial). * **Compatibles con MCP:** "Compatible with MCP" translates directly to "compatibles con MCP." The best option depends on the specific context and what you want to emphasize. If you want a simple, direct translation, Option 1 is fine. If you want to clarify the purpose or compatibility, Option 2 or 3 might be better.

Agentic Vault MCP Server

Exposes an EVM wallet to AI agents via MCP, using AWS KMS for HSM-backed signing and a deny-by-default policy engine for secure DeFi transaction approvals.

CulturalTruth MCP

An advanced MCP server that combines Qloo's cultural API with bias detection and compliance analysis to analyze text for patterns, generate cultural insights, and assess regulatory risk.

Datadog MCP Server

Enables integration with Datadog APIs to monitor and retrieve information about monitors, metrics, dashboards, logs, events, and incidents through the Model Context Protocol.

SIN-Code-Frontend-Design-Skill

Provides 8 MCP tools for frontend design: load design system, generate components, scaffold pages, review consistency, extract tokens, check WCAG 2.2 AA, test responsiveness, and export to Figma.

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.

AltText.ai MCP Server

Enables AI assistants to generate alt text, manage image libraries, and audit web pages for accessibility using the AltText.ai 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.

Yanyue MCP

Enables searching and retrieving cigarette product information from Yanyue.cn, providing detailed data about various cigarette brands and products through keyword search.

MCP Blinds Controller

Allows control of motorized window blinds through the Bond Bridge API, enabling users to open, close, or stop blinds with filtering by name, location, or row.

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!

ToolsDNS

Semantic search engine for MCP tools that indexes thousands of tool schemas and returns only the relevant ones to AI agents, reducing token usage and improving tool discovery.

agentoracle-mcp

MCP server that connects AI assistants (Claude, Cursor, Windsurf) to AgentOracle's real-time research API. Agents can research any topic and get structured JSON with summary, key facts, sources, and confidence scores. Powered by Perplexity Sonar via x402 protocol on Base

Dokploy MCP Server

Enables AI assistants to manage cloud infrastructure through natural language by providing a unified interface to the Dokploy platform. Supports Docker containers, applications, databases, domains, monitoring, and deployment operations through conversational commands.

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.

biothings-mcp

Provides a Model Context Protocol server for accessing and querying biomedical data from BioThings services, including gene, variant, chemical, and taxon annotations.

ozon-mcp

ozon-mcp is a knowledge-rich MCP server that turns the entire Ozon seller toolkit into 15 high-leverage tools. AI agents (Claude, Cursor, Cline, Continue, Goose, Zed, …) can search the API in Russian or English, drill into any of 466 methods with a fully-resolved JSON Schema, and execute calls with built-in safety guards. Subscription- aware, automatic pagination over all 4 cursor styles, retry/ba

Toronto MCP Server

An MCP server that provides tools for intelligently querying, analyzing, and retrieving datasets from Toronto's CKAN-powered open data portal. It enables AI assistants to perform natural language searches, inspect data structures, and track dataset update frequencies across the city's open data catalog.

iranti

Persistent shared memory for AI coding agents. Stores facts as entity/key/value triples with hybrid semantic search, task checkpoints, and conflict resolution — shared across Claude Code, Codex CLI, and GitHub Copilot.

Engineering MCP Server

Enables language-model agents to create, modify, analyze, and persist process-engineering diagrams (P\&IDs and flowsheets) in machine-readable formats via the Model Context Protocol.

Duyet MCP Server

An experimental Model Context Protocol server that enables AI assistants to access information about Duyet, including his CV, blog posts, and GitHub activity through natural language queries.

mcp-sports

Wraps TheSportsDB API to enable AI agents to query sports data through natural language.

ServiceNow MCP Server

Enables Claude to interact with ServiceNow instances through the ServiceNow API, allowing data retrieval, record management, and workflow execution. Supports multiple authentication methods and tool packaging for role-based access control.

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.

MCP A2A AP2 Food Delivery & Payments

Enables AI agents to discover and order food from multiple delivery services (DoorDash, UberEats, Grubhub) using A2A protocol and process payments via Stripe with AP2 protocol mandates for cryptographically signed user authorization.

Atlassian MCP Server for Heroku

An MCP server that provides integration with Jira and Confluence for managing issues, boards, sprints, and documentation pages. It is specifically designed for native deployment on Heroku to enable AI models to interact with Atlassian resources using standardized tools.

hamravesh-mcp

MCP server to manage Hamravesh (Darkube) apps via the console's internal API, supporting read and write operations like listing apps, viewing logs, restarting, scaling, and updating environment variables.

UnrealMCPHub

Central management platform for Unreal Engine MCP instances that bridges AI agents with Unreal Engine, handling plugin installation, project compilation, editor launch, crash recovery, and transparent proxy of tool calls.

mcp-score

AI-powered music notation server that lets you create and edit scores using natural language, integrating with MuseScore for live manipulation.