Discover Awesome MCP Servers

CloakBrowser MCP

CloakBrowser MCP is a Python MCP server that lets agents control a CloakBrowser-backed browser from Linux servers, CI jobs, and other environments where a normal desktop browser is not available.

Datadog Logs MCP Server

Enables searching and retrieving Datadog logs through the Model Context Protocol with customizable queries, time ranges, and result limits.

SQLite Explorer

MCP server for exploring SQLite databases, offering tools to list tables, describe table structures, and execute read-only SQL queries.

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.

MCP Server

Servidor MCP

AKHQ MCP Server

Enables AI assistants to interact with Apache Kafka clusters through AKHQ's REST API. Supports multi-environment configuration, flexible authentication, and comprehensive coverage of topics, consumer groups, schema registry, Kafka Connect, ksqlDB, and ACLs.

Ownership & Attestation Protocol

An MCP server that enforces explicit task ownership through acceptance and mandatory provenance tagging (Observed/Reviewed/Reported) on all completion claims, providing six tools for task creation, acceptance, completion reporting, handoff, and status/history queries backed by PostgreSQL.

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.

mcp-a2a-documentation

Search and retrieve Agent2Agent (A2A) protocol documentation using full-text search and section filtering.

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.

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!

nucleo-mcp

Enables AI assistants to search, retrieve, and save Nucleo icons from the user's local library directly into projects.

Gingugu

Persistent long-term memory for AI coding assistants. Local SQLite, no cloud - 16 MCP tools to store, search, relate, and consolidate typed memories with a confidence lifecycle, hybrid BM25 + semantic search, namespaces, a knowledge graph, and a built-in OS keychain credential vault.

mcp-4o-Image-Generator

mcp-4o-Image-Generator

Acopia

MCP server for querying and simulating the dispatch plan of a solar PV + battery system in the Chilean electricity market, using deterministic optimization and optional DRL.

upnote-mcp

Enables AI assistants to interact with Upnote via its x-callback-url API, allowing creation of notes, notebooks, tag management, and search. It also supports navigation to various Upnote sections and custom filters.

SimuBridge

Enables AI assistants to control MATLAB Simulink models through natural language, providing tools for model creation, block management, wiring, simulation, and more via a local MCP backend.

MojaWave MCP

Connects any MCP-compatible AI assistant to the MojaWave SMS Gateway, enabling sending SMS, checking credit balances, and managing bulk SMS jobs.

mcp-dev-tools

Provides AI coding assistants with tools to run git status, recent commits, tests, and linter on a real repository.

koios-mcp

An MCP server that provides LLMs with access to 95 tools covering the Koios Cardano blockchain REST API, enabling queries for on-chain data like transactions, addresses, assets, and governance.

HREVN MCP Server

Minimal stdio MCP server that exposes HREVN compliance and audit tools as structured MCP tools, enabling baseline checks, profile validation, and bundle generation via a managed runtime.

xtapdown-mcp

An MCP server that provides LLM clients with direct access to XTapDown's Twitter creator toolkit, enabling tweet downloads, engagement calculations, content generation, and trend analysis without authentication or rate limits.

CashClaw GHL MCP

An MCP server for GoHighLevel with 82 live-tested tools, enabling CRM operations like contact management, appointments, invoices, and workflows via natural language.

Phpactor MCP Server

Provides project-wide semantic PHP refactoring tools (find references, rename classes/members, move class, class info) for AI assistants by wrapping Phpactor.

Heygen MCP Server

Permite que o Claude Desktop e os Agentes gerem avatares e vídeos de IA através da API da HeyGen, fornecendo ferramentas para criar e gerenciar vídeos de avatar com texto e opções de voz especificados.

supragents-mcp

A read-only research MCP server that provides search and browsing tools for Hacker News, Reddit, and Product Hunt. Works with zero API keys for basic use.

Find Flights MCP Server

Enables searching and retrieving flight information using Duffel API, supporting one-way, round-trip, and multi-city queries with flexible search parameters.

AgentBridge

A local, read-only prototype for agent communication and project sharing with configurable permissions, supporting Codex Desktop and Claude Code integration.

gitequity-mcp

MCP server that exposes your GitEquity portfolio to AI clients, enabling balance queries, stock prices, and trade proposals confirmed via GitHub comments.

arduino-mcp-server

Um servidor Arduino MCP escrito em Go.