Discover Awesome MCP Servers

Article Quadrant Analyzer MCP Server

Extracts content from articles, URLs, and images (via OCR), then generates intelligent 2x2 quadrant analysis visualizations in Chinese with direct ASCII matrix output for analyzing work processes, collaboration patterns, and content strategy.

Email MCP Server

Enables AI to send, read, search, delete and reply to emails through SMTP or Gmail API, supporting common email services like QQ, 163, Gmail and Outlook with HTML/text formats and attachments.

Anki MCP Server

Cermin dari

mcp-kagi-search

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

File Operations MCP Server

Provides tools for common file processing operations including reading files, listing directories, searching across files, getting file info, and counting lines with built-in security features like path traversal protection.

mcp-4o-Image-Generator

mcp-4o-Image-Generator

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.

thoughtproof-mcp

Adversarial multi-model reasoning verification for AI agents. Claude, Grok, and DeepSeek challenge each decision — returns ALLOW or HOLD with JWKS-signed attestation. x402-gated on Base.

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!

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

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.

OWL-MCP

A Model-Context-Protocol server that enables AI assistants to create, edit, and manage Web Ontology Language (OWL) ontologies through function calls using OWL functional syntax.

strava-mcp

There isn't a direct "MCP server" specifically designed for Strava. It's possible you're thinking of something else, or perhaps a misunderstanding of terms. Here are a few possibilities and how they relate to Strava: * **MCP (Master Control Program):** This is a term often associated with mainframe computers or specific industrial control systems. It's highly unlikely to be directly related to Strava. * **Strava API and Third-Party Integrations:** Strava has an API (Application Programming Interface) that allows developers to create applications and services that interact with Strava data. It's possible someone has built a custom application or server that uses the Strava API for specific purposes. If you have more details about what you're trying to achieve, I can provide more specific guidance. * **Data Analysis and Visualization Servers:** Some users might set up their own servers to collect, analyze, and visualize their Strava data beyond what Strava provides natively. This could involve using tools like Python, R, or other data analysis platforms. To help me understand what you're looking for, could you provide more context? For example: * What are you trying to achieve with this "MCP server"? * Where did you hear about this "MCP server" in relation to Strava? * What kind of functionality are you hoping it would provide? **Translation to Indonesian:** Tidak ada "server MCP" yang secara khusus dirancang untuk Strava. Mungkin Anda memikirkan sesuatu yang lain, atau mungkin ada kesalahpahaman istilah. Berikut adalah beberapa kemungkinan dan bagaimana mereka berhubungan dengan Strava: * **MCP (Master Control Program):** Ini adalah istilah yang sering dikaitkan dengan komputer mainframe atau sistem kontrol industri tertentu. Sangat tidak mungkin terkait langsung dengan Strava. * **API Strava dan Integrasi Pihak Ketiga:** Strava memiliki API (Application Programming Interface) yang memungkinkan pengembang untuk membuat aplikasi dan layanan yang berinteraksi dengan data Strava. Mungkin saja seseorang telah membuat aplikasi atau server khusus yang menggunakan API Strava untuk tujuan tertentu. Jika Anda memiliki detail lebih lanjut tentang apa yang ingin Anda capai, saya dapat memberikan panduan yang lebih spesifik. * **Server Analisis dan Visualisasi Data:** Beberapa pengguna mungkin menyiapkan server mereka sendiri untuk mengumpulkan, menganalisis, dan memvisualisasikan data Strava mereka di luar apa yang disediakan Strava secara native. Ini dapat melibatkan penggunaan alat seperti Python, R, atau platform analisis data lainnya. Untuk membantu saya memahami apa yang Anda cari, bisakah Anda memberikan lebih banyak konteks? Contohnya: * Apa yang ingin Anda capai dengan "server MCP" ini? * Di mana Anda mendengar tentang "server MCP" ini sehubungan dengan Strava? * Fungsi seperti apa yang Anda harapkan darinya?

R2R FastMCP Server

Integrates R2R (Retrieval-Augmented Generation) with Claude Desktop, enabling semantic search across knowledge bases and RAG-based question answering with support for vector, graph, web, and document search.

API Health Check MCP Server

Monitors API endpoint health by checking availability, measuring response times, and providing detailed status reports with error handling and timeout protection for the localhost:8080/api/ticket endpoint.

Logo MCP

An intelligent website logo extraction system built on the Model Context Protocol (MCP) that automatically identifies and extracts logo icons from websites.

AWS Diagram MCP Server

Enables users to generate professional AWS architecture diagrams, sequence diagrams, flow charts, and class diagrams using Python code through the diagrams package. Supports customizable styling and secure diagram generation for cloud infrastructure visualization.

Investidor10 MCP Server

Investidor10 MCP Server

Explore MCP

A demonstration MCP server that exposes basic arithmetic tools (add, subtract, ping) through FastAPI and shows how to integrate them with OpenAI's tool-calling API for LLM orchestration.

Sequential Thinking MVP Server

Enables AI assistants to perform structured, step-by-step reasoning by breaking down complex problems into numbered thoughts, with support for revising previous steps and exploring alternative reasoning paths.

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

VeChain MCP Server

Enables interaction with the VeChain blockchain network, providing access to documentation search, Thor REST API queries for accounts/transactions/blocks, and wallet management with cryptographic signing capabilities for both Mainnet and Testnet.

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.