Discover Awesome MCP Servers

RF Tools

MCP server for rftools.io — 213 RF & electronics calculators + 13 server-side simulation tools for AI agents. Give Claude, Cursor, or any MCP-compatible AI assistant access to validated engineering calculators and heavy server-side simulations. Microstrip impedance, link budgets, filter design, converter sizing, antenna patterns, and 190+ more calculators — plus NEC2 antenna simulation, FDTD, Mon

SAP ADT MCP Server

An MCP server that enables AI assistants to interact with SAP systems via the ABAP Development Tools (ADT) REST API. It allows users to read ABAP source code, inspect DDIC objects, and execute SQL queries directly.

Claude Google Sheets MCP Server

A comprehensive MCP server for Google Sheets integration with Claude, enabling spreadsheet discovery, data manipulation, and formatting through natural language commands and slash commands.

google-sheet-mcp

A local MCP server for creating, reading, and updating Google Sheets.

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.

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!

codesteer-atlas

Local MCP server for semantic code search using Tree-sitter AST parsing, local embeddings, and hybrid search; enables indexing and querying codebases entirely offline.

VulnerabilityMCPServer

MCP server for retrieving vulnerability data (CVE) via HTTP, testable with MCP Inspector and OpenCode.

AE-MCP

An MCP server that enables AI assistants to control Adobe After Effects with 70+ tools for compositing, animation, effects, and motion graphics.

jlcpcb-search-mcp

Enables AI assistants to search JLCPCB's 450K+ electronic component catalog with real-time stock levels and pricing, supporting keyword search, filtering, and detailed component information.

system-prompts-mcp-server

Model Context Protocol server exposing system prompt files and summaries.

ServiceNow Cowork Automation API

MCP-compatible backend that automates ServiceNow incident handling via Microsoft 365 Copilot, offering tools for incident analysis, automation, and job status retrieval.

QBO-MCP-TS

Enables QuickBooks Online integration for financial management with CRUD operations, reporting, real-time updates, and automation.

Progresso MCP

Enables MCP clients to interact with a live Progresso workspace for board, CRM, projects, and time tracking via Supabase.

mcp-locator

An MCP server that lets AI agents read and write locale JSON translation files directly from the conversation without loading the whole catalog into context.

Captain Data MCP API

Uma API de middleware que conecta assistentes de IA como o ChatGPT às ferramentas do Captain Data para extrair informações de páginas de empresas e perfis do LinkedIn.

ReleaseGuard MCP Server

Provides MCP tools for scanning, redacting, and packaging dataset/model directories for public release, leveraging Presidio for PII detection and generating Hugging Face cards and EU AI Act training-data summaries.

qveris-agent-toolkit

Capability routing network for AI agents to discover, inspect, and call 10,000+ real-world financial capabilities through one unified MCP protocol.

vault-mcp

Markdown + SQLite knowledge store with bidirectional wikilinks, exposed as an MCP server for AI agents to maintain an interconnected knowledge base.

SQLite MCP Server

Um servidor leve de Protocolo de Contexto de Modelo (MCP) que permite que Modelos de Linguagem Grandes (LLMs) interajam autonomamente com bancos de dados SQLite.

Purefeed MCP Server

Connects AI assistants to Purefeed for access to AI-curated Twitter/X feeds, signals, semantic search, and post creation.

Kontomanager MCP Server

Enables programmatic access to Austrian mobile carriers (yesss!, Georg, XOXO) account management. Allows users to check usage, download bills, manage SIM settings, and configure call forwarding through natural language interactions.

eyeshot-mcp

Provides screenshot capture and vision analysis tools that enable AI to see and analyze screen content on Windows, forming an automated capture-analyze pipeline.

canvas-mcp

Connects Canvas LMS to Claude Desktop, enabling natural-language queries about courses, assignments, grades, and more.

ditto

An MCP server that loads your Ditto profile, mined from your local Claude Code, Codex, and OpenCode session logs, so your agent works like you. Exposes the load_ditto_profile tool over the Model Context Protocol.

data-centrevaldeloire

Enables AI agents to search, query, and explore datasets from the Centre-Val de Loire Open Data portal, covering regional services, transport, education, and environment.

kitty-mcp-server

MCP server for controlling the kitty terminal emulator. Exposes 40 tools for managing windows, tabs, layouts, text, appearance, and more.

powerplan

An MCP server that gives agents a human-language API over PLAN.md, enabling project plan management, task tracking, and iteration lifecycle without direct file editing.

Shopify MCP Server

Provides AI assistants with real-time access to Shopify store analytics, sales data, and inventory through ShopifyQL and the Admin GraphQL API. It enables users to query store performance, customer metrics, and marketing insights using natural language.

gmail-mcp

A Cloudflare Workers-based MCP server that connects Gmail to AI assistants, enabling search, read, send, reply-all, forward, and management of messages, drafts, labels, and threads across multiple Google accounts simultaneously.