Discover Awesome MCP Servers

ShipStation MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for ShipStation (beta): https://www.cdata.com/download/download.aspx?sku=HSZK-V&type=beta

Appointment Manager MCP Server

Enables users to manage appointments through a FastAPI backend with PostgreSQL database. Supports creating, listing, updating, and deleting appointments via natural language interactions through Claude.

Habit Tracker AI MCP

Habit Tracker AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

MCP-Blender

Enables Claude AI to directly interact with and control Blender for rapid, natural language-based 3D modeling. Supports parametric design and relational design through direct Blender integration.

Xiaomi smart home MCP server

mijia-control A production-ready MCP server that enables AI agents (Claude Code, Claude Desktop, Cursor, Hermes, etc.) to directly control Xiaomi/Mijia smart home devices through natural language. What it does Turns conversations into physical actions — "turn on the desk lamp to 50%" becomes actual device control in real-time.

docbrain

Self-improving documentation engine that ingests Slack and GitHub PRs to detect knowledge gaps and improve documentation automatically.

FM8 MCP Server

Enables AI assistants to control Native Instruments FM8 synthesizer parameters through MIDI CC messages, allowing natural language programming of FM synthesis sounds including operator routing, frequency ratios, and modulation matrix settings.

Math Agent with Microsoft Word and Gmail Integration

Here's the translation of "MCP server for Math Agent with Microsoft Word and Gmail Integration" into Indonesian: **Server MCP untuk Agen Matematika dengan Integrasi Microsoft Word dan Gmail** Here's a breakdown of the translation: * **MCP server:** Server MCP * **for:** untuk * **Math Agent:** Agen Matematika * **with:** dengan * **Microsoft Word and Gmail Integration:** Integrasi Microsoft Word dan Gmail

Katana MCP Server

Integrates ProjectDiscovery's Katana web crawler with Claude Desktop, enabling users to crawl websites, discover endpoints and hidden resources, extract JavaScript files, and perform reconnaissance with customizable depth, scope, and filtering options.

oda-mcp

Enables agentic grocery shopping on Oda (Norway) and Mathem (Sweden) platforms through an MCP-compatible interface. Users can search for products, manage their shopping cart, and access order history using natural language commands.

MiniMax MCP Server

Bridges MiniMax AI capabilities to the Model Context Protocol, enabling AI agents to perform image understanding, text-to-image generation, and speech synthesis. It provides a standardized interface for accessing MiniMax's core tools via JSON-RPC.

Wayland MCP Server

Enables AI assistants to automate Wayland desktop environments through screenshot analysis, mouse control, and keyboard input simulation. It supports visual context via VLM providers like Gemini and OpenRouter to perform complex, multi-step desktop actions.

Mcp Server

