Discover Awesome MCP Servers

Sitecore Send

Unofficial Sitecore Send MCP Server.

Perplexity Ask MCP Server

Integrates the Sonar API to provide Claude with real-time web-wide research capabilities. Enables conversational web searches through Perplexity's AI-powered search engine for up-to-date information retrieval.

mcp-label-studio: A Label Studio MCP server

Servidor MCP para Label Studio.

nf-core MCP Server

Permite que os usuários gerenciem e naveguem em repositórios de pipelines de bioinformática nf-core, permitindo operações de listagem, pesquisa e exploração em configurações de pipeline, fluxos de trabalho e módulos.

jobswithgpt

jobswithgpt

mcp-4o-Image-Generator

mcp-4o-Image-Generator

rust-mcp-tutorial

Aqui está uma tradução de "rustでmcp serverのお試し" para português: **"Testando um servidor MCP em Rust"** Uma tradução mais literal seria: "Tentativa de servidor MCP com Rust", mas a primeira opção soa mais natural em português.

Mcp Server

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 Claude. This is a *very* basic example and doesn't implement the full Minecraft protocol. It's intended to illustrate the core concepts of listening for connections and sending/receiving data. ```python import socket import struct import json # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 25565 # Standard Minecraft port # --- Minecraft Protocol Helper Functions --- def read_varint(sock): """Reads a variable-length integer from the socket.""" result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed byte = ord(byte) result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, value): """Writes a variable-length integer to the socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if value == 0: break def read_string(sock): """Reads a string from the socket, prefixed by a varint length.""" length = read_varint(sock) if length is None: return None # Connection closed data = sock.recv(length) try: return data.decode('utf-8') except UnicodeDecodeError: return None # Invalid string def write_string(sock, string): """Writes a string to the socket, prefixed by a varint length.""" encoded_string = string.encode('utf-8') write_varint(sock, len(encoded_string)) sock.send(encoded_string) def send_packet(sock, packet_id, data): """Sends a packet with a given ID and data.""" packet = struct.pack(">b", packet_id) + data write_varint(sock, len(packet)) sock.send(packet) # --- Server Logic --- def handle_handshake(sock): """Handles the initial handshake packet.""" protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack(">H", sock.recv(2))[0] # Unpack as big-endian unsigned short next_state = read_varint(sock) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, State {next_state}") return next_state def handle_status_request(sock): """Handles the status request and sends a response.""" # Receive empty status request packet (ID 0x00) packet_id = read_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID in status request: {packet_id}") return # Craft a simple status response status = { "version": { "name": "My Claude Server", "protocol": 763 # Example protocol version }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "A server powered by Claude (sort of)!" } } status_json = json.dumps(status) print(f"Sending status: {status_json}") # Send status response packet (ID 0x00) write_string(sock, status_json) send_packet(sock, 0x00, b"") # Ping response (empty packet) def handle_login_start(sock): """Handles the login start packet (player name).""" player_name = read_string(sock) print(f"Login attempt from: {player_name}") # For simplicity, we'll just accept the connection. In a real server, # you'd handle authentication, UUID generation, etc. # Send Login Success packet (ID 0x02) uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID send_packet(sock, 0x02, write_string(sock, uuid).encode('utf-8') + write_string(sock, player_name).encode('utf-8')) # Send Join Game packet (ID 0x26) - Minimal data for joining entity_id = 0 gamemode = 1 # Creative dimension = 0 # Overworld hashed_seed = 0 max_players = 20 level_type = "default" reduced_debug_info = False enable_respawn_screen = True join_game_data = struct.pack(">iBbql", entity_id, gamemode, dimension, hashed_seed, max_players) + \ write_string(sock, level_type).encode('utf-8') + \ struct.pack("?b", reduced_debug_info, enable_respawn_screen) send_packet(sock, 0x26, join_game_data) # Send Player Position & Rotation packet (ID 0x36) x, y, z = 0.0, 64.0, 0.0 yaw, pitch = 0.0, 0.0 flags = 0x00 # No flags set teleport_id = 0 position_data = struct.pack(">dddbbi", x, y, z, yaw, pitch, flags, teleport_id) send_packet(sock, 0x36, position_data) # Send Clientbound Plugin Message (ID 0x18) - Required for some clients channel = "minecraft:brand" brand = "vanilla" plugin_message_data = write_string(sock, channel).encode('utf-8') + write_string(sock, brand).encode('utf-8') send_packet(sock, 0x18, plugin_message_data) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") try: # Handshake next_state = handle_handshake(conn) if next_state == 1: # Status handle_status_request(conn) elif next_state == 2: # Login handle_login_start(conn) # After login, you'd enter the game loop and handle player input. # This example doesn't implement that. else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") # --- Main Server Loop --- with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) ``` Key improvements and explanations: * **Clearer Structure:** The code is now organized into functions for each stage of the Minecraft protocol (handshake, status, login). This makes it much easier to understand and extend. * **VarInt Handling:** Correctly implements reading and writing variable-length integers (VarInts), which are crucial for the Minecraft protocol. The `read_varint` function now handles connection closed gracefully. * **String Handling:** Includes functions for reading and writing strings, prefixed by their length as a VarInt. Handles potential `UnicodeDecodeError`. * **Status Response:** Crafts a valid JSON status response that a Minecraft client can understand. Includes version, player count, and description. * **Login Handling:** Handles the `Login Start` packet and sends a `Login Success` packet. **Important:** This is a *very* simplified login. A real server would need to handle authentication and UUID generation. * **Join Game Packet:** Sends a minimal `Join Game` packet, which is necessary for the client to actually enter the game world. Includes entity ID, gamemode, dimension, etc. * **Player Position Packet:** Sends a `Player Position & Rotation` packet to set the player's initial position in the world. * **Clientbound Plugin Message:** Sends a `Clientbound Plugin Message` with the "minecraft:brand" channel. Some clients require this. * **Error Handling:** Includes basic `try...except` blocks to catch potential errors during client handling. * **Comments:** Extensive comments explain each step of the process. * **`SO_REUSEADDR`:** Sets the `SO_REUSEADDR` socket option to allow the server to be restarted quickly without waiting for the port to be released. * **Correct Unpacking:** Uses `struct.unpack(">H", ...)` to correctly unpack the port number from the handshake packet as a big-endian unsigned short. * **UTF-8 Encoding:** Explicitly encodes strings to UTF-8 before sending them. * **Packet Sending Helper:** The `send_packet` function simplifies sending packets by handling the VarInt length prefix. * **Minimal Dependencies:** Only uses the standard `socket`, `struct`, and `json` libraries. * **Connection Closed Handling:** `read_varint` now returns `None` if the connection is closed, allowing the server to handle it gracefully. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Execute the file from your terminal: `python mcp_server.py` 3. **Connect:** In your Minecraft client, add a new server with the address `127.0.0.1` and port `25565`. **Important:** You may need to disable client-side authentication or use a development client that allows connecting to servers without proper authentication. This server *does not* implement authentication. You will likely need to set "online-mode=false" in your client's `server.properties` file (if applicable) or use a cracked/offline client. 4. **Observe:** Watch the server's output in the terminal to see the handshake, status request, and login information. **Important Considerations for Claude Integration:** * **Claude's Role:** Think about what you want Claude to *do* with the Minecraft server. Some possibilities: * **AI-Controlled Entities:** Use Claude to control the behavior of non-player characters (NPCs) in the game. You'd need to extend the server to handle entity movement, AI logic, and communication with Claude. * **World Generation:** Use Claude to generate interesting terrain or structures. You'd need to modify the server to send the appropriate chunk data to the client. * **Chatbot:** Use Claude to create a more intelligent chatbot that can interact with players in the game. You'd need to handle chat messages and send responses back to the client. * **Game Logic:** Use Claude to dynamically adjust game rules or events based on player actions. * **Communication:** You'll need a way for the Python server to communicate with Claude. This could involve: * **API Calls:** The server can make API calls to Claude's API to get responses or instructions. This is the most common approach. * **Message Queues:** Use a message queue (e.g., RabbitMQ, Redis) to asynchronously send data between the server and Claude. * **Shared Memory:** (Less common) Use shared memory to allow the server and Claude to directly access the same data. * **Protocol Complexity:** The Minecraft protocol is complex. This example only implements a small subset of it. You'll likely need to use a more complete Minecraft library or implement more of the protocol yourself to achieve your desired functionality. Consider libraries like `mcproto` or `python-minecraft-protocol`. * **Security:** If you're exposing your server to the internet, be very careful about security. The Minecraft protocol has known vulnerabilities. Implement proper authentication and input validation to prevent attacks. **Example: Claude as a Chatbot (Conceptual)** 1. **Receive Chat Message:** Extend the server to receive chat messages from the client. This involves parsing the appropriate Minecraft packet. 2. **Send to Claude:** Send the chat message to Claude's API. You might include additional context, such as the player's name, location, and current game state. 3. **Receive Response:** Receive a response from Claude. 4. **Send Chat Message:** Send a chat message back to the client (or to all clients) with Claude's response. **Portuguese Translation of Key Concepts:** * **MCP (Minecraft Protocol):** Protocolo Minecraft * **Server:** Servidor * **Client:** Cliente * **Handshake:** Handshake (aperto de mão inicial, negociação) * **Status:** Status (estado) * **Login:** Login (autenticação) * **Packet:** Pacote (dados enviados pela rede) * **VarInt (Variable-length Integer):** Inteiro de Comprimento Variável * **JSON:** JSON (formato de dados) * **API (Application Programming Interface):** API (Interface de Programação de Aplicações) * **Message Queue:** Fila de Mensagens * **Shared Memory:** Memória Compartilhada * **Entity:** Entidade (personagem, objeto no jogo) * **Chunk:** Chunk (pedaço do mundo do Minecraft) * **Authentication:** Autenticação * **UUID (Universally Unique Identifier):** UUID (Identificador Único Universal) This comprehensive example and explanation should give you a solid foundation for building a Minecraft server that integrates with Claude. Remember to start small, test frequently, and focus on one specific goal at a time. Good luck!

