Discover Awesome MCP Servers

MyMCP Prompt

MyMCP Prompt é uma ferramenta para gerar servidores Model Context Protocol (MCP) a partir de descrições em linguagem natural. Este MVP usa a API Google Gemini para converter descrições do usuário em servidores MCP Python funcionais com configurações JSON correspondentes.

MCP Teamtailor

A Model Context Protocol server that enables integration with the Teamtailor API, allowing users to list, filter, and retrieve candidate information from their Teamtailor recruitment platform.

browser-mcp

An MCP server that allows users to interact with their browser through natural language commands, enabling actions like getting page content as markdown, modifying page styles, and searching browser history.

MCP Server

An implementation of the Model Context Protocol (MCP) server that enables multiple clients to connect simultaneously and handles basic context management and messaging with an extendable architecture.

Azure Kusto MCP Server

Um Servidor MCP para Azure Kusto

AgenticRAG MCP Server

An intelligent codebase processing server that provides agentic RAG capabilities for code repositories, enabling semantic search and contextual understanding through self-evaluating retrieval loops.

Jokes MCP Server

A Model Context Protocol server that provides joke delivery functionality, allowing users to request various types of jokes (Chuck Norris, Dad jokes, etc.) through Microsoft Copilot Studio or Visual Studio Code.

mcp-confluence

Um servidor de contexto de modelo que fornece prompts que podem ser usados como comandos de barra (slash commands) para clientes como o Zed Editor, a fim de adicionar o conteúdo da página como contexto ao assistente de IA.

HowToCook-MCP Server

An MCP server that transforms AI assistants into personal chefs by providing recipe recommendations and meal planning features based on the HowToCook repository.

GitHub API MCP Server

A Multi-Agent Conversation Protocol Server for the GitHub API, auto-generated using AG2's MCP builder, allowing users to interact with GitHub services through natural language.

Next.js MCP Server

Uma ferramenta de utilidade que analisa as rotas de aplicações Next.js e fornece informações detalhadas sobre os caminhos da API, métodos HTTP, parâmetros, códigos de status e esquemas de requisição/resposta.

MCP Telegram

MCP Server for Telegram

ORAS MCP Server

Enables users to interact with container registries through the ORAS CLI, providing information about container images, platforms, and signatures via natural language queries.

Jira JQL Tool for Claude

Ferramentas MCP Simples e Práticas

Nanoleaf MCP Server

A Model Context Protocol server that enables controlling Nanoleaf smart lights through Warp terminal or any MCP-compatible client, providing tools for device discovery, authorization, and control of lights, brightness, colors, and effects.

build-simple-mcp

Okay, here's a guide on how to build a simple Minecraft Protocol (MCP) server in Python. This will be a very basic server, capable of handling a single client, and will only implement a small subset of the Minecraft protocol. It's intended for learning and experimentation, not for actual gameplay. **Important Considerations:** * **Complexity:** The Minecraft protocol is complex. This example will only cover the bare minimum to get a client to connect and receive a basic status response. * **Security:** This is a simplified example and does *not* include any security measures. Do not expose this server to the public internet. * **Libraries:** We'll use the `socket` library for networking and `struct` for packing and unpacking data. You might consider using a more robust library like `nbt` for handling NBT data in a real server. * **Protocol Version:** This example will target a specific Minecraft protocol version. You'll need to adjust the code if you want to support different versions. I'll use a relatively recent version (e.g., 763 for 1.17.1), but you should check the Minecraft wiki for the correct version for your client. * **Error Handling:** This example will have minimal error handling for brevity. A real server needs robust error handling. **Code (Python):** ```python import socket import struct import json # Configuration HOST = 'localhost' # Listen on all interfaces PORT = 25565 PROTOCOL_VERSION = 763 # Minecraft 1.17.1 SERVER_VERSION_NAME = "My Simple Server" MAX_PLAYERS = 20 MOTD = "§aA Simple Minecraft Server" # Use Minecraft color codes # Helper functions for reading and writing Minecraft protocol data def read_varint(sock): result = 0 shift = 0 while True: byte = sock.recv(1)[0] result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, data): while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if data == 0: break def write_string(sock, data): encoded_data = data.encode('utf-8') write_varint(sock, len(encoded_data)) sock.send(encoded_data) def read_string(sock): length = read_varint(sock) data = sock.recv(length) return data.decode('utf-8') # Server status response def get_status_response(): status = { "version": { "name": SERVER_VERSION_NAME, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": 0, "sample": [] # Add player samples if you want }, "description": { "text": MOTD } } return json.dumps(status) # Handle the handshake def handle_handshake(sock): protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack(">H", sock.recv(2))[0] # Big-endian unsigned short next_state = read_varint(sock) print(f"Protocol Version: {protocol_version}") print(f"Server Address: {server_address}") print(f"Server Port: {server_port}") print(f"Next State: {next_state}") return next_state # Handle status requests def handle_status(sock): # Expect an empty packet (request) packet_length = read_varint(sock) packet_id = sock.recv(1)[0] if packet_id == 0x00: # Send the status response status_response = get_status_response() status_response_bytes = status_response.encode('utf-8') packet = struct.pack("b", 0x00) + status_response_bytes write_varint(sock, len(packet)) sock.send(packet) # Handle ping packet_length = read_varint(sock) packet_id = sock.recv(1)[0] if packet_id == 0x01: ping_payload = sock.recv(8) # 8-byte payload packet = struct.pack("b", 0x01) + ping_payload write_varint(sock, len(packet)) sock.send(packet) else: print(f"Unexpected packet ID: {packet_id}") # Main server loop def main(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow address reuse server_socket.bind((HOST, PORT)) server_socket.listen(1) # Only allow one connection print(f"Server listening on {HOST}:{PORT}") while True: client_socket, client_address = server_socket.accept() print(f"Client connected from {client_address}") try: # Handshake next_state = handle_handshake(client_socket) if next_state == 1: # Status handle_status(client_socket) elif next_state == 2: # Login (not implemented in this example) print("Login requested (not implemented)") else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print("Client disconnected") if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries. 2. **Configuration:** Sets up server parameters like host, port, protocol version, MOTD, etc. **Crucially, make sure `PROTOCOL_VERSION` matches the version your Minecraft client is using.** 3. **Helper Functions:** * `read_varint(sock)`: Reads a variable-length integer (VarInt) from the socket. VarInts are used extensively in the Minecraft protocol. * `write_varint(sock, data)`: Writes a VarInt to the socket. * `write_string(sock, data)`: Writes a string to the socket, prefixed by its length as a VarInt. * `read_string(sock)`: Reads a string from the socket, reading the length as a VarInt first. 4. **`get_status_response()`:** Creates the JSON response that the server sends to the client when it requests the server status. This includes the server version, player count, and MOTD. The MOTD uses Minecraft color codes (e.g., `§a` for green). 5. **`handle_handshake(sock)`:** Handles the initial handshake packet from the client. It reads the protocol version, server address, port, and the "next state" (1 for status, 2 for login). It prints this information to the console. 6. **`handle_status(sock)`:** Handles the status request from the client. It expects an empty packet (0x00) and then sends the status response. It also handles the ping request (0x01) by echoing back the ping payload. 7. **`main()`:** * Creates a socket and binds it to the specified host and port. * Listens for incoming connections. * Accepts a client connection. * Calls `handle_handshake()` to process the handshake. * Based on the "next state" from the handshake, calls `handle_status()` or prints a message if login is requested (which is not implemented). * Closes the client socket. **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. **Connect with Minecraft:** * Start your Minecraft client. * Go to "Multiplayer". * Click "Add Server". * Enter a server name (e.g., "My Server"). * Enter the server address as `localhost:25565` (or the IP address and port you configured). * **Important:** You may need to manually specify the Minecraft version in your client's installation settings to match the `PROTOCOL_VERSION` in the server code. If the versions don't match, the client will refuse to connect. You can often do this by creating a new installation profile in the Minecraft launcher. 4. **Observe:** You should see the server in your server list. When you hover over it, you should see the MOTD and player count. If you can't see the server, double-check the following: * The server is running. * The server address and port are correct in the Minecraft client. * The `PROTOCOL_VERSION` in the server code matches the Minecraft client version. * Firewall rules are not blocking the connection. **Limitations and Next Steps:** * **No Login:** This server doesn't handle player login. * **No World:** There's no world generation or game logic. * **Single Client:** It only supports one client at a time. * **Basic Protocol:** It only implements a small part of the Minecraft protocol. * **Error Handling:** Needs much better error handling. To build a more complete server, you would need to: * Implement the login sequence (encryption, authentication). * Generate or load a world. * Handle player movement, block updates, and other game events. * Implement a more robust networking architecture to handle multiple clients. * Use a library like `nbt` to handle NBT data (used for storing world data, player data, etc.). * Add security measures to prevent cheating and attacks. This example provides a starting point for understanding the basics of the Minecraft protocol and building your own server. Good luck!

Blabber-MCP

Um servidor MCP que permite que LLMs gerem áudio falado a partir de texto usando a API Text-to-Speech da OpenAI, com suporte para diversas vozes, modelos e formatos de áudio.

Feather Code MCP Server

A GitHub integration for Claude Desktop that provides access to GitHub features directly from Claude, offering 15 powerful tools for repository management, issues, pull requests, and code operations.

MCP-NAVER-Map

Servidor MCP do Naver Map

MCP Mailtrap Server

Servidor MCP oficial do mailtrap.io

Fal.ai MCP Server

Enables Claude Desktop and other MCP clients to generate images, videos, music, and audio using Fal.ai models. Supports text-to-image generation, video creation, music composition, text-to-speech, audio transcription, and image enhancement through natural language prompts.

ArXiv MCP Server

Uma ponte entre assistentes de IA e o repositório de pesquisa ArXiv que permite pesquisar, baixar e ler artigos acadêmicos através do Protocolo de Controle de Mensagens.

Plane MCP Server

Espelho de

edu_video_gen

edu_video_gen

Swagger MCP

An MCP server that connects to a Swagger specification and helps an AI to build all the required models to generate a MCP server for that service.

LLM Server

Um servidor MCP que fornece aos LLMs acesso a outros LLMs.

A sample MCP server for understanding cloud spend

MCP para AWS Cost Explorer e logs do CloudWatch

Color Scheme Generator MCP Server

Generates harmonious color schemes for design projects using The Color API, offering eight different palette generation methods including monochrome, analogic, complement, triad, and quad schemes.