Okay, here's an example of a simple MCP (Minecraft Protocol) server written in Python, designed to be easily understood and potentially adapted for use with a large language model like Claude. This is a very basic example and doesn't implement all the features of a real Minecraft server. It focuses on handling the initial handshake and sending a simple status response. ```python import socket import struct import json def handle_handshake(sock): """Handles the initial handshake from the client.""" # Read the packet length (VarInt) packet_length, bytes_read = read_varint(sock) print(f"Packet length: {packet_length}, Bytes read: {bytes_read}") # Read the packet ID (VarInt) packet_id, bytes_read_id = read_varint(sock) print(f"Packet ID: {packet_id}, Bytes read: {bytes_read_id}") # Read the protocol version (VarInt) protocol_version, bytes_read_version = read_varint(sock) print(f"Protocol Version: {protocol_version}, Bytes read: {bytes_read_version}") # Read the server address (String) server_address_length, bytes_read_address_length = read_varint(sock) server_address = sock.recv(server_address_length).decode('utf-8') print(f"Server Address: {server_address}, Bytes read: {bytes_read_address_length}") # Read the server port (Unsigned Short) server_port = struct.unpack('>H', sock.recv(2))[0] # Big-endian unsigned short print(f"Server Port: {server_port}") # Read the next state (VarInt) next_state, bytes_read_state = read_varint(sock) print(f"Next State: {next_state}, Bytes read: {bytes_read_state}") return next_state def handle_status_request(sock): """Handles the status request from the client and sends a response.""" # Read the packet length (VarInt) - should be 1 for an empty status request packet_length, bytes_read = read_varint(sock) print(f"Status Request Packet Length: {packet_length}, Bytes read: {bytes_read}") # Read the packet ID (VarInt) - should be 0 for a status request packet_id, bytes_read_id = read_varint(sock) print(f"Status Request Packet ID: {packet_id}, Bytes read: {bytes_read_id}") # Construct the status response status = { "version": { "name": "My Awesome Server", "protocol": 763 # Example protocol version (1.17.1) }, "players": { "max": 100, "online": 0, "sample": [] }, "description": { "text": "A server powered by Python and AI!" } } status_json = json.dumps(status) status_bytes = status_json.encode('utf-8') status_length = len(status_bytes) # Create the response packet packet = bytearray() write_varint(packet, status_length) # Length of the JSON string packet.extend(status_bytes) # Prepend the packet length packet_length = len(packet) response = bytearray() write_varint(response, packet_length) response.extend(packet) # Send the response sock.sendall(response) def handle_ping(sock): """Handles the ping request from the client and sends a response.""" # Read the packet length (VarInt) - should be 9 packet_length, bytes_read = read_varint(sock) print(f"Ping Packet Length: {packet_length}, Bytes read: {bytes_read}") # Read the packet ID (VarInt) - should be 1 packet_id, bytes_read_id = read_varint(sock) print(f"Ping Packet ID: {packet_id}, Bytes read: {bytes_read_id}") # Read the payload (Long) payload = struct.unpack('>q', sock.recv(8))[0] # Big-endian long print(f"Ping Payload: {payload}") # Create the response packet (same payload) response = bytearray() write_varint(response, 8) # Packet Length (8 bytes for long) write_varint(response, 0) # Packet ID (0 for pong) response.extend(struct.pack('>q', payload)) # Payload # Prepend the packet length packet_length = len(response) final_response = bytearray() write_varint(final_response, packet_length) final_response.extend(response) # Send the response sock.sendall(final_response) def read_varint(sock): """Reads a VarInt from the socket.""" num_read = 0 result = 0 shift = 0 while True: byte = sock.recv(1)[0] num_read += 1 result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break if num_read > 5: raise Exception("VarInt is too big") return result, num_read def write_varint(buffer, value): """Writes a VarInt to the buffer.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 buffer.append(byte) if value == 0: break def main(): """Main server loop.""" host = 'localhost' port = 25565 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of address server_socket.bind((host, port)) server_socket.listen(1) # Listen for one connection at a time print(f"Server listening on {host}:{port}") while True: try: client_socket, address = server_socket.accept() print(f"Accepted connection from {address}") try: # Handle the handshake next_state = handle_handshake(client_socket) if next_state == 1: # Handle status request handle_status_request(client_socket) # Handle ping request handle_ping(client_socket) elif next_state == 2: print("Login requested. Not implemented in this example.") # In a real server, you'd handle login here. pass else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print(f"Connection from {address} closed.") except KeyboardInterrupt: print("Shutting down server...") break except Exception as e: print(f"Error in main loop: {e}") server_socket.close() if __name__ == "__main__": main() ``` Key improvements and explanations: * **VarInt Handling:** Minecraft uses VarInts (variable-length integers) for packet lengths and IDs. The `read_varint` and `write_varint` functions correctly handle these. This is *crucial* for Minecraft protocol communication. The code now includes error handling to prevent infinite loops if a VarInt is too large. * **Status Response:** The `handle_status_request` function now constructs a valid JSON status response. This is what the Minecraft client displays in the server list. The `protocol` field in the status is important; it needs to match the client's version. I've set it to 763, which corresponds to Minecraft 1.17.1. You can find a list of protocol versions online. The `description` field is what's displayed as the server's MOTD (message of the day). * **Ping Handling:** The `handle_ping` function now correctly handles the ping request and sends back the same payload. This is what determines the server's latency in the client. * **Error Handling:** Includes `try...except` blocks to catch potential errors during client communication and in the main loop. This prevents the server from crashing if a client sends invalid data. * **Socket Reuse:** `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)` allows you to quickly restart the server without waiting for the socket to time out. * **Clearer Output:** Prints more informative messages to the console, making it easier to debug. * **Big-Endian:** Uses `struct.pack('>H', ...)` and `struct.unpack('>q', ...)` to ensure that multi-byte values are packed and unpacked in big-endian order, as required by the Minecraft protocol. * **Bytearray:** Uses `bytearray` for building packets. This is more efficient than repeatedly concatenating strings. * **Comments:** Added more comments to explain the code. * **Next State Handling:** The `handle_handshake` function now returns the `next_state` value, which determines whether the client is requesting the server status (1) or attempting to log in (2). The main loop then branches based on this value. A placeholder is included for login handling, but it's not implemented. * **Complete Example:** This is a complete, runnable example. You should be able to copy and paste it into a Python file and run it. **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. **Minecraft:** In your Minecraft client, add a new server with the address `localhost:25565`. (If you're running the server on a different machine, use that machine's IP address instead of `localhost`.) 4. **Observe:** You should see your server in the server list with the MOTD "A server powered by Python and AI!". The latency should be displayed after the ping is handled. **How to Adapt for Claude:** The key is to modify the `handle_status_request` function to use Claude to generate the status response. Here's a conceptual outline: 1. **Claude Integration:** You'll need to install the Anthropic Python client library (`anthropic`). You'll also need an API key. 2. **Prompt Engineering:** Craft a prompt that tells Claude what kind of status response you want. For example: ```python import anthropic client = anthropic.Anthropic(api_key="YOUR_ANTHROPIC_API_KEY") def generate_status_with_claude(): prompt = """You are a helpful assistant that generates JSON responses for a Minecraft server status. The server is called "My Awesome Server". It has a maximum of 100 players. The current time is [current time]. The server's description should be witty and engaging. Include information about the server's features. Generate a JSON object with the following structure: ```json { "version": { "name": "My Awesome Server", "protocol": 763 }, "players": { "max": 100, "online": [number of online players], "sample": [] }, "description": { "text": "[witty server description]" } } ``` Only return the JSON object. Do not include any other text. """ # Replace [current time] and [number of online players] with actual values import datetime now = datetime.datetime.now() prompt = prompt.replace("[current time]", now.strftime("%Y-%m-%d %H:%M:%S")) prompt = prompt.replace("[number of online players]", "0") # Replace with actual online player count response = client.completions.create( model="claude-3-opus-20240229", # Or another suitable Claude model max_tokens_to_sample=500, prompt=f"{anthropic.HUMAN_PROMPT} {prompt} {anthropic.AI_PROMPT}", ) try: status = json.loads(response.completion) return status except json.JSONDecodeError as e: print(f"Error decoding JSON from Claude: {e}") # Return a default status if Claude fails return { "version": {"name": "Error", "protocol": 763}, "players": {"max": 100, "online": 0, "sample": []}, "description": {"text": "Error generating status."} } ``` 3. **Modify `handle_status_request`:** Replace the hardcoded `status` dictionary in `handle_status_request` with a call to `generate_status_with_claude()`: ```python def handle_status_request(sock): # ... (existing code) ... status = generate_status_with_claude() # Get the status from Claude # ... (existing code) ... ``` **Important Considerations for Claude Integration:** * **API Key:** Store your Anthropic API key securely (e.g., in an environment variable). Do *not* hardcode it directly into the script. * **Rate Limiting:** Be mindful of Anthropic's rate limits. You might need to implement caching or other strategies to avoid exceeding the limits. * **Error Handling:** Claude might sometimes return invalid JSON or fail to respond. Implement robust error handling to gracefully handle these cases. Provide a default status response if Claude fails. * **Prompt Engineering:** Experiment with different prompts to get the desired behavior from Claude. The prompt is key to controlling the content of the status response. * **Cost:** Using Claude costs money. Be aware of the pricing and monitor your usage. * **Latency:** Calling Claude will add latency to the status request. This might be noticeable to players. This example provides a solid foundation for building a more sophisticated Minecraft server that leverages the power of a large language model. Remember to handle errors, rate limits, and security considerations carefully. Good luck!

