Discover Awesome MCP Servers

ngspice-mcp

Un servidor MCP para interactuar con el simulador de circuitos ngspice.

Scratchpad MCP Server

Provides a 'think' tool that allows Claude and other LLMs to add dedicated thinking steps during complex tool use scenarios, creating space for structured reasoning and improving problem-solving capabilities.

MCP Ahrefs

Enables integration with Ahrefs SEO tools and services through MCP protocol. Provides automated exception handling, comprehensive logging, and parallel processing capabilities for SEO data analysis and operations.

Compresto MCP

A Model Context Protocol server that provides AI assistants with real-time data about Compresto's file compression app usage statistics, including total users, processed files, and total size reduced.

Developer Roadmaps MCP Server

Provides access to developer roadmap content from roadmap.sh, allowing users to list available roadmaps and fetch detailed Markdown content for specific career paths.

NetSuite MCP Server

A Model Context Protocol server that enables querying and analyzing NetSuite sales orders and invoices with filtering capabilities by customer, item, date range, and other parameters.

MCP Utility Tools

A collection of tools that enhance MCP-based workflows with caching, retry logic, batch operations, and rate limiting capabilities.

MCP Registry

Here are a few ways to translate "MCP server that searches MCP Servers," depending on the nuance you want to convey: **Option 1 (Most straightforward):** * **Spanish:** Servidor MCP que busca servidores MCP. **Option 2 (Slightly more descriptive, emphasizing the search function):** * **Spanish:** Servidor MCP que busca otros servidores MCP. (This translates to "MCP server that searches for *other* MCP servers.") **Option 3 (If you want to emphasize the purpose of the server):** * **Spanish:** Servidor MCP para buscar servidores MCP. (This translates to "MCP server *for* searching MCP servers.") **Explanation of Choices:** * **"Servidor"** is the standard Spanish word for "server." * **"Que busca"** is the most common way to say "that searches." * **"Otros"** (in Option 2) adds the nuance of searching for *different* MCP servers. * **"Para buscar"** (in Option 3) emphasizes the *purpose* of the server. The best option depends on the specific context. If you just want a direct translation, Option 1 is perfectly fine. If you want to emphasize the search function or the purpose of the server, Options 2 or 3 might be better.

MCP Server Proto-OKN

A Model Context Protocol server that provides tools for querying SPARQL endpoints, with specialized support for Proto-OKN knowledge graphs hosted on the FRINK platform.

MCP Server for ServiceNow

Este servidor MCP para ServiceNow está diseñado para ser tanto genérico como extensible. Aprovecha un enfoque modular para manejar una amplia gama de casos de uso de ServiceNow, desde operaciones centrales de ITSM hasta la gestión avanzada de CMDB y la orquestación dinámica de flujos de trabajo.

OpenRouter Web Search MCP Server

Un servidor MCP que proporciona búsqueda web utilizando openrouter :online

Dockerized MCP Server Template

Una plantilla reutilizable de servidor Python en Docker que implementa el Protocolo de Contexto de Modelo (MCP) con Eventos Enviados por el Servidor (SSE), construida utilizando la biblioteca FastMCP para una fácil integración con Modelos de Lenguaje Grandes (LLMs).

mc-server-clash-of-clans

Servidor MCP para la API de Clash of Clans. Puede obtener información de jugadores y clanes, analizar guerras en curso, así como registros de guerra (siempre y cuando sean públicos).

UseScraper

Un servidor MCP basado en TypeScript que utiliza la API UseScraper para proporcionar capacidades de web scraping, permitiendo a los usuarios extraer contenido de páginas web en varios formatos.

Google Meet MCP Server

El servidor MCP de Google Meet permite a los agentes de IA crear, gestionar y recuperar reuniones de Google Meet. Construido sobre el Protocolo de Contexto de Modelo, expone herramientas para programar, actualizar y eliminar reuniones, facilitando la integración de las funcionalidades de Google Meet.

Polar Signals Remote MCP

MCP server for Polar Signals Cloud continuous profiling platform, enabling AI assistants to analyze CPU performance, memory usage, and identify optimization opportunities in production systems.

AutoCAD MCP Server

Un servidor que permite la interacción en lenguaje natural con AutoCAD a través de modelos de lenguaje grandes como Claude, permitiendo a los usuarios crear y modificar dibujos utilizando comandos conversacionales.

template-mcp-server

