Discover Awesome MCP Servers

KeyboardCrumbs MCP Server

Provides real-time threat intelligence including IP risk scores, CVE lookups, and malware hash analysis without requiring an API key. It enables users to monitor active threats, predict CISA KEV additions, and detect pre-attack infrastructure staging through natural language.

FlexSim MCP Server

Control and automate FlexSim simulations through AI assistants like Claude, enabling manufacturing and warehouse digital twin analysis, parameter studies, and real-time model manipulation via tools for opening models, running simulations, evaluating FlexScript, and exporting results.

MCP Salesforce Connector

A server implementation that enables LLMs to interact with Salesforce data through SOQL queries, SOSL searches, and API operations including retrieving, creating, updating, and deleting records.

vmysql-mcp

A lightweight, multi-environment MySQL MCP server that provides secure, policy-gated database access through simplified query and execution tools. It enables AI agents to interact with multiple database environments safely using environment-based routing and strict security constraints.

UI Flowchart Creator

MCP互換システム内で使いやすいAPIを通じて、ユーザーインターフェースとインタラクションの可視化を生成し、UIフローチャートを作成できるようにします。

Supabase Notes

TypeScript で構築された MCP (マイクロコンテンツプラットフォーム) サーバーで、Next.js を使用したシンプルなノートシステムを処理します。MCP の概念を利用して、テキストノートの作成と要約をサポートします。

Tello Drone MCP Server

ドローンを制御するためのMCPサーバー

Pierre Fitness Platform MCP Server

Connects AI assistants to fitness data from over 150 wearables including Strava, Garmin, and Fitbit through the Model Context Protocol. It provides 47 tools for sports science-based analysis, training load management, recovery tracking, and personalized nutrition planning.

Security Context MCP Server

Provides instant access to authoritative security documentation from organizations like OWASP, NIST, and major cloud providers through natural language semantic search. It enables users to retrieve security best practices, frameworks, and vulnerability information directly from a locally cached knowledge base.

MCP Commute Assistant

A smart commute assistant that monitors travel routes via the Amap API and sends automated notifications to DingTalk. It enables users to schedule daily route checks and receive real-time traffic updates using a modular MCP-based architecture.

Notion ReadOnly MCP Server

An optimized read-only server for AI assistants to efficiently query and retrieve Notion content, featuring parallel processing and a minimized toolset of 7 essential read-only operations.

mc-server-clash-of-clans

クラッシュ・オブ・クランAPI用のMCPサーバー。プレイヤーやクランの情報を取得したり、進行中の戦争を分析したり、戦争ログ（公開されている場合）を取得したりできます。

UseScraper

TypeScript で構築された MCP サーバーで、UseScraper API を利用してウェブスクレイピング機能を提供します。これにより、ユーザーは様々な形式でウェブページからコンテンツを抽出できます。

Google Meet MCP Server

Google Meet MCPサーバーは、AIエージェントがGoogle Meetの会議を作成、管理、および取得できるようにします。Model Context Protocol上に構築されており、会議のスケジュール、更新、削除のためのツールを公開し、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

Claudeのような大規模言語モデルを通じて、AutoCADとの自然言語インタラクションを可能にするサーバー。ユーザーは会話形式のコマンドを使って図面を作成・修正できます。

template-mcp-server