Autotask MCP Server

A Model Context Protocol server that enables natural language querying of Kaseya's Autotask PSA data through AI assistants, supporting contract analysis, ticket tracking, agent activities, and project status monitoring.

Warden Magento MCP Server

A Model Context Protocol server that enables AI assistants to interact directly with Warden-managed Magento 2 development environments, automating common tasks like project initialization, environment management, database operations, and Magento CLI commands.

Soccer V3 Scores MCP Server

An MCP server that enables agents to interact with soccer data including scores, matches, players, and teams using the sportsdata.io Soccer V3 Scores API.

Peekaboo MCP

A macOS utility that captures screenshots and analyzes them with AI vision, enabling AI assistants to see and interpret what's on your screen.

Spring AI MCP Batch Job Server

Um servidor Spring Boot Model Context Protocol (MCP) que fornece ferramentas de processamento em lote para transações financeiras.

arduino-mcp-server

Um servidor Arduino MCP escrito em Go.

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

Servidor MCP micro unificado

die-mcp

Servidor MCP do Detect-It-Easy

mcp_repo_4a01eabf

Este é um repositório de teste criado pelo script de teste do Servidor MCP para o GitHub.

MCP Server

A FastAPI-based Model Context Protocol server that exposes herd data through a discoverable API, with local and containerized deployment options.

