Discover Awesome MCP Servers

Linkup Search

Claudeにリアルタイムの知識とプレミアムコンテンツへのアクセスを提供します。Linkupの強力な検索機能を通じて、Claudeのカットオフデータを解消し、最新のイベントや信頼できるプレミアムソースでClaudeの応答を変換します。

Azure MCP Server

Azure MCP Server

YApi MCP Server

Enables access to YApi interface documentation by retrieving API details through interface IDs or direct YApi URLs.

Cursor MCP File Organizer

ダウンロードフォルダ内のファイルを、ファイルの種類に基づいて適切なディレクトリに自動的に分類して整理します。

ReactBits MCP Server

A Model Context Protocol server that provides AI assistants with access to ReactBits.dev components - a collection of 135+ animated React components for creative developers.

ClickUp Operator

Claudeと互換性のあるMCPサーバー。カスタムURIスキームを用いたシンプルなノート保存システムにより、ノートの保存と要約を可能にします。

Zerocracy MCP Server

A server module for Claude Desktop that enables integration with Zerocracy, allowing interaction with the Zerocracy project management platform through natural language commands.

TickTick MCP Server

A comprehensive Model Context Protocol server providing complete TickTick task management API integration (112 operations) for Claude Code users, enabling seamless task creation, project management, habit tracking, and productivity features.

Next.js MCP Server

A Model Context Protocol server built with Next.js that provides AI assistants with access to custom tools and resources. Includes example tools for echoing messages and performing mathematical operations, with support for both SSE and HTTP transports.

Awesome MCPs

An awesome collection of Model Context Protocol (MCP) tools

OpenRouter Web Search MCP Server

OpenRouter を利用してウェブ検索を提供する MCP サーバー :オンライン

Dockerized MCP Server Template

再利用可能な Docker 化された Python サーバーテンプレート。Model Context Protocol (MCP) を Server-Sent Events (SSE) で実装しており、大規模言語モデル (LLM) との簡単な統合のために FastMCP ライブラリを使用しています。

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.

MS Access MCP Explorer

Microsoft Access データベース用 MCP サーバー

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.

FIWARE MCP Server

鏡 (Kagami)

Local Filesystem MCP Server

Enables exploration and search of local filesystems using glob pattern matching to find files and grep to search for text patterns within files.

Stealth-AntiCheat MCP

Real-time anti-cheat analysis system that monitors Discord servers for cheating code patterns using AI (GPT-4), automatically detects and analyzes suspicious code, and generates custom anti-cheat signatures with 24/7 monitoring capabilities.

PostgREST

これは、PostgREST用のMCPサーバーです。LLM（大規模言語モデル）が、PostgRESTを介してPostgresデータベースに対するクエリや操作を実行できるようにします。このサーバーは、Supabaseプロジェクト（PostgRESTを使用）とスタンドアロンのPostgRESTサーバーの両方で動作します。

Gemini MCP Server

A TypeScript implementation of a Model Context Protocol server that integrates with Google's Gemini 2.0 Flash model, enabling Claude Desktop users to interact with Gemini through natural language conversations.

Jina AI Remote MCP Server

Provides access to Jina AI's suite of web tools including URL reading, web/image/academic search, content extraction, embeddings, and reranking capabilities. Enables AI assistants to search the web, extract content from URLs, and process information with semantic understanding.

Nano Currency MCP Server

Send Nano currency from AI agents/LLMs

Hive Intelligence

The Ultimate Cryptocurrency MCP for AI Assistants - Unified access to crypto, DeFi, and Web3 analytics | MCP Endpoint.

Florentine.ai MCP Server

Enables natural language querying of MongoDB data by transforming AI agent questions into MongoDB aggregations. Supports secure data separation, semantic vector search, and advanced lookup capabilities for database interactions.