Discover Awesome MCP Servers

Hands-on MCP (Message Control Protocols) Guide

MCP básico

MCP Weather SSE Server

Um servidor MCP que conecta assistentes de IA a dados meteorológicos em tempo real através da API OpenWeatherMap, usando Eventos Enviados pelo Servidor (Server-Sent Events - SSE).

Get笔记 MCP Server

Integrates with Get笔记 (GetBiji) API to enable AI-powered knowledge base search and retrieval. Provides tools for enhanced semantic search, raw content recall, and rate limit monitoring.

Nutrient Document Engine MCP Server

Enables AI agents and users to process documents through natural language, supporting PDF operations like text extraction, redaction, splitting, form filling, annotations, and content search.

AgentGo MCP Service

A Model Context Protocol service that enables agent authentication and integration with TrustGo platform, providing access to real-time data like price, sigma score, and mindshare bubble analytics.

Activity Collector MCP

Collects and aggregates developer activity data from GitLab, GitHub, Google Calendar, and Outlook Calendar. Enables tracking of commits, pull requests, code reviews, issues, and meeting information across multiple platforms with secure OAuth authentication.

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.

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!

Think MCP

Enables structured step-by-step reasoning with branching, revisions, and self-critique to help break down complex problems into manageable steps with confidence tracking and thought history search.

UniFi MCP Server

Enables comprehensive management of UniFi network infrastructure through the UniFi Cloud API, including device control, client management, camera settings, and access door control through natural language.

Zoom API MCP Server

Enables interaction with Zoom services through the Zoom API. Provides access to Zoom's functionality for meeting management, user operations, and platform features through natural language.

crawleo-mcp

Crawleo is a privacy-first, real-time web search and crawling API built for LLM applications, RAG pipelines, AI agents, and automation workflows. With a single API call, Crawleo performs live web search, optionally crawls result pages, and returns clean, AI-ready data in formats like Markdown, Text

traverse

Enables AI models to generate interactive, clickable code walkthrough diagrams using Mermaid code and node descriptions. It provides a web interface for viewing, persisting, and sharing these diagrams via a local database and a dedicated share server.

m365-copilot-mcp

Integrates Microsoft 365 enterprise data into GitHub Copilot and Claude Desktop using Microsoft 365 Copilot APIs. It enables natural language queries across SharePoint, OneDrive, emails, calendars, and Teams meetings while maintaining full enterprise permission enforcement.

APLCart MCP Server

An MCP server providing access to the APLCart idiom collection with semantic search and syntax matching capabilities. It enables users to find APL expressions and idioms through natural language queries, keyword searches, and exact syntax lookups.

arch-mcp

Arch MCP provides three main capabilities: * Access to Arch Wiki, AUR packages, official repos, and installed packages * Search, analyze, and securely install packages with built-in 50+ safety checks * Guided workflows for troubleshooting, security audits, and dependency analysis

MCP Server for Smithery Integration

MCP Server for integrating Greptile API with Smithery Framework, featuring rate limiting and API abstraction

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