Discover Awesome MCP Servers

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.

MCP Authentication Example

Demonstrates OAuth2/OIDC authentication for MCP servers using Asgardeo, with JWT validation and a sample weather tool to showcase secured API access.

Excel MCP Server

Enables AI agents to create, read, and manipulate Excel workbooks without Microsoft Excel installed, supporting formulas, formatting, charts, pivot tables, and data validation operations.

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!

AutoBrowser MCP

Autobrowser MCP is a Model Context Provider (MCP) server that allows AI applications to control your browser

MCP4GVA

Enables access to GVA GIS (Generalitat Valenciana) geographic data through ArcGIS REST API, allowing queries, filtering, and exporting of land activity information in the Valencian Community.

MCP Notion Server

MCP server for using the Notion API

Meta Marketing API MCP Server

Enables AI assistants to manage Facebook and Instagram advertising data through the Meta Marketing API. It supports full campaign lifecycle management, performance analytics, audience targeting, and creative optimization.

MCP Add Server

A minimal Model Context Protocol server that provides a simple add(a, b) tool for computing the sum of two numbers.

eda-mcp

An MCP server for Electronic Design Automation that provides comprehensive tools for managing KiCad 9.x PCB design workflows. It enables users to create schematics, layout PCBs, perform design rule checks, and export manufacturing files through a standardized interface.

WeiWanMcpServer

Servidor Mcp Privado

CHUK Music MCP Server

Enables AI-assisted music composition through copyable pattern templates, style constraints, and arrangement tools that compile to MIDI files. Provides 30+ tools for managing musical structures, layers, patterns, and styles with deterministic compilation from YAML arrangements.

mcp-linkedinads

Analyse your LinkedIn Ads performance. Compare to benchmarks and get optimisation recommendations.

富途 MCP 服务器 (Futu MCP Server)

Exposes Futu API client capabilities as an MCP (Model Context Protocol) tool, allowing AI assistants to access stock data from Futu through a standardized interface.

Cisco ISE MCP Server

Enables management of Cisco Identity Services Engine (ISE) resources through the ERS API. Supports identity management, endpoint registration, network device configuration, and authorization profiles through natural language interactions.

MCP Memory Server - HTTP Streaming

Enables creation and management of knowledge graphs with entities, relationships, and observations through HTTP streaming. Supports persistent storage, search functionality, and CRUD operations for building and querying interconnected knowledge bases.

Boilerplate MCP

A template repository for developing Model Context Protocol (MCP) servers with devcontainer setup and curated learning resources.

Lanhu MCP Server

Enables AI to directly read and analyze Lanhu design drafts and requirement documents to generate HTML, CSS, and structural analyses. It allows users to extract design slices and process prototype pages directly within AI clients.

MCP Document Server

A simple server implementing the Model Context Protocol for document search

Slack MCP Server

A server implementing Model Context Protocol that enables AI assistants to interact with Slack API through a standardized interface, providing tools for messaging, channel management, user information retrieval, and more.

semantic-code-mcp

A local MCP server that provides semantic code search for Python codebases using tree-sitter for chunking and LanceDB for vector storage. It enables natural language queries to find relevant code snippets based on meaning rather than just text matching.

Oracle MCP Server by CData

Oracle MCP Server by CData

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.

Metabase MCP

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

Genai Toolbox

Servidor MCP de código aberto especializado em ferramentas fáceis, rápidas e seguras para bancos de dados.

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.

Browser MCP Server (Anchor)

Enables browser automation through Anchor Browser's cloud infrastructure with built-in proxies, stealth features, and anti-detection capabilities. Allows LLMs to navigate, click, type, take screenshots, and interact with web pages using Playwright's accessibility tree without requiring local browser installations.

cite-mcp

Recupere dados de citação sem esforço do CiteAs e do Google Scholar. Obtenha citações formatadas em BibTeX para seus recursos com apenas alguns comandos. Melhore seu fluxo de trabalho de pesquisa integrando a recuperação de citações diretamente em seus aplicativos.