Discover Awesome MCP Servers

groundtruth-mcp

Enables coding agents to run project-specific checks, replays, simulations, and queries as MCP tools, providing ground-truth feedback on config edits instead of guessing.

Social Media Manager MCP

Enables social media account management including content calendars, posting cadence, captions, hashtags, engagement strategies, metrics interpretation, and client reporting.

ai-test-process-mcp

MCP server that generates ISO/IEC/IEEE 29119-3 compliant test plan drafts from project information, providing a structured resource for the standard's test plan outline and a tool for draft creation.

Metabase MCP

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

piston-mcp

Connects LLMs to the Piston code execution engine to run code in various languages.

Gradle Tomcat MCP Server

Enables management of Gradle-based Tomcat applications with capabilities for starting, stopping, restarting processes and querying application logs.

VeniAI-Hukuk-EmsalKarar-MCPServer

An AI-powered legal research tool that enables users to search for and retrieve legal precedents and case law decisions through a Model Context Protocol server. It supports both Turkish and English, providing lawyers and researchers with streamlined access to a comprehensive database of jurisprudence.

garmin-mcp

A local, single-user, read-only MCP server that gives Claude Code access to your Garmin health and training data, exposing tools for health snapshots, training status, run details, body metrics, and training analysis.

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.

Crystallize MCP

MCP server for Crystallize headless commerce. Gives AI agents read and write access to your catalogue, products, shapes, orders, customers, and tenant config.

Azure Kusto MCP Server

Um Servidor MCP para Azure Kusto

gmail-mcp

Enables interacting with multiple Gmail accounts through a single MCP server, supporting search, labels, drafts, and thread management with per-account OAuth.

filesystem-mcp-ignore

A Node.js MCP server for filesystem operations with support for custom ignore files (like .gitignore) to protect sensitive data from AI agents.

mcp-crypto-feeds

A server that provides access to curated crypto feeds and RSS/Atom feed fetching, enabling users to list feeds, read feed items, and fetch any feed by URL.

codelore-mcp

Turn any code repository into a searchable Obsidian vault — then let Claude Code navigate it as a set of MCP tools.

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.

pcb-mcp

Enables AI assistants to read and modify KiCAD PCB designs through the KiCAD IPC API, providing tools for board queries, footprint placement, track creation, DRC, and export.

CRM MCP Server

Enables AI agents to manage contacts, deals, pipelines, and team collaboration in a multi-tenant CRM with Arabic/RTL support.

open-webSearch

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

Kleap

Enables AI agents to build, edit, and publish live websites with hosting, database, auth, and domains via the Model Context Protocol.

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.

infoset-mcp

MCP server for Infoset CRM that enables AI assistants to manage tickets, contacts, companies, SLA, and email threads with built-in rate limit handling and batch operations.

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.

mcp-confluence

Um servidor de contexto de modelo que fornece prompts que podem ser usados como comandos de barra (slash commands) para clientes como o Zed Editor, a fim de adicionar o conteúdo da página como contexto ao assistente de IA.

test-files-mcp

Generates test files locally (images, PDFs, CSVs, corrupted files, etc.) from natural language prompts, with configurable sizes and safety limits.

PixelCheck

An MCP server that gives AI agents real browser capabilities including screenshotting, action execution, data extraction, and multi-persona auditing for frontend validation.

build-simple-mcp