Okay, here's a PDM template structure and some example files to help you get started developing an MCP (Minecraft Protocol) server in Python. This template focuses on setting up a good project structure, dependency management with PDM, and basic scaffolding for handling network connections. **Project Structure:** ``` mcp_server_template/ ├── pyproject.toml # PDM configuration file ├── pdm.lock # PDM lockfile (generated) ├── src/ │ └── mcp_server/ │ ├── __init__.py │ ├── server.py # Main server logic │ ├── protocol/ │ │ ├── __init__.py │ │ ├── packets.py # Packet definitions │ │ ├── handlers.py # Packet handling logic │ ├── config.py # Server configuration │ ├── utils.py # Utility functions ├── tests/ │ ├── __init__.py │ ├── conftest.py # Pytest configuration │ ├── test_server.py # Example tests ├── README.md └── .gitignore ``` **Explanation:** * **`mcp_server_template/`:** The root directory of your project. * **`pyproject.toml`:** This is the heart of your PDM project. It defines your project metadata, dependencies, and build settings. * **`pdm.lock`:** PDM uses this file to lock down the exact versions of your dependencies, ensuring reproducible builds. *Do not edit this file directly.* * **`src/mcp_server/`:** This is where your main application code lives. Using `src` is a best practice for Python projects. * **`__init__.py`:** Makes `mcp_server` a Python package. * **`server.py`:** Contains the core server logic: socket setup, connection handling, main loop. * **`protocol/`:** Handles the Minecraft protocol itself. * **`packets.py`:** Defines the structure of Minecraft packets (e.g., using `struct` or a more advanced serialization library). This is *crucial* for MCP. * **`handlers.py`:** Contains functions to handle incoming packets. This is where you'll implement the game logic. * **`config.py`:** Loads and manages server configuration (port, max players, etc.). * **`utils.py`:** Utility functions that don't fit elsewhere (logging, data conversion, etc.). * **`tests/`:** Contains your unit tests. * **`conftest.py`:** Pytest configuration (fixtures, etc.). * **`test_server.py`:** Example tests for your server. * **`README.md`:** A description of your project. * **`.gitignore`:** Specifies files that should not be tracked by Git (e.g., `__pycache__`, `.venv`, `pdm.lock`). **Example Files:** **1. `pyproject.toml`:** ```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" keywords = ["minecraft", "server", "mcp", "protocol"] classifiers = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] [tool.pdm] version = {source = "scm"} auto_global = true [tool.pdm.dev-dependencies] dev = [ "pytest", "pytest-cov", "mypy", "flake8", "black", ] [build-system] requires = ["pdm-backend"] build-backend = "pdm.backend" [tool.pdm.scripts] start = "python src/mcp_server/server.py" test = "pytest -v --cov=src/mcp_server tests/" lint = "flake8 src/mcp_server tests/" format = "black src/mcp_server tests/" typecheck = "mypy src/mcp_server" [tool.pytest.ini_options] testpaths = ["tests"] addopts = ["-v", "--cov=src/mcp_server"] [tool.mypy] strict = true ignore_missing_imports = true [tool.flake8] max-line-length = 120 exclude = [".venv", "__pycache__", "migrations"] ``` **2. `src/mcp_server/server.py`:** ```python import socket import threading import logging from .config import Config # Import the Config class from .protocol.handlers import handle_packet # Import the packet handler logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') class MinecraftServer: def __init__(self, config: Config): self.config = config self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address self.server_socket.bind((self.config.host, self.config.port)) self.server_socket.listen(self.config.max_connections) self.clients = [] # List to store connected clients logging.info(f"Server listening on {self.config.host}:{self.config.port}") def run(self): try: while True: client_socket, client_address = self.server_socket.accept() logging.info(f"Accepted connection from {client_address}") self.clients.append(client_socket) # Add the client to the list client_thread = threading.Thread(target=self.handle_client, args=(client_socket,)) client_thread.start() except KeyboardInterrupt: logging.info("Shutting down server...") finally: self.stop() def handle_client(self, client_socket): try: while True: data = client_socket.recv(1024) # Adjust buffer size as needed if not data: break # Client disconnected # Process the received data (Minecraft packets) handle_packet(client_socket, data) # Pass the socket and data to the handler except ConnectionResetError: logging.warning("Client disconnected abruptly.") except Exception as e: logging.error(f"Error handling client: {e}") finally: self.clients.remove(client_socket) # Remove the client from the list client_socket.close() logging.info("Connection closed.") def stop(self): for client in self.clients: client.close() self.server_socket.close() logging.info("Server stopped.") if __name__ == "__main__": config = Config(host="127.0.0.1", port=25565, max_connections=10) # Example configuration server = MinecraftServer(config) server.run() ``` **3. `src/mcp_server/config.py`:** ```python class Config: def __init__(self, host: str, port: int, max_connections: int): self.host = host self.port = port self.max_connections = max_connections def __repr__(self): return f"Config(host='{self.host}', port={self.port}, max_connections={self.max_connections})" ``` **4. `src/mcp_server/protocol/packets.py`:** ```python # This file will define the structure of Minecraft packets. # You'll likely use the `struct` module for packing and unpacking data. # Example (very simplified): import struct # Example packet: Handshake (ID 0x00) # Fields: Protocol Version (VarInt), Server Address (String), Server Port (Unsigned Short), Next State (VarInt) def pack_handshake(protocol_version: int, server_address: str, server_port: int, next_state: int) -> bytes: """Packs a Handshake packet.""" # Implement VarInt encoding (see Minecraft protocol documentation) def encode_varint(value: int) -> bytes: data = bytearray() while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 data.append(byte) if value == 0: break return bytes(data) protocol_version_bytes = encode_varint(protocol_version) server_address_bytes = server_address.encode('utf-8') server_address_length = encode_varint(len(server_address_bytes)) server_port_bytes = struct.pack("!H", server_port) # Unsigned short (big-endian) next_state_bytes = encode_varint(next_state) packet_data = protocol_version_bytes + server_address_length + server_address_bytes + server_port_bytes + next_state_bytes packet_length = encode_varint(len(packet_data)) return packet_length + packet_data def unpack_handshake(data: bytes) -> tuple[int, str, int, int]: """Unpacks a Handshake packet.""" # Implement VarInt decoding (see Minecraft protocol documentation) def decode_varint(data: bytes) -> tuple[int, int]: # Returns (value, bytes_read) result = 0 shift = 0 index = 0 while True: byte = data[index] index += 1 result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break if shift > 35: raise ValueError("VarInt is too big") # Prevent infinite loop return result, index protocol_version, bytes_read = decode_varint(data) data = data[bytes_read:] server_address_length, bytes_read = decode_varint(data) data = data[bytes_read:] server_address = data[:server_address_length].decode('utf-8') data = data[server_address_length:] server_port = struct.unpack("!H", data[:2])[0] data = data[2:] next_state, bytes_read = decode_varint(data) return protocol_version, server_address, server_port, next_state # Add more packet definitions here as needed. ``` **5. `src/mcp_server/protocol/handlers.py`:** ```python import logging from .packets import unpack_handshake # Import packet unpacking functions def handle_packet(client_socket, data: bytes): """Handles incoming Minecraft packets.""" # Determine packet ID (first byte or VarInt) # For simplicity, assuming Handshake (ID 0x00) for now. You'll need a proper packet ID system. try: protocol_version, server_address, server_port, next_state = unpack_handshake(data) logging.info(f"Received Handshake: Protocol {protocol_version}, Address {server_address}, Port {server_port}, Next State {next_state}") # Handle the next state (e.g., Status or Login) if next_state == 1: # Status handle_status(client_socket) elif next_state == 2: # Login handle_login(client_socket) else: logging.warning(f"Unknown next state: {next_state}") except Exception as e: logging.error(f"Error handling packet: {e}") def handle_status(client_socket): """Handles Status requests.""" # Implement Status handling logic (e.g., send server info) logging.info("Handling Status request") # Example: Send a simple JSON response (you'll need to format it correctly) status_response = '{"version": {"name": "My Server", "protocol": 757}, "players": {"max": 10, "online": 0}, "description": {"text": "A simple Minecraft server"}}' # You need to pack this into a Minecraft packet (length-prefixed string) # See Minecraft protocol documentation for details. # For now, just sending the raw string (this won't work correctly with a real client) client_socket.sendall(status_response.encode('utf-8')) def handle_login(client_socket): """Handles Login requests.""" # Implement Login handling logic (e.g., authentication, encryption) logging.info("Handling Login request") # Placeholder pass ``` **6. `tests/test_server.py`:** ```python import pytest import socket import threading import time from src.mcp_server.server import MinecraftServer from src.mcp_server.config import Config @pytest.fixture def server(): config = Config(host="127.0.0.1", port=25566, max_connections=1) # Use a different port for testing server = MinecraftServer(config) server_thread = threading.Thread(target=server.run, daemon=True) # Daemon thread so it exits with the test server_thread.start() time.sleep(0.1) # Give the server a moment to start yield server server.stop() def test_server_connection(server): """Tests that the server can accept a connection.""" try: client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client_socket.connect(("127.0.0.1", 25566)) client_socket.close() assert True # Connection was successful except ConnectionRefusedError: assert False # Connection failed ``` **7. `.gitignore`:** ``` __pycache__/ .venv/ pdm.lock .idea/ *.pyc *.log ``` **How to Use This Template:** 1. **Install PDM:** `pip install pdm` 2. **Create the Project:** Create the directory structure and save the files above. 3. **Initialize PDM:** `pdm init` (Answer the questions to set up your project.) 4. **Install Dependencies:** `pdm install` (This will install the dependencies listed in `pyproject.toml`.) 5. **Run the Server:** `pdm run start` (This will execute the `start` script defined in `pyproject.toml`.) 6. **Run Tests:** `pdm run test` 7. **Lint Code:** `pdm run lint` 8. **Format Code:** `pdm run format` 9. **Type Check:** `pdm run typecheck` **Key Concepts and Next Steps:** * **Minecraft Protocol:** The *most important* thing is to thoroughly understand the Minecraft protocol. Refer to the official documentation (if available) and community resources like the Wiki.vg page on the Minecraft protocol. Pay close attention to: * **VarInt and VarLong:** Variable-length integers are used extensively. The example code includes basic encoding/decoding. * **Packet IDs:** Each packet has a unique ID that identifies its type. * **Data Types:** Strings, integers, booleans, arrays, etc., are encoded in specific ways. * **States:** The connection goes through different states (Handshake, Status, Login, Play). * **Asynchronous I/O (asyncio):** For a production-quality server, consider using `asyncio` for asynchronous network handling. This will allow you to handle many connections concurrently without using threads for each connection. This template uses threads for simplicity. * **Serialization Libraries:** Instead of manually packing and unpacking packets with `struct`, consider using a serialization library like `construct` or `protogen`. These libraries can make your code much cleaner and easier to maintain. * **Authentication:** Implement proper authentication to prevent unauthorized access to your server. * **Game Logic:** Start implementing the core game logic (world generation, player movement, block placement, etc.). * **Error Handling:** Robust error handling is crucial for a stable server. * **Logging:** Use logging extensively to help debug issues. * **Configuration:** Make your server configurable through a configuration file. * **Testing:** Write comprehensive unit tests to ensure your code is working correctly. **Important Considerations for MCP Servers:** * **Performance:** Minecraft servers can be resource-intensive. Optimize your code for performance. Profiling tools can help you identify bottlenecks. * **Security:** Security is paramount. Protect your server from attacks (e.g., denial-of-service, exploits). * **Scalability:** If you plan to support a large number of players, design your server to be scalable. This template provides a solid foundation for building your MCP server. Good luck! Let me know if you have any more questions.