Okay, here's a PDM template structure and some key considerations for developing an MCP (Minecraft Protocol) server in Python. This template focuses on project organization, dependency management, and basic server structure. **Project Structure (using PDM)** ``` mcp_server/ ├── pyproject.toml # PDM configuration file ├── src/ │ ├── mcp_server/ # Main package directory │ │ ├── __init__.py # Makes 'mcp_server' a package │ │ ├── server.py # Core server logic │ │ ├── protocol/ # Protocol handling │ │ │ ├── __init__.py │ │ │ ├── packets.py # Packet definitions (classes) │ │ │ ├── serialization.py # Packet serialization/deserialization │ │ │ ├── handshake.py # Handshake logic │ │ │ ├── status.py # Status logic (ping, server info) │ │ │ ├── login.py # Login logic │ │ │ ├── play.py # In-game logic (chat, movement, etc.) │ │ ├── player.py # Player class │ │ ├── world/ # World management │ │ │ ├── __init__.py │ │ │ ├── chunk.py # Chunk representation │ │ │ ├── world.py # World class │ │ │ ├── generator.py # World generation │ │ ├── config.py # Server configuration │ │ ├── utils.py # Utility functions │ ├── main.py # Entry point to start the server ├── tests/ │ ├── __init__.py │ ├── conftest.py # Pytest configuration │ ├── test_packets.py # Unit tests for packet handling │ ├── test_server.py # Unit tests for server logic ├── README.md ├── LICENSE ``` **1. `pyproject.toml` (PDM Configuration)** ```toml [project] name = "mcp_server" version = "0.1.0" description = "A Minecraft Protocol (MCP) server implementation in Python." authors = [ {name = "Your Name", email = "your.email@example.com"} ] license = {text = "MIT"} # Or your preferred license readme = "README.md" requires-python = ">=3.8" # Minimum Python version keywords = ["minecraft", "server", "mcp", "protocol"] classifiers = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] [project.urls] "Homepage" = "https://github.com/yourusername/mcp_server" "Bug Tracker" = "https://github.com/yourusername/mcp_server/issues" [tool.pdm] version = {source = "scm"} [tool.pdm.dev-dependencies] dev = [ "pytest", "pytest-cov", "mypy", "flake8", "black", ] [tool.pdm.scripts] test = "pytest -v --cov=src/mcp_server" lint = "flake8 src/mcp_server tests" format = "black src/mcp_server tests" typecheck = "mypy src/mcp_server" start = "python src/main.py" [tool.pytest.ini_options] testpaths = ["tests"] addopts = ["-v", "--cov=src/mcp_server"] [tool.mypy] strict = true ignore_missing_imports = true [build-system] requires = ["pdm-backend"] build-backend = "pdm.backend" ``` **Explanation of `pyproject.toml`:** * **`[project]`:** Metadata about your project (name, version, description, authors, license, etc.). * **`[tool.pdm]`:** PDM-specific settings. * `version = {source = "scm"}`: Automatically manages the version based on Git tags (requires `pdm-plugin-version`). You can also use a static version. * **`[tool.pdm.dev-dependencies]`:** Development dependencies (testing, linting, formatting, type checking). These are *not* required for running the server, only for development. * **`[tool.pdm.scripts]`:** Defines convenient commands you can run with `pdm run <script_name>`. For example, `pdm run test` will run your tests. * **`[tool.pytest.ini_options]`:** Configuration for `pytest`. * **`[tool.mypy]`:** Configuration for `mypy` (static type checker). * **`[build-system]`:** Specifies the build backend (PDM in this case). **2. `src/mcp_server/server.py` (Core Server Logic)** ```python import asyncio import logging import socket from typing import Tuple from .protocol.handshake import handle_handshake from .protocol.login import handle_login from .protocol.status import handle_status from .player import Player class MinecraftServer: def __init__(self, host: str, port: int): self.host = host self.port = port self.running = False self.players: list[Player] = [] self.logger = logging.getLogger("MinecraftServer") self.logger.setLevel(logging.INFO) # Adjust as needed self.logger.addHandler(logging.StreamHandler()) async def handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter): addr = writer.get_extra_info('peername') self.logger.info(f"New connection from {addr}") try: # Handshake protocol_version, server_address, server_port, next_state = await handle_handshake(reader) if next_state == 1: # Status await handle_status(writer) elif next_state == 2: # Login player = await handle_login(reader, writer) if player: self.players.append(player) self.logger.info(f"Player {player.name} logged in.") # TODO: Start the play sequence (game loop) await self.play_sequence(player, reader, writer) else: self.logger.warning(f"Login failed for {addr}") else: self.logger.warning(f"Unknown next state: {next_state}") except Exception as e: self.logger.exception(f"Error handling client {addr}: {e}") finally: writer.close() await writer.wait_closed() self.logger.info(f"Connection closed with {addr}") async def play_sequence(self, player: Player, reader: asyncio.StreamReader, writer: asyncio.StreamWriter): """Handles the in-game play sequence for a connected player.""" try: while True: # TODO: Implement packet handling for in-game actions # Example: # packet_id, packet_data = await read_packet(reader) # if packet_id == 0x03: # Chat Message # message = parse_chat_message(packet_data) # self.broadcast_message(f"<{player.name}> {message}") await asyncio.sleep(0.01) # Prevent busy-waiting except Exception as e: self.logger.exception(f"Error in play sequence for {player.name}: {e}") finally: self.players.remove(player) self.logger.info(f"Player {player.name} disconnected.") writer.close() await writer.wait_closed() async def start(self): self.running = True try: server = await asyncio.start_server( self.handle_client, self.host, self.port ) addr = server.sockets[0].getsockname() self.logger.info(f"Serving on {addr}") async with server: await server.serve_forever() except Exception as e: self.logger.error(f"Server error: {e}") finally: self.running = False async def stop(self): self.running = False # TODO: Implement graceful shutdown (disconnect clients, save data) self.logger.info("Server stopping...") # Example usage (in main.py): async def main(): server = MinecraftServer("127.0.0.1", 25565) await server.start() if __name__ == "__main__": asyncio.run(main()) ``` **3. `src/mcp_server/protocol/` (Protocol Handling)** This directory contains modules for handling different stages of the Minecraft protocol. Each module (e.g., `handshake.py`, `status.py`, `login.py`, `play.py`) will contain functions to: * **Read packets:** Parse the incoming byte stream to identify the packet ID and extract the data. * **Serialize/Deserialize packets:** Convert Python objects to byte streams for sending, and vice versa. Use a library like `struct` or `construct` for this. * **Implement the protocol logic:** Handle the specific steps for each stage (e.g., responding to a status request, authenticating a player). **Example: `src/mcp_server/protocol/handshake.py`** ```python import asyncio import struct import logging async def read_varint(reader: asyncio.StreamReader) -> int: """Reads a Minecraft VarInt from the stream.""" result = 0 shift = 0 while True: byte = await reader.readexactly(1) value = byte[0] result |= (value & 0x7F) << shift shift += 7 if not (value & 0x80): break if shift > 35: raise ValueError("VarInt is too big") return result async def handle_handshake(reader: asyncio.StreamReader) -> tuple[int, str, int, int]: """Handles the initial handshake with the client.""" packet_length = await read_varint(reader) packet_id = await read_varint(reader) if packet_id != 0x00: raise ValueError(f"Unexpected packet ID in handshake: {packet_id}") protocol_version = await read_varint(reader) server_address_length = await read_varint(reader) server_address_bytes = await reader.readexactly(server_address_length) server_address = server_address_bytes.decode('utf-8') server_port = struct.unpack('>H', await reader.readexactly(2))[0] # Big-endian unsigned short next_state = await read_varint(reader) logging.info(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, Next State {next_state}") return protocol_version, server_address, server_port, next_state ``` **Example: `src/mcp_server/protocol/status.py`** ```python import asyncio import json import struct async def write_varint(writer: asyncio.StreamWriter, value: int): """Writes a Minecraft VarInt to the stream.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 writer.write(struct.pack('B', byte)) if value == 0: break await writer.drain() async def handle_status(writer: asyncio.StreamWriter): """Handles the status request from the client.""" # Respond to Request (empty packet) await write_varint(writer, 1) # Packet Length await write_varint(writer, 0x00) # Packet ID await writer.drain() # Prepare Status Response status = { "version": { "name": "1.20.4", # Replace with your supported version "protocol": 762 }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "My Awesome Minecraft Server" } } status_json = json.dumps(status) status_bytes = status_json.encode('utf-8') packet_length = len(status_bytes) + 1 # +1 for the packet ID # Send Response await write_varint(writer, packet_length) await write_varint(writer, 0x00) # Packet ID writer.write(status_bytes) await writer.drain() ``` **4. `src/mcp_server/player.py`** ```python class Player: def __init__(self, name: str, uuid: str): self.name = name self.uuid = uuid # Add other player-related attributes (position, health, etc.) here def __repr__(self): return f"Player(name='{self.name}', uuid='{self.uuid}')" ``` **5. `src/main.py` (Entry Point)** ```python import asyncio import logging from mcp_server.server import MinecraftServer async def main(): logging.basicConfig(level=logging.INFO) # Configure basic logging server = MinecraftServer("127.0.0.1", 25565) await server.start() if __name__ == "__main__": asyncio.run(main()) ``` **Key Considerations and Next Steps:** * **Minecraft Protocol Documentation:** The *most important* resource is the official Minecraft protocol documentation. It's complex, but essential. Search for "Minecraft Protocol Documentation" to find up-to-date resources. The wiki.vg site is a good starting point. * **Asynchronous Programming (asyncio):** This template uses `asyncio` for handling multiple client connections concurrently. Make sure you understand how `async`, `await`, `asyncio.StreamReader`, and `asyncio.StreamWriter` work. * **Packet Serialization/Deserialization:** This is a critical part. You'll need to precisely pack and unpack data according to the Minecraft protocol. Libraries like `struct` (built-in) and `construct` (more powerful, but requires installation) are helpful. `construct` is often preferred for complex binary formats. * **VarInt/VarLong:** Minecraft uses variable-length integers (VarInt and VarLong) to efficiently encode numbers. Implement functions to read and write these. The example `handshake.py` shows how to read a VarInt. * **Error Handling:** Robust error handling is crucial. Use `try...except` blocks to catch exceptions and prevent the server from crashing. Log errors appropriately. * **Logging:** Use the `logging` module to record server events, errors, and debugging information. * **Configuration:** Use a configuration file (e.g., `config.py` or a `.toml` file) to store server settings (port, MOTD, max players, etc.). * **World Generation:** Implement a world generator to create the game world. This can be simple (flat world) or complex (using algorithms like Perlin noise). * **Game Logic:** This is where you implement the actual gameplay: player movement, block placement, chat, entities, etc. * **Security:** Consider security aspects, such as preventing exploits and protecting against denial-of-service attacks. * **Testing:** Write unit tests to verify the correctness of your code, especially packet handling and game logic. * **Libraries:** * **`struct`:** Built-in for packing and unpacking binary data. * **`construct`:** A more powerful library for defining binary data structures. Install with `pdm add construct`. * **`PyCryptodome`:** For encryption (if you implement online mode authentication). Install with `pdm add pycryptodome`. * **`nbt`:** For reading and writing NBT data (used for storing world data). Install with `pdm add nbt`. **How to Use This Template:** 1. **Install PDM:** `pip install pdm` 2. **Create the Project:** `pdm init` (Follow the prompts to create a new project.) 3. **Replace `pyproject.toml`:** Copy the contents of the `pyproject.toml` example above into your project's `pyproject.toml` file. 4. **Create the Directory Structure:** Create the `src`, `tests`, and other directories as shown in the project structure. 5. **Create the Files:** Create the Python files (`server.py`, `handshake.py`, etc.) and copy the example code into them. 6. **Install Dependencies:** `pdm install` (This will install the development dependencies.) 7. **Run the Server:** `pdm run start` (This will execute the `start` script defined in `pyproject.toml`, which runs `src/main.py`.) 8. **Start Developing:** Begin implementing the Minecraft protocol and game logic. This template provides a solid foundation for building your MCP server. Remember to consult the Minecraft protocol documentation and break down the project into smaller, manageable tasks. Good luck!

