Discover Awesome MCP Servers

Yamcs MCP Server

Enables AI assistants to interact with Yamcs mission control systems through natural language, providing tools and resources for telemetry, commands, links, storage, instances, and alarms.

PubMed Custom Connector MCP Server

Enables users to search and fetch PubMed biomedical literature articles through natural language queries in Microsoft 365 Copilot.

MCPez - 微服务命令代理管理平台

Mikro server MCP terpadu

die-mcp

Detect It Easy (DIE) MCP Server

GitLab MCP

Exposes the GitLab REST API to MCP clients for managing projects, issues, merge requests, repositories, and CI/CD pipelines. It is multi-tenant, allowing each user to authenticate with their own token and instance URL.

hwms-mcp-server

AI-driven module selection and scaffold generation for hybrid web applications. Enables automatic dependency resolution and project structure creation via natural language queries.

cn-financial-mcp

Provides access to Chinese mainland financial data including A-stock quotes, financial statements, industry analysis, and macroeconomics through 42 MCP tools, with automatic data source fallback and no API key required.

Dell Unity MCP Server

An MCP server for Dell Unity storage arrays that automatically generates tools from OpenAPI specifications, enabling AI assistants like Claude and n8n to interact with Unity storage systems without storing credentials.

Security Scan MCP Server

An MCP server that provides CVE-driven security prompts for code review, enabling coding agents to get actionable security checks based on real vulnerabilities.

MySQL MCP Server

This server connects to MySQL databases, enabling listing databases and tables, describing table schemas, and executing read-only SQL queries with optional write support and SSL security.

Resonant Mind

MCP server providing persistent cognitive infrastructure including semantic memory, emotional processing, identity continuity, and a subconscious daemon for pattern analysis.

stylelint-mcp

Enables AI models to run Stylelint on CSS files and fix linting warnings directly through the Model Context Protocol.

@cloud9-labs/mcp-github

MCP (Model Context Protocol) server for GitHub API integration. This server provides comprehensive tools for interacting with GitHub repositories, issues, pull requests, branches, and code search through a unified interface.

Android MCP

Enables interaction with Android devices and emulators through ADB, allowing control actions like tapping, text input, screenshots, UI inspection, and app launching through natural language.

Screen Vision MCP Server

Enables screen capture, OCR text extraction, and automated clicking on macOS through MCP. Supports fullscreen, window, and region capture with optional text recognition and monitoring.

OpenLink MCP Server for ODBC

Enables LLMs to query ODBC-accessible databases via DSN, supporting SQL, SPARQL, and schema exploration.

Stripe MCP

Enables integration with Stripe APIs through function calling, supporting operations on customers, products, invoices, subscriptions, and more.

mcp-server-duckdb

Enables DuckDB database interaction through MCP, supporting SQL queries, table creation, and schema inspection with optional read-only mode.

Zhipu AI Image Generator MCP Server

Enables text-to-image generation using Zhipu AI's CogView4 model with support for multiple image sizes (1024x1024, 768x768, 576x1024) and automatic local saving of generated images.

ZCP

ZCP is a CLI with Zerops MCP that makes your agent a Zerops power-user. It runs either inside your project, or is connected through zCLI's VPN functionality to the project from your terminal. Your agent. Your subscription. Your code. Your infrastructure. Your IDE.

Malaysian Weather MCP Server

Provides real-time weather forecasts for locations across Malaysia by fetching data directly from MET Malaysia's API. It enables AI assistants to query today's conditions and seven-day forecasts for states, districts, and towns.

Mistral OCR MCP Server

Extracts text and images from PDFs and image files using the Mistral OCR API, with a security sandbox for file writes.

agenticpay

agenticpay lets MCP server developers monetize tools via per-call USDC micropayments on Solana, using the x402 protocol. Each tool declares a price; agents pay via signed Solana transactions; settlement happens on-chain in ~1.5–2 seconds.

TogoMCP

An MCP server that gives AI assistants access to biological and biomedical RDF databases via SPARQL at the RDF Portal, as well as selected REST APIs (NCBI E-utilities, UniProt, ChEMBL, PDB, Reactome, Rhea, MeSH, and more).

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!

figma-to-markdown-mcp

Converts Figma to Markdown. Strips out visual noise to drastically reduce LLM token consumption.

ProxmoxMCP

A Python-based MCP server for interacting with Proxmox hypervisors, enabling management of nodes, VMs, containers, and executing commands via QEMU Guest Agent.

proxmox-mcp

MCP server for full Proxmox VE management - VMs, containers, storage, backups, networking.

yoto-mcp-server

Enables audio uploads and MYO card creation for Yoto players directly from the terminal, using OAuth authentication and Warp AI integration.