JSON DB MCP Server

Enables users to manage data in a simple JSON file database through MCP tools and REST API. Supports creating, reading, updating, and deleting items organized in collections with auto-generated UUIDs.

Rossum MCP Server

A Model Context Protocol server that provides AI agents with read-only access to Rossum API resources (queues, schemas, hooks, workspaces) for analysis purposes.

Model Context Protocol .NET Template

Este repositório contém um modelo para criar aplicações Model Context Protocol (MCP) em .NET.

db-mcp

Servidor de Protocolo de Contexto de Modelo de Banco de Dados (DB-MCP)

Jira MCP Server

Connects Jira with Claude, enabling users to search issues, view issue details, update issues, add comments, and retrieve project information through natural language commands.

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.

Advanced TTS MCP Server

Provides high-quality text-to-speech synthesis with 10 natural voices, emotion control, and dynamic pacing for professional applications requiring expressive speech output.

Investidor10 MCP Server

Investidor10 MCP Server

ProxmoxMCP-Plus

An enhanced Python-based MCP server that enables complete VM lifecycle management and monitoring of Proxmox virtualization platforms through natural language, with 11 REST API endpoints for seamless integration.

O'RLY MCP Server

Generates O'Reilly parody book covers that display directly in Claude Desktop application, allowing users to create custom covers with titles, subtitles, authors, and visual themes.

Ransomware Live MCP Server

Servidor MCP Ransomware Ativo ✨🔐