nft-analytics-mcp

An MCP server that delivers NFT collection analytics powered by data from Dune Analytics.

Spurs Blog Mcp Server

Un servidor MCP para el blog Pounding The Rock, que ofrece una cobertura exhaustiva de los San Antonio Spurs.

Cursor MCP Installer

Un servidor de Protocolo de Contexto de Modelo (MCP) para el IDE Cursor que simplifica la instalación y configuración de otros servidores MCP.

302_basic_mcp

Proporcionar funciones básicas como búsqueda, ejecución de código, calculadora y análisis web.

README

Estos son servidores MCP que he implementado. Siéntete libre de utilizarlos si los necesitas.

MCP Math Gmail Client

Here are a few options for translating "Agent with MCP server solves math task and emails the output" into Spanish, with slightly different nuances: **Option 1 (Most straightforward):** * **Un agente con un servidor MCP resuelve una tarea matemática y envía el resultado por correo electrónico.** * This is a direct translation and is perfectly understandable. **Option 2 (Slightly more formal):** * **Un agente que utiliza un servidor MCP resuelve un problema matemático y envía el resultado por correo electrónico.** * Using "que utiliza" (that uses) is a bit more formal than "con" (with). "Problema" (problem) is a synonym for "tarea" (task) and can sometimes sound more professional. **Option 3 (Focus on the action):** * **Un agente, mediante un servidor MCP, resuelve un problema matemático y envía el resultado por correo electrónico.** * This emphasizes the *means* by which the agent solves the problem. "Mediante" means "by means of" or "through." **Option 4 (Emphasizing the process):** * **Un agente, utilizando un servidor MCP, resuelve una tarea matemática y envía el resultado por correo electrónico.** * This emphasizes the *process* of using the MCP server. **Which option is best depends on the specific context.** If you want a simple, clear translation, Option 1 is perfectly fine. If you want to sound more formal or emphasize the role of the MCP server, Options 2, 3, or 4 might be better.

hyper-mcp

A configurable MCP server wrapper for Cursor that eliminates tool count limits when using the Model Context Protocol.

Epicor Kinetic MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Epicor Kinetic (beta): https://www.cdata.com/download/download.aspx?sku=UEZK-V&type=beta

mcp-minimal

Un servidor MCP mínimo para validar que las configuraciones del cliente MCP están funcionando.

@profullstack/mcp-server

@profullstack/mcp-server