Discover Awesome MCP Servers

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.

vantagate-mcp-server

Human-in-the-Loop authorization gateway for AI Agents. Securely pause MCP workflows and route high-risk actions to human approvers via Slack or Email.

Sophia Labs

Two MCP endpoints for building cognitive AI agents. /blueprint/mcp serves a 9-chapter architecture blueprint (4 tools). /devops/mcp serves a 7-chapter coding agent playbook (3 tools). Each product has its own Gumroad license key. Free chapters available without auth.

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.

LLM Tool-Calling Assistant

Connects local LLMs to external tools (calculator, knowledge base) via MCP protocol, enabling automatic tool detection and execution to enhance query responses.

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.

Umami MCP Server

Enables AI assistants to interact with Umami Analytics for both Cloud and self-hosted instances. It provides tools to retrieve website statistics, visitor metrics, pageview trends, and real-time active user counts.

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).

Airbnb Search & Listings

Enables users to search Airbnb listings with advanced filtering options and retrieve detailed property information through an MCP server interface.

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.

Attendee MCP Server

A Model Context Protocol server that allows users to create and manage meeting bots capable of joining video calls, speaking, sending chat messages, and retrieving meeting transcripts.

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.

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!

AutoBrowser MCP

Autobrowser MCP là một máy chủ Cung cấp Bối cảnh Mô hình (MCP) cho phép các ứng dụng AI điều khiển trình duyệt của bạn.

Substreams Search MCP Server

MCP server that lets AI agents search the substreams.dev package registry.

AI Naming Standard MCP Server

Enables automatic generation and validation of standardized file names using AI-driven conventions for microservices architecture. Supports multi-language naming with structured components like microservice, layer, domain, and action identifiers.

ClawHire MCP

An employer-facing MCP server that enables hiring managers to post jobs, search for candidates, and manage applications through natural language conversation. It integrates with WonderCV's hiring infrastructure and features a unique system for identifying and filtering talent with AI-agent fluency.

Color Scheme Generator MCP Server

Generates harmonious color schemes for design projects using The Color API, offering eight different palette generation methods including monochrome, analogic, complement, triad, and quad schemes.

WYGIWYH Expense Tracking MCP Server

Enables AI agents to interact with the WYGIWYH expense tracking API through 75 dynamically generated MCP tools. Supports comprehensive financial operations including transaction management, account handling, recurring expenses, and investment tracking.

HeadHunter MCP Server

Enables AI assistants to search job vacancies, manage resumes, and apply to jobs on HeadHunter (hh.ru), Russia's largest job search platform. Includes OAuth 2.0 integration for secure job applications and an automated vacancy hunter agent with intelligent matching.

edstem-mcp

Exposes the full Ed Discussion API to MCP clients, enabling users to manage threads, comments, and course activity through natural language. It provides comprehensive tools for searching and posting content, featuring automatic conversion from markdown to Ed's internal XML format.

Scientific Search MCP for Cursor

Máy chủ MCP để tìm kiếm trong các tài nguyên khoa học. Được AI tạo mã vibe cho AI.

US Government Open Data MCP

MCP server + TypeScript SDK for 36 U.S. government data APIs — 188 tools. Treasury, FRED, Congress, FDA, CDC, FEC, lobbying, and more. Works with VS Code Copilot, Claude Desktop, Cursor.