Reachy Claude MCP

Integrates the Reachy Mini robot or its simulation with Claude Code to provide interactive physical feedback through emotions, speech, and celebratory animations. It features advanced capabilities like sentiment analysis, semantic problem search, and cross-project memory to enhance the developer experience.

MCP Greetings Server

Enables AI assistants to greet users in 7 different languages including English, Spanish, French, German, Japanese, Chinese, and Korean. A lightweight multilingual greeting tool for the Model Context Protocol.

nft-analytics-mcp

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

MCP Math Gmail Client

エージェントがMCPサーバーを使って数学の問題を解き、結果をメールで送信します。

Fear & Greed Index MCP Server

A Model Context Protocol server that provides real-time CNN Fear & Greed Index data for the US stock market, including current sentiment scores and historical comparisons.

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

OmniMCP

AIモデルに豊富なUIコンテキストとインタラクション機能を提供し、Model Context Protocolを通じて、視覚的な分析と正確なインタラクションによるユーザーインターフェースの深い理解を可能にするサーバー。

Korea Stock Analyzer MCP Server

Provides comprehensive Korean stock market analysis using investment strategies from 6 legendary investors including Warren Buffett and Peter Lynch. Offers real-time KOSPI/KOSDAQ data, technical indicators, DCF valuations, and buy/hold/sell recommendations through natural language queries.

Kotlin Crypto Price Spring MCP Server Demo

Kotlin Spring AI MCP (Message Channel Platform) サーバーのデモ。Binance から暗号通貨の価格を取得します。

Cursor MCP Installer

Cursor IDE用のModel Context Protocol (MCP)サーバー。他のMCPサーバーのインストールと設定を簡素化します。

302_basic_mcp

検索、コード実行、電卓、ウェブ解析などの基本機能を提供します。