Okay, here's a guide on how to build a simple Minecraft Protocol (MCP) server in Python. This will be a very basic server, capable of handling a single client, and will only implement a small subset of the Minecraft protocol. It's intended for learning and experimentation, not for actual gameplay. **Important Considerations:** * **Complexity:** The Minecraft protocol is complex. This example will only cover the bare minimum to get a client to connect and receive a basic status response. * **Security:** This is a simplified example and does *not* include any security measures. Do not expose this server to the public internet. * **Libraries:** We'll use the `socket` library for networking and `struct` for packing and unpacking data. You might consider using a more robust library like `nbt` for handling NBT data in a real server. * **Protocol Version:** This example will target a specific Minecraft protocol version. You'll need to adjust the code if you want to support different versions. I'll use a relatively recent version (e.g., 763 for 1.17.1), but you should check the Minecraft wiki for the correct version for your client. * **Error Handling:** This example will have minimal error handling for brevity. A real server needs robust error handling. **Code (Python):** ```python import socket import struct import json # Configuration HOST = 'localhost' # Listen on all interfaces PORT = 25565 PROTOCOL_VERSION = 763 # Minecraft 1.17.1 SERVER_VERSION_NAME = "My Simple Server" MAX_PLAYERS = 20 MOTD = "§aA Simple Minecraft Server" # Use Minecraft color codes # Helper functions for reading and writing Minecraft protocol data 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, data): while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if data == 0: break def write_string(sock, data): encoded_data = data.encode('utf-8') write_varint(sock, len(encoded_data)) sock.send(encoded_data) def read_string(sock): length = read_varint(sock) data = sock.recv(length) return data.decode('utf-8') # Server status response def get_status_response(): status = { "version": { "name": SERVER_VERSION_NAME, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": 0, "sample": [] # Add player samples if you want }, "description": { "text": MOTD } } return json.dumps(status) # Handle the handshake def handle_handshake(sock): protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack(">H", sock.recv(2))[0] # Big-endian unsigned short next_state = read_varint(sock) print(f"Protocol Version: {protocol_version}") print(f"Server Address: {server_address}") print(f"Server Port: {server_port}") print(f"Next State: {next_state}") return next_state # Handle status requests def handle_status(sock): # Expect an empty packet (request) packet_length = read_varint(sock) packet_id = sock.recv(1)[0] if packet_id == 0x00: # Send the status response status_response = get_status_response() status_response_bytes = status_response.encode('utf-8') packet = struct.pack("b", 0x00) + status_response_bytes write_varint(sock, len(packet)) sock.send(packet) # Handle ping packet_length = read_varint(sock) packet_id = sock.recv(1)[0] if packet_id == 0x01: ping_payload = sock.recv(8) # 8-byte payload packet = struct.pack("b", 0x01) + ping_payload write_varint(sock, len(packet)) sock.send(packet) else: print(f"Unexpected packet ID: {packet_id}") # Main server loop def main(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow address reuse server_socket.bind((HOST, PORT)) server_socket.listen(1) # Only allow one connection print(f"Server listening on {HOST}:{PORT}") while True: client_socket, client_address = server_socket.accept() print(f"Client connected from {client_address}") try: # Handshake next_state = handle_handshake(client_socket) if next_state == 1: # Status handle_status(client_socket) elif next_state == 2: # Login (not implemented in this example) print("Login requested (not implemented)") else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print("Client disconnected") if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries. 2. **Configuration:** Sets up server parameters like host, port, protocol version, MOTD, etc. **Crucially, make sure `PROTOCOL_VERSION` matches the version your Minecraft client is using.** 3. **Helper Functions:** * `read_varint(sock)`: Reads a variable-length integer (VarInt) from the socket. VarInts are used extensively in the Minecraft protocol. * `write_varint(sock, data)`: Writes a VarInt to the socket. * `write_string(sock, data)`: Writes a string to the socket, prefixed by its length as a VarInt. * `read_string(sock)`: Reads a string from the socket, reading the length as a VarInt first. 4. **`get_status_response()`:** Creates the JSON response that the server sends to the client when it requests the server status. This includes the server version, player count, and MOTD. The MOTD uses Minecraft color codes (e.g., `§a` for green). 5. **`handle_handshake(sock)`:** Handles the initial handshake packet from the client. It reads the protocol version, server address, port, and the "next state" (1 for status, 2 for login). It prints this information to the console. 6. **`handle_status(sock)`:** Handles the status request from the client. It expects an empty packet (0x00) and then sends the status response. It also handles the ping request (0x01) by echoing back the ping payload. 7. **`main()`:** * Creates a socket and binds it to the specified host and port. * Listens for incoming connections. * Accepts a client connection. * Calls `handle_handshake()` to process the handshake. * Based on the "next state" from the handshake, calls `handle_status()` or prints a message if login is requested (which is not implemented). * Closes the client socket. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Open a terminal or command prompt and run the script: `python mcp_server.py` 3. **Connect with Minecraft:** * Start your Minecraft client. * Go to "Multiplayer". * Click "Add Server". * Enter a server name (e.g., "My Server"). * Enter the server address as `localhost:25565` (or the IP address and port you configured). * **Important:** You may need to manually specify the Minecraft version in your client's installation settings to match the `PROTOCOL_VERSION` in the server code. If the versions don't match, the client will refuse to connect. You can often do this by creating a new installation profile in the Minecraft launcher. 4. **Observe:** You should see the server in your server list. When you hover over it, you should see the MOTD and player count. If you can't see the server, double-check the following: * The server is running. * The server address and port are correct in the Minecraft client. * The `PROTOCOL_VERSION` in the server code matches the Minecraft client version. * Firewall rules are not blocking the connection. **Limitations and Next Steps:** * **No Login:** This server doesn't handle player login. * **No World:** There's no world generation or game logic. * **Single Client:** It only supports one client at a time. * **Basic Protocol:** It only implements a small part of the Minecraft protocol. * **Error Handling:** Needs much better error handling. To build a more complete server, you would need to: * Implement the login sequence (encryption, authentication). * Generate or load a world. * Handle player movement, block updates, and other game events. * Implement a more robust networking architecture to handle multiple clients. * Use a library like `nbt` to handle NBT data (used for storing world data, player data, etc.). * Add security measures to prevent cheating and attacks. This example provides a starting point for understanding the basics of the Minecraft protocol and building your own server. Good luck!

Excel MCP Server

Enables LLMs to work with Excel and CSV files through structured tools for workbook operations, formatting, charts, ETL, analysis, and more.