Discover Awesome MCP Servers

Mnemosyne MCP

An active, stateful software knowledge graph engine that serves as an 'all-knowing development partner' for AI agents and human developers by modeling software projects into queryable knowledge graphs.

CucumberStudio MCP Server

Implementa um servidor de Protocolo de Contexto de Modelo que fornece contexto do CucumberStudio para assistentes de IA, permitindo que eles busquem dados e gerem ou modifiquem cenários de teste, features e outros recursos do CucumberStudio.

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!

Professional Penetration Testing MCP Server

Provides access to over 40 industry-standard penetration testing tools, including Nmap, SQLMap, and Metasploit, within an isolated Kali Linux Docker container. It enables security professionals to perform comprehensive network reconnaissance, web application testing, and vulnerability research through natural language commands.

🤖 MCP Server Examples with AutoGen

Este repositório demonstra como usar o AutoGen para integrar servidores MCP (Model Context Protocol) locais e remotos. Ele apresenta uma ferramenta matemática local (math_server.py) usando Stdio e uma ferramenta Apify remota (RAG Web Browser Actor) via SSE para tarefas como aritmética e navegação na web.

MCP Quickstart Weather Server

A basic MCP server adapted from the official quickstart guide that provides weather data functionality and works with OpenAI chat completions API. Demonstrates MCP server setup with configuration examples for Claude Desktop and development tools.

MCP Chess Server

Provides Chess.com player data integration, enabling AI assistants to fetch real-time chess player profiles and comprehensive statistics including ratings, game counts, and performance metrics from Chess.com's public API.

Dock AI MCP

Discover which MCP servers can interact with real-world entities like restaurants, hotels, and salons by querying the Dock AI registry using domain names.

system-prompts-mcp-server

Model Context Protocol server exposing system prompt files and summaries.

Dev MCP Prompt Server

A lightweight server that provides curated, high-quality prompts for common development tasks like UI/UX design, project setup, and debugging to enhance AI-powered development workflows.

Gmail MCP Server

Enables sending emails through Gmail using Google's Gmail API. Requires OAuth authentication setup through Google Cloud Console.

Financial MCP Server

Provides mock financial data including bank transactions, credit reports, and EPF details for the Finarrator application through authenticated API endpoints.

trykittai-mcp-server

trykittai-mcp-server

Jokes MCP Server

Enables users to retrieve jokes from various categories including Chuck Norris jokes and dad jokes. Provides a humor-focused tool that can be integrated into Microsoft Copilot Studio agents for delivering appropriate and engaging jokes upon request.

Hacker News Companion MCP

Obtém e processa discussões do Hacker News para prepará-las para que o Claude gere resumos de alta qualidade, lidando com a estrutura de comentários e metadados para ajudar o Claude a entender a importância relativa de diferentes comentários.

Remote MCP Server Template

A template for deploying MCP servers on Cloudflare Workers without authentication. Provides a foundation for building custom MCP tools that can be accessed remotely from various MCP clients like Claude Desktop or the Cloudflare AI Playground.

NutriAI MCP Server

Enables nutritional analysis of food descriptions by integrating with OpenAI's API to provide calorie estimates, macronutrient breakdowns, and dietary insights. Designed for educational purposes and follows OpenAI Apps SDK design guidelines.

MCP Test Server

A TypeScript-based test implementation for the Model Context Protocol (MCP) with example configurations and Jest test cases. Provides a development foundation for building and testing MCP server functionality.

Iceland News MCP Server

Fetches latest news from 6 Icelandic sources via 60+ RSS feeds across categories in Icelandic, English, and Polish, with configurable article limits and feed discovery.

Claude MCP Server

A lightweight Flask-based server that enables Claude AI to perform real-time web searches via DuckDuckGo during conversations, allowing the AI to access current information.

GitLab MCP Server

Enables AI assistants to interact with GitLab projects, allowing users to query merge requests, view code reviews and discussions, check pipeline test results, and respond to comments through natural language chat commands.

Mermaid Lint MCP

A tool for validating Mermaid diagram syntax through CLI and MCP interfaces, providing real-time error checking and line-specific feedback. It enables AI assistants to self-validate and debug generated diagrams across all Mermaid types, ensuring valid visual documentation.

deep-filesystem-tree

Uma implementação do Protocolo de Contexto de Modelo (MCP) que oferece visualização e manipulação profunda de árvores de sistema de arquivos. Esta ferramenta permite a navegação e o gerenciamento eficientes de estruturas de diretórios complexas, aprimorando os fluxos de trabalho de desenvolvimento com operações de sistema de arquivos alimentadas por IA. Compatível com

Fastmail MCP Server

Enables AI assistants to securely access and search Fastmail emails via the JMAP API. Supports searching emails, retrieving full email content, and listing mailboxes with read-only access using Fastmail API tokens.

Smartsheet MCP Server by CData

Smartsheet MCP Server by CData

Oura Ring OAuth2 MCP Server

Enables access to Oura Ring sleep data through OAuth2 authentication. Supports querying sleep scores and data from last night, past week, or specific dates.

Jina AI MCP Server

Um servidor MCP que fornece acesso aos poderosos serviços web da Jina AI (leitura de páginas, pesquisa na web, verificação de fatos) através do Claude.

MCP Calculator

A protocol implementation that extends AI capabilities through a WebSocket interface, enabling mathematical calculations, email operations, knowledge search, and remote device control.