MCP Server with OpenAI Integration

Production-ready MCP server that integrates OpenAI API with extensible tool support, enabling dynamic plugin loading and knowledge search capabilities through multiple interfaces including CLI and browser UI.

Wireshark MCP Server

A containerized server that enables AI clients to perform automated network packet analysis, protocol inspection, and traffic forensics using Wireshark/tshark. It features a stateless design that synchronizes PCAP files directly from GitHub for secure and ephemeral analysis sessions.

User Info MCP Server

An MCP server providing tools for user information management with capabilities for retrieving, searching, and adding user data stored in a JSON file.

KubeBlocks Cloud MCP Server

MCP server for KubeBlocks Cloud

TalkToAnki

An MCP server that enables AI assistants to seamlessly manage Anki flashcards, decks, and templates through the AnkiConnect API. It supports intelligent querying, batch note creation, and detailed study progress analysis using natural language.

Xiaohongshu (RedBook) MCP Server

Enables automated interaction with Xiaohongshu (Little Red Book) platform including searching posts, retrieving content and comments, and posting AI-generated comments with persistent login support.

Twilio MCP Server by CData

This read-only MCP Server allows you to connect to Twilio data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Stimulus Docs MCP Server

An MCP server that provides access to up-to-date Stimulus JS documentation directly within Claude conversations and VS Code.

Actor-Critic Thinking MCP Server

Provides dual-perspective analysis through alternating actor (creator/performer) and critic (analyzer/evaluator) viewpoints, generating comprehensive performance evaluations with balanced, actionable feedback.

Ecommerce AI MCP

Ecommerce AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

FastMCP Development Assistant

Provides comprehensive development tools for FastMCP projects including documentation access, NPM package version management, and TypeScript type definitions retrieval. Enables developers to fetch FastMCP documentation, analyze NPM packages, and access MCP architecture information through natural language.

Google Search Tool

Enables AI assistants to perform real-time Google searches with anti-bot protection. Bypasses search engine restrictions using advanced browser automation to extract search results locally without requiring paid API services.

Claw-Cleaning

This server lets users order apartment cleaning services to their home.

rpn-mcp

An MCP server that provides tools for evaluating Reverse Polish Notation (RPN) expressions and managing a calculator stack. It supports standard arithmetic operators along with stack operations like duplicate, swap, and clear.

Houtini-lm

Houtini LM - LM Studio MCP Server with Expert Prompt Library and Custom Prompting - Offload tasks to LM Studio from Claude Desktop.

MCPHub

Solusi Embeddable Model Context Protocol (MCP) untuk layanan AI. Integrasikan server MCP dengan mulus dengan kerangka kerja OpenAI Agents, LangChain, dan Autogen melalui antarmuka terpadu. Menyederhanakan konfigurasi, pengaturan, dan pengelolaan alat MCP di berbagai aplikasi AI.

mcp-kagi-search

Implementasi server MCP untuk API Kagi menggunakan npx, sehingga dapat dengan mudah dijalankan di n8n.