Discover Awesome MCP Servers

Agentic MCP Server

Enables AI-driven orchestration of GitHub development workflows including automated issue analysis, code generation, code review, and PR creation through multiple specialized agents. Integrates with GitHub Actions to automate the complete development process from issue to pull request.

Webshot MCP

Enables taking screenshots of web pages with support for multiple devices (desktop, mobile, tablet), custom dimensions, full-page capture, and various image formats. Built with Playwright for reliable web page rendering and screenshot generation.

MCP Search Server

An MCP server that provides semantic search capabilities by integrating with an OpenSearch-based search service. It enables users to perform complex document searches across multiple indices with support for advanced filtering and robust error handling.

AgenticRAG MCP Server

An intelligent codebase processing server that provides agentic RAG capabilities for code repositories, enabling semantic search and contextual understanding through self-evaluating retrieval loops.

Jokes MCP Server

A Model Context Protocol server that provides joke delivery functionality, allowing users to request various types of jokes (Chuck Norris, Dad jokes, etc.) through Microsoft Copilot Studio or Visual Studio Code.

Obsidian MCP Tools

A read-only toolkit for searching and analyzing Markdown note directories and Obsidian vaults through AI clients. It enables metadata extraction, full-text search, and natural language querying of note content, tags, and backlinks.

open-webSearch

Web search using free multi-engine search (NO API KEYS REQUIRED) — Supports Bing, Baidu, DuckDuckGo, Brave, Exa, and CSDN.

MCP Teamtailor

A Model Context Protocol server that enables integration with the Teamtailor API, allowing users to list, filter, and retrieve candidate information from their Teamtailor recruitment platform.

SAST MCP Server

Integrates 15+ static application security testing tools (Semgrep, Bandit, TruffleHog, etc.) with Claude Code AI, enabling automated vulnerability scanning and security analysis through natural language commands. Supports cross-platform operation with remote execution on dedicated security VMs.

browser-mcp

An MCP server that allows users to interact with their browser through natural language commands, enabling actions like getting page content as markdown, modifying page styles, and searching browser history.

Metabase MCP

Query and manage Metabase dashboards, cards, and data via Claude

PAMPA

Provides semantic code search and retrieval capabilities for AI agents, enabling them to query codebases using natural language with automatic learning, hybrid search, and intelligent chunking of functions and classes.

epsg-mcp

An MCP server that provides knowledge about Coordinate Reference Systems (CRS).

MCP Server

An implementation of the Model Context Protocol (MCP) server that enables multiple clients to connect simultaneously and handles basic context management and messaging with an extendable architecture.

Dice MCP Server

Provides comprehensive TRPG dice rolling functionality including standard notation, advantage/disadvantage mechanics, and success-counting dice pools. It enables users to perform complex dice logic and track roll history through an MCP-compliant interface.

Dedalus MCP Documentation Server

Enables AI-powered querying and serving of markdown documentation with search, Q\&A capabilities, and document analysis. Built for the YC Agents Hackathon with OpenAI integration and rate limiting protection.

JVLink MCP Server

Enables natural language queries and analysis of Japanese horse racing data from JRA-VAN without writing SQL. Supports analyzing race results, jockey performance, breeding trends, and track conditions through conversation with Claude.

Feature Evaluation MCP Server

Enables comprehensive feature engineering for classification datasets with automated preprocessing and 13 specialized analysis tools. Supports feature importance calculation, correlation analysis, recursive feature elimination, and model evaluation with integrated visualization capabilities.

Liara MCP Server

Enables AI assistants to deploy and manage applications, databases, object storage, VMs, DNS, and infrastructure on the Liara cloud platform through natural language commands.

Azure Kusto MCP Server

Máy chủ MCP cho Azure Kusto

build-simple-mcp

Okay, here's a guide on how to build a simple Minecraft Protocol (MCP) server in Vietnamese. This will be a very basic server, focusing on the core protocol and not on gameplay features. It's intended for learning and experimentation, not for hosting a real Minecraft server. **Disclaimer:** Building a Minecraft server from scratch is a complex task. This guide provides a simplified overview. You'll need a good understanding of networking, sockets, and data serialization/deserialization. This example will likely be in Python for simplicity, but you can adapt it to other languages. **1. Choose a Programming Language and Libraries** * **Python:** A good choice for beginners due to its readability and available libraries. * **`socket`:** For network communication. * **`struct`:** For packing and unpacking binary data (essential for the Minecraft protocol). * **`zlib`:** For compression (used in some parts of the protocol). * **Java:** More complex but closer to the original Minecraft server. * **`java.net.Socket`:** For network communication. * **`java.io.DataInputStream` and `java.io.DataOutputStream`:** For reading and writing binary data. * **`java.util.zip.Inflater` and `java.util.zip.Deflater`:** For compression. **2. Set Up Your Development Environment** * Install Python (if using Python). * Install Java Development Kit (JDK) (if using Java). * Choose a code editor (VS Code, PyCharm, IntelliJ IDEA, etc.). **3. Understand the Minecraft Protocol** * **Crucial:** The Minecraft protocol is documented on the Minecraft Wiki (search for "Minecraft Protocol"). You *must* refer to this documentation. It describes the packets, their structure, and the data types used. * **Key Concepts:** * **Packets:** The fundamental unit of communication. Each packet has an ID and data. * **Data Types:** Minecraft uses specific data types like VarInt, VarLong, strings, integers, etc. You need to handle these correctly. * **States:** The connection goes through different states: Handshaking, Status, Login, Play. * **Compression:** The protocol can use zlib compression to reduce bandwidth. **4. Basic Server Structure (Python Example)** ```python import socket import struct import zlib # Configuration HOST = 'localhost' PORT = 25565 # Helper functions for reading and writing Minecraft data types def read_varint(sock): result = 0 shift = 0 while True: byte = sock.recv(1)[0] result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, value): while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(bytes([byte])) if value == 0: break def read_string(sock): length = read_varint(sock) data = sock.recv(length) return data.decode('utf-8') def write_string(sock, string): encoded = string.encode('utf-8') write_varint(sock, len(encoded)) sock.send(encoded) # Server logic def handle_client(conn, addr): print(f"Connected by {addr}") # Handshaking State packet_length = read_varint(conn) packet_id = read_varint(conn) if packet_id == 0x00: # Handshake protocol_version = read_varint(conn) server_address = read_string(conn) server_port = struct.unpack('>H', conn.recv(2))[0] # Unpack as big-endian unsigned short next_state = read_varint(conn) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, Next State {next_state}") if next_state == 1: # Status # Status Request packet_length = read_varint(conn) packet_id = read_varint(conn) if packet_id == 0x00: # Respond with Server Info server_info = { "version": { "name": "My Simple Server", "protocol": protocol_version }, "players": { "max": 10, "online": 0 }, "description": { "text": "A simple Minecraft server." } } import json json_response = json.dumps(server_info) response_bytes = json_response.encode('utf-8') # Construct the response packet packet_id = 0x00 packet_data = struct.pack('b', packet_id) + write_string_bytes(json_response) # Use the byte version of write_string packet_length = len(packet_data) write_varint(conn, packet_length) conn.send(packet_data) # Ping Request packet_length = read_varint(conn) packet_id = read_varint(conn) if packet_id == 0x01: ping_payload = conn.recv(8) # 8 bytes # Respond with the same payload packet_id = 0x01 packet_data = struct.pack('b', packet_id) + ping_payload packet_length = len(packet_data) write_varint(conn, packet_length) conn.send(packet_data) elif next_state == 2: # Login # Login Start packet_length = read_varint(conn) packet_id = read_varint(conn) if packet_id == 0x00: player_name = read_string(conn) print(f"Login attempt by: {player_name}") # Respond with Login Success uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID packet_id = 0x02 packet_data = struct.pack('b', packet_id) + write_string_bytes(uuid) + write_string_bytes(player_name) packet_length = len(packet_data) write_varint(conn, packet_length) conn.send(packet_data) # Send Join Game packet (minimal) entity_id = 0 gamemode = 1 # Creative dimension = 0 # Overworld hashed_seed = 0 max_players = 10 difficulty = 2 world_name = "minecraft:overworld" packet_id = 0x26 # Join Game packet_data = struct.pack('>iibbqlbi', entity_id, gamemode, dimension, hashed_seed, max_players, difficulty, 0, 0) + write_string_bytes(world_name) packet_length = len(packet_data) write_varint(conn, packet_length) conn.send(packet_data) # Send Player Position and Look x = 0.0 y = 64.0 z = 0.0 yaw = 0.0 pitch = 0.0 flags = 0 packet_id = 0x36 # Player Position and Look packet_data = struct.pack('>ddffb', x, y, z, yaw, pitch, flags) packet_length = len(packet_data) write_varint(conn, packet_length) conn.send(packet_data) # Send Chunk Data (very basic) chunk_x = 0 chunk_z = 0 primary_bit_mask = 1 # Create a simple chunk section (all air) chunk_data = bytearray() for _ in range(16 * 16 * 16 * 2): # 16x16x16 blocks, 2 bytes per block chunk_data.extend(b'\x00\x00') # Compress the chunk data compressed_data = zlib.compress(bytes(chunk_data)) packet_id = 0x22 # Chunk Data packet_data = struct.pack('>ii?', chunk_x, chunk_z, True) + struct.pack('>i', primary_bit_mask) + struct.pack('>i', len(compressed_data)) + compressed_data packet_length = len(packet_data) write_varint(conn, packet_length) conn.send(packet_data) conn.close() print(f"Connection closed by {addr}") def write_string_bytes(string): encoded = string.encode('utf-8') length = len(encoded) length_bytes = bytearray() while True: byte = length & 0x7F length >>= 7 if length != 0: byte |= 0x80 length_bytes.append(byte) if length == 0: break return bytes(length_bytes) + encoded # Main server loop with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) ``` **Explanation of the Code (Python):** 1. **Imports:** Imports necessary libraries. 2. **Configuration:** Sets the host and port. 3. **Helper Functions:** * `read_varint(sock)`: Reads a VarInt from the socket. * `write_varint(sock, value)`: Writes a VarInt to the socket. * `read_string(sock)`: Reads a Minecraft string from the socket. * `write_string(sock, string)`: Writes a Minecraft string to the socket. 4. **`handle_client(conn, addr)`:** This function handles the communication with a single client. * **Handshaking:** Reads the Handshake packet and determines the next state (Status or Login). * **Status:** If the next state is Status, it responds to the Status Request and Ping Request. The server info is a simple JSON string. * **Login:** If the next state is Login, it reads the Login Start packet and responds with a Login Success packet. Then, it sends a Join Game packet to tell the client to enter the game. Finally, it sends a Player Position and Look packet and a very basic Chunk Data packet. 5. **Main Server Loop:** * Creates a socket. * Binds the socket to the host and port. * Listens for incoming connections. * Accepts connections and calls `handle_client` to handle each client. **5. Running the Server** 1. Save the code as a Python file (e.g., `mcp_server.py`). 2. Run the file from your terminal: `python mcp_server.py` **6. Connecting with a Minecraft Client** 1. **Important:** You'll need a Minecraft client that allows you to connect to custom servers. The official client *might* work, but you might need a modified client or a proxy like ViaVersion to handle protocol differences. Older versions of Minecraft are more likely to work without modification. 2. In your Minecraft client, add a new server with the address `localhost` and port `25565`. 3. Try to connect. **Important Considerations and Next Steps:** * **Error Handling:** The code lacks proper error handling. Add `try...except` blocks to catch exceptions and handle them gracefully. * **Protocol Version:** The Minecraft protocol changes with each version. Make sure your server and client are using compatible protocol versions. The `protocol_version` field in the Handshake packet is crucial. * **Data Types:** Pay close attention to the data types used in the protocol. Use the `struct` module (in Python) or the appropriate Java classes to pack and unpack data correctly. Big-endian vs. little-endian is important. * **Compression:** Implement compression if you want to support it. The `zlib` library is used for this. * **Login:** The login process is more complex in real servers. It involves authentication with Mojang's servers. This example uses a dummy UUID. * **Game Logic:** This server doesn't implement any game logic. You'll need to add code to handle player movement, block placement, etc. * **Chunk Generation:** The chunk generation is extremely basic. You'll need to generate more realistic terrain. * **Multi-threading:** For a real server, you'll need to use multi-threading or asynchronous programming to handle multiple clients concurrently. **Vietnamese Translation of Key Terms:** * **Server:** Máy chủ * **Client:** Máy khách * **Protocol:** Giao thức * **Packet:** Gói tin * **Handshake:** Bắt tay (trong giao tiếp) * **Status:** Trạng thái * **Login:** Đăng nhập * **Data:** Dữ liệu * **Socket:** Ổ cắm mạng * **Compression:** Nén * **Decompression:** Giải nén * **VarInt:** Một kiểu số nguyên có độ dài thay đổi (Variable Integer) * **UUID:** Mã định danh duy nhất toàn cầu (Universally Unique Identifier) * **Chunk:** Một phần của thế giới Minecraft (16x16x256 khối) * **Entity:** Thực thể (người chơi, quái vật, v.v.) **Lời khuyên (Advice):** * **Bắt đầu từ từ (Start slowly):** Don't try to implement everything at once. Focus on getting the basic handshake and status working first. * **Đọc tài liệu (Read the documentation):** The Minecraft Wiki is your best friend. * **Gỡ lỗi (Debug):** Use a debugger to step through your code and see what's happening. Print statements are also helpful. * **Tham khảo mã nguồn mở (Refer to open-source code):** Look at existing open-source Minecraft server implementations for inspiration. However, don't just copy and paste code; try to understand it. This is a challenging project, but it's a great way to learn about networking and game development. Good luck!

MCP Session Saver

An MCP server that enables users to save, search, and manage AI conversation records as organized Markdown files across various IDEs. It automatically categorizes sessions by IDE name, date, and description for efficient storage and easy retrieval.

ORAS MCP Server

Enables users to interact with container registries through the ORAS CLI, providing information about container images, platforms, and signatures via natural language queries.

Jira JQL Tool for Claude

Công cụ MCP đơn giản và thiết thực

Nanoleaf MCP Server

A Model Context Protocol server that enables controlling Nanoleaf smart lights through Warp terminal or any MCP-compatible client, providing tools for device discovery, authorization, and control of lights, brightness, colors, and effects.

AURA MCP Server

Enables Claude and ChatGPT to interact with AdEx AURA API for DeFi portfolio analysis, yield opportunity scanning, and automated trading strategy execution across multiple EVM chains. Includes risk management guardrails and on-chain payment verification.

Betaflight MCP Server

Enables natural language interaction with Betaflight FPV drone flight controllers for configuration, PID tuning, sensor monitoring, VTX control, and blackbox management through Claude AI.