Discover Awesome MCP Servers

E*TRADE MCP Server

Provides access to E\*TRADE's Market API for retrieving real-time stock quotes, looking up securities, and analyzing option chains with strikes and expirations.

CNCjs MCP Server

Bridges Claude Code to CNCjs to enable remote control and monitoring of GRBL-based CNC machines. It provides a comprehensive toolset for managing G-code jobs, machine movement, and safety operations through natural language.

Heroku Code MCP

A token-efficient MCP server for the Heroku Platform API that uses a search-and-execute pattern to minimize context window overhead. It enables secure app management through just-in-time endpoint discovery and built-in safety guardrails for API mutations.

Parcel MCP Server

Enables AI assistants to track and manage deliveries by interacting with the Parcel delivery tracking API. Users can add new shipments, retrieve active delivery statuses, and look up carrier information through natural language.

Weather MCP Server with Descope Auth

Enables real-time weather data streaming through a secure MCP server. Features authentication using Descope and can be deployed to Fly.io for remote access.

Blog RSS MCP Server

Enables interaction with blog RSS/Atom feeds to list posts, fetch content, get recent posts, retrieve blog metadata, and perform full-text search across post content. Supports any blog with an RSS/Atom feed through natural language queries.

Activepieces MCP

An open source toolkit that converts 280+ integrations into MCP servers for use with Claude Desktop, Cursor, or Windsurf, enabling AI automation through a type-safe pieces framework written in TypeScript.

MCP PostgreSQL Server

Enables user name resolution and team management with PostgreSQL backend, providing fuzzy user lookup, batch operations, team hierarchy navigation, and calendar insights through natural language queries.

Trademark Big Data MCP Server

Provides comprehensive trademark information services, including fuzzy company search, detailed trademark status tracking, and statistical analysis. Users can analyze trademark portfolios by tracking application trends, registration data, and category distributions for specific companies.

refinore-mcp

An MCP server that enables AI agents to autonomously manage ORE mining on the Solana blockchain via the refinORE platform. It provides tools for starting mining sessions, monitoring rewards, and managing multi-token balances through natural language commands.

MCP Server for eBay Marketing API

An MCP (Multi-Agent Conversation Protocol) Server that enables interaction with eBay's Sell Marketing API through natural language, auto-generated using AG2's MCP builder.

Hands-on MCP (Message Control Protocols) Guide

MCP básico

DevPlan MCP Server

Transforms ideas into detailed, executable development plans with built-in verification, lessons learned tracking, and GitHub issue remediation workflows. Guides Claude through structured interviews, plan generation, execution with Haiku agents, and verification with Sonnet agents to maintain context and code quality across sessions.

Ravelry MCP Server

Um servidor de Protocolo de Contexto de Modelo que se integra com a API do Ravelry, permitindo que assistentes de IA pesquisem e recuperem padrões de tricô e crochê.

MCP DEMO

Este projeto demonstra uma arquitetura cliente-servidor usando um servidor MCP (Protocolo de Configuração de Modelo) personalizado integrado com ferramentas MCP para gerar e retornar dinamicamente código React + TypeScript.

Security Scanner MCP Server

Enables comprehensive vulnerability scanning using Nuclei scanner with support for single targets, network ranges, and cluster-wide security assessments with customizable severity levels and automated scheduling.

GoCardless MCP Server

Enables AI assistants to interact with GoCardless payment data, providing tools to manage customers, payments, mandates, subscriptions, and payouts. Includes Xero integration support for automatic parsing of metadata.

huuh

huuh.me is AI-native Youtube - dead easy AI for people with stuff to do - collaborative AI projects for teams - public AI-native knowledge sharing - monetization of AI-native content streams

webmin-mcp-server

MCP server for Webmin system administration. 61 tools across 12 modules covering system monitoring, services, users, cron, packages, files, storage (SMART + LVM), security (Fail2ban), MySQL databases, Webmin ACL, and disk quotas. Four-tier safety framework with safe mode on by default. Python, MIT license, Docker and local deployment supported.

MCP Manager Local

Servidor para gerenciar servidores de Minecraft (MCP).

simple-mcp-server

Here's a basic outline and code snippets for a simple Minecraft Protocol (MCP) server implementation using Java Spring Boot. Keep in mind that a *full* MCP server is a complex undertaking, and this is a simplified example to get you started. It focuses on the core networking and basic handshake. **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is intricate and changes with each version. This example uses a very simplified approach and likely won't be compatible with modern Minecraft clients without significant modification. You'll need to consult the official Minecraft protocol documentation for the specific version you're targeting. [https://wiki.vg/Protocol](https://wiki.vg/Protocol) is an excellent resource. * **Security:** This example lacks proper security measures. In a real-world scenario, you'd need to implement encryption, authentication, and anti-cheat mechanisms. * **Error Handling:** The error handling is minimal. Robust error handling is crucial for a production server. * **Threading:** This example uses basic threading. For a high-performance server, consider using a more sophisticated threading model (e.g., an ExecutorService). * **Libraries:** While Spring Boot simplifies things, you'll likely need additional libraries for more advanced protocol handling (e.g., Netty, Kryo, or similar). **Project Setup (Spring Boot):** 1. **Create a Spring Boot Project:** Use Spring Initializr ([https://start.spring.io/](https://start.spring.io/)) to create a new Spring Boot project. Include the "Web" dependency. 2. **Dependencies (pom.xml):** ```xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.2.0</version> <!-- Use the latest stable version --> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.example</groupId> <artifactId>minecraft-server</artifactId> <version>0.0.1-SNAPSHOT</version> <name>minecraft-server</name> <description>Simple Minecraft Server with Spring Boot</description> <properties> <java.version>17</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> ``` **Code Example:** ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.stereotype.Component; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; @SpringBootApplication public class MinecraftServerApplication { public static void main(String[] args) { SpringApplication.run(MinecraftServerApplication.class, args); } } @Component class MinecraftServer { private static final int PORT = 25565; // Default Minecraft port public MinecraftServer() { startServer(); } private void startServer() { new Thread(() -> { try (ServerSocket serverSocket = new ServerSocket(PORT)) { System.out.println("Minecraft server started on port " + PORT); while (true) { Socket clientSocket = serverSocket.accept(); System.out.println("Client connected from " + clientSocket.getInetAddress()); new ClientHandler(clientSocket).start(); } } catch (IOException e) { System.err.println("Error starting server: " + e.getMessage()); } }).start(); } static class ClientHandler extends Thread { private final Socket clientSocket; public ClientHandler(Socket socket) { this.clientSocket = socket; } @Override public void run() { try (DataInputStream in = new DataInputStream(clientSocket.getInputStream()); DataOutputStream out = new DataOutputStream(clientSocket.getOutputStream())) { // Handle Handshake int packetLength = readVarInt(in); int packetId = readVarInt(in); System.out.println("Received packet with length: " + packetLength + ", ID: " + packetId); if (packetId == 0x00) { // Handshake packet int protocolVersion = readVarInt(in); String serverAddress = readString(in); int serverPort = in.readUnsignedShort(); int nextState = readVarInt(in); System.out.println("Handshake: Protocol " + protocolVersion + ", Address " + serverAddress + ", Port " + serverPort + ", State " + nextState); if (nextState == 1) { // Status handleStatus(out); } else if (nextState == 2) { // Login handleLogin(in, out); } } } catch (IOException e) { System.err.println("Error handling client: " + e.getMessage()); } finally { try { clientSocket.close(); System.out.println("Client disconnected."); } catch (IOException e) { System.err.println("Error closing socket: " + e.getMessage()); } } } private void handleStatus(DataOutputStream out) throws IOException { // Respond to Status Request (Ping) int packetLength = readVarInt(new DataInputStream(clientSocket.getInputStream())); int packetId = readVarInt(new DataInputStream(clientSocket.getInputStream())); if (packetId == 0x00) { System.out.println("Received Status Request"); // Craft a simple server status response (JSON) String jsonResponse = "{\"version\": {\"name\": \"1.20.2\", \"protocol\": 764}, \"players\": {\"max\": 10, \"online\": 0}, \"description\": {\"text\": \"A Simple Minecraft Server\"}}"; byte[] jsonBytes = jsonResponse.getBytes("UTF-8"); writeString(out, jsonResponse); // Send the response int responseLength = jsonBytes.length; writeVarInt(out, responseLength); out.write(jsonBytes); // Handle Ping packetLength = readVarInt(new DataInputStream(clientSocket.getInputStream())); packetId = readVarInt(new DataInputStream(clientSocket.getInputStream())); if (packetId == 0x01) { long pingPayload = new DataInputStream(clientSocket.getInputStream()).readLong(); System.out.println("Received Ping with payload: " + pingPayload); // Send back the same payload writeVarInt(out, 8); // Length of long (8 bytes) writeVarInt(out, 0x01); // Ping packet ID out.writeLong(pingPayload); out.flush(); } } } private void handleLogin(DataInputStream in, DataOutputStream out) throws IOException { // Handle Login Start int packetLength = readVarInt(in); int packetId = readVarInt(in); if (packetId == 0x00) { String playerName = readString(in); System.out.println("Login Start: Player name is " + playerName); // Send Login Success (UUID is required for modern versions) String uuid = "00000000-0000-0000-0000-000000000000"; // Dummy UUID String loginSuccessJson = "{\"uuid\": \"" + uuid + "\", \"name\": \"" + playerName + "\"}"; byte[] loginSuccessBytes = loginSuccessJson.getBytes("UTF-8"); writeVarInt(out, loginSuccessBytes.length + 36); // Length of UUID + name writeVarInt(out, 0x02); // Login Success packet ID writeString(out, uuid); writeString(out, playerName); out.flush(); System.out.println("Login Success sent to " + playerName); } } // Helper methods for reading and writing VarInts and Strings (Minecraft Protocol) private int readVarInt(DataInputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = in.readByte(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt is too big"); } } while ((read & 0x80) != 0); return result; } private void writeVarInt(DataOutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.writeByte(value); return; } out.writeByte((value & 0x7F) | 0x80); value >>>= 7; } } private String readString(DataInputStream in) throws IOException { int length = readVarInt(in); byte[] bytes = new byte[length]; in.readFully(bytes); return new String(bytes, "UTF-8"); } private void writeString(DataOutputStream out, String s) throws IOException { byte[] bytes = s.getBytes("UTF-8"); writeVarInt(out, bytes.length); out.write(bytes); } } } ``` **Explanation:** 1. **`MinecraftServerApplication`:** The main Spring Boot application class. 2. **`MinecraftServer`:** * Starts a `ServerSocket` on port 25565 (the default Minecraft port). * Listens for incoming client connections in a loop. * Creates a `ClientHandler` thread for each new connection. 3. **`ClientHandler`:** * Handles communication with a single Minecraft client. * Reads data from the client's input stream (`DataInputStream`). * Writes data to the client's output stream (`DataOutputStream`). * **Handshake:** Reads the initial handshake packet (ID 0x00). Parses the protocol version, server address, port, and next state. * **Status:** If the next state is 1 (Status), it calls `handleStatus()`. * **Login:** If the next state is 2 (Login), it calls `handleLogin()`. * **`handleStatus()`:** Responds to the status request (ping). It crafts a simple JSON response containing server information (version, player count, description). It also handles the ping request by sending back the same payload. * **`handleLogin()`:** Handles the login process. It reads the player's name and sends a "Login Success" packet back to the client. **Important:** Modern Minecraft versions require a UUID for login. This example uses a dummy UUID. * **`readVarInt()` and `writeVarInt()`:** These methods handle reading and writing VarInts, which are a variable-length integer format used in the Minecraft protocol. * **`readString()` and `writeString()`:** These methods handle reading and writing strings, which are prefixed with a VarInt indicating their length. **How to Run:** 1. Build the project using Maven (`mvn clean install`). 2. Run the application using `mvn spring-boot:run` or by running the `MinecraftServerApplication` class directly from your IDE. **Testing:** 1. **Minecraft Client:** Try connecting to `localhost:25565` with a Minecraft client. **Important:** The client's version *must* be compatible with the protocol version you're implementing. This example is very basic and likely won't work with modern clients without significant changes. You might need to use an older client version or modify the code to support the correct protocol. 2. **Telnet (for basic testing):** You can use Telnet to connect to the server and send raw bytes to test the handshake. However, this requires a good understanding of the Minecraft protocol. **Next Steps:** * **Protocol Documentation:** Study the Minecraft protocol documentation ([https://wiki.vg/Protocol](https://wiki.vg/Protocol)) for the specific version you want to support. * **Packet Handling:** Implement handlers for more packets (e.g., chat messages, player movement, world updates). * **World Generation:** Implement a basic world generator. * **Player Management:** Keep track of connected players. * **Security:** Add encryption and authentication. * **Threading:** Use a more robust threading model for better performance. * **Libraries:** Consider using libraries like Netty or Kryo to simplify networking and serialization. This example provides a starting point. Building a fully functional Minecraft server is a substantial project. Good luck! **Portuguese Translation:** Aqui está um esboço básico e trechos de código para uma implementação simples de um servidor Minecraft Protocol (MCP) usando Java Spring Boot. Tenha em mente que um servidor MCP *completo* é uma tarefa complexa, e este é um exemplo simplificado para você começar. Ele se concentra na rede principal e no handshake básico. **Considerações Importantes:** * **Complexidade do Protocolo Minecraft:** O protocolo Minecraft é intrincado e muda a cada versão. Este exemplo usa uma abordagem muito simplificada e provavelmente não será compatível com clientes Minecraft modernos sem modificações significativas. Você precisará consultar a documentação oficial do protocolo Minecraft para a versão específica que você está almejando. [https://wiki.vg/Protocol](https://wiki.vg/Protocol) é um excelente recurso. * **Segurança:** Este exemplo carece de medidas de segurança adequadas. Em um cenário do mundo real, você precisaria implementar criptografia, autenticação e mecanismos anti-cheat. * **Tratamento de Erros:** O tratamento de erros é mínimo. Um tratamento de erros robusto é crucial para um servidor de produção. * **Threads:** Este exemplo usa threading básico. Para um servidor de alto desempenho, considere usar um modelo de threading mais sofisticado (por exemplo, um ExecutorService). * **Bibliotecas:** Embora o Spring Boot simplifique as coisas, você provavelmente precisará de bibliotecas adicionais para um tratamento de protocolo mais avançado (por exemplo, Netty, Kryo ou similares). **Configuração do Projeto (Spring Boot):** 1. **Crie um Projeto Spring Boot:** Use o Spring Initializr ([https://start.spring.io/](https://start.spring.io/)) para criar um novo projeto Spring Boot. Inclua a dependência "Web". 2. **Dependências (pom.xml):** ```xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.2.0</version> <!-- Use a versão estável mais recente --> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.example</groupId> <artifactId>minecraft-server</artifactId> <version>0.0.1-SNAPSHOT</version> <name>minecraft-server</name> <description>Simple Minecraft Server with Spring Boot</description> <properties> <java.version>17</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> ``` **Exemplo de Código:** ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.stereotype.Component; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; @SpringBootApplication public class MinecraftServerApplication { public static void main(String[] args) { SpringApplication.run(MinecraftServerApplication.class, args); } } @Component class MinecraftServer { private static final int PORT = 25565; // Porta padrão do Minecraft public MinecraftServer() { startServer(); } private void startServer() { new Thread(() -> { try (ServerSocket serverSocket = new ServerSocket(PORT)) { System.out.println("Servidor Minecraft iniciado na porta " + PORT); while (true) { Socket clientSocket = serverSocket.accept(); System.out.println("Cliente conectado de " + clientSocket.getInetAddress()); new ClientHandler(clientSocket).start(); } } catch (IOException e) { System.err.println("Erro ao iniciar o servidor: " + e.getMessage()); } }).start(); } static class ClientHandler extends Thread { private final Socket clientSocket; public ClientHandler(Socket socket) { this.clientSocket = socket; } @Override public void run() { try (DataInputStream in = new DataInputStream(clientSocket.getInputStream()); DataOutputStream out = new DataOutputStream(clientSocket.getOutputStream())) { // Manipular Handshake int packetLength = readVarInt(in); int packetId = readVarInt(in); System.out.println("Pacote recebido com comprimento: " + packetLength + ", ID: " + packetId); if (packetId == 0x00) { // Pacote de Handshake int protocolVersion = readVarInt(in); String serverAddress = readString(in); int serverPort = in.readUnsignedShort(); int nextState = readVarInt(in); System.out.println("Handshake: Protocolo " + protocolVersion + ", Endereço " + serverAddress + ", Porta " + serverPort + ", Estado " + nextState); if (nextState == 1) { // Status handleStatus(out); } else if (nextState == 2) { // Login handleLogin(in, out); } } } catch (IOException e) { System.err.println("Erro ao manipular o cliente: " + e.getMessage()); } finally { try { clientSocket.close(); System.out.println("Cliente desconectado."); } catch (IOException e) { System.err.println("Erro ao fechar o socket: " + e.getMessage()); } } } private void handleStatus(DataOutputStream out) throws IOException { // Responder à Solicitação de Status (Ping) int packetLength = readVarInt(new DataInputStream(clientSocket.getInputStream())); int packetId = readVarInt(new DataInputStream(clientSocket.getInputStream())); if (packetId == 0x00) { System.out.println("Solicitação de Status Recebida"); // Crie uma resposta de status do servidor simples (JSON) String jsonResponse = "{\"version\": {\"name\": \"1.20.2\", \"protocol\": 764}, \"players\": {\"max\": 10, \"online\": 0}, \"description\": {\"text\": \"Um Servidor Minecraft Simples\"}}"; byte[] jsonBytes = jsonResponse.getBytes("UTF-8"); writeString(out, jsonResponse); // Envie a resposta int responseLength = jsonBytes.length; writeVarInt(out, responseLength); out.write(jsonBytes); // Manipular Ping packetLength = readVarInt(new DataInputStream(clientSocket.getInputStream())); packetId = readVarInt(new DataInputStream(clientSocket.getInputStream())); if (packetId == 0x01) { long pingPayload = new DataInputStream(clientSocket.getInputStream()).readLong(); System.out.println("Ping recebido com payload: " + pingPayload); // Envie de volta o mesmo payload writeVarInt(out, 8); // Comprimento de long (8 bytes) writeVarInt(out, 0x01); // ID do pacote Ping out.writeLong(pingPayload); out.flush(); } } } private void handleLogin(DataInputStream in, DataOutputStream out) throws IOException { // Manipular Início de Login int packetLength = readVarInt(in); int packetId = readVarInt(in); if (packetId == 0x00) { String playerName = readString(in); System.out.println("Início de Login: Nome do jogador é " + playerName); // Enviar Login com Sucesso (UUID é necessário para versões modernas) String uuid = "00000000-0000-0000-0000-000000000000"; // UUID fictício String loginSuccessJson = "{\"uuid\": \"" + uuid + "\", \"name\": \"" + playerName + "\"}"; byte[] loginSuccessBytes = loginSuccessJson.getBytes("UTF-8"); writeVarInt(out, loginSuccessBytes.length + 36); // Comprimento do UUID + nome writeVarInt(out, 0x02); // ID do pacote Login com Sucesso writeString(out, uuid); writeString(out, playerName); out.flush(); System.out.println("Login com Sucesso enviado para " + playerName); } } // Métodos auxiliares para ler e escrever VarInts e Strings (Protocolo Minecraft) private int readVarInt(DataInputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = in.readByte(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt é muito grande"); } } while ((read & 0x80) != 0); return result; } private void writeVarInt(DataOutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.writeByte(value); return; } out.writeByte((value & 0x7F) | 0x80); value >>>= 7; } } private String readString(DataInputStream in) throws IOException { int length = readVarInt(in); byte[] bytes = new byte[length]; in.readFully(bytes); return new String(bytes, "UTF-8"); } private void writeString(DataOutputStream out, String s) throws IOException { byte[] bytes = s.getBytes("UTF-8"); writeVarInt(out, bytes.length); out.write(bytes); } } } ``` **Explicação:** 1. **`MinecraftServerApplication`:** A classe principal da aplicação Spring Boot. 2. **`MinecraftServer`:** * Inicia um `ServerSocket` na porta 25565 (a porta padrão do Minecraft). * Escuta por conexões de clientes de entrada em um loop. * Cria uma thread `ClientHandler` para cada nova conexão. 3. **`ClientHandler`:** * Manipula a comunicação com um único cliente Minecraft. * Lê dados do fluxo de entrada do cliente (`DataInputStream`). * Escreve dados no fluxo de saída do cliente (`DataOutputStream`). * **Handshake:** Lê o pacote de handshake inicial (ID 0x00). Analisa a versão do protocolo, o endereço do servidor, a porta e o próximo estado. * **Status:** Se o próximo estado for 1 (Status), ele chama `handleStatus()`. * **Login:** Se o próximo estado for 2 (Login), ele chama `handleLogin()`. * **`handleStatus()`:** Responde à solicitação de status (ping). Ele cria uma resposta JSON simples contendo informações do servidor (versão, contagem de jogadores, descrição). Ele também manipula a solicitação de ping enviando de volta o mesmo payload. * **`handleLogin()`:** Manipula o processo de login. Ele lê o nome do jogador e envia um pacote "Login com Sucesso" de volta para o cliente. **Importante:** As versões modernas do Minecraft exigem um UUID para login. Este exemplo usa um UUID fictício. * **`readVarInt()` e `writeVarInt()`:** Esses métodos manipulam a leitura e escrita de VarInts, que são um formato de inteiro de comprimento variável usado no protocolo Minecraft. * **`readString()` e `writeString()`:** Esses métodos manipulam a leitura e escrita de strings, que são prefixadas com um VarInt indicando seu comprimento. **Como Executar:** 1. Compile o projeto usando Maven (`mvn clean install`). 2. Execute a aplicação usando `mvn spring-boot:run` ou executando a classe `MinecraftServerApplication` diretamente do seu IDE. **Testando:** 1. **Cliente Minecraft:** Tente se conectar a `localhost:25565` com um cliente Minecraft. **Importante:** A versão do cliente *deve* ser compatível com a versão do protocolo que você está implementando. Este exemplo é muito básico e provavelmente não funcionará com clientes modernos sem alterações significativas. Você pode precisar usar uma versão mais antiga do cliente ou modificar o código para suportar o protocolo correto. 2. **Telnet (para testes básicos):** Você pode usar o Telnet para se conectar ao servidor e enviar bytes brutos para testar o handshake. No entanto, isso requer um bom entendimento do protocolo Minecraft. **Próximos Passos:** * **Documentação do Protocolo:** Estude a documentação do protocolo Minecraft ([https://wiki.vg/Protocol](https://wiki.vg/Protocol)) para a versão específica que você deseja suportar. * **Manipulação de Pacotes:** Implemente manipuladores para mais pacotes (por exemplo, mensagens de bate-papo, movimento do jogador, atualizações do mundo). * **Geração de Mundo:** Implemente um gerador de mundo básico. * **Gerenciamento de Jogadores:** Acompanhe os jogadores conectados. * **Segurança:** Adicione criptografia e autenticação. * **Threads:** Use um modelo de threading mais robusto para melhor desempenho. * **Bibliotecas:** Considere usar bibliotecas como Netty ou Kryo para simplificar a rede e a serialização. Este exemplo fornece um ponto de partida. Construir um servidor Minecraft totalmente funcional é um projeto substancial. Boa sorte!

Coin Railz MCP Server

Provides access to 41 micropayment-based services for blockchain analytics, trading signals, prediction markets, and financial sentiment analysis. It enables users to perform crypto-native tasks like auditing smart contracts, tracking whale alerts, and analyzing DeFi liquidity through natural language.

Awesome MCP Servers

Uma coleção de servidores MCP

Processing MCP Server

An MCP server that enables AI assistants to create and run Processing sketches directly through natural language commands.

coderide

coderide

Knowledge Server

Provides LLM-agnostic access to API documentation through MCP and REST endpoints, enabling AI assistants to retrieve, search, and proxy requests to whitelisted APIs across multiple platforms.

LinkedIn MCP Server

A Model Context Protocol implementation that bridges language models with LinkedIn's API, enabling profile access, posting content, searching people, and retrieving company information through standardized tools.

Puppeteer MCP Server

Enables LLMs to perform browser automation including web navigation, element interaction, and screenshot capture using Puppeteer. It provides capabilities for executing JavaScript in the browser and monitoring console logs for debugging